摘要：序列化工具類序列化工具的序列化與反序列化使用實(shí)現(xiàn)序列化和反序列化反序列化時(shí)，必須要有默認(rèn)構(gòu)造函數(shù)，否則報(bào)錯(cuò)使用序列化緩存此類分別包含序列化序列化序列化三種序列化方式。

序列化即將對象序列化為字節(jié)數(shù)組，反序列化就是將字節(jié)數(shù)組恢復(fù)成對象。
主要的目的是方便傳輸和存儲(chǔ)。

序列化工具類：

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實(shí)現(xiàn)序列化和反序列化
     *
     * @param object
     * @return
     */
    public static byte[] FastJsonObjectToBytes(Object object) {
        byte[] bytes = JSON.toJSONBytes(object);
        return bytes;
    }

    /**
     * fastjosn反序列化時(shí)，class必須要有默認(rèn)構(gòu)造函數(shù)，否則報(bào)錯(cuò)
     * @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
        

首先定義一個(gè)類用于測試,注意此類沒有默認(rèn)構(gòu)造函數(shù)。

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默認(rèn)序列化方式的效率極低，protobuf效率和字節(jié)都非常高效。

特別注意：fastjson反序列化的對象必須要有默認(rèn)構(gòu)造函數(shù)，否則會(huì)報(bào)錯(cuò)。protostuff使用objenesis不需要默認(rèn)構(gòu)函數(shù)創(chuàng)建對象。但是json格式可讀性好，性能也還可以，推薦性能不高的場景優(yōu)先json格式，對性能要求高的場景使用protostuff。