分布式通信序列化

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量160 收藏
点赞数
分类专栏： 分布式基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38660866/article/details/108012380
版权

知识点

概述

什么是序列化？
序列化就是把对象转化为字节序列的过程就是对象的序列化，反之则是对象的反序列化。
java的序列化机制是serialize接口
缺点在于：
1）序列化数据结果比较大，传输效率低
2）无法跨语言

后续xml编码格式的对象序列化机制成为了主流：
1）多语言
2）便于理解

使用恰当的序列化洗衣额不仅可以提高系统的通用性，强壮性，安全性，优化性能，同时还能让系统更加便于调试和扩展。

java序列化

java序列化实例

首先定义一个对象并且集成serialize接口

package com.hikvision.rabbitmq.serialize;

import java.io.Serializable;

/**
 * @author lulinfeng
 * @ClassName Person
 * @Description TODO
 * @autuor lulinfeng
 * @Date 2020/8/13
 * @Version 1.0
 */
public class Person implements Serializable {

    private static final long serialVersionUID = -4035677026738967782L;
    private String name;

    private int age;

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

实现序列化及反序列化操作，采取文件流

package com.hikvision.rabbitmq.serialize;

import java.io.*;

/**
 * @ClassName SerializeDemo
 * @Description TODO
 * @Autuor lulinfeng
 * @Date 2020/8/13
 * @Version 1.0
 */
public class SerializeDemo {
    public static void main(String[] args) {
        //序列化人员
        serializePerson();
        //反序列化人员
        unSerializePerson();
    }

    private static void unSerializePerson() {

        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(new File("person")));
            Person person = null;
            try {
                person = (Person) ois.readObject();
                System.out.println("name：" + person.getName());
                System.out.println("age:" + person.getAge());
                System.out.println("反序列化成功");
                ois.close();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void serializePerson() {
        try {
            ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(new File("person")));
            Person person = new Person();
            person.setName("llf");
            person.setAge(18);
            os.writeObject(person);
            System.out.println("序列化成功");
            os.close();
        } catch (Exception e) {
        }
    }
}

seriaVersionUID的作用

  1. 保证序列化对象和反序列化对象是同一个。序列化会有版本号，如果没有这个的话，会生成新的。
    2）静态变量的序列化
    序列化不保存静态变量状态
    序列化之后然后修改一个静态变量的值，然后再反序列化后发现对象的值已经变成修改后的值了。

Tranisent 变量的作用

Tranisent修饰的属性不参与序列化

序列化的父子类问题

如果父类没有实现序列化，而子类实现序列化，那么父类中的成员没法做序列化操作

序列化的存储规则

对同一个对象进行多次写入，打印出第一次存储结果和第二次存储结果只多5个字节的引用关系，不会导致文件累加。

深克隆和浅克隆

1）浅克隆 ：复制对象，不复制对象的引用
2）深克隆 ：复制对象，复制对象的引用

可以采取序列化来实现深克隆

package com.llf.sericalizeClone;

import java.io.Serializable;

public class Teacher implements Serializable{
	
	/**
	 * 
	 */
	private static final long serialVersionUID = -6957411933291636976L;
	private String Name;

	public String getName() {
		return Name;
	}

	public void setName(String name) {
		Name = name;
	}

	@Override
	public String toString() {
		return "Teacher [Name=" + Name + "]";
	}
}

创建student类来继承teacher类

package com.llf.sericalizeClone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Student implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = -6029082021501636342L;
	
	private String Name;
	private int age;
	
	private Teacher teacher;
	
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
	
