【优化技术专题】针对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;
}
复制代码

推荐：blog.csdn.net/fanjunjaden…

借鉴网上的一个很不错的工具类！

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();
            }
        }
    }
复制代码

参考官方文档：github.com/EsotericSof…

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);
}
复制代码

官方文档： github.com/RuedigerMoe…

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库（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;
}
复制代码

下表是几种方案的各项指标的一个对比

【优化技术专题】针对Java对象压缩及序列化技术的探索之路

序列化和反序列化

为何需要有序列化呢？

Java实现序列化的方式

二进制格式 + 指定语言层级

二进制格式 + 跨语言层级

JSON 格式化

类JSON格式化：

XML文件格式化

序列化的分类

在速度的对比上一般有如下规律：

Java原生序列化(青铜级别)

Kryo序列化框架（星耀级别）

KryoUtils序列化和反序列化操作

Kryo有三组读写对象的方法

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

Kryo 和 KryoRegister

Kryo有两种模式:

Kryo的操作模式

Kryo的Register操作模式

FST序列化机制（钻石级别）

Maven配置

案例代码

protostuff（王者级别）

protostuff工具类

Fastjson（钻石）

Maven配置

Gson（钻石）

Jackson（铂金）

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

【优化技术专题】针对Java对象压缩及序列化技术的探索之路

序列化和反序列化

为何需要有序列化呢？

Java实现序列化的方式

二进制格式 + 指定语言层级

二进制格式 + 跨语言层级

JSON 格式化

类JSON格式化：

XML文件格式化

序列化的分类

在速度的对比上一般有如下规律：

Java原生序列化(青铜级别)

Kryo序列化框架（星耀级别）

KryoUtils序列化和反序列化操作

Kryo有三组读写对象的方法

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

Kryo 和 KryoRegister

Kryo有两种模式:

Kryo的操作模式

Kryo的Register操作模式

FST序列化机制（钻石级别）

Maven配置

案例代码

protostuff（王者级别）

protostuff工具类

Fastjson（钻石）

Maven配置

Gson（钻石）

Jackson（铂金）

热门文章

最新文章

相关课程

相关电子书

相关实验场景