java主流对象序列化方式使用样例

最新推荐文章于 2022-03-20 12:31:51 发布
最新推荐文章于 2022-03-20 12:31:51 发布
阅读量291 收藏
点赞数
分类专栏： ++++ Java based 文章标签： java序列化 json protobuf kyro hessian
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eussi/article/details/84351469
版权

1、运行结果

先看运行结果，本机自行测试，非官方数据，仅作参考 ：

初始化数据============================
Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

原生API序列化============================
序列化后数据长度:239
初始化时间：1ms
序列化10000次花费时间(包含初始化时间)：17ms
序列化10000次花费时间(不包含初始化时间)：16ms
反序列化后数据:Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

jackson序列化============================
序列化后数据长度:93
初始化时间：383ms
序列化10000次花费时间(包含初始化时间)：538ms
序列化10000次花费时间(不包含初始化时间)：155ms
反序列化后数据:Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

FastJson序列化============================
序列化后数据长度:93
初始化时间：0ms
序列化10000次花费时间(包含初始化时间)：204ms
序列化10000次花费时间(不包含初始化时间)：204ms
反序列化后数据:Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

Hessian序列化============================
序列化后数据长度:146
初始化时间：28ms
序列化10000次花费时间(包含初始化时间)：33ms
序列化10000次花费时间(不包含初始化时间)：5ms
反序列化后数据:Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

ProtoBuf序列化============================
序列化后数据长度:31
初始化时间：1913ms
序列化10000次花费时间(包含初始化时间)：7018ms
序列化10000次花费时间(不包含初始化时间)：5105ms
反序列化后数据:Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

Kyro序列化============================
序列化后数据长度:49
初始化时间：49ms
序列化10000次花费时间(包含初始化时间)：725ms
序列化10000次花费时间(不包含初始化时间)：676ms
反序列化后数据:Student{id='00011', name='Y', age=18, grade='100', teacher=Teacher{id='00001', name='X', age=18}}

2、代码

pom.xml文件依赖：
	<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.52</version>
        </dependency>
        <dependency>
            <groupId>com.baidu</groupId><!-- 百度封装了google protobuf的实现 -->
            <artifactId>jprotobuf</artifactId>
            <version>2.2.6</version>
        </dependency>
        <dependency>
            <groupId>com.caucho</groupId>
            <artifactId>hessian</artifactId>
            <version>4.0.51</version>
        </dependency>
        <dependency>
            <groupId>com.esotericsoftware</groupId>
            <artifactId>kryo</artifactId>
            <version>4.0.2</version>
        </dependency>
    </dependencies>
实例化对象：
Student：
public class Teacher implements Serializable{
    private static final long serialVersionUID = 1L;
    @Protobuf(required = true, order = 1, fieldType = FieldType.STRING)
    private String id;
    @Protobuf(required = true, order = 2, fieldType = FieldType.STRING)
    private String name;
    @Protobuf(required = true, order = 3, fieldType = FieldType.INT32)
    private int age;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
Teacher：
public class Student implements Serializable{
    private static final long serialVersionUID = 1L;
    @Protobuf(required = true, order = 1, fieldType = FieldType.STRING)
    private String id;
    @Protobuf(required = true, order = 2, fieldType = FieldType.STRING)
    private String name;
    @Protobuf(required = true, order = 3, fieldType = FieldType.INT32)
    private int age;
    @Protobuf(required = true, order = 4, fieldType = FieldType.STRING)
    private String grade;
    @Protobuf(required = true, order = 5, fieldType = FieldType.OBJECT)
    private Teacher teacher;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGrade() {
        return grade;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", grade='" + grade + '\'' +
                ", teacher=" + teacher.toString() +
                '}';
    }
}
序列化实现：
public class SerializableDemo {

    //初始化
    private final static int SERIALIZABLE_NUM = 10000;


    public static void main(String[] args) throws Exception {
        System.out.println("初始化数据============================\n" + init().toString() + "\n");
        //java原生
        excuteWithNative();
        //jackson
        excuteWithJackSon();
        //fastJson
        excuteWithFastJson();
        //hessian
        excuteWithHessian();
        //protobuf，baidu公司开发，底层给予protobuf,不用proto文件，通过注解即可实现序列化反序列化
        excuteWithProtoBuf();
        //kryo
        excuteWithKryo();

        //主流序列化方式JSON/Hessian(2) /xml/protobuf/kryo/MsgPack/FST/thrift/protostuff/Avro
        //更多序列化方式查看网络资料即可
    }

