【Java技術專題】「性能優化系列」針對Java對象壓縮及序列化技術的探索之路

序列化和反序列化

• 序列化就是指把對象轉換為字節碼；

  • 對象傳遞和保存時，保證對象的完整性和可傳遞性。把對象轉換為有字節碼，以便在網絡上傳輸或保存在本地文件中；

• 反序列化就是指把字節碼恢復為對象；

  • 根據字節流中保存的對象狀態及描述信息，通過反序列化重建對象；

• 一般情況下要求實現Serializable接口，該接口中沒有定義任何成員，只是起到標記對象是否可以被序列化的作用。

  • 對象在進行序列化和反序列化的時候，必須實現Serializable接口，但並不強制聲明唯一的serialVersionUID，是否聲明serialVersionUID對於對象序列化的向上向下的兼容性有很大的影響。

為何需要有序列化呢？

• 一方面是為了存儲在磁盤中，
• 另一方面為了網絡遠程傳輸的內容。

Java實現序列化的方式

二進制格式 + 指定語言層級

JavaBuiltIn（java原生）、JavaManual（根據成員變量類型，手工寫）、FstSerliazation、Kryo

二進制格式 + 跨語言層級

Protobuf(Google)、Thrift(Facebook)、 AvroGeneric、Hessian

JSON 格式化

Jackson、Gson、FastJSON等

類JSON格式化：

CKS （textual JSON-like format）、BSON（JSON-like format with extended datatypes）、JacksonBson、MongoDB

XML文件格式化

XmlXStream等

序列化的分類

序列化工具大致就可以分為以上幾類，簡單概括就分為二進制binary和文本格式（json、xml）兩大類。

在速度的對比上一般有如下規律：

• binary > textual
• language-specific > language-unspecific

而textual中，由json相比xml冗余度更低因此速度上更勝一籌，而json又比bson這類textual serialization技術上更成熟，框架的選擇上更豐富和優秀。

下面重點介紹下Kryo、fast-serialiation、fastjson、protocol-buffer

Java原生序列化(青銅級別)

• Java本身提供的序列化工具基本上能勝任大多數場景下的序列化任務，關於其序列化機制。

• 需要類實現了Serializable或Externalizable接口，否則會拋出異常，然后使用ObjectOutputStream與ObjectInputStream將對象寫入寫出。

• Java自帶的序列化工具在序列化過程中需要不僅需要將對象的完整的class name記錄下來，還需要把該類的定義也都記錄下，包括所有其他引用的類，這會是一筆很大的開銷，尤其是僅僅序列化單個對象的時候。

• 正因為java序列化機制會把所有meta-data記錄下來，因此當修改了類的所在的包名后，反序列化則會報錯。

 //對象轉成字節碼
 ByteArrayOutputStream byteArrayOutputStream = new  ByteArrayOutputStream();
 ObjectOutputStream outputStream = new
 ObjectOutputStream(byteArrayOutputStream);
 outputStream.writeObject(VoUtil.getUser());
 byte  []bytes = byteArrayOutputStream.toByteArray();
 outputStream.close();
 //字節碼轉換成對象
 ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
 ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
 Model result = （Model) inputStream.readObject();
 inputStream.close();

Kryo序列化框架（星耀級別）

• kryo根據上述Java原生序列化機制的一些問題，對了很多優化工作，而且提供了很多serializer，甚至封裝了Unsafe類型的序列化方式，更多關於Unsafe類型的序列化方式。

• kryo，是一個快速序列化/反序列化工具，效率比java高出一個級別，序列化出來的結果，是其自定義的、獨有的一種格式，體積更小，一般只用來進行序列化和反序列化，而不用於在多個系統、甚至多種語言間進行數據交換（目前 kryo 也只有 java 實現），目前已經有多家大公司使用，相對比較穩定。

    <dependency> 
       <groupId>com.esotericsoftware</groupId> 
       <artifactId>kryo</artifactId> 
       <version>4.0.0</version> 
     </dependency> 

KryoUtils序列化和反序列化操作

Kryo有三組讀寫對象的方法

• 如果不知道對象的具體類，且對象可以為null：

kryo.writeClassAndObject(output, object);
Object object = kryo.readClassAndObject(input);

• 如果類已知且對象可以為null：

kryo.writeObjectOrNull(output, someObject);
SomeClass someObject = kryo.readObjectOrNull(input, SomeClass.class);

• 如果類已知且對象不能為null:

kryo.writeObject(output, someObject);
SomeClass someObject = kryo.readObject(input, SomeClass.class);

