摘要：序列化工具類序列化工具的序列化與反序列化使用實現序列化和反序列化反序列化時，必須要有默認構造函數，否則報錯使用序列化緩存此類分別包含序列化序列化序列化三種序列化方式。

序列化即將對象序列化為字節數組，反序列化就是將字節數組恢復成對象。
主要的目的是方便傳輸和存儲。

序列化工具類：

public class SerializeUtil {

    private static Map, Schema> cachedSchema = new ConcurrentHashMap<>();

    private static Objenesis objenesis = new ObjenesisStd(true);

    /**
     * jdk 序列化工具的序列化與反序列化
     *
     * @param object
     * @return
     * @throws IOException
     */
    public static byte[] JDKObjectToBytes(Object object) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutput objectOutput = new ObjectOutputStream(byteArrayOutputStream);
        objectOutput.writeObject(object);
        return byteArrayOutputStream.toByteArray();
    }

    public static  T JDKBytesToObject(byte[] bytes, Class clazz) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
        Object object = objectInputStream.readObject();
        return (T) object;
    }

    /**
     * 使用fastjson實現序列化和反序列化
     *
     * @param object
     * @return
     */
    public static byte[] FastJsonObjectToBytes(Object object) {
        byte[] bytes = JSON.toJSONBytes(object);
        return bytes;
    }

    /**
     * fastjosn反序列化時，class必須要有默認構造函數，否則報錯
     * @param bytes
     * @param clazz
     * @param 
     * @return
     */
    public static  T FastJsonBytesToObject(byte[] bytes, Class clazz) {
        return (T) JSON.parseObject(bytes, clazz);
    }

    /**
     * 使用protostuff序列化
     * @param obj
     * @param 
     * @return
     */
    public static  byte[] serialize(T obj) {
        Class cls = (Class) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            Schema schema = getSchema(cls);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        } finally {
            buffer.clear();
        }
    }

    public static  T deserialize(byte[] data, Class cls) {
        try {
            T message = objenesis.newInstance(cls);
            Schema schema = getSchema(cls);
            ProtostuffIOUtil.mergeFrom(data, message, schema);
            return message;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

    /**
     * 緩存schema
     * @param cls
     * @param 
     * @return
     */
    private static  Schema getSchema(Class cls) {
        Schema schema = (Schema) cachedSchema.get(cls);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(cls);
            if (schema != null) {
                cachedSchema.put(cls, schema);
            }
        }
        return schema;
    }
}

此類分別包含jdk序列化、fastjson序列化、protobuf序列化三種序列化方式。

注意prostuff需要包含maven依賴：

        
        
            org.objenesis
            objenesis
            2.6
        

        
            io.protostuff
            protostuff-core
            1.4.0
        

        
            io.protostuff
            protostuff-runtime
            1.4.0
        
        
        
        
            com.alibaba
            fastjson
            1.2.31
        

首先定義一個類用于測試,注意此類沒有默認構造函數。

public class Monster implements Serializable{
    Integer hp;
    Integer mp;
    String name;
    Integer level;

    public Monster(String name,Integer level){
        this.name=name;
        this.level=level;
    }
    
    //省略getter、setter、hashCode、equals...
}

測試類：

public class SerializeUtilTest {

    Monster monster = new Monster("boss", 100);
    Class clazz = Monster.class;

    @Test
    public void jdkSerializeTest() throws Exception {
        byte[] bytes = SerializeUtil.JDKObjectToBytes(monster);
        System.out.println(bytes.length);
        Monster object = SerializeUtil.JDKBytesToObject(bytes,clazz);
        Assert.assertEquals(object, monster);
    }

    @Test(expected = com.alibaba.fastjson.JSONException.class)
    public void fastJsonSerializeTest(){
        byte[] bytes = SerializeUtil.FastJsonObjectToBytes(monster);
        System.out.println(bytes.length);
        Monster object = SerializeUtil.FastJsonBytesToObject(bytes,clazz);
        Assert.assertEquals(object, monster);
    }

    @Test
    public void serialize(){
        byte[] serialize = SerializeUtil.serialize(monster);
        System.out.println(serialize.length);
        Object deserialize = SerializeUtil.deserialize(serialize, clazz);
        Assert.assertEquals(deserialize,monster);
    }
}

輸出分別為199、27、8。
可以看出jdk默認序列化方式的效率極低，protobuf效率和字節都非常高效。

特別注意：fastjson反序列化的對象必須要有默認構造函數，否則會報錯。protostuff使用objenesis不需要默認構函數創建對象。但是json格式可讀性好，性能也還可以，推薦性能不高的場景優先json格式，對性能要求高的場景使用protostuff。