Netty中序列化的作用及自定義協(xié)議詳解

更新時間：2023年12月21日 10:10:31 作者：Colins~

這篇文章主要介紹了Netty中序列化的作用及自定義協(xié)議詳解,Netty自身就支持很多種協(xié)議比如Http、Websocket等等,但如果用來作為自己的RPC框架通常會自定義協(xié)議,所以這也是本文的重點,需要的朋友可以參考下

前言

上一章已經說了怎么解決沾包和拆包的問題，但是這樣離一個成熟的通信還是有一點距離，我們還需要讓服務端和客戶端使用同一個"語言"來溝通，要不然一個講英文一個講中文，兩個都聽不懂豈不是很尷尬？這種語言就叫協(xié)議。

Netty自身就支持很多種協(xié)議比如Http、Websocket等等，但如果用來作為自己的RPC框架通常會自定義協(xié)議，所以這也是本文的重點！

序列化的重要性

在說協(xié)議之前，我們需要先知道什么是序列化，序列化是干嘛的？

我們要知道數據在傳輸的過程中是以0和1的形式傳輸的，而把對象轉化成二進制的過程就叫序列化，將二進制轉化為對象的過程就叫反序列化。

為什么要說這個很重要呢？因為序列化和反序列化是需要耗時的，而序列化后的字節(jié)大小也會影響到傳輸的效率，所以選對一種高效的序列化方式是非常之重要的，下面我們以JDK自帶的序列化和我們常用的JSON序列化來做一個對比，序列化后大小的對比、序列化效率的對比

大小對比

我們先準備一個實體類SerializeTestVO實現(xiàn)Serializable 接口

public class SerializeTestVO implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    private Integer sex;
    private Integer bodyWeight;
    private Integer height;
    private String school;
    //Set、get方法省略
}

測試方法：

public static void main(String[] args) throws IOException {
        // 普普通通的實體類
        SerializeTestVO serializeTestVO = new SerializeTestVO();
        serializeTestVO.setAge(18);
        serializeTestVO.setBodyWeight(120);
        serializeTestVO.setHeight(180);
        serializeTestVO.setId(10000);
        serializeTestVO.setName("張三");
        serializeTestVO.setSchool("XXXXXXXXXXXX");
        // JDK序列化
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(serializeTestVO);
        objectOutputStream.flush();
        objectOutputStream.close();
        System.out.println("JDK 序列化大小: "+(byteArrayOutputStream.toByteArray().length));
        byteArrayOutputStream.close();
        //JSON序列化
        System.out.println("JSON 序列化大小: " + JSON.toJSONString(serializeTestVO).getBytes().length);
}

結果：

在這里插入圖片描述

可以看到序列化后大小相差了好幾倍，這也意味著傳輸效率的幾倍

效率對比

實體類保持不變，我們序列化300W次，看看結果

public static void main(String[] args) throws IOException {
        SerializeTestVO serializeTestVO = new SerializeTestVO();
        serializeTestVO.setAge(18);
        serializeTestVO.setBodyWeight(120);
        serializeTestVO.setHeight(180);
        serializeTestVO.setId(10000);
        serializeTestVO.setName("張三");
        serializeTestVO.setSchool("XXXXXXXXXXXX");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 3000000; i++) {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(serializeTestVO);
            objectOutputStream.flush();
            objectOutputStream.close();
            byte[] bytes = byteArrayOutputStream.toByteArray();
            byteArrayOutputStream.close();
        }
        System.out.println("JDK 序列化耗時： " + (System.currentTimeMillis() - start));
        long start1 = System.currentTimeMillis();
        for (int i = 0; i < 3000000; i++) {
            byte[] bytes = JSON.toJSONString(serializeTestVO).getBytes();
        }
        System.out.println("JSON 序列化耗時： " + (System.currentTimeMillis() - start1));
    }

結果：

在這里插入圖片描述

幾乎6倍的差距，結合序列化后的大小綜合來看，選擇一種好的序列化方式是多么的重要

自定義協(xié)議

其實到現(xiàn)在我們已經掌握了自定義協(xié)議里面最關鍵的幾個點了，序列化、數據結構、編解碼器，我們一個一個來

序列化

直接采用我們常用且熟悉的JSON序列化

數據結構

我們設置為消息頭和消息體，結構如下：

