基于Netty实现高性能通信程序之序列化与反序列化

1、序列化接口

package serializer.service;

/**
 * 序列化接口
 *
 * @author liupengr
 * @date 2020/2/12 18:17
 */
public interface Serializer {

    /**
     * 获取当前序列化类型
     *
     * @return
     */
    SerializerEnum getSerializerType();

    /**
     * java对象转换成二进制
     */
    byte[] serialize(Object object);

    /**
     * 二进制转换成 java 对象
     */
    <T> T deserialize(Class<T> clazz, byte[] bytes);
}

2、序列化实现

package serializer.impl;

import com.alibaba.fastjson.JSON;
import serializer.service.Serializer;
import serializer.service.SerializerEnum;

/**
 * Json实现序列化与反序列化
 *
 * @author liupengr
 * @date 2020/2/12 18:26
 */
public class JsonSerializer implements Serializer {
    @Override
    public SerializerEnum getSerializerType() {
        return SerializerEnum.JSON;
    }

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

    @Override
    public <T> T deserialize(Class<T> clazz, byte[] bytes) {
        return JSON.parseObject(bytes, clazz);
    }
}

package serializer.impl;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import serializer.service.Serializer;
import serializer.service.SerializerEnum;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;


/**
 * kryo序列化与反序列化
 * @author liupengr
 * @date 2020/2/12 18:26
 */
public class kryoSerializer implements Serializer {

    /**
     * 由于kryo不是线程安全的，针对多线程情况下的使用，要对kryo进行一个简单的封装设计，从而可以多线程安全的使用序列化和反序列化
     */
    static final ThreadLocal<Kryo> kryoThreadLocal = ThreadLocal.withInitial(()->{
        Kryo kryo = new Kryo();
        kryo.setReferences(true);
        kryo.setRegistrationRequired(false);
        return kryo;
    });

    public static Kryo getInstance() {
        return kryoThreadLocal.get();
    }

    @Override
    public SerializerEnum getSerializerType() {
        return SerializerEnum.KRYO;
    }

    @Override
    public byte[] serialize(Object object) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        Output output = new Output(byteArrayOutputStream);
        getInstance().writeClassAndObject(output,object);
        output.flush();
        return byteArrayOutputStream.toByteArray();
    }

    @Override
    public <T> T deserialize(Class<T> clazz, byte[] bytes) {
        ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(bytes);
        Input input=new Input(byteArrayInputStream);
        return (T) getInstance().readClassAndObject(input);
    }
}

package serializer.impl;

import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
import serializer.service.Serializer;
import serializer.service.SerializerEnum;

/**
 * protoStuff 序列化与反序列化
 * @author liupengr
 * @date 2020/2/12 18:28
 */
public class ProtoStuffSerializer implements Serializer{
    @Override
    public SerializerEnum getSerializerType() {
        return SerializerEnum.PROTOSTUFF;
    }

    @Override
    public byte[] serialize(Object object) {
        //RuntimeSchema类用于在运行时从Java实体对象中生成所需的模式Schema
        Schema<Object>  scheme = (Schema<Object>) RuntimeSchema.createFrom(object.getClass());
        //LinkedBuffer是一个缓冲区类，它封装了字节数组并具有对下一个缓冲区的引用以便能动态增加容量。
        LinkedBuffer linkedBuffer=LinkedBuffer.allocate(512);
        //ProtostuffIOUtil是一个工具类，用于对消息或对象进行序列化/反序列化
        return ProtostuffIOUtil.toByteArray(object,scheme,linkedBuffer);
    }

    @Override
    public <T> T deserialize(Class<T> clazz, byte[] bytes) {
        Schema<T> schema = RuntimeSchema.getSchema(clazz);
        T t = schema.newMessage();
        ProtostuffIOUtil.mergeFrom(bytes, t, schema);
        return t;
    }
}

3、序列化工厂

package serializer.impl;

import serializer.service.Serializer;
import serializer.service.SerializerEnum;

/**
 * @author liupengr
 * @date 2020/2/12 16:08
 */
public class SerializerFactory {

    public static Serializer getSerializerInstance(SerializerEnum serializerEnum) {
        switch (serializerEnum.getCode()) {
            case 1:
                return new JsonSerializer();
            case 2:
                return new kryoSerializer();
            case 3:
                return new ProtoStuffSerializer();
            default:
                return new ProtoStuffSerializer();
        }
    }
}

4、序列化枚举

package serializer.service;

/**
 * @author liupengr
 * @date 2020/2/12 18:30
 */
public enum SerializerEnum {
    JSON(1, "Json"),
    KRYO(2, "Kryo"),
    PROTOSTUFF(3, "ProtoStuff");
    private Integer code;
    private String description;

    private SerializerEnum(Integer code, String desc) {
        this.code = code;
        this.description = desc;
    }

    public Integer getCode() {
        return code;
    }

    public String getDescription() {
        return description;
    }

    public static SerializerEnum valueOf(int code) {
        for (SerializerEnum source : values()) {
            if (source.code == code) {
                return source;
            }
        }
        return null;
    }
}