    private static void excuteWithNative() throws IOException, ClassNotFoundException {
        Student student = init();
        System.out.println("原生API序列化============================");
        Long start1=System.currentTimeMillis();//初始化时间
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        Long start2=System.currentTimeMillis();//序列化时间
        for(int i=0;i<SERIALIZABLE_NUM;i++){
            oos.writeObject(student);
            //因为是累加的，只取第一次序列化后的数据
            if(i==0){
                System.out.println("序列化后数据长度:" + bos.toByteArray().length);
            }
        }
        Long end = System.currentTimeMillis();

        System.out.println("初始化时间：" +(start2-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(包含初始化时间)：" +(end-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(不包含初始化时间)：" +(end-start2)+"ms");

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Student student1 = (Student) ois.readObject();
        System.out.println("反序列化后数据:" + student1.toString() + "\n");
    }

    private static void excuteWithJackSon() throws IOException {
        Student student = init();
        System.out.println("jackson序列化============================");
        Long start1=System.currentTimeMillis();//初始化时间
        ObjectMapper mapper=new ObjectMapper();
        byte[] writeBytes=null;

        Long start2=System.currentTimeMillis();//序列化时间
        for(int i=0;i<SERIALIZABLE_NUM;i++){
            writeBytes=mapper.writeValueAsBytes(student);
        }
        Long end = System.currentTimeMillis();

        System.out.println("序列化后数据长度:" + writeBytes.length);
        System.out.println("初始化时间：" +(start2-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(包含初始化时间)：" +(end-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(不包含初始化时间)：" +(end-start2)+"ms");

        Student student1 = mapper.readValue(writeBytes,Student.class);
        System.out.println("反序列化后数据:" + student1.toString() + "\n");
    }


    private static void excuteWithFastJson() throws IOException {
        Student student = init();
        System.out.println("FastJson序列化============================");
        Long start1=System.currentTimeMillis();//初始化时间
        String text=null;

        Long start2=System.currentTimeMillis();//序列化时间
        for(int i=0;i<SERIALIZABLE_NUM;i++){
            text=JSON.toJSONString(student);
        }
        Long end = System.currentTimeMillis();

        System.out.println("序列化后数据长度:" + text.getBytes().length);
        System.out.println("初始化时间：" +(start2-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(包含初始化时间)：" +(end-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(不包含初始化时间)：" +(end-start2)+"ms");

        Student student1 = JSON.parseObject(text,Student.class);
        System.out.println("反序列化后数据:" + student1.toString() + "\n");
    }

    private static void excuteWithHessian() throws IOException {
        Student student = init();
        System.out.println("Hessian序列化============================");
        Long start1=System.currentTimeMillis();//初始化时间
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        HessianOutput ho=new HessianOutput(bos);

        Long start2=System.currentTimeMillis();//序列化时间
        for(int i=0;i<SERIALIZABLE_NUM;i++){
            ho.writeObject(student);
            if(i==0){
                System.out.println("序列化后数据长度:" + bos.toByteArray().length);
            }
        }
        Long end = System.currentTimeMillis();

        System.out.println("初始化时间：" +(start2-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(包含初始化时间)：" +(end-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(不包含初始化时间)：" +(end-start2)+"ms");

        HessianInput hi=new HessianInput(new ByteArrayInputStream(bos.toByteArray()));
        Student student1=(Student)hi.readObject();
        System.out.println("反序列化后数据:" + student1.toString() + "\n");
    }

    private static void excuteWithProtoBuf() throws IOException {
        Student student = init();
        System.out.println("ProtoBuf序列化============================");
        Long start1=System.currentTimeMillis();//初始化时间
        Codec<Student> studentCodec= ProtobufProxy.create(Student.class,false);
        byte[] bytes=null;

        Long start2=System.currentTimeMillis();//序列化时间
        for(int i=0;i<SERIALIZABLE_NUM;i++){
            bytes=studentCodec.encode(student);
        }
        Long end = System.currentTimeMillis();

        System.out.println("序列化后数据长度:" + bytes.length);
        System.out.println("初始化时间：" +(start2-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(包含初始化时间)：" +(end-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(不包含初始化时间)：" +(end-start2)+"ms");

        Student student1 = studentCodec.decode(bytes);;
        System.out.println("反序列化后数据:" + student1.toString() + "\n");
    }

    private static void excuteWithKryo() throws IOException {
        Student student = init();
        System.out.println("Kyro序列化============================");
        Long start1=System.currentTimeMillis();//初始化时间
        Kryo kryo = new Kryo();
        Output output = new Output();
        byte[] bytes = new byte[60 * SERIALIZABLE_NUM];//这个buffer需要可以保留所有序列化后的对象
        output.setBuffer(bytes);

        Long start2=System.currentTimeMillis();//序列化时间
        for(int i=0;i<SERIALIZABLE_NUM;i++){
            kryo.writeObject(output, student);
            output.toBytes();
            if(i==0){
                System.out.println("序列化后数据长度:" + output.toBytes().length);
            }
        }
        Long end = System.currentTimeMillis();
        System.out.println("初始化时间：" +(start2-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(包含初始化时间)：" +(end-start1)+"ms");
        System.out.println("序列化" + SERIALIZABLE_NUM + "次花费时间(不包含初始化时间)：" +(end-start2)+"ms");

        Input input = new Input(output.toBytes());
        Student student1 = kryo.readObject(input, Student.class);
        System.out.println("反序列化后数据:" + student1.toString() + "\n");
    }

    /**
     * 序列化bean初始化
     * @return
     */
    private static Student init(){
        Teacher teacher = new Teacher();
        teacher.setId("00001");
        teacher.setName("X");
        teacher.setAge(18);

        Student student = new Student();
        student.setId("00011");
        student.setName("Y");
        student.setAge(18);
        student.setGrade("100");
        student.setTeacher(teacher);

        return student;
    }
}
更多序列化方式及分析请自行查阅网络资料
Laiix
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java序列化的几种方式
学无止境
02-28 3416
【Java序列化的几种方式】
Java 序列化详解
最新发布
兴趣是最好的老师，勤能补拙
05-15 2713
Java 序列化（Serialization）是指将一个 Java 对象转换成字节序列，以便在网络上传输或存储在本地磁盘中。而反序列化（Deserialization）则是将已经序列化的字节序列恢复为 Java 对象。Java 提供了自带的序列化机制，可以通过实现 Serializable 接口以及使用 ObjectOutputStream 和 ObjectInputStream 类来实现序列化和反序列化。
JAVA基础（JAVA 序列化）
ITWUYI的博客
10-11 363
JAVA基础（JAVA 序列化）知识点 JAVA基础（JAVA 序列化）的目的就是创建可复用的 Java 对象。 （1）保存(持久化)对象及其状态到内存或者磁盘 Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。 但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java 对象序列化就能够帮助我们实现该功能。 （2）序列化对象以
java 序列化 alt+enter生成序列号
Zeng11123的博客
03-20 2860
java 一键生成序列 类继承了Serializable接口之后，使用alt+enter快捷键自动创建序列化id idea默认设置没有开启：alt+enter (不同系统和自定义的配置可能会快捷键可能略有不同)发现并没有提供 在Idea左上角点击 然后输入serializations issues，点击without serialVersionUid。 点击即可 ...
Java对象序列化详解
爱雨轩
08-10 3万+
所有分布式应用常常需要跨平台，跨网络，因此要求所有传的参数、返回值都必须实现序列化。一、定义　　序列化：把Java对象转换为字节序列的过程。 　　 　　反序列化：把字节序列恢复为Java对象的过程。二、用途　　对象的序列化主要有两种用途： 　　 　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；（持久化对象） 　　 　　2） 在网络上传送对象的字节序列。（网络传输对象）...
Java中对象序列化与反序列化详解
09-03
在Java编程中，对象序列化是一个重要的概念，它允许将Java对象转换为字节序列，便于存储或在网络中传输。这个过程被称为序列化，而将字节序列恢复为原来的对象则称为反序列化。本文将深入探讨Java中的对象序列化与反...
Java对象的序列化和反序列化实践
12-22
　把Java对象转换为字节序列的过程称为对象的序列化。 　把字节序列恢复为Java对象的过程称为对象的反序列化。 　对象的序列化主要有两种用途： 　1）把对象的字节序列地保存到硬盘上，通常存放在一个文件中...
java常见的序列化方式
09-01
Hessian序列化不包含Java序列化那么多元数据，它主要关注数据本身，通过简单的类型描述和数据内容来序列化对象。例如，对于基本类型的Integer对象，Hessian会将其表示为'I'开头的字节流，后面跟着实际的数值。 ...
Java对象序列化操作详解
08-27
* 打印流：可以使用 java.io.ObjectOutputStream 和 java.io.ObjectInputStream 实现序列化和反序列化。 总结：Java 对象序列化操作详解是 Java 语言中一种重要的机制，它允许将 Java 对象转换为字节序列，以便在...
Java中对象的序列化方式克隆详解
08-31
Java中的对象序列化是将一个对象转换为字节序列的过程，这一过程允许对象的状态被持久化，例如存储到磁盘或在网络中传输。反序列化则是将字节序列恢复为原来的对象状态。对象序列化是Java提供的一种强大的工具，尤其...
Java实现对象序列化的两种方式Demo
howroad的博客
05-05 2372
package com.luhao.serializable; import java.io.Externalizable; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInput; import java.io.
对象序列化的几种方式的比较
我的角落
01-25 597
 在java中socket传输数据时，数据类型往往比较难选择。可能要考虑带宽、跨语言、版本的兼容等问题。比较常见的做法有两种：一是把对象包装成JSON字符串传输，二是采用java对象的序列化和反序列化。随着Google工具protoBuf的开源，protobuf也是个不错的选择。对JSON,Object Serialize,ProtoBuf 做个对比。 定义一个待传输的对象UserVo： ...
Java基础——对象的序列化（通俗易懂，排版优美）
扬俊的小屋
05-23 2万+
Java基础——对象的序列化什么是对象的序列化(Serialization) “序列化”是一种把对象的状态转化成字节流的机制，“反序列”是其相反的过程，把序列化成的字节流用来在内存中重新创建一个实际的Java对象。这个机制被用来“持久化”对象。通过对象序列化，可以方便的实现对象的持久化储存以及在网络上的传输。大致的过程如下图所示： 对象被转换成“字节流”后可以存入文件，内存，亦或者是数...
对象序列化
在路上---品味生活
09-02 677
1、序列化是干什么的？ 简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存Object States，但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。 2、什么情况下需要序列化 a）当你想把的内存中的对象保存到一个文件中或者数据库中时候； b）当你想用套接字在网络上传送对象的时候； c）当你想
Java对象的序列化（Serialization）和反序列化详解
热门推荐
OceanSky的专栏
02-13 12万+
1.序列化和反序列化 序列化（Serialization）是将对象的状态信息转化为可以存储或者传输的形式的过程，一般将一个对象存储到一个储存媒介，例如档案或记忆体缓冲等，在网络传输过程中，可以是字节或者XML等格式；而字节或者XML格式的可以还原成完全相等的对象，这个相反的过程又称为反序列化； 2.Java对象的序列化和反序列化 在Java中，我们可以通过多种方式来创建对象，并且只要对象...
对象序列化的含义和意义
huhahuha_的博客
06-03 2万+
序列化机制允许将实现序列化的Java对象转换成字节序列 ,这些字节序列可以被保存在磁盘上,或者通过网络传输,以备以后重新恢复成原来的对象.1.对象的序列化(serialize)指将一个Java对象写入IO流中,对象的反序列化机制(Deserialize)则指从IO流中恢复该Java对象.如果需要让某个对象可以支持序列化机制,必须让它的类是可序列化的(实现Serialize接口或者Externali...
序列化和反序列化以及创建对象的几种方式
qq_41942241的博客
08-12 6693
    如何将对象中的信息永久保存           1.将来将对象信息存入数据库           2.java 中提供的序列化方式来永久保存数据 序列化流的概述            所谓的序列化：就是把对象通过流的方式存储到文件中.注意：此对象 要重写Serializable 接口才能被序列化 package org.westos.Demo; import java.io.*; ...
Java基础（28）——对象的序列化详解及示例分析
清风不渡
05-26 438
Java基础（28）——对象的序列化详解及示例分析版权声明一、对象的序列化（1）什么是对象序列化（2）API（3）Serializable接口（4）案例：序列化和反序列化Dog对象 版权声明 本文原创作者：清风不渡 博客地址：https://blog.csdn.net/WXKKang 一、对象的序列化 （1）什么是对象序列化   前两篇我们学习了字节流与字符流，通过它们我们既可以把数据从硬盘中读取出来，也可以把数据储存在硬盘中，那么我们是否可以将我们在程序中创建的对象也存储在硬盘中呢？当然是可以的
从java序列化来聊聊目前流行的几个编解码框架
mffandxx的博客
07-26 6097
我们为什么要序列化举个例子：下雨天我们要打伞，但是之后我们要把伞折叠起来，方便我们存放。那么运用到我们java中道理是一样的，我们要将数据分解成字节流，以便存储在文件中或在网络上传输，这叫序列化。我们要用的时候，就需要将字节流重构成对象，这叫反序列化。不知道我这么说大家能不能理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值