Simple RPC - 02 通用高性能序列化和反序列化设计与实现

文章目录

  • 概述
  • 设计实现
    • 通用的序列化接口
    • 通用的序列化实现【推荐】 vs 专用的序列化实现
    • 专用序列化接口定义
    • 序列化实现

在这里插入图片描述

概述

网络传输和序列化这两部分的功能相对来说是非常通用并且独立的，在设计的时候，只要能做到比较好的抽象，这两部的实现，它的通用性是非常强的。不仅可以用于 RPC 框架中，同样可以直接拿去用于实现消息队列，或者其他需要互相通信的分布式系统中。

我们先来实现序列化和反序列化部分，因为后面的部分会用到序列化和反序列化。

设计实现

通用的序列化接口

首先我们需要设计一个可扩展的，通用的序列化接口，为了方便使用，我们直接使用静态类的方式来定义这个接口（严格来说这并不是一个接口）


public class SerializeSupport {public static  <E> E parse(byte [] buffer) {// ...}public static <E> byte [] serialize(E  entry) {// ...}
}
  • parse 方法用于反序列化
  • serialize 方法用于序列化

比如

// 序列化
MyClass myClassObject = new MyClass();
byte [] bytes = SerializeSupport.serialize(myClassObject);
// 反序列化
MyClass myClassObject1 = SerializeSupport.parse(bytes);

通用的序列化实现【推荐】 vs 专用的序列化实现

在讲解序列化和反序列化的时候说过，可以使用通用的序列化实现，也可以自己来定义专用的序列化实现。

  • 专用的序列化性能最好，但缺点是实现起来比较复杂，你要为每一种类型的数据专门编写序列化和反序列化方法。
  • 一般的 RPC 框架采用的都是通用的序列化实现，比如 gRPC 采用的是 Protobuf 序列化实现，Dubbo 支持 hession2 等好几种序列化实现

为什么这些 RPC 框架不像消息队列一样，采用性能更好的专用的序列化实现呢？这个原因很简单，消息队列它需要序列化数据的类型是固定的，只是它自己的内部通信的一些命令。但 RPC 框架，它需要序列化的数据是，用户调用远程方法的参数，这些参数可能是各种数据类型，所以必须使用通用的序列化实现，确保各种类型的数据都能被正确的序列化和反序列化。

我们这里还是采用专用的序列化实现，主要的目的是一起来实践一下，如何来实现序列化和反序列化

专用序列化接口定义

public interface Serializer<T> {/*** 计算对象序列化后的长度，主要用于申请存放序列化数据的字节数组* @param entry 待序列化的对象* @return 对象序列化后的长度*/int size(T entry);/*** 序列化对象。将给定的对象序列化成字节数组* @param entry 待序列化的对象* @param bytes 存放序列化数据的字节数组* @param offset 数组的偏移量，从这个位置开始写入序列化数据* @param length 对象序列化后的长度，也就是{@link Serializer#size(java.lang.Object)}方法的返回值。*/void serialize(T entry, byte[] bytes, int offset, int length);/*** 反序列化对象* @param bytes 存放序列化数据的字节数组* @param offset 数组的偏移量，从这个位置开始写入序列化数据* @param length 对象序列化后的长度* @return 反序列化之后生成的对象*/T parse(byte[] bytes, int offset, int length);/*** 用一个字节标识对象类型，每种类型的数据应该具有不同的类型值*/byte type();/*** 返回序列化对象类型的Class对象。*/Class<T> getSerializeClass();
}

这个接口中，除了 serialize 和 parse 这两个序列化和反序列化两个方法以外，还定义了下面这几个方法：

