高性能序列化protostuff

protostuff基于Google protobuf，但是提供了更多的功能和更简易的用法。

protobuf的一个缺点是需要数据结构的预编译过程，首先要编写.proto格式的配置文件，再通过protobuf提供的工具生成各种语言响应的代码。

由于java具有反射和动态代码生成的能力，这个预编译过程不是必须的，可以在代码执行时来实现。这就是protostuff

SerializationUtils1

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

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

/**
 *
 * 使用protostuff进行序列化和反序列化
 */
public class SerializationUtils {

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

    private static Objenesis objenesis = new ObjenesisStd(true);

    private SerializationUtils() {
    }


    //对象 转 字节数组   序列化
    public static <T> byte[] serialize(T obj) {
        Class<T> clazz = (Class<T>) obj.getClass();//获得对象的类
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);//使用LinkedBuffer分配一块默认大小的buffer空间
        try {//通过对象的类构建对应的schema
            Schema<T> schema = getSchma(clazz);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);//使用给定的schema将对象序列化为一个byte数组，并返回
        } finally {
            buffer.clear();
        }

    }

    private static <T> Schema<T> getSchma(Class<T> clazz) {
        Schema<T> schema = (Schema<T>) cachedSchema.get(clazz);//构建schema的过程比较耗时，使用map将schema缓存起来
        if (schema == null) {
            schema = RuntimeSchema.createFrom(clazz);
            cachedSchema.put(clazz, schema);
        }
        return schema;
    }

    //字节数组 转 对象   反序列化
    public static <T> T deserialize(byte[] data, Class<T> clazz) {
        T message = objenesis.newInstance(clazz);//使用objenesis实例化一个类的对象
        Schema<T> schma = getSchma(clazz);//通过对象的类构建对应的schema
        ProtostuffIOUtil.mergeFrom(data, message, schma);//使用给定的schema将byte数组和对象合并
        return message;
    }
}

SerializationUtils2
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

/**
 *
 * 使用protostuff进行序列化和反序列化
 */
public class SerializationUtils2 {

    private static SchemaCache schemaCache = SchemaCache.getInstance();

    private static Objenesis objenesis = new ObjenesisStd(true);

    private SerializationUtils2() {
    }


    //对象 转 字节数组   序列化
    public static <T> byte[] serialize(T obj) {
        Class<T> clazz = (Class<T>) obj.getClass();//获得对象的类
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);//使用LinkedBuffer分配一块默认大小的buffer空间
        try {//通过对象的类构建对应的schema
            Schema<T> schema = getSchma(clazz);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);//使用给定的schema将对象序列化为一个byte数组，并返回
        } finally {
            buffer.clear();
        }

    }

    private static <T> Schema<T> getSchma(Class<T> clazz) {
        Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
        return schema;
    }

    //字节数组 转 对象   反序列化
    public static <T> T deserialize(byte[] data, Class<T> clazz) {
        T message = objenesis.newInstance(clazz);//使用objenesis实例化一个类的对象
        Schema<T> schma = getSchma(clazz);//通过对象的类构建对应的schema
        ProtostuffIOUtil.mergeFrom(data, message, schma);//使用给定的schema将byte数组和对象合并
        return message;
    }
}
SchemaCache
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;


public class SchemaCache {
    //使用单例模式，构建缓存类
    private static class SchemaCacheHolder {
        private static SchemaCache cache = new SchemaCache();
    }

    public static SchemaCache getInstance() {
        return SchemaCacheHolder.cache;
    }

    /*
    使用cacheBuilder生成器生成缓存
    maximumSize:缓存如果达到限额，则回收(接近时就会启动回收)
    expireAfterAccess:缓存在给定时间没有被访问，则回收
     */
    private Cache<Class<?>, Schema<?>> cache = CacheBuilder.newBuilder()
            .maximumSize(1024).expireAfterAccess(1, TimeUnit.HOURS)
            .build();

    /*
    cache.get(k,Callable)方法返回缓存中的值，或者使用call方法将结果加入到缓存中。
     */

    private Schema<?> get(final Class<?> clazz, Cache<Class<?>, Schema<?>> cache) {
        try {
            return cache.get(clazz, new Callable<RuntimeSchema<?>>() {
                public RuntimeSchema<?> call() throws Exception {
                    return RuntimeSchema.createFrom(clazz);
                }
            });
        } catch (ExecutionException e) {
            return null;
        }
    }

    public Schema<?> get(final Class<?> clazz) {
        return get(clazz, cache);
    }
}





由于protostuff的schema中包含了对象进行序列化和反序列化的逻辑，所以构建过程比较耗时，这边需要使用缓存来做优化。
utils1中使用了concurrenthashmap作为缓存
utils2中使用了google的guava中的cache。
两者各有优劣
concurrenthashmap速度快，但是不能自动对内存进行有效控制，如果元素过多，存在内存风险
guava可以通过配置限制使用的内存大小，效率也比较快

大家可以根据具体的业务场景，来考虑应用哪一个缓存。