基于Netty和SpringBoot实现一个轻量级RPC框架-协议篇

最近对网络编程方面比较有兴趣，在微服务实践上也用到了相对主流的RPC框架如Spring Cloud Gateway底层也切换为Reactor-Netty，像Redisson底层也是使用Netty封装通讯协议，最近调研和准备使用的SOFARpc也是基于Netty封装实现了多种协议的兼容。因此，基于Netty造一个轮子，在SpringBoot的加持下，实现一个轻量级的RPC框架。这篇博文介绍的是RPC框架协议的定义以及对应的编码解码处理的实现。

截止本文（2020-01-12）编写完成之时，Netty的最新版本为4.1.44.Final，而SpringBoot的最新版本为2.2.2.RELEASE，因此引入这两个版本的依赖，加上其他工具包和序列化等等的支持，pom文件的核心内容如下：

    
        
            
                org.springframework.boot
                spring-boot-dependencies
                ${spring.boot.version}
                pom
                import
            
        
    
    
        
            org.springframework.boot
            spring-boot-starter
        
        
            io.netty
            netty-all
            ${netty.version}
        
        
            org.projectlombok
            lombok
            1.18.10
            provided
        
        
            com.alibaba
            fastjson
            1.2.61
        
        
            com.google.guava
            guava
            28.1-jre
        
    

部分参数的序列化会依赖到FastJson或者Jackson，具体看偏好而定。

为了提高协议传输的效率，需要定制一套高效的RPC协议，设计协议所需的字段和类型。

基础Packet字段：

// 消息枚举类型
@RequiredArgsConstructor
public enum MessageType {

    
    REQUEST((byte) 1),

    
    RESPONSE((byte) 2),

    
    PING((byte) 3),

    
    PONG((byte) 4),

    
    NULL((byte) 5),

    ;

    @Getter
    private final Byte type;

    public static MessageType fromValue(byte value) {
        for (MessageType type : MessageType.values()) {
            if (type.getType() == value) {
                return type;
            }
        }
        throw new IllegalArgumentException(String.format("value = %s", value));
    }
}

// 基础Packet
@Data
public abstract class BaseMessagePacket implements Serializable {

    
    private int magicNumber;

    
    private int version;

    
    private String serialNumber;

    
    private MessageType messageType;

    
    private Map attachments = new HashMap<>();

    
    public void addAttachment(String key, String value) {
        attachments.put(key, value);
    }
}

请求Packet扩展字段：

@EqualsAndHashCode(callSuper = true)
@Data
public class RequestMessagePacket extends BaseMessagePacket {

    
    private String interfaceName;

    
    private String methodName;

    
    private String[] methodArgumentSignatures;

    
    private Object[] methodArguments;
}

响应Packet扩展字段：

@EqualsAndHashCode(callSuper = true)
@Data
public class ResponseMessagePacket extends BaseMessagePacket {

    
    private Long errorCode;

    
    private String message;

    
    private Object payload;
}

需要注意以下几点：

• 非基本类型在序列化和反序列化的时候，一定注意要先写入或者先读取序列的长度，以java.lang.String类型为例：

// 序列化 - 流水号
out.writeInt(packet.getSerialNumber().length());
out.writeCharSequence(packet.getSerialNumber(), ProtocolConstant.UTF_8);

// 反序列化 - 流水号
int serialNumberLength = in.readInt();
packet.setSerialNumber(in.readCharSequence(serialNumberLength, ProtocolConstant.UTF_8).toString());

• 特殊编码的字符串在序列化的时候，要注意字符串编码的长度，例如UTF-8编码下一个中文字符占3个字节，这一点可以抽取一个工具类专门处理字符串的序列化：

public enum ByteBufferUtils {

    // 单例
    X;

    public void encodeUtf8CharSequence(ByteBuf byteBuf, CharSequence charSequence) {
        int writerIndex = byteBuf.writerIndex();
        byteBuf.writeInt(0);
        int length = ByteBufUtil.writeUtf8(byteBuf, charSequence);
        byteBuf.setInt(writerIndex, length);
    }
}

• 方法参数数组的序列化和反序列化方案需要定制，笔者为了简化自定义协议，定义了方法参数签名数组，长度和方法参数数组一致，这样做方便后面编写服务端代码的时候，简化对方法参数数组进行反序列化以及宿主类目标方法的查找。注意一下Object[]的序列化和反序列化相对特殊，因为ByteBuf无法处理自定义类型的写入和读取（这个很好理解，网络编程就是面向0和1的编程）：

