public interface Serializer {

    /**
     * 对对象进行编码
     *
     * @param obj 要编码的对象
     * @return 编码后的字节数组
     */
    byte[] serialize(Object obj);

    /**
     * 将字节数组解码为指定类型的对象
     *
     * @param bytes 要解码的字节数组
     * @param clazz 要解码成的对象的类型
     * @return 解码后得到的对象
     */
    <T> T deserialize(byte[] bytes, Class<T> clazz);

    /**
     * 获取序列化协议类型
     *
     * @return 序列化协议类型
     */
    SerializationType protocolType();

    /**
     * 序列化器实例销毁时做些什么
     */
    default void unregister() {

    }

}

@Getter
@AllArgsConstructor
public enum SerializationType {

    JDK((byte) 1),

    JSON((byte) 2),

    MSGPACK((byte) 3),

    HESSIAN((byte) 4),

    PROTOSTUFF((byte) 5),

    KRYO((byte) 6),

    ;

    private final byte code;

    public static SerializationType fromCode(byte code) {
        for (SerializationType protocolType : values()) {
            if (protocolType.code == code) {
                return protocolType;
            }
        }
        return null;
    }

}

public class SerializeException extends RuntimeException {

    /**
     * SerializeException构造函数，使用给定的消息初始化异常
     *
     * @param message 异常消息
     */
    public SerializeException(String message) {
        super(message);
    }

    /**
     * 构造一个带指定详细消息和原因的新异常。
     *
     * @param message 详细消息描述
     * @param cause   异常原因
     */
    public SerializeException(String message, Throwable cause) {
        super(message, cause);
    }
}

/**
 * INSTANCE
 */
private static volatile Serializer INSTANCE;

/**
 * 私有构造函数
 */
private JdkSerializer() {
}

/**
 * 获取序列化器实例
 * @return 返回序列化器实例
 */
public static Serializer getInstance() {
    if (INSTANCE == null) {
        synchronized (JdkSerializer.class) {
            if (INSTANCE == null) {
                INSTANCE = new JdkSerializer();
            }
        }
    }
    return INSTANCE;
}

@Override
public <T> T deserialize(byte[] bytes, Class<T> clazz) {
    try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
        return (T) ois.readObject();
    } catch (ClassNotFoundException | IOException e) {
        throw new SerializeException("jdk反序列化出现异常", e);
    }
}

@Override
public SerializationType protocolType() {
    return SerializationType.JDK;
}

@Override
public byte[] serialize(Object obj) {
    try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos)) {
        oos.writeObject(obj);
        return bos.toByteArray();
    } catch (IOException e) {
        throw new SerializeException("jdk序列化出现异常", e);
    }
}

public class HessianSerializer implements Serializer {

    /**
     * INSTANCE
     */
    private static volatile Serializer INSTANCE;

    /**
     * 构造方法
     */
    private HessianSerializer() {
    }