在這里插入圖片描述

消息頭包含：開始標志、時間戳、消息體長度

消息體包含：通信憑證、消息ID、消息類型、消息

實體類如下：

@Data
public class NettyMsg {
    private NettyMsgHead msgHead=new NettyMsgHead();
    private NettyBody nettyBody;
    public NettyMsg(ServiceCodeEnum codeEnum, Object msg){
        this.nettyBody=new NettyBody(codeEnum, msg);
    }
}
@Data
public class NettyMsgHead {
    // 開始標識
    private short startSign = (short) 0xFFFF;
    // 時間戳
    private final int timeStamp;
    public NettyMsgHead(){
        this.timeStamp=(int)(DateUtil.current() / 1000);
    }
}
@Data
public class NettyBody {
    // 通信憑證
    private String token;
    // 消息ID
    private String msgId;
    // 消息類型
    private short msgType;
    // 消息 這里序列化采用JSON序列化
    // 所以這個msg可以是實體類的msg 兩端通過消息類型來判斷實體類類型
    private String msg;
    public NettyBody(){
    }
    public NettyBody(ServiceCodeEnum codeEnum,Object msg){
        this.token=""; // 鑒權使用
        this.msgId=""; // 拓展使用
        this.msgType=codeEnum.getCode();
        this.msg= JSON.toJSONString(msg);
    }
}

消息類型枚舉

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum ServiceCodeEnum {
    TEST_TYPE((short) 0xFFF1, "測試");


    private final short code;
    private final String desc;

    ServiceCodeEnum(short code, String desc) {
        this.code = code;
        this.desc = desc;
    }
    
    public short getCode() {
        return code;
    }

}

自定義編碼器

編碼器的作用就是固定好我們的數據格式，無需在每次發(fā)送數據的時候還需要去對數據進行格式編碼

public class MyNettyEncoder extends MessageToByteEncoder<NettyMsg> {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, NettyMsg msg, ByteBuf out) throws Exception {
        // 寫入開頭的標志
        out.writeShort(msg.getMsgHead().getStartSign());
        // 寫入秒時間戳
        out.writeInt(msg.getMsgHead().getTimeStamp());
        byte[] bytes = JSON.toJSON(msg.getNettyBody()).toString().getBytes();
        // 寫入消息長度
        out.writeInt(bytes.length);
        // 寫入消息主體
        out.writeBytes(bytes);
    }
}

自定義解碼器

解碼器的第一個作用就是解決沾包和拆包的問題，第二個作用就是對數據有效性的校驗，比如數據協(xié)議是否匹配、數據是否被篡改、數據加解密等等

所以我們直接繼承LengthFieldBasedFrameDecoder類，重寫decode方法，利用父類來解決沾包和拆包問題，自定義來解決數據有效性問題

public class MyNettyDecoder extends LengthFieldBasedFrameDecoder {
    // 開始標記
    private final short HEAD_START = (short) 0xFFFF;
    public MyNettyDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) {
        super(maxFrameLength, lengthFieldOffset, lengthFieldLength);
    }
    public MyNettyDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment, int initialBytesToStrip) {
        super(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip);
    }
    public MyNettyDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment, int initialBytesToStrip, boolean failFast) {
        super(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip, failFast);
    }
    public MyNettyDecoder(ByteOrder byteOrder, int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment, int initialBytesToStrip, boolean failFast) {
        super(byteOrder, maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip, failFast);
    }
    @Override
    protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        // 經過父解碼器的處理 我們就不需要在考慮沾包和半包了
        // 當然，想要自己處理沾包和半包問題也不是不可以
        ByteBuf decode = (ByteBuf) super.decode(ctx, in);
        if (decode == null) {
            return null;
        }
        // 開始標志校驗  開始標志不匹配直接 過濾此條消息
        short startIndex = decode.readShort();
        if (startIndex != HEAD_START) {
            return null;
        }
        // 時間戳
        int timeIndex = decode.readInt();
        // 消息體長度
        int lenOfBody = decode.readInt();
        // 讀取消息
        byte[] msgByte = new byte[lenOfBody];
        decode.readBytes(msgByte);
        String msgContent = new String(msgByte);
        // 將消息轉成實體類 傳遞給下面的數據處理器
        return JSON.parseObject(msgContent, NettyBody.class);
    }
}