序列化和反序列化操作工具類KryoUtils

Kryo 和 KryoRegister

Kryo的運行速度是java Serializable 的20倍左右
Kryo的文件大小是java Serializable的一半左右

Kryo有兩種模式:

一種是先注冊(regist)，再寫對象，即writeObject函數，實際上如果不先注冊，在寫對象時也會注冊，並為class分配一個id。

注意，跨進程，則必須兩端都按同樣的模式，否則會出錯，因為必須要明確類對應的唯一id。

另一種是寫類名及對象，即writeClassAndObject函數。

writeClassAndObject函數是先寫入一個約定的數字，再寫入類ID（第一次要先寫-1，再寫類ID + 類名），寫入引用關系，最后才寫真正的數據。

Kryo的操作模式

static Kryo kryo = new Kryo();

public static byte[] serialize(Object obj) {
    byte[] buffer = new byte[2048];
    Output output = new Output(buffer);
    kryo.writeClassAndObject(output, obj);
    byte[] bs = output.toBytes();
    output.close();
    return bs;
}

public static Object deserialize(byte[] src) {
    Input input = new Input(src);
    Object obj = kryo.readClassAndObject(input);
    input.close();
    return obj;
}

Kryo的Register操作模式

static Kryo kryo = null;
static{
    kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(false);
    kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
}

public static byte[] serialize(Object obj) {
    kryo.register(obj.getClass());
    byte[] buffer = new byte[2048];
    Output output = new Output(buffer);
    kryo.writeObject(output, obj);
    byte[] bs = output.toBytes();
    output.close();
    return bs;
}

public static Object deserialize(byte[] src, Class<?> clazz) {
    kryo.register(clazz);
    Input input = new Input(src);
    Object obj = kryo.readObject(input, clazz);
    input.close();
    return obj;
}

推薦：https://blog.csdn.net/fanjunjaden/article/details/72823866

借鑒網上的一個很不錯的工具類！

public class KryoUtils  {
    /**
     * （池化Kryo實例）使用ThreadLocal
     */
    private static final ThreadLocal<Kryo> kryos = new ThreadLocal<Kryo>() {
        @Override
        protected Kryo initialValue() {
            Kryo kryo = new Kryo();
            //支持對象循環引用（否則會棧溢出）
            kryo.setReferences(true);
            // 不強制要求注冊類（注冊行為無法保證多個 JVM 內同一個類的注冊編號相同；
			// 而且業務系統中大量的 Class 也難以一一注冊）
            kryo.setRegistrationRequired(false); 
            //Fix the NPE bug when deserializing Collections.
            kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
            return kryo;
        }
    };
    /**
     * （池化Kryo實例）使用KryoPool
     */
    private static KryoFactory factory = new KryoFactory() {
        public Kryo create () {
            Kryo kryo = new Kryo();
            return kryo;
        }
    };
    private static KryoPool pool = new KryoPool.Builder(factory).softReferences().build();
    /**
     * 使用ThreadLocal創建Kryo
     * 把java對象序列化成byte[];
     * @param obj java對象
     * @return
     */
    public static <T>  byte[] serializeObject(T obj) {
        ByteArrayOutputStream os=null;
        Output output=null;
        if(null != obj){
            Kryo kryo = kryos.get();
            try {
                os = new ByteArrayOutputStream();
                output = new Output(os);
                kryo.writeObject(output, obj);
                close(output);
                return os.toByteArray();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                close(os);
            }
        }
        return null;
    }

    /**
     * 使用ThreadLocal創建Kryo
     * 把byte[]反序列化成指定的java對象
     * @param bytes
     * @param t 指定的java對象
     * @param <T>
     * @return 指定的java對象
     */
    public static <T> T unSerializeObject(byte[] bytes,Class<T> t) {
        ByteArrayInputStream is=null;
        Input input=null;
        if(null != bytes && bytes.length>0 && null!=t){
            try {
                Kryo kryo = kryos.get();
                is = new ByteArrayInputStream(bytes);
                input = new Input(is);
                return kryo.readObject(input,t);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                close(is);
                close(input);
            }
        }
        return null;
    }

    /**
     * 使用ThreadLocal創建Kryo
     * 把List序列化成byte[];
     * @param list java對象
     * @return
     */
    public static <T>  byte[]  serializeList(List<T> list ) {
        ByteArrayOutputStream os=null;
        Output output=null;
        byte[] bytes = null;
        if(null != list && list.size()>0){
            Kryo kryo = kryos.get();
            try {
                os = new ByteArrayOutputStream();
                output = new Output(os);
                kryo.writeObject(output,list);
                close(output);
                bytes = os.toByteArray();
                return bytes;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                close(os);
            }
        }
        return null;
    }
 
