基於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 <T> byte[] serialize(T obj) {
        // 獲取泛型對象的類型
        Class<T> clazz = (Class<T>) obj.getClass();
        // 創建泛型對象的schema對象
        RuntimeSchema<T> 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> T deserialize(byte[] data, Class<T> clazz) {
        // 創建泛型對象的schema對象
        RuntimeSchema<T> 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<Class<?>, RuntimeSchema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, RuntimeSchema<?>>();

    /**
     * 根據獲取相應類型的schema方法
     * 
     * @param clazz
     * @return
     */
    @SuppressWarnings({ "unchecked", "unused" })
    private <T> RuntimeSchema<T> getSchema(Class<T> clazz) {
        // 先嘗試從緩存schema map中獲取相應類型的schema
        RuntimeSchema<T> schema = (RuntimeSchema<T>) 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 <T> byte[] serialize(T obj) {
        // 獲取泛型對象的類型
        Class<T> clazz = (Class<T>) obj.getClass();
        // 創建泛型對象的schema對象
        RuntimeSchema<T> 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> T deserialize(byte[] data, Class<T> clazz) {
        // 創建泛型對象的schema對象
        RuntimeSchema<T> 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

基於protostuff的序列化工具類開發