java常用序列化与反序列化方法

摘要：序列化工具类序列化工具的序列化与反序列化使用实现序列化和反序列化反序列化时，必须要有默认构造函数，否则报错使用序列化缓存此类分别包含序列化序列化序列化三种序列化方式。

序列化即将对象序列化为字节数组，反序列化就是将字节数组恢复成对象。
主要的目的是方便传输和存储。

序列化工具类：

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。