基于Netty实现高性能通信程序之传输协议编码与解码

1、协议抽象实体

package protocal.model;

import lombok.Data;

/**
 * @author liupengr
 * @date 2020/2/12 18:21
 */
@Data
public abstract class AbstractProtocalEntity {

    /**
     * 获取序列化工具由子类实现
     *
     * @return
     */
    public abstract Byte getSerializerType();

    /**
     * 获取操作指令
     * @return
     */
    public abstract Byte getCommand();

    /**
     * 协议版本号
     */
    private Byte version = 1;


}

2、业务操作实体（信息传递）

package protocal.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import serializer.service.SerializerEnum;

/**
 * 消息传输实体
 *
 * @author liupengr
 * @date 2020/2/12 18:38
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class MsgEntity extends AbstractProtocalEntity {

    /**
     * 序号:TCP 连接它是一个全双工的通道，同时进行数据的双向收发,此时就需要序号来使请求和响应对应
     */
    private Integer num;

    /**
     * 会话ID
     */
    private Integer session;

    /**
     * 用户ID
     */
    private Integer userId;

    /**
     * 内容
     */
    private String content;

    /**
     * 得到当前传输实体的编码格式
     *
     * @return
     */
    @Override
    public Byte getSerializerType() {
        return SerializerEnum.PROTOSTUFF.getCode().byteValue();
    }

    /**
     * 获取当前传输实体的操作标识
     *
     * @return
     */
    @Override
    public Byte getCommand() {
        return Contrast.Msg;
    }

}

3、常量类

package protocal.model;

import java.util.HashMap;

/**
 * 
 * @author liupengr
 * @date 2020/2/12 18:41
 */
public class Contrast {

    public static final HashMap<Byte, Class> commondMap;
    public static final byte Msg = 1;

    static {
        commondMap = new HashMap<>();
        commondMap.put(Msg, MsgEntity.class);
    }


}

4、解码与编码

package protocal;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import protocal.model.AbstractProtocalEntity;
import protocal.model.Contrast;
import serializer.impl.SerializerFactory;
import serializer.service.Serializer;
import serializer.service.SerializerEnum;

/**
 * <br/>
 * 通信协议
 * 魔数0x12345678(4字节)|版本号(1字节)|序列化算法(1字节)|指令(1字节)|数据长度(4字节)|数据(N字节)
 *
 * @author liupengr
 * @date 2020/2/12 18:49
 */
public class protocalProcess {

    private static final int MAGIC_NUMBER = 0x12345678;

    public ByteBuf encode(AbstractProtocalEntity entity) {
        // 1. 创建 ByteBuf 对象
        ByteBuf byteBuf = ByteBufAllocator.DEFAULT.ioBuffer();
        // 2. 序列化 Java 对象
        byte[] bytes = getSerializer(entity.getSerializerType()).serialize(entity);
        // 3. 实际编码过程
        byteBuf.writeInt(MAGIC_NUMBER);
        byteBuf.writeByte(entity.getVersion());
        byteBuf.writeByte(entity.getSerializerType());
        byteBuf.writeByte(entity.getCommand());
        byteBuf.writeInt(bytes.length);
        byteBuf.writeBytes(bytes);

        return byteBuf;
    }

    public AbstractProtocalEntity decode(ByteBuf byteBuf) {
        // 跳过 magic number
        byteBuf.skipBytes(4);
        // 跳过版本号
        byteBuf.skipBytes(1);
        // 序列化算法标识
        byte serializeType = byteBuf.readByte();
        // 指令
        byte command = byteBuf.readByte();
        // 数据包长度
        int length = byteBuf.readInt();
        byte[] bytes = new byte[length];
        byteBuf.readBytes(bytes);
        Class<? extends AbstractProtocalEntity> requestType = Contrast.commondMap.get(command);
        Serializer serializer = getSerializer(serializeType);
        if (requestType != null && serializer != null) {
            return serializer.deserialize(requestType, bytes);
        }

        return null;
    }

    private Serializer getSerializer(Byte type) {
        return SerializerFactory.getSerializerInstance(SerializerEnum.valueOf(type));
    }
}