当前位置：网站首页>对象序列化

对象序列化

2022-06-27 11:56:00 【瑾琳】

什么是对象序列化?

　序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程.
　这是百度百科的说明,也很浅显易懂,比如说,我有一个java对象,我想传输给远端的程序,如何传输尼?
　java提供了序列化接口,只要实现了Serializable接口,就可将java对象序列化成字节,然后以流的形式传输,然后在远端再反序列化成对象,这就达到了传输消息的目的.
　但是这种序列化存在一些缺陷,1不能跨语言,2,序列化体积大
　所以为了支持跨语言,并提高序列效率,减少传输时的码流大小,好多公司或者大神开发了各种序列化库,hession,protostuff,kryo,jackson,xml等,比如json也算是一种序列化,方式,也是目前使用的最为广泛的一种,但是json严格来说并不是一种序列化,它只是一种通用的信息描述方式,一组json信息,可能对应不同的对象模式.比如你可以将一组json转换成java bean对象也可以转换成map,形式具有不确定性.所以一般的远程调用不会采用json来作为序列化实现.

序列类型	是否跨语言	优缺点
hession	支持	跨语言,序列化后体积小,速度较快
protostuff	支持	跨语言,序列化后体积小,速度快,但是需要Schema,可以动态生成
jackson	支持	跨语言,序列化后体积小,速度较快,且具有不确定性
fastjson	支持	跨语言支持较困难,序列化后体积小,速度较快,只支持java,c#
kryo	支持	跨语言支持较困难,序列化后体积小,速度较快
fst	不支持	跨语言支持较困难,序列化后体积小,速度较快，兼容jdk

|jdk|不支持|序列化后体积很大,速度快|

序列化可以做什么?

如第一节提的一样,对象序列化可以用来传输消息,并且以流的形式传输,提高传输效率,使用场景如远程服务调用rpc

各个序列化库比较

0.准备依赖

        <!-- protostuff -->
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.0.8</version>
        </dependency>
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.0.8</version>
        </dependency>
        <!-- objenesis(support protostuff,可以使用无参构造方法) -->
        <dependency>
            <groupId>org.objenesis</groupId>
            <artifactId>objenesis</artifactId>
            <version>2.1</version>
        </dependency>
        <!-- hessian -->
        <dependency>
            <groupId>com.caucho</groupId>
            <artifactId>hessian</artifactId>
            <version>4.0.38</version>
        </dependency>
        <!-- jackson -->        
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
        </dependency>
<!-- fastjson-->        
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>


                <!-- kryo  -->
            <dependency>
        <groupId>com.esotericsoftware</groupId>
        <artifactId>kryo</artifactId>
        <version>4.0.0</version>
    </dependency>
         <!-- fst  -->
    <dependency>
  <groupId>de.ruedigermoeller</groupId>
  <artifactId>fst</artifactId>
<version>2.57</version>
</dependency>

1.编写序列化接口

public interface Serializer {

    <T> byte[] serialize(T obj);
    <T> Object deserialize(byte[] bytes, Class<T> clazz);
}

2.实现接口

hession实现

public class HessianSerializer implements Serializer {

