本项目所有代码可见：https://github.com/weiyu-zeng/SimpleRPC
前言
序列化（Serialization）是一种将对象的状态信息转换为可以存储或传输的格式的过程。在序列化过程中，对象的所有必要数据（包括其属性值和可能包含的其他对象）被转化为一种字节流或文本格式。
序列化是为了方便数据的持久化，保存到磁盘或数据库中，或在网络上传输对象。通过序列化，复杂的对象结构可以被压缩成一种便于传输或存储的形式，然后再在需要的时候通过反序列化过程恢复成原始的对象状态。
本次改进主要针对序列化的方式进行改进。之前一直在使用java自带的序列化方式，或者是netty的序列化方式，性能不高。
这个版本我们定义自己的序列化方式。
实现
项目创建
创建一个名为simpleRPC-05的 module
创建名为com.rpc的包
依赖配置
我们需要新加入一个fastjson依赖：
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>SimpleRPC</artifactId>
<groupId>org.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>simpleRPC-05</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.51.Final</version>
</dependency>
<!-- fastjson序列化框架 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.67</version>
</dependency>
</dependencies>
</project>
common
我们需要修改 RPCResponse.java 来适应新的序列化方式：
RPCResponse.java
package com.rpc.common;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
/**
* 服务器端回应
*
*/
@Data
@Builder
@AllArgsConstructor
public class RPCResponse implements Serializable {
private int code;
private String message;
// 更新,这里我们需要加入这个，不然用其它序列化方式（除了java Serialize）得不到data的type
private Class<?> dataType;
private Object data;
public static RPCResponse success(Object data) {
return RPCResponse.builder().code(200).data(data).dataType(data.getClass()).build();
}
public static RPCResponse fail() {
return RPCResponse.builder().code(500).message("服务器发生错误").build();
}
}
RPCRequest.java 跟原来一样
package com.rpc.common;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
/**
* 客户端请求的抽象（接口名，方法名，参数，参数类型）
*/
@Data
@Builder
@AllArgsConstructor
public class RPCRequest implements Serializable {
// 服务类名，客户端只知道接口名，在服务端中用接口名指向实现类
private String interfaceName;
// 方法名
private String methodName;
// 参数列表
private Object[] params;
// 参数类型
private Class<?>[] paramsTypes;
}
Blog.java
package com.rpc.common;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Blog implements Serializable {
private Integer id;
private Integer useId;
private String title;
}
User.java
定义简单User信息
package com.rpc.common;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @author weiyu_zeng
*
* 定义简单User信息
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
// 客户端和服务端共有的，模拟RPC中传输的信息
private Integer id;
private String userName;
private Boolean sex;
}
service
ServiceProvider.java
服务提供方
package com.rpc.server;
import java.util.HashMap;
import java.util.Map;
/**
* @author zwy
*/
public class ServiceProvider {
/**
* 一个实现类可能实现多个接口
*/
private Map<String, Object> interfaceProvider;
// 构造函数，初始化一个空的 hashmap 赋给 Map<String, Object> interfaceProvider
public ServiceProvider() {
this.interfaceProvider = new HashMap<>();
}
public void provideServiceInterface(Object service) {
// 反射，.getClass().getInterfaces()得到class的interface，按照interfaces name(key)和object(value)存入map
Class<?>[] interfaces = service.getClass().getInterfaces();
for (Class clazz : interfaces) {
interfaceProvider.put(clazz.getName(), service);
}
}
public Object getService(String interfaceName) {
return interfaceProvider.get(interfaceName); // 通过interface name得到object
}
}
UserService.java
package com.rpc.server;
import com.rpc.common.User;
/**
* @author zwy
*
* 服务器端提供服务的方法的接口
*/
public interface UserService {
// 客户端通过这个接口调用服务端的实现类
User getUserByUserId(Integer id);
// 给这个服务增加一个功能
Integer insertUserId(User user);
}
UserServiceImpl.java
package com.rpc.server;
import com.rpc.common.User;
/**
* @author zwy
*
* 服务器端提供服务的方法
*/
public class UserServiceImpl implements UserService {
@Override
public User getUserByUserId(Integer id) {
// 模拟从数据库中取用户的行为
User user = User.builder()
.id(id)
.userName("he2121")
.sex(true).build();
System.out.println("客户端查询了" + id + "的用户");
return user;
}
@Override
public Integer insertUserId(User user) {
System.out.println("插入数据成功: " + user);
return 1;
}
}
BlogService.java
package com.rpc.server;
import com.rpc.common.Blog;
public interface BlogService {
Blog getBlogById(Integer id);
}
BlogServiceImpl.java
package com.rpc.server;
import com.rpc.common.Blog;
public class BlogServiceImpl implements BlogService {
@Override
public Blog getBlogById(Integer id) {
Blog blog = Blog.builder()
.id(id)
.title("我的博客")
.useId(22).build();
System.out.println("客户端查询了" + id + "博客");
return blog;
}
}
codec
序列化通常涉及这些步骤：
- 选择要序列化的对象：确定哪些对象需要被转化为字节流。
- 转换对象状态：使用特定的序列化算法或库将对象的属性和嵌套对象转化为字节流或文本格式。
- 保存或传输序列化数据：将序列化后的数据写入文件、数据库、网络连接等目标位置。
- 反序列化：当需要恢复对象时，从存储或接收到的数据中读取字节流，并使用相应的反序列化过程将其还原为原始的对象结构。
我们定义序列化接口：
Serializer.java
我们把对象序列化成字节数组，从字节数组反序列化成消息, 使用java自带序列化方式不用messageType也能得到相应的对象（序列化字节数组里包含类信息），其它方式需指定消息格式，再根据message转化成相应的对象
package com.rpc.codec;
public interface Serializer {
// 把对象序列化成字节数组
byte[] serialize(Object obj);
// 从字节数组反序列化成消息, 使用java自带序列化方式不用messageType也能得到相应的对象（序列化字节数组里包含类信息）
// 其它方式需指定消息格式，再根据message转化成相应的对象
Object deserialize(byte[] bytes, int messageType);
// 返回使用的序列器，是哪个
// 0：java自带序列化方式, 1: json序列化方式
int getType();
// 根据序号取出序列化器，暂时有两种实现方式，需要其它方式，实现这个接口即可
static Serializer getSerializerByCode(int code){
switch (code){
case 0:
return new ObjectSerializer();
case 1:
return new JsonSerializer();
default:
return null;
}
}
}
定义序列化类
ObjectSerializer.java
package com.rpc.codec;
import java.io.*;
public class ObjectSerializer implements Serializer {
// 利用java IO 对象 -> 字节数组
@Override
public byte[] serialize(Object obj) {
byte[] bytes = null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
oos.flush();
bytes = bos.toByteArray();
oos.close();
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
return bytes;
}
// 字节数组 -> 对象
@Override
public Object deserialize(byte[] bytes, int messageType) {
Object obj = null;
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
try {
ObjectInputStream ois = new ObjectInputStream(bis);
obj = ois.readObject();
ois.close();
bis.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return obj;
}
// 0 代表java原生序列化器
@Override
public int getType() {
return 0;
}
}
JsonSerializer.java
由于json序列化的方式是通过把对象转化成字符串，丢失了Data对象的类信息，所以deserialize需要了解对象对象的类信息，根据类信息把JsonObject -> 对应的对象
package com.rpc.codec;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.rpc.common.RPCRequest;
import com.rpc.common.RPCResponse;
/**
* 由于json序列化的方式是通过把对象转化成字符串，丢失了Data对象的类信息，所以deserialize需要
* 了解对象对象的类信息，根据类信息把JsonObject -> 对应的对象
*/
public class JsonSerializer implements Serializer{
// 序列化底层是FASTJSON把对象转化为字节流（byte数组）
@Override
public byte[] serialize(Object obj) {
byte[] bytes = JSONObject.toJSONBytes(obj);
return bytes;
}
// 反序列化
@Override
public Object deserialize(byte[] bytes, int messageType) {
Object obj = null;
// 传输的消息分为request与response
switch (messageType){
case 0: // 如果是request
RPCRequest request = JSON.parseObject(bytes, RPCRequest.class);
// 修bug 参数为空 直接返回
if(request.getParams() == null) return request;
Object[] objects = new Object[request.getParams().length];
// 把json字串转化成对应的对象， fastjson可以读出基本数据类型，不用转化
for(int i = 0; i < objects.length; i++){
Class<?> paramsType = request.getParamsTypes()[i];
if (!paramsType.isAssignableFrom(request.getParams()[i].getClass())){
objects[i] = JSONObject.toJavaObject((JSONObject) request.getParams()[i],request.getParamsTypes()[i]);
}else{
objects[i] = request.getParams()[i];
}
}
request.setParams(objects);
obj = request;
break;
case 1: // 如果是response
RPCResponse response = JSON.parseObject(bytes, RPCResponse.class);
Class<?> dataType = response.getDataType();
if(! dataType.isAssignableFrom(response.getData().getClass())){
response.setData(JSONObject.toJavaObject((JSONObject) response.getData(),dataType));
}
obj = response;
break;
default:
System.out.println("暂时不支持此种消息");
throw new RuntimeException();
}
return obj;
}
// 1 代表着json序列化方式
@Override
public int getType() {
return 1;
}
}
MessageType.java
package com.rpc.codec;
import lombok.AllArgsConstructor;
@AllArgsConstructor
public enum MessageType {
REQUEST(0),RESPONSE(1);
private int code;
public int getCode() {
return code;
}
}
MyEncode.java
依次按照自定义的消息格式写入，传入的数据为request或者response需要持有一个serialize器，负责将传入的对象序列化成字节数组
package com.rpc.codec;
import com.rpc.common.RPCRequest;
import com.rpc.common.RPCResponse;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import lombok.AllArgsConstructor;
/**
* 自己的编码器
*
* 依次按照自定义的消息格式写入，传入的数据为request或者response
* 需要持有一个serialize器，负责将传入的对象序列化成字节数组
*/
@AllArgsConstructor
public class MyEncode extends MessageToByteEncoder {
private Serializer serializer;
@Override
protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception {
// 写入消息类型
if(msg instanceof RPCRequest){
out.writeShort(MessageType.REQUEST.getCode());
}
else if(msg instanceof RPCResponse){
out.writeShort(MessageType.RESPONSE.getCode());
}
// 写入序列化方式
out.writeShort(serializer.getType());
// 得到序列化数组
byte[] serialize = serializer.serialize(msg);
// 写入长度
out.writeInt(serialize.length);
// 写入序列化字节数组
out.writeBytes(serialize);
}
}
MyDecode.java
按照自定义的消息格式解码数据
package com.rpc.codec;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import lombok.AllArgsConstructor;
import java.util.List;
/**
* 按照自定义的消息格式解码数据
*/
@AllArgsConstructor
public class MyDecode extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
// 1. 读取消息类型
short messageType = in.readShort();
// 现在还只支持request与response请求
if(messageType != MessageType.REQUEST.getCode() &&
messageType != MessageType.RESPONSE.getCode()){
System.out.println("暂不支持此种数据");
return;
}
// 2. 读取序列化的类型
short serializerType = in.readShort();
// 根据类型得到相应的序列化器
Serializer serializer = Serializer.getSerializerByCode(serializerType);
if (serializer == null) throw new RuntimeException("不存在对应的序列化器");
// 3. 读取数据序列化后的字节长度
int length = in.readInt();
// 4. 读取序列化数组
byte[] bytes = new byte[length];
in.readBytes(bytes);
// 用对应的序列化器解码字节数组
Object deserialize = serializer.deserialize(bytes, messageType);
out.add(deserialize);
}
}
- 读取消息类型
- 读取序列化的类型，根据类型得到相应的序列化器
- 读取数据序列化后的字节长度
- 读取序列化数组，用对应的序列化器解码字节数组
client
客户端部分和simpleRPC-04基本一样，但是NettyClientHandler.java 需要修改一下：
NettyClientInitializer.java
package com.rpc.client;
import com.rpc.codec.JsonSerializer;
import com.rpc.codec.MyDecode;
import com.rpc.codec.MyEncode;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.serialization.ClassResolver;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
/**
* @author weiyu_zeng
*
* 同样的与服务端解码和编码格式
*/
public class NettyClientInitializer extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// 使用自定义的编解码器
pipeline.addLast(new MyDecode());
// 编码需要传入序列化器，这里是json，还支持ObjectSerializer，也可以自己实现其他的
pipeline.addLast(new MyEncode(new JsonSerializer()));
pipeline.addLast(new NettyClientHandler());
}
}
其他部分都一样。
server
server部分和simpleRPC-04基本一样，同样的，NettyServerInitializer.java需要修改一下：
NettyServerInitializer.java
package com.rpc.server;
import com.rpc.codec.JsonSerializer;
import com.rpc.codec.MyDecode;
import com.rpc.codec.MyEncode;
import com.rpc.service.ServiceProvider;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.serialization.ClassResolver;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import lombok.AllArgsConstructor;
/**
* @author zwy
*/
@AllArgsConstructor
public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {
private ServiceProvider serviceProvider;
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// 使用自定义的解码器
pipeline.addLast(new MyDecode());
// 使用自定义的编码器，而且解码器需要传入序列化器，这里是json，还支持ObjectSerializer，也可以自己实现其他的
pipeline.addLast(new MyEncode(new JsonSerializer()));
pipeline.addLast(new NettyRPCServerHandler(serviceProvider));
}
}
这里我们使用自定义的解码器，而且解码器需要传入序列化器，这里是json，还支持ObjectSerializer，也可以自己实现其他的
其他部分一样。
文件结构
simpleRPC-05文件结构如下：
运行
运行TestServer.java
再运行TestClient.java
运行成功！
扫一扫
412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