    /**
     * 使用ThreadLocal創建Kryo
     * 把byte[]反序列化成指定的List<T>
     * @param bytes byte數組
     * @param <T>
     * @return 指定java對象的List
     */
    public static <T> List<T> unSerializeList(byte[] bytes) {
        ByteArrayInputStream is=null;
        Input input=null;
        if(null !=bytes && bytes.length>0){
            try {
                Kryo kryo = kryos.get();
                is = new ByteArrayInputStream(bytes);
                input = new Input(is);
                List<T> list = kryo.readObject(input,ArrayList.class);
                return list;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                close(is);
                close(input);
            }
        }
        return null;
    }
    /**
     * 使用ThreadLocal創建Kryo
     * 把java對象轉序列化存儲在文件中;
     * @param obj java對象
     * @return
     */
    public static <T>  boolean serializeFile(T obj,String path) {
        if(null != obj){
            Output output=null;
            try {
                Kryo kryo = kryos.get();
                output = new Output(new FileOutputStream(path));
                kryo.writeObject(output, obj);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                close(output);
            }
        }
        return false;
    }
 
    /**
     * 使用ThreadLocal創建Kryo
     * 把序列化的文件反序列化成指定的java對象
     * @param path 文件路徑
     * @param t 指定的java對象
     * @param <T>
     * @return 指定的java對象
     */
    public static <T> T unSerializeFile(String path,Class<T> t) {
        if(null != path && null !=t ){
            Input input=null;
            try {
                Kryo kryo = kryos.get();
                input = new Input(new FileInputStream(path));
                return kryo.readObject(input,t);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                close(input);
            }
        }
        return null;
    }
 