    @Override
    public <T> byte[] serialize(T obj){
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        HessianOutput ho = new HessianOutput(os);
        try {
            ho.writeObject(obj);
        } catch (IOException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
        return os.toByteArray();
    }

    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz) {
        ByteArrayInputStream is = new ByteArrayInputStream(bytes);
        HessianInput hi = new HessianInput(is);
        try {
            return hi.readObject();
        } catch (IOException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

}

jackson实现

public class JacksonSerializer implements Serializer {
    private final static ObjectMapper objectMapper = new ObjectMapper();


    @Override
    public <T> byte[] serialize(T obj) {
        try {
            return objectMapper.writeValueAsBytes(obj);
        } catch (JsonProcessingException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz)  {
        try {
            return objectMapper.readValue(bytes, clazz);
        } catch (JsonParseException e) {
            throw new IllegalStateException(e.getMessage(), e);
        } catch (JsonMappingException e) {
            throw new IllegalStateException(e.getMessage(), e);
        } catch (IOException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

}

fastjson实现

import com.alibaba.fastjson.JSON;

public class FastJsonSerializer implements Serializer {


    @Override
    public <T> byte[] serialize(T obj) {
        try {
            return JSON.toJSONBytes(obj);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz)  {
        try {
            return JSON.parseObject(bytes, clazz);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

}

prostfuff实现

public class ProtostuffSerializer implements Serializer {
    private static Objenesis objenesis = new ObjenesisStd(true);
    private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();
    private static <T> Schema<T> getSchema(Class<T> cls) {
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>) cachedSchema.get(cls);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(cls);
            if (schema != null) {
                cachedSchema.put(cls, schema);
            }
        }
        return schema;
    }

    @Override
    public <T> byte[] serialize(T obj) {
        @SuppressWarnings("unchecked")
        Class<T> cls = (Class<T>) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            Schema<T> schema = getSchema(cls);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        } finally {
            buffer.clear();
        }
    }

    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz) {
        try {
            T message = (T) objenesis.newInstance(clazz);
            Schema<T> schema = getSchema(clazz);
            ProtostuffIOUtil.mergeFrom(bytes, message, schema);
            return message;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

}

kryo实现



import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.pool.KryoFactory;
import com.esotericsoftware.kryo.pool.KryoPool;

/**
 * @author 都市桃源
 *
 */
public class KryoSerializer implements Serializer {

    /**
     * kryo 不是线程安全的，所以使用池控制
     */
    private static final KryoPool kryoPool = new KryoPool.Builder(
            new KryoFactory() {
                public Kryo create() {
                    Kryo kryo = new Kryo();
                    return kryo;

                }

            }).build();

    @Override
    public <T> byte[] serialize(T obj) throws Exception {
        try (
                Output output = new Output(new ByteArrayOutputStream())) {
            Kryo kryo = kryoPool.borrow();
            kryo.writeObject(output, obj);
            kryoPool.release(kryo);
            output.flush();
            return ((ByteArrayOutputStream) output.getOutputStream()).toByteArray();

        }

    }

    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz)
            throws Exception {
        try (Input input = new Input(new ByteArrayInputStream(bytes))) {
            Kryo kryo = kryoPool.borrow();
            T res = kryo.readObject(input, clazz);
            kryoPool.release(kryo);
            return res;
        }
    }
}

jdk实现

public class JdkSerializer implements Serializer {

    @Override
    public <T> byte[] serialize(T obj) {

        try {
            ByteArrayOutputStream byteArr = new ByteArrayOutputStream();
            ObjectOutputStream out=new ObjectOutputStream(byteArr);
            out.writeObject(obj);
            out.flush();
            return byteArr.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz) {
        try {
            ObjectInputStream input=new ObjectInputStream(new ByteArrayInputStream(bytes));
            return input.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

}

fst实现

import org.nustaq.serialization.FSTConfiguration;

public class FstSerializer implements Serializer {
    private static final FSTConfiguration configuration = FSTConfiguration
            .createStructConfiguration();

    @Override
    public <T> byte[] serialize(T obj) {
        return configuration.asByteArray(obj);
    }

    @Override
    public <T> Object deserialize(byte[] bytes, Class<T> clazz) {
        return configuration.asObject(bytes);
    }
}

3,准备序列对象

序列化对象需要实现Serializable,有的需要有的不需要,hession需要,而且还需要有默认的无参构造方法jackson需要

public class User  implements Serializable{
    private String name;
    private String address;
    private Integer age;

    public User() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public User(String name, String address, Integer age) {
        super();
        this.name = name;
        this.address = address;
        this.age = age;
    }

}

4.序列化速度比较

public class SerTest {
    public static void main(String[] args) {

        int len=10;
        test(new HessianSerializer(), "hession",len);
        test(new JacksonSerializer(), "jackson",len);
        test(new ProtostuffSerializer(),  "protostu",len);
        test(new JdkSerializer(),"jdk",len);
        test(new KryoSerializer(),"kryo",len);
        test(new FstSerializer(),"fst",len);
        test(new FastJsonSerializer(),"fastjson",len);
    }

    public static void test(Serializer s,String tag,int len){

        long cap=0;
        long sumTime=0;
        for(int i=0;i<len;i++){
            User u=new User("taoyuan"+i, i+"addr", i);
            long start=System.currentTimeMillis();
            byte[] serialize = s.serialize(u);
             cap+=serialize.length;
             s.deserialize(serialize, User.class);
             long cal= System.currentTimeMillis()-start;
             sumTime+=cal;

        }
          System.out.println(tag+"-->["+len+"]对象序列总体积大小:"+cap);
         System.out.println(tag+"->["+len+"]对象总消耗时间为:"+sumTime);
    }
}

结果:
hession–>[100]对象序列总体积大小:7780
hession->[100]对象总消耗时间为:197
jackson–>[100]对象序列总体积大小:4770
jackson->[100]对象总消耗时间为:122
protostu–>[100]对象序列总体积大小:2080
protostu->[100]对象总消耗时间为:102
jdk–>[100]对象序列总体积大小:21380
jdk->[100]对象总消耗时间为:122
kryo–>[100]对象序列总体积大小:2016
kryo->[100]对象总消耗时间为:47
fst–>[100]对象序列总体积大小:4880
fst->[100]对象总消耗时间为:35
fastjson–>[100]对象序列总体积大小:4770
fastjson->[100]对象总消耗时间为:206