write Object --> ByteBuf#writeInt() && ByteBuf#writeBytes()

read Object --> ByteBuf#readInt() && ByteBuf#readBytes() [<== 这个方法返回值是ByteBuf实例]

• 最后注意释放ByteBuf的引用，否则有可能导致内存泄漏。

自定义协议编码解码主要包括四个部分的编码解码器：

• 请求Packet编码器：RequestMessagePacketEncoder，主要用于客户端把RequestMessagePacket实例序列化为二进制序列。
• 请求Packet解码器：RequestMessagePacketDecoder，主要用于服务端把二进制序列反序列化为RequestMessagePacket实例。
• 响应Packet编码器：ResponseMessagePacketEncoder，主要用于服务端把ResponseMessagePacket实例序列化为二进制序列。
• 响应Packet解码器：ResponseMessagePacketDecoder，主要用于客户端把二进制序列反序列化为ResponseMessagePacket实例。

画个图描述一下几个组件的交互流程（省略了部分入站和出站处理器）：

序列化器Serializer的代码如下：

public interface Serializer {

    byte[] encode(Object target);

    Object decode(byte[] bytes, Class targetClass);
}

// FastJson实现
public enum FastJsonSerializer implements Serializer {

    // 单例
    X;

    @Override
    public byte[] encode(Object target) {
        return JSON.toJSONBytes(target);
    }

    @Override
    public Object decode(byte[] bytes, Class targetClass) {
        return JSON.parseObject(bytes, targetClass);
    }
}

请求Packet编码器RequestMessagePacketEncoder的代码如下：

@RequiredArgsConstructor
public class RequestMessagePacketEncoder extends MessageToByteEncoder {

    private final Serializer serializer;

    @Override
    protected void encode(ChannelHandlerContext context, RequestMessagePacket packet, ByteBuf out) throws Exception {
        // 魔数
        out.writeInt(packet.getMagicNumber());
        // 版本
        out.writeInt(packet.getVersion());
        // 流水号
        out.writeInt(packet.getSerialNumber().length());
        out.writeCharSequence(packet.getSerialNumber(), ProtocolConstant.UTF_8);
        // 消息类型
        out.writeByte(packet.getMessageType().getType());
        // 附件size
        Map attachments = packet.getAttachments();
        out.writeInt(attachments.size());
        // 附件内容
        attachments.forEach((k, v) -> {
            out.writeInt(k.length());
            out.writeCharSequence(k, ProtocolConstant.UTF_8);
            out.writeInt(v.length());
            out.writeCharSequence(v, ProtocolConstant.UTF_8);
        });
        // 接口全类名
        out.writeInt(packet.getInterfaceName().length());
        out.writeCharSequence(packet.getInterfaceName(), ProtocolConstant.UTF_8);
        // 方法名
        out.writeInt(packet.getMethodName().length());
        out.writeCharSequence(packet.getMethodName(), ProtocolConstant.UTF_8);
        // 方法参数签名(String[]类型) - 非必须
        if (null != packet.getMethodArgumentSignatures()) {
            int len = packet.getMethodArgumentSignatures().length;
            // 方法参数签名数组长度
            out.writeInt(len);
            for (int i = 0; i < len; i++) {
                String methodArgumentSignature = packet.getMethodArgumentSignatures()[i];
                out.writeInt(methodArgumentSignature.length());
                out.writeCharSequence(methodArgumentSignature, ProtocolConstant.UTF_8);
            }
        } else {
            out.writeInt(0);
        }
        // 方法参数(Object[]类型) - 非必须
        if (null != packet.getMethodArguments()) {
            int len = packet.getMethodArguments().length;
            // 方法参数数组长度
            out.writeInt(len);
            for (int i = 0; i < len; i++) {
                byte[] bytes = serializer.encode(packet.getMethodArguments()[i]);
                out.writeInt(bytes.length);
                out.writeBytes(bytes);
            }
        } else {
            out.writeInt(0);
        }
    }
}

请求Packet解码器RequestMessagePacketDecoder的代码如下：

@RequiredArgsConstructor
public class RequestMessagePacketDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext context, ByteBuf in, List