	public Object deapClone(){
		ByteArrayOutputStream os=new ByteArrayOutputStream();
		ObjectOutputStream oos=null;
		ByteArrayInputStream is=null;
		ObjectInputStream ois = null;
		try {
			//序列化
			oos=new ObjectOutputStream(os);
			oos.writeObject(this);
			//反序列化
			is=new ByteArrayInputStream(os.toByteArray());
		    ois=new ObjectInputStream(is);
			try {
				return ois.readObject();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				ois.close();
				is.close();
				oos.close();
				os.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	@Override
	public String toString() {
		return "Student [Name=" + Name + ", age=" + age + "]";
	}
}

测试一下

package com.llf.sericalizeClone;

public class CloneDemo {
	public static void main(String[] args) {
		Teacher teacher=new Teacher();
		teacher.setName("LLF");
		Student student=new Student();
		student.setName("CQ");
		student.setAge(18);
		student.setTeacher(teacher);
		
		Student student2=(Student) student.deapClone();//克隆一个对象
		
		System.out.println(student);
		System.out.println(student2);
	}
}

这边总结一下：
1）在java中，只要一个类实现了java.io.serializable接口，那么它就可以被序列化
2） 通过objectoutputstream和objectinputstream对对象进行序列化和反序列化
3）对象是否被反序列化，不仅取决于对象的代码是否一致，同样还有一个重要因素（UID）
4）序列化不保存静态变量
5）要想父类对象也参与序列化操作，必须要让父类也实现serializable接口
6）Transient主要是控制控制变量是否能被序列化。如果没有被序列化的成员变量反序列化后会被设置为初始值。
7）通过序列化操作可以实现实现深度克隆。

当前主流的序列化技术有哪些

JSON
Hessian(2)
xml
protobuf
kryo
msgpack
FST
thrify
protostuff
avro

演示几种序列化手段的demo
首先是JSON
为了方便演示
定义公用的init方法

  //初始化对象
    private static Person init() {
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        return person;
    }

JSON

首先引入pom

 <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>

首先是jackson

private static void executeWithJackson() {
        Person person = init();
        ObjectMapper mapper = new ObjectMapper();
        byte[] writeBytes = null;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            try {
                //序列化
                writeBytes = mapper.writeValueAsBytes(person);
            } catch (JsonGenerationException e) {
                e.printStackTrace();
            } catch (JsonMappingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("JSON 序列化 " + (System.currentTimeMillis() - start) + "ms : 总大小为-->" + writeBytes.length);
        //反序列化
        try {
            Person person2 = mapper.readValue(writeBytes, Person.class);
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

然后是fastjson

private static void executeWithFastJson() {
        Person person = init();
        String text = null;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            //序列化
            text = JSON.toJSONString(person);
        }
        System.out.println("fastjson JSON 序列化 " + (System.currentTimeMillis() - start) +
                "ms : 总大小为-->" + text.getBytes().length);
        //反序列化
        Person person2 = JSON.parseObject(text, Person.class);
    }

protobuf

首先引入pom

 <dependency>
            <groupId>com.baidu</groupId>
            <artifactId>jprotobuf</artifactId>
            <version>2.1.2</version>
        </dependency>

然后使用protobuf需要在对象字段上加注解如下
在这里插入图片描述
然后

private static void executeWithProtoBuf() {
        Person person = init();
        byte[] Bytes = null;
        Codec<Person> personCodec = ProtobufProxy.create(Person.class, false);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            //序列化
            try {
                Bytes = personCodec.encode(person);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("protobuf JSON 序列化 " + (System.currentTimeMillis() - start) +
                "ms : 总大小为-->" + Bytes.length);
        //反序列化
        try {
            Person person2 = personCodec.decode(Bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

protobuf优势就是字节数少，非常适合网络传输。

hessian

引入pom

  <dependency>
            <groupId>com.caucho</groupId>
            <artifactId>hessian</artifactId>
            <version>4.0.63</version>
        </dependency>

定义方法

 private static void executeWithHessian() {
        Person person = init();
        byte[] Bytes = null;
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        HessianOutput ho = new HessianOutput(os);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            //序列化
            try {
                ho.writeObject(person);
                if (i == 0) {
                    System.out.println(os.toByteArray().length);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("hessian JSON 序列化 " + (System.currentTimeMillis() - start) +
                "ms : 总大小为-->" + Bytes.length);
        //反序列化
        HessianInput hi = new HessianInput(new ByteArrayInputStream(os.toByteArray()));
        try {
            Person person2= (Person) hi.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

字节比较多，但是耗时很低

我们看下各个序列化手段的耗时和字节对比
在这里插入图片描述

Allen烽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从分布式到微服务：深入理解网络，网络传输中的对象序列化问题
stone_tmp的博客
06-12 311
网络传输中的对象序列化问题 仅仅懂了Socket编程还不够,因为我们不是简单地写一个发送字符串的Hello World程序，需要实现复杂的对象实例传输，因此，如何将一个对象实例编码成为高效的二进制数据报文传输到对端，并且正确地“还原”出来，就是一个专业的技术问题了。 对象序列化技术是Java本身的重要底层机制之一，因为Java一开始就是面向网络的，远程方法调用（RPC）是必不可少的，需要方便地将一个对象实例通过网络传输到远端。Java自身的序列化机制有两个大问题。 序列化的数据比较大，传输效率低。
通信协议之序列化
07-24 1043
通信协议可以理解两个节点之间为了协同工作实现信息交换，协商一定的规则和约定，例如规定字节序，各个字段类型，使用什么压缩算法或加密算法等。常见的有tcp，udo，http，sip等常见协议。协议有流程规范和编码规范。流程如呼叫流程等信令流程，编码规范规定所有信令和数据如何打包/解包。 编码规范就是我们通常所说的编解码，序列化。不光是用在通信工作上，在存储工作上我们也经常用到。如我们经常想把内存
通信协议-序列化
Kevin_Czl的博客
12-31 602
通信协议-序列化 序列化的含义 序列化（serialization）就是将对象序列化为二进制形式（字节数组），一般也将序列化称为编码（Encode），主要用于网络传输、数据持久化等； 反序列化（deserialization）则是将从网络、磁盘等读取的字节数组还原成原始对象，以便后续业务的进行，一般也将反序列化称为解码（Decode），主要用于网络传输对象的解码，以便完成远程调用。 序列化协议的需求 通用性 跨平台、跨语言 流行性 可读性 对于序列化后的二进制串，需要同时编写反序列化程序来验证序列
序列化通信协议
Kelvin_Yan的专栏
12-04 1191
不同编程语言间的交互，可以通过文件的形式，更准确应该叫做通信协议。现在有不少的结构化数据存储格式可以完成这一任务，如xstream,jackjson,jdk,hessian,facebook的thrift,google protocol buffer 序列化原理：http://blog.chinaunix.net/uid-27105712-id-3266286.html 几种序列化协议(p
网络通信的序列化和反序列化
JDSZGLLL的博客
05-31 1206
由于在系统底层，数据的传输形式是简单的字节序列形式传递，即在底层，系统不认识对象，只认识字节序列，而为了达到进程通讯的目的，需要先将数据序列化，而序列化就是将对象转化字节序列的过程。相反地，当字节序列被运到相应的进程的时候，进程为了识别这些数据，就要将其反序列化，即把字节序列转化为对象无论是在进程间通信、本地数据存储又或者是网络数据传输都离不开序列化的支持。而针对不同场景选择合适的序列化方案对于应用的性能有着极大的影响。
知识整理和序列化
12-22
这个过程对于数据持久化、跨网络通信以及实现某些高级功能（如对象缓存和分布式计算）至关重要。下面将详细讨论序列化的基本原理、注意事项以及如何在实际代码中应用。 **序列化概念** 序列化是将对象转换成可存储...
0729分布式通信框架-RMI1
08-08
在分布式通信中，序列化是将对象转换为字节流以便在网络中传输的关键步骤。Java中，SerialVersionUID用于版本控制，静态变量不参与序列化，Transient关键字标记不需序列化的成员。此外，还有多种序列化库，如Kryo、...
内置序列化内置序列化内置序列化扩展
04-29
序列化有多种用途，例如持久化对象状态、跨进程通信（如在分布式系统中）、缓存和网络传输。但是，需要注意的是，序列化可能会暴露敏感信息，因此在处理包含敏感数据的对象时，应谨慎使用，并考虑使用加密或其他安全...
java序列化和反序列化，面试必备
12-21
Java序列化和反序列化是Java开发中常见且重要的概念，尤其在...总之，Java序列化和反序列化是处理对象持久化和网络通信的关键技术。了解其原理和实现方式，对于Java开发者来说是必不可少的技能，也是面试中的常考点。
Java中对象序列化与反序列化详解
09-03
2. **网络传输**：通过序列化，对象可以在不同的Java虚拟机之间传递，实现分布式应用。 3. **进程间通信**：在多线程或者多进程环境中，序列化可以用来在进程间传递对象。 为了实现序列化，对象所属的类需要实现`...
实战篇 | 19 网络通信与序列化
LorneNote
06-25 1448
进程间通信 通信与机器学习的关系 这些内容看起来好像和机器学习没有关系，但是对于一个完整的分布式实时处理系统来说，机器学习的框架是基于实时分布式处理系统的基础上去架构的，从而形成一个完整的Machine Learning Platform。如下图： 同一台机器内的进程间通信 为什么需要进程间通信 思考这样一个背景问题 场景一： 我们为什么需要进程间通信，大家想想这样一...
Hadoop序列化及IPC通信机制简析
Universe — Higher and farther
11-23 842
一、Hadoop序列化 1、简介： 什么是序列化？将对象编码成一个字节流。 反序列化：将一个字节流编码成对象。 序列化主要有三种主要用途: 作为一种持久化存储。可以把对象序列化后存储到磁盘上，供以后反序列化使用。 作为一种通信数据格式。 作为一种拷贝、克隆机制。 序列化在分布式数据处理的常用上面提到的前两种功能：持久化存储和进程间通信。 处理大规模数据的hadoop...
对象序列化在网络通信中的运用
csdn问鼎
11-13 507
都知道对象序列化这个知识，可到底有什么用处？ a当你想把的内存中的对象保存到一个文件中或者数据库中时候； b当你想用套接字在网络上传送对象的时候； c当你想通过RMI传输对象的时候 2.今天通过实例来看看对象序列化在网络通信的运用（socket） 3.对象继承序列化接口import java.io.Serializable;public class TestObject implement
IPC通信基础概念之序列化
錦小白的博客
03-31 361
一、对象序列化    何为对象序列化？看着名字就有点抽象。那么官方的解释是：序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。   从上面的解释可以粗略的得知序列化就是将对象状态写入到存储区中。那么既然可以写入状态，就可以从存储区中读取对象...
枚举工具类
qq_43049583的博客
08-04 212
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 205
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 608
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 559
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值