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

序列化工具类

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

序列化工具类:

public class SerializeUtil {

    private static Map<Class<?>, 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> 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 <T>
     * @return
     */
    public static <T> T FastJsonBytesToObject(byte[] bytes, Class clazz) {
        return (T) JSON.parseObject(bytes, clazz);
    }

    /**
     * 使用protostuff序列化
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> byte[] serialize(T obj) {
        Class<T> cls = (Class<T>) 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> T deserialize(byte[] data, Class<T> cls) {
        try {
            T message = objenesis.newInstance(cls);
            Schema<T> schema = getSchema(cls);
            ProtostuffIOUtil.mergeFrom(data, message, schema);
            return message;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

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

此类分别包含jdk序列化、fastjson序列化、protobuf序列化三种序列化方式。

注意prostuff需要包含maven依赖:

        <!-- protostuff序列化,objenesis用来创建对象:不需要默认构造函数 -->
        <dependency>
            <groupId>org.objenesis</groupId>
            <artifactId>objenesis</artifactId>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupId>io.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.4.0</version>
        </dependency>

        <dependency>
            <groupId>io.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.4.0</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>

使用

首先定义一个类用于测试,注意此类没有默认构造函数。

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。

评论

暂无评论