  • size 方法计算序列化之后的数据长度，用于事先来申请存放序列化数据的字节数组；
  • type 方法定义每种序列化实现的类型，这个类型值也会写入到序列化之后的数据中，主要的作用是在反序列化的时候，能够识别是什么数据类型的，以便找到对应的反序列化实现类；
  • getSerializeClass 这个方法返回这个序列化实现类对应的对象类型，目的是，在执行序列化的时候，通过被序列化的对象类型找到对应序列化实现类

序列化实现

利用这个 Serializer 接口，我们就可以来实现 SerializeSupport 这个支持任何对象类型序列化的通用静态类了。

首先我们定义两个 Map，这两个 Map 中存放着所有实现 Serializer 接口的序列化实现类

private static Map<Class<?>/*序列化对象类型*/, Serializer<?>/*序列化实现*/> serializerMap = new HashMap<>();
private static Map<Byte/*序列化实现类型*/, Class<?>/*序列化对象类型*/> typeMap = new HashMap<>();
  • serializerMap 中的 key 是序列化实现类对应的序列化对象的类型，它的用途是在序列化的时候，通过被序列化的对象类型，找到对应的序列化实现类。
  • typeMap 的作用和 serializerMap 是类似的，它的 key 是序列化实现类的类型，用于在反序列化的时候，从序列化的数据中读出对象类型，然后找到对应的序列化实现类

理解了这两个 Map 的作用，实现序列化和反序列化这两个方法就很容易了。这两个方法的实现思路是一样的，都是通过一个类型在这两个 Map 中进行查找，查找的结果就是对应的序列化实现类的实例，也就是 Serializer 接口的实现，然后调用对应的序列化或者反序列化方法就可以了。

public class SerializeSupport {private static final Logger logger = LoggerFactory.getLogger(SerializeSupport.class);private static Map<Class<?>/*序列化对象类型*/, Serializer<?>/*序列化实现*/> serializerMap = new HashMap<>();private static Map<Byte/*序列化实现类型*/, Class<?>/*序列化对象类型*/> typeMap = new HashMap<>();static {for (Serializer serializer : ServiceSupport.loadAll(Serializer.class)) {registerType(serializer.type(), serializer.getSerializeClass(), serializer);logger.info("Found serializer, class: {}, type: {}.",serializer.getSerializeClass().getCanonicalName(),serializer.type());}}private static byte parseEntryType(byte[] buffer) {return buffer[0];}private static <E> void registerType(byte type, Class<E> eClass, Serializer<E> serializer) {serializerMap.put(eClass, serializer);typeMap.put(type, eClass);}@SuppressWarnings("unchecked")private static  <E> E parse(byte [] buffer, int offset, int length, Class<E> eClass) {Object entry =  serializerMap.get(eClass).parse(buffer, offset, length);if (eClass.isAssignableFrom(entry.getClass())) {return (E) entry;} else {throw new SerializeException("Type mismatch!");}}public static  <E> E parse(byte [] buffer) {return parse(buffer, 0, buffer.length);}private static  <E> E parse(byte[] buffer, int offset, int length) {byte type = parseEntryType(buffer);@SuppressWarnings("unchecked")Class<E> eClass = (Class<E> )typeMap.get(type);if(null == eClass) {throw new SerializeException(String.format("Unknown entry type: %d!", type));} else {return parse(buffer, offset + 1, length - 1,eClass);}}public static <E> byte [] serialize(E  entry) {@SuppressWarnings("unchecked")Serializer<E> serializer = (Serializer<E>) serializerMap.get(entry.getClass());if(serializer == null) {throw new SerializeException(String.format("Unknown entry class type: %s", entry.getClass().toString()));}byte [] bytes = new byte [serializer.size(entry) + 1];bytes[0] = serializer.type();serializer.serialize(entry, bytes, 1, bytes.length - 1);return bytes;}
}

所有的 Serializer 的实现类是怎么加载到 SerializeSupport 的那两个 Map 中的呢？这里面利用了 Java 的一个 SPI 类加载机制

public class ServiceSupport {private final static Map<String, Object> singletonServices = new HashMap<>();public synchronized static <S> S load(Class<S> service) {return StreamSupport.stream(ServiceLoader.load(service).spliterator(), false).map(ServiceSupport::singletonFilter).findFirst().orElseThrow(ServiceLoadException::new);}public synchronized static <S> Collection<S> loadAll(Class<S> service) {return StreamSupport.stream(ServiceLoader.load(service).spliterator(), false).map(ServiceSupport::singletonFilter).collect(Collectors.toList());}@SuppressWarnings("unchecked")private static <S>  S singletonFilter(S service) {if(service.getClass().isAnnotationPresent(Singleton.class)) {String className = service.getClass().getCanonicalName();Object singletonInstance = singletonServices.putIfAbsent(className, service);return singletonInstance == null ? service : (S) singletonInstance;} else {return service;}}
}

到这里，我们就封装好了一个通用的序列化的接口，

  • 对于使用序列化的模块来说，它只要依赖 SerializeSupport 这个静态类，调用它的序列化和反序列化方法就可以了，不需要依赖任何序列化实现类。

