[toc]


基于protostuff的序列化工具类开发

前言

前面在介绍protostuff的基本使用时(可以参考文章protostuff基本使用),都是针对某个类写的序列化和反序列化方法,显然这样不具有通用性,例如在进行远程过程调用时,传输的对象并不唯一,这时就需要开发具有通用性的序列化工具类,即不管序列化的对象是什么类型,都可以使用该工具类进行序列化。下面就来开发这样的工具类。

基于这个需要,下面会开发两个序列化工具类,一个是不具有缓存功能的SerializationUtil,一个是具有缓存功能的增强版本SerializationUtil2

需要注意的是,protostuff序列化工具类的开发需要大量使用到Java泛型的知识,因此在阅读这些源代码时应该需要具有一定的泛型知识储备,否则代码阅读起来会比较难懂,尽管我已经全部加了注释。

protostuff序列化工具类SerializationUtil

下面直接给出源代码:

package cn.xpleaf.protostuff.netty.utils;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.runtime.RuntimeSchema;

/**
 * 序列化工具类,基于Protostuff实现(其基于Google Protobuf实现)
 * 
 * @author yeyonghao
 *
 */
public class SerializationUtil {

    /**
     * 序列化方法,将对象序列化为字节数组(对象 ---> 字节数组)
     * 
     * @param obj
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  byte[] serialize(T obj) {
        // 获取泛型对象的类型
        Class clazz = (Class) obj.getClass();
        // 创建泛型对象的schema对象
        RuntimeSchema schema = RuntimeSchema.createFrom(clazz);
        // 创建LinkedBuffer对象
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        // 序列化
        byte[] array = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        // 返回序列化对象
        return array;
    }

    /**
     * 反序列化方法,将字节数组反序列化为对象(字节数组 ---> 对象)
     * 
     * @param data
     * @param clazz
     * @return
     */
    public static  T deserialize(byte[] data, Class clazz) {
        // 创建泛型对象的schema对象
        RuntimeSchema schema = RuntimeSchema.createFrom(clazz);
        // 根据schema实例化对象
        T message = schema.newMessage();
        // 将字节数组中的数据反序列化到message对象
        ProtostuffIOUtil.mergeFrom(data, message, schema);
        // 返回反序列化对象
        return message;
    }
}

protostuff序列化工具类SerializationUtil2

SerializationUtil的问题在于,每次调用序列化方法和反序列化方法时都需要重新生成一个schema对象,所以可以把生成的schema对象保存起来,在下一次调用方法时就不需要重新生成这些schema对象,这样可以提高序列化和反序列化的性能。

package cn.xpleaf.protostuff.netty.utils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.runtime.RuntimeSchema;

/**
 * 具备缓存功能的序列化工具类,基于Protostuff实现(其基于Google Protobuf实现)
 * 
 * @author yeyonghao
 *
 */
public class SerializationUtil2 {

    // 缓存schema对象的map
    private static Map, RuntimeSchema> cachedSchema = new ConcurrentHashMap, RuntimeSchema>();

    /**
     * 根据获取相应类型的schema方法
     * 
     * @param clazz
     * @return
     */
    @SuppressWarnings({ "unchecked", "unused" })
    private  RuntimeSchema getSchema(Class clazz) {
        // 先尝试从缓存schema map中获取相应类型的schema
        RuntimeSchema schema = (RuntimeSchema) cachedSchema.get(clazz);
        // 如果没有获取到对应的schema,则创建一个该类型的schema
        // 同时将其添加到schema map中
        if (schema == null) {
            schema = RuntimeSchema.createFrom(clazz);
            if (schema != null) {
                cachedSchema.put(clazz, schema);
            }
        }
        // 返回schema对象
        return schema;
    }

    /**
     * 序列化方法,将对象序列化为字节数组(对象 ---> 字节数组)
     * 
     * @param obj
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  byte[] serialize(T obj) {
        // 获取泛型对象的类型
        Class clazz = (Class) obj.getClass();
        // 创建泛型对象的schema对象
        RuntimeSchema schema = RuntimeSchema.createFrom(clazz);
        // 创建LinkedBuffer对象
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        // 序列化
        byte[] array = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        // 返回序列化对象
        return array;
    }

    /**
     * 反序列化方法,将字节数组反序列化为对象(字节数组 ---> 对象)
     * 
     * @param data
     * @param clazz
     * @return
     */
    public static  T deserialize(byte[] data, Class clazz) {
        // 创建泛型对象的schema对象
        RuntimeSchema schema = RuntimeSchema.createFrom(clazz);
        // 根据schema实例化对象
        T message = schema.newMessage();
        // 将字节数组中的数据反序列化到message对象
        ProtostuffIOUtil.mergeFrom(data, message, schema);
        // 返回反序列化对象
        return message;
    }
}

测试

测试代码如下:

package cn.xpleaf.protostuff.netty.utils;

import static org.junit.Assert.*;

import org.junit.Test;

import cn.xpleaf.pojo.User;

public class TestUtil {

    @Test
    public void testUtil01() throws Exception {
        User user = new User("xpleaf", 10);
        System.out.println(user);
        // 序列化
        byte[] array = SerializationUtil.serialize(user);
        // 反序列化
        User user2 = SerializationUtil.deserialize(array, User.class);
        System.out.println(user2);
        // 判断值是否相等
        System.out.println(user.toString().equals(user2.toString()));
    }

    @Test
    public void testUtil02() throws Exception {
        User user = new User("xpleaf", 10);
        System.out.println(user);
        // 序列化
        byte[] array = SerializationUtil2.serialize(user);
        // 反序列化
        User user2 = SerializationUtil2.deserialize(array, User.class);
        System.out.println(user2);
        // 判断值是否相等
        System.out.println(user.toString().equals(user2.toString()));
    }
}

执行testUtil01时的输出结果如下:

User [name=xpleaf, age=10]
User [name=xpleaf, age=10]
true

执行testUtil02时的输出结果如下:

User [name=xpleaf, age=10]
User [name=xpleaf, age=10]
true