    /**
     * 获取序列化器实例
     *
     * @return 返回序列化器实例
     */
    public static Serializer getInstance() {
        if (INSTANCE == null) {
            synchronized (HessianSerializer.class) {
                if (INSTANCE == null) {
                    INSTANCE = new HessianSerializer();
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {
        if (bytes == null) {
            return null;
        }
        try (ByteArrayInputStream is = new ByteArrayInputStream(bytes)) {
            Hessian2Input input = new JDSafeHessian2Input(is);
            return (T) input.readObject();
        } catch (Exception e) {
            throw new SerializeException("hessian反序列化出现异常", e);
        }
    }

    @Override
    public byte[] serialize(Object obj) {
        try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
            Hessian2Output output = new Hessian2Output(os);
            output.writeObject(obj);
            output.flush();
            return os.toByteArray();
        } catch (Exception e) {
            throw new SerializeException("hessian序列化出现异常", e);
        }
    }

    @Override
    public SerializationType protocolType() {
        return SerializationType.HESSIAN;
    }

}

public class JsonSerializer implements Serializer {

    /**
     * INSTANCE
     */
    private static volatile Serializer INSTANCE;

    /**
     * 构造函数
     */
    private JsonSerializer() {
    }

    /**
     * 获取单例实例
     *
     * @return 返回单例实例
     */
    public static Serializer getInstance() {
        if (INSTANCE == null) {
            synchronized (JsonSerializer.class) {
                if (INSTANCE == null) {
                    INSTANCE = new JsonSerializer();
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {
        String json = new String(bytes, StandardCharsets.UTF_8);
        return JSON.parseObject(json, clazz);
    }

    @Override
    public byte[] serialize(Object obj) {
        if (obj == null) {
            return new byte[0];
        }
        return JSON.toJSONString(obj).getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public SerializationType protocolType() {
        return SerializationType.JSON;
    }

}

public class KryoSerializer implements Serializer {

    /**
     * INSTANCE
     */
    private static volatile KryoSerializer INSTANCE;

    private final KryoPool pool;

    /**
     * 构造函数
     */
    private KryoSerializer() {
        this.pool = new KryoPool.Builder(() -> {
            Kryo kryo = new Kryo();
            // Kryo 配置
            kryo.setReferences(false);
            kryo.setRegistrationRequired(false);
            return kryo;
        }).build();
    }

    /**
     * 获取单例实例
     *
     * @return 返回实例
     */
    public static KryoSerializer getInstance() {
        if (INSTANCE == null) {
            synchronized (KryoSerializer.class) {
                if (INSTANCE == null) {
                    INSTANCE = new KryoSerializer();
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public byte[] serialize(Object obj) {
        Kryo kryo = pool.borrow();
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            Output output = new Output(bos);
            kryo.writeObject(output, obj);
            output.close();
            return bos.toByteArray();
        } catch (IOException e) {
            throw new SerializeException("kryo序列化出现异常", e);
        } finally {
            pool.release(kryo);
        }
    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {
        Kryo kryo = pool.borrow();
        try (Input input = new Input(new ByteArrayInputStream(bytes))) {
            return kryo.readObject(input, clazz);
        } finally {
            pool.release(kryo);
        }
    }

    @Override
    public SerializationType protocolType() {
        return SerializationType.KRYO;
    }

}

public class ProtostuffSerializer implements Serializer {

    /**
     * INSTANCE
     */
    private static volatile Serializer INSTANCE;

    /**
     * 缓存Schema
     */
    private static Map<Class<?>, Schema<?>> schemaCache;

    /**
     * 构造函数
     */
    private ProtostuffSerializer() {
    }

    /**
     * 获取单例实例
     *
     * @return 返回单例实例
     */
    public static Serializer getInstance() {
        if (INSTANCE == null) {
            synchronized (ProtostuffSerializer.class) {
                if (INSTANCE == null) {
                    schemaCache = new ConcurrentHashMap<>();
                    INSTANCE = new ProtostuffSerializer();
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public byte[] serialize(Object obj) {
        // serialize
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            return ProtostuffIOUtil.toByteArray(obj, this.registerSchema(obj.getClass()), buffer);
        } finally {
            buffer.clear();
        }
    }

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

    @Override
    public SerializationType protocolType() {
        return SerializationType.PROTOSTUFF;
    }

    public Schema registerSchema(Class clazz) {
        Schema schema = schemaCache.get(clazz);
        if (schema == null) {
            // this is lazily created and cached by RuntimeSchema
            // so its safe to call RuntimeSchema.getSchema(Foo.class) over and over
            // The getSchema method is also thread-safe
            schema = RuntimeSchema.getSchema(clazz);
            schemaCache.put(clazz, schema);
        }
        return schema;
    }

    @Override
    public void unregister() {
        schemaCache.clear();
        schemaCache = null;
    }
}

public class MsgPackSerializer implements Serializer {

    private static volatile MsgPackSerializer INSTANCE;

    private static ObjectMapper objectMapper;

    private MsgPackSerializer() {
    }

    /**
     * 获取序列化器实例
     *
     * @return 返回序列化器实例
     */
    public static Serializer getInstance() {
        if (INSTANCE == null) {
            synchronized (MsgPackSerializer.class) {
                if (INSTANCE == null) {
                    objectMapper = new MessagePackMapper();
                    INSTANCE = new MsgPackSerializer();
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public byte[] serialize(Object obj) {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            objectMapper.writeValue(baos, obj);
            return baos.toByteArray();
        } catch (IOException e) {
            throw new SerializeException("msgpack序列化异常", e);
        }
    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {
        try {
            return objectMapper.readValue(bytes, clazz);
        } catch (IOException e) {
            throw new SerializeException("反序列化异常", e);
        }
    }

    @Override
    public SerializationType protocolType() {
        return SerializationType.MSGPACK;
    }

}

public class ExampleClass implements Serializable {  
    private static final long serialVersionUID = 1L;  
  
    // 静态字段，不会被序列化  
    private static String staticField = "Static Value";  
  
    // 瞬态字段，不会被序列化  
    private transient String transientField = "Transient Value";  
  
    // 非瞬态且非静态字段，会被序列化  
    private String nonTransientNonStaticField = "Non-Transient, Non-Static Value";  
  
    // 不会被序列化
    private int baseInt; 
  
    // ... 其他代码，如getter和setter ...  
}

@Getter
@Setter
public final class SerializableBean implements Serializable {

    private static final long serialVersionUID = 12345L;

    private static String staticField;

    private String strVal;

    private Integer intVal;

    private Long longVal;

    private BigDecimal bigDecimal;

    private Date date;

    private Class<?> genericClazz;

    private Class<?> interfaceClazz;

    public static void setStaticField(String staticField) {
        SerializableBean.staticField = staticField;
    }

    public static String getStaticField() {
        return staticField;
    }

    @Override
    public String toString() {
        return "SerializableBean{" +
                "staticField='" + staticField + '\'' +
                ", strVal='" + strVal + '\'' +
                ", intVal=" + intVal +
                ", longVal=" + longVal +
                ", bigDecimal=" + bigDecimal +
                ", date=" + date +
                ", genericClazz=" + genericClazz +
                ", interfaceClazz=" + interfaceClazz +
                '}';
    }
}

@Slf4j
public class SerializerTest {

    private static SerializableBean serializableBean;

    @BeforeClass
    public static void beforeClass() {
        serializableBean = new SerializableBean();
        serializableBean.setStrVal("serializableBean");
        serializableBean.setIntVal(1);
        serializableBean.setLongVal(2L);
        serializableBean.setBigDecimal(new BigDecimal("999"));
        serializableBean.setDate(new Date());
        serializableBean.setInterfaceClazz(Serializer.class);
        serializableBean.setGenericClazz(SerializerFactory.class);
        SerializableBean.setStaticField("staticField");
    }

    @Test
    public void testSerializer() {
        testSerializer(JdkSerializer.getInstance());
        testSerializer(HessianSerializer.getInstance());
        testSerializer(JsonSerializer.getInstance());
        testSerializer(KryoSerializer.getInstance());
        testSerializer(ProtostuffSerializer.getInstance());
        testSerializer(MsgPackSerializer.getInstance());
    }

    /**
     * 测试序列化器的方法
     *
     * @param serializer 序列化器对象
     * @return void
     */
    private void testSerializer(Serializer serializer) {
        final String name = serializer.getClass().getName();
        log.info(String.format("---------------- %s ----------------", name));
        byte[] bytes = serializer.serialize(serializableBean);
        
       // log.info("code result size: {}, bytes: {}", bytes.length, Arrays.toString(bytes));
        log.info("serialize result size: {}", bytes.length);
        SerializableBean decode = serializer.deserialize(bytes, SerializableBean.class);
        log.info("deserialize result: {}", decode);
        serializer.unregister();
        // log.info(String.format("---------------- %s ----------------\n", name));
    }

}

private static final long serialVersionUID = 1L;