    /**
     * 使用KryoPool SoftReferences創建Kryo
     * 把java對象序列化成byte[] ;
     * @param obj java對象
     * @return
     */
    public static <T>  byte[] serializePoolSoftReferences (T obj) {
        if(null!=obj){
            Kryo kryo =pool.borrow();
            ByteArrayOutputStream os=null;
            Output output=null;
            try {
                os = new ByteArrayOutputStream();
                output = new Output(os);
                kryo.writeObject(output, obj);
                close(output);
                byte [] bytes = os.toByteArray();
                return bytes;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                pool.release(kryo);
                close(os);
            }
        }
        return null;
    }
    /**
     * 使用KryoPool SoftReferences創建Kryo
     * 把byte[]反序列化成指定的java對象
     * @param bytes
     * @return
     */
    public static <T> T unSerializePoolSoftReferences(byte[] bytes,Class<T> t) {
        if(null !=bytes && bytes.length>0 && null!=t){
            Kryo kryo =pool.borrow();
            ByteArrayInputStream is=null;
            Output output=null;
            try {
                is = new ByteArrayInputStream(bytes);
                Input input= new Input(is);
                return kryo.readObject(input, t);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                pool.release(kryo);
                close(is);
                close(output);
            }
        }
        return null;
    }
 
 
    /**
     * 使用KryoPool SoftReferences創建Kryo
     * 把java對象序列化成byte[] ;
     * @param obj java對象
     * @return
     */
    public static <T>  byte[] serializePoolCallback (final T obj) {
        if(null != obj){
            try {
                return pool.run(new KryoCallback<byte[]>() {
                    public byte[] execute(Kryo kryo) {
                        ByteArrayOutputStream os = new ByteArrayOutputStream();
                        Output output = new Output(os);
                        kryo.writeObject(output,obj);
                        output.close();
                        try {
                            os.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return os.toByteArray();
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
 
    /**
     * 使用KryoPool SoftReferences創建Kryo
     * 把byte[]反序列化成指定的java對象
     * @param bytes
     * @return
     */
    public static <T> T unSerializePoolCallback(final byte[] bytes, final Class<T> t) {
        if(null != bytes && bytes.length>0 && null != t){
            try {
              return pool.run(new KryoCallback<T>() {
                    public T execute(Kryo kryo) {
                        ByteArrayInputStream is = new ByteArrayInputStream(bytes);
                        Input input = new Input(is);
                        T result =kryo.readObject(input,t);
                        input.close();
                        try {
                            is.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return result;
                    }
              });
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
 
    /**
     * 關閉io流對象
     *
     * @param closeable
     */
    public static void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

參考官方文檔：https://github.com/EsotericSoftware/kryo

FST序列化機制（鑽石級別）

• FST（Fast-serialization-Tool），與kryo類似是apache組織的一個開源項目，完全兼容JDK序列化協議的系列化框架，序列化速度大概是JDK的4-10倍，體積更小，大小是JDK大小1/3左右，重新實現的 Java 快速對象序列化的開發包。

• 相對來說是一個很新的序列化工具，速度於kryo有一些差距，在生產環境上的場景上測試，效果幾乎於kryo一致，都能瞬間反序列化出內容並渲染。

Java 快速序列化庫 FST 已經發布了 2.0 版本，該版本的包名已經更改，無法平滑升級。另外官方建議為了穩定性考慮還是使用最新的 1.58 版本為好

Maven配置

<dependency> 
       <groupId>de.ruedigermoeller</groupId> 
       <artifactId>fst</artifactId> 
       <version>1.58</version> 
</dependency> 

案例代碼

static FSTConfiguration configuration = FSTConfiguration
           .createDefaultConfiguration();

public static byte[] serialize(Object obj){
     return configuration.asByteArray((Serializable)obj);
}
public static Object deserialize(byte[] sec){
    return configuration.asObject(sec);
}

官方文檔： https://github.com/RuedigerMoeller/fast-serialization/wiki/Serialization

protostuff（王者級別）

Protocol buffers是一個用來序列化結構化數據的技術，支持多種語言諸如C++、Java以及Python語言，可以使用該技術來持久化數據或者序列化成網絡傳輸的數據。相比較一些其他的XML技術而言，該技術的一個明顯特點就是更加節省空間（以二進制流存儲）、速度更快以及更加靈活。

protostuff，是google在原來的protobuffer是的優化產品。使用起來也比較簡單易用，目前效率也是最好的一種序列化工具。

 <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> 

protostuff工具類

public class ProtostuffUtil {
 
    public static <T> byte[] serializer(T t){
        Schema schema = RuntimeSchema.getSchema(t.getClass());
        return ProtostuffIOUtil.toByteArray(t,schema,
                LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
 
    }

    public static <T> T deserializer(byte []bytes,Class<T> c) {
        T t = null;
        try {
            t = c.newInstance();
            Schema schema = RuntimeSchema.getSchema(t.getClass());
             ProtostuffIOUtil.mergeFrom(bytes,t,schema);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return t;
    }
}

Fastjson（鑽石）

一個JSON庫涉及的最基本功能就是序列化和反序列化。Fastjson支持java bean的直接序列化。 使用com.alibaba.fastjson.JSON這個類進行序列化和反序列化。

public static String serialize(Object obj){
    String json = JSON.toJSONString(obj);
    return json;
}
public static Object deserialize(String json, Class<?> clazz){
    Object obj = JSON.parseObject(json, clazz);
    return obj;
}

Maven配置

 <dependency> 
       <groupId>com.alibaba</groupId> 
       <artifactId>fastjson</artifactId> 
       <version>1.2.47</version> 
  </dependency> 

Gson（鑽石）

這里采用JSON格式同時使用采用Google的gson進行轉義.

static Gson gson = new Gson();

public static String serialize(Object obj){
    String json = gson.toJson(obj);
    return json;
}
public static Object deserialize(String json, Class<?> clazz){
    Object obj = gson.fromJson(json, clazz);
    return obj;
}

Jackson（鉑金）

Jackson庫（http://jackson.codehaus.org），是基於java語言的開源json格式解析工具，整個庫（使用最新的2.2版本）包含3個jar包：

• jackson-core.jar——核心包（必須），提供基於“流模式”解析的API。
• jackson-databind——數據綁定包（可選），提供基於“對象綁定”和“樹模型”相關API。
• jackson-annotations——注解包（可選），提供注解功能。

性能較高，“流模式”的解析效率超過絕大多數類似的json包。
核心包：JsonParser（json流讀取），JsonGenerator（json流輸出）。
數據綁定包：ObjectMapper（構建樹模式和對象綁定模式），JsonNode（樹節點）

public static String serialize(Object obj){
    ObjectMapper mapper = new ObjectMapper();
    String json = null;
    try {
        json = mapper.writeValueAsString(obj);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return json;
}
public static Object deserialize(String json, Class<?> clazz){
    ObjectMapper mapper = new ObjectMapper();
    Object obj = null;
    try {
        obj = mapper.readValue(json, clazz);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return obj;
}

下表是幾種方案的各項指標的一個對比