  • 对于序列化实现的提供者来说，也只需要依赖并实现 Serializer 这个接口就可以了。

比如，我们的 HelloService 例子中的参数是一个 String 类型的数据，我们需要实现一个支持 String 类型的序列化实现

public class StringSerializer implements Serializer<String> {@Overridepublic int size(String entry) {return entry.getBytes(StandardCharsets.UTF_8).length;}@Overridepublic void serialize(String entry, byte[] bytes, int offset, int length) {byte [] strBytes = entry.getBytes(StandardCharsets.UTF_8);System.arraycopy(strBytes, 0, bytes, offset, strBytes.length);}@Overridepublic String parse(byte[] bytes, int offset, int length) {return new String(bytes, offset, length, StandardCharsets.UTF_8);}@Overridepublic byte type() {return Types.TYPE_STRING;}@Overridepublic Class<String> getSerializeClass() {return String.class;}
}

在把 String 和 byte 数组做转换的时候，一定要指定编码方式，确保序列化和反序列化的时候都使用一致的编码，我们这里面统一使用 UTF8 编码。否则，如果遇到执行序列化和反序列化的两台服务器默认编码不一样，就会出现乱码。我们在开发过程用遇到的很多中文乱码问题，绝大部分都是这个原因

还有一个更复杂的序列化实现 MetadataSerializer，用于将注册中心的数据持久化到文件中

/*** Size of the map                     2 bytes*      Map entry:*          Key string:*              Length:                2 bytes*              Serialized key bytes:  variable length*          Value list*              List size:              2 bytes*              item(URI):*                  Length:             2 bytes*                  serialized uri:     variable length*              item(URI):*              ...*      Map entry:*      ...**/
public class MetadataSerializer implements Serializer<Metadata> {@Overridepublic int size(Metadata entry) {return Short.BYTES +                   // Size of the map                  2 bytesentry.entrySet().stream().mapToInt(this::entrySize).sum();}@Overridepublic void serialize(Metadata entry, byte[] bytes, int offset, int length) {ByteBuffer buffer = ByteBuffer.wrap(bytes, offset, length);buffer.putShort(toShortSafely(entry.size()));entry.forEach((k,v) -> {byte [] keyBytes = k.getBytes(StandardCharsets.UTF_8);buffer.putShort(toShortSafely(keyBytes.length));buffer.put(keyBytes);buffer.putShort(toShortSafely(v.size()));for (URI uri : v) {byte [] uriBytes = uri.toASCIIString().getBytes(StandardCharsets.UTF_8);buffer.putShort(toShortSafely(uriBytes.length));buffer.put(uriBytes);}});}private int entrySize(Map.Entry<String, List<URI>> e) {// Map entry:return Short.BYTES +       // Key string length:               2 bytese.getKey().getBytes().length +    // Serialized key bytes:   variable lengthShort.BYTES + // List size:              2 bytese.getValue().stream() // Value list.mapToInt(uri -> {return Short.BYTES +       // Key string length:               2 bytesuri.toASCIIString().getBytes(StandardCharsets.UTF_8).length;    // Serialized key bytes:   variable length}).sum();}@Overridepublic Metadata parse(byte[] bytes, int offset, int length) {ByteBuffer buffer = ByteBuffer.wrap(bytes, offset, length);Metadata metadata = new Metadata();int sizeOfMap = buffer.getShort();for (int i = 0; i < sizeOfMap; i++) {int keyLength = buffer.getShort();byte [] keyBytes = new byte [keyLength];buffer.get(keyBytes);String key = new String(keyBytes, StandardCharsets.UTF_8);int uriListSize = buffer.getShort();List<URI> uriList = new ArrayList<>(uriListSize);for (int j = 0; j < uriListSize; j++) {int uriLength = buffer.getShort();byte [] uriBytes = new byte [uriLength];buffer.get(uriBytes);URI uri  = URI.create(new String(uriBytes, StandardCharsets.UTF_8));uriList.add(uri);}metadata.put(key, uriList);}return metadata;}@Overridepublic byte type() {return Types.TYPE_METADATA;}@Overridepublic Class<Metadata> getSerializeClass() {return Metadata.class;}private short toShortSafely(int v) {assert v < Short.MAX_VALUE;return (short) v;}
}

到这里序列化的部分就实现完成了。我们这个序列化的实现，对外提供服务的就只有一个 SerializeSupport 静态类，并且可以通过扩展支持序列化任何类型的数据，这样一个通用的实现，不仅可以用在我们这个 RPC 框架的例子中，完全可以把这部分直接拿过去用在业务代码中

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/163693.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Spring5学习笔记之整合MyBatis

Spring5学习笔记之整合MyBatis

✅作者简介&#xff1a;大家好&#xff0c;我是Leo&#xff0c;热爱Java后端开发者&#xff0c;一个想要与大家共同进步的男人&#x1f609;&#x1f609; &#x1f34e;个人主页&#xff1a;Leo的博客 &#x1f49e;当前专栏&#xff1a; Spring专栏 ✨特色专栏&#xff1a; M…
阅读更多...
nvm 安装 node 安装不上 npm

nvm 安装 node 安装不上 npm

遇到一个问题 nvm install 18.18.2 node -v 安装上了 npm -v 发现没有安装上 解决办法 nvm -v 查看到自己的 nvm 版本号是 1.1.7 NVM下载 - NVM中文网 下载最新版本的 nvm .exe 文件 nvm list 查看手里 node 的所有版本 nvm uninstall 各个版本只保留一个最低版本 点…
阅读更多...
百分点科技受邀参加“一带一路”国际合作高峰论坛

百分点科技受邀参加“一带一路”国际合作高峰论坛

10月17-18日&#xff0c;第三届“一带一路”国际合作高峰论坛在北京成功举行。作为新一代信息技术出海企业代表&#xff0c;百分点科技董事长兼CEO苏萌受邀出席高峰论坛开场活动——“一带一路”企业家大会&#xff0c;与来自82个国家和地区的企业或机构、有关国际组织、经济机…
阅读更多...
从功能测试到自动化测试，待遇翻倍，我整理的超全学习指南！

从功能测试到自动化测试，待遇翻倍，我整理的超全学习指南！

在这个吃技术的IT行业来说&#xff0c;我刚入行的时候每天做的也是最基础的工作&#xff0c;但是随着时间的消磨&#xff0c;我产生了对自我和岗位价值和意义的困惑。 一是感觉自己在浪费时间&#xff0c;另一个就是做了快2年的测试&#xff0c;感觉每天过得浑浑噩噩&#xff…
阅读更多...
《数据结构、算法与应用C++语言描述》使用C++语言实现数组队列

《数据结构、算法与应用C++语言描述》使用C++语言实现数组队列

《数据结构、算法与应用C语言描述》使用C语言实现数组队列 定义 队列的定义 队列&#xff08;queue&#xff09;是一个线性表&#xff0c;其插入和删除操作分别在表的不同端进行。插入元素的那一端称为队尾&#xff08;back或rear&#xff09;&#xff0c;删除元素的那一端称…
阅读更多...
并发编程——2.基础概念及其它相关的概述

并发编程——2.基础概念及其它相关的概述

这篇文章我们来讲一下并发编程中的线程及其相关的概述内容。 目录 1.J.U.C 2.进程、线程、协程 2.1进程 2.2线程 2.3纤程&#xff08;协程&#xff09; 2.4概念小结 3.并发、并行、串行 3.1并发 3.2并行 3.3串行 3.4概念小结 4.CPU核心数和线程数的关系 5.上下文…
阅读更多...
直线模组有哪些配件组成的？

直线模组有哪些配件组成的？

直线模组又称线性模组或线性滑台&#xff0c;是自动化设备中重要的传动元件&#xff0c;主要由以下几部分组成&#xff1a; 1、直线导轨&#xff1a;直线导轨又称线性滑轨&#xff0c;是用于直线往复运动场合的重要零部件&#xff0c;它具有比直线轴承更高的额定负载&#xff0…
阅读更多...
SpringBoot面试题3：Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

SpringBoot面试题3：Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

该文章专注于面试，面试只要回答关键点即可，不需要对框架有非常深入的回答，如果你想应付面试，是足够了，抓住关键点 面试官：Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？ Spring Boot 的核心注解是 @SpringBootApplication。 @SpringBootApplication 是一…
阅读更多...
IDEA2023.1版本新建Web项目并配置本地Tomcat

IDEA2023.1版本新建Web项目并配置本地Tomcat

IDEA2023.1版本新建Web项目并配置本地Tomcat 一、新建Web项目 一、新建Web项目 由于我最初是新建了一个空项目作为工作空间的&#xff0c;所以这里选择直接新建module&#xff0c;如下所示。&#xff08;这里使用的是idea的newUI&#xff09; 新建module&#xff0c;输入信息…
阅读更多...
waf、yakit和ssh免密登录

waf、yakit和ssh免密登录

WAF安全狗 脏数据适用于所有漏洞绕过waf&#xff0c;但是前提条件垃圾信息必须放在危险信息前&#xff0c;是不能打断原有数据包的结构&#xff0c;不能影响后端对数据包的解析。 以DVWA靶场文件上传为例 新建php文件 上传文件被安全狗拦截 使用bp抓包查看 在数据包Content-…
阅读更多...
基于Java的农资采购销售管理系统设计与实现(源码+lw+部署文档+讲解等)

基于Java的农资采购销售管理系统设计与实现(源码+lw+部署文档+讲解等)

文章目录 前言具体实现截图论文参考详细视频演示为什么选择我自己的网站自己的小程序&#xff08;小蔡coding&#xff09; 代码参考数据库参考源码获取 前言 &#x1f497;博主介绍&#xff1a;✌全网粉丝10W,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作者&am…
阅读更多...
MySQL高可用架构学习

MySQL高可用架构学习

MHA&#xff08;Master HA&#xff09;是一款开源的由Perl语言开发的MySQL高可用架构方案。它为MySQL 主从复制架构提供了 automating master failover 功能。MHA在监控到 master 节点故障时&#xff0c;会提升其中拥有最新数据的 slave 节点成为新的 master 节点&#xff0c;在…
阅读更多...
Apache DolphinScheduler 3.0.0 升级到 3.1.8 教程

Apache DolphinScheduler 3.0.0 升级到 3.1.8 教程

安装部署可参考官网 Version 3.1.8/部署指南/伪集群部署(Pseudo-Cluster)https://dolphinscheduler.apache.org/zh-cn/docs/3.1.8/guide/installation/pseudo-cluster 也可以参考我写贴子 DolphinScheduler 3.0安装及使用-CSDN博客DolphinScheduler 3.0版本的安装教程https:…
阅读更多...
springboot+html实现密码重置功能

springboot+html实现密码重置功能

目录 登录注册&#xff1a; 前端&#xff1a; chnangePssword.html 后端&#xff1a; controller: Mapper层&#xff1a; 逻辑&#xff1a; 登录注册&#xff1a; https://blog.csdn.net/m0_67930426/article/details/133849132 前端&#xff1a; 通过点击忘记密码跳转…
阅读更多...
OpenCV Series : TI - DSP - CCS

OpenCV Series : TI - DSP - CCS

Code Composer Studio V5.5 https://www.ti.com/tool/download/CCSTUDIO https://www.ti.com/tool/download/CCSTUDIO/5.5.0.00077
阅读更多...
边写代码边学习之mlflow

边写代码边学习之mlflow

1. 简介 MLflow 是一个多功能、可扩展的开源平台&#xff0c;用于管理整个机器学习生命周期的工作流程和工件。 它与许多流行的 ML 库内置集成&#xff0c;但可以与任何库、算法或部署工具一起使用。 它被设计为可扩展的&#xff0c;因此您可以编写插件来支持新的工作流程、库和…
阅读更多...
设计模式：单例模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

设计模式：单例模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

大家好&#xff01;本节主要介绍设计模式中的单例模式。 简介&#xff1a; 单例模式&#xff0c;它是一种常用的软件设计模式&#xff0c;它属于创建类型。单例模式的主要目的是确保一个类仅有一个实例&#xff0c;并提供一个全局访问点。 在单例模式中&#xff0c;一个类只有…
阅读更多...
世界国家/地区行驶方向数据

世界国家/地区行驶方向数据

Part1数据背景 道路通行方向规则是交通规则的重要部分之一。不同国家及地区通行方向并不一样&#xff0c;受风俗、习惯、风潮因素等影响。 最近也在学道路行驶&#xff0c;结果差强人意&#xff0c;继续努力吧。祝学车的小伙伴们一次过~ Part2数据详情 今天分享的国家/地区行…
阅读更多...
C语言——二周目——输入输出辨析

C语言——二周目——输入输出辨析

一、对输入输出的理解 1.明确输入的意义 以往的输入为默认形式&#xff08;标准输入流——stdin——键盘&#xff09;。但是输入的形式不止此一种。可以从键盘上敲出输入的数据&#xff0c;同时也可以将文件中、某个字符串甚至结构体的数据作为输入内容进行输入。 输入&#x…
阅读更多...
Required MultipartFile parameter ‘file‘ is not present

Required MultipartFile parameter ‘file‘ is not present

出现这个原因我们首先想到的是加一个RequestParam("file")&#xff0c;但是还有可能的原因是因为我们的名字有错误 <span class"input-group-addon must">模板上传 </span> <input id"uploadFileUpdate" name"importFileU…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023