分布式通信序列化（分布式三）

最新推荐文章于 2020-01-04 15:25:30 发布
最新推荐文章于 2020-01-04 15:25:30 发布
阅读量325 收藏 1
点赞数
分类专栏： 分布式
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/85649448
版权

目录

序列化与反序列化

在这里插入图片描述

序列化与分布式通信关系

通过 序列化+反序列化+网络 的结合，不同的应用服务器可以共同协作起来，共同构建分布式应用
在这里插入图片描述

java中实现一个序列化与反序列化

三个步骤

  1. 实现Serializable接口
  2. 使用ObjectInputStream读
  3. 使用ObjectOutputStream 写

对应代码例子

public class Person implements Serializable{
	
	private static final long serialVersionUID = 385470237187218240L;
	
	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;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}


public class SerializeDemo {

	public static void main(String[] args) throws Exception {
		// 序列化
		serializePerson();
		// 反序列化
		deSerializePerson();
	}

	private static void serializePerson() throws Exception {
		Person person = new Person();
		person.setName("张三");
		person.setAge(12);
		// System.out.println(person);
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
		oos.writeObject(person);
		
		System.out.println("序列化完成，文件大小为：" + new File("person.txt").length());
	}
	
	private static void deSerializePerson() throws Exception {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
		Person person = (Person) ois.readObject();
		System.out.println(person);
	}

}

java序列化的细节

serialVersionUID

=版本号
序列化以后，修改版本号，进行反序列化

Exception in thread "main" java.io.InvalidClassException: priv.dengjili.distributed_s1.serialize.bean.Person; local class incompatible: stream classdesc serialVersionUID = 385470237187218240, local class serialVersionUID = 85470237187218240
	at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
	at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
	at java.io.ObjectInputStream.readClassDesc(Unknown Source)
	at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
	at java.io.ObjectInputStream.readObject0(Unknown Source)
	at java.io.ObjectInputStream.readObject(Unknown Source)
	at priv.dengjili.distributed_s1.serialize.demo.SerializeDemo2.deSerializePerson(SerializeDemo2.java:34)
	at priv.dengjili.distributed_s1.serialize.demo.SerializeDemo2.main(SerializeDemo2.java:17)

ps: 添加会删除字段，不修改版本后，则反序列正常

静态变量的序列化

序列化并不保存静态变量的状态,因为静态变量不属于对象本身的内容

Transient关键字

transient关键字表示指定属性不参与序列化，过滤的意思

父子类问题

如果父类没有实现序列化，而子类实现列序列化。
只会序列化子类
在这里插入图片描述

序列化的存储规则

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

序列化实现深度克隆

java中的深拷贝与浅拷贝：https://blog.csdn.net/dengjili/article/details/85716058

class Book implements Serializable {
	private static final long serialVersionUID = 8234484588726379017L;
	private String name;

	public String getName() {
		return name;
	}

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

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

class Teacher implements Serializable {
	private static final long serialVersionUID = -7471815149371769182L;

	private int no;

	private Book book;

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	public Book getBook() {
		return book;
	}

	public void setBook(Book book) {
		this.book = book;
	}

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

	public static void main(String[] args) throws Exception {
		// 序列化
		Book book = new Book();
		book.setName("语文");
		Teacher teacher = new Teacher();
		teacher.setNo(10001);
		teacher.setBook(book);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(teacher);

		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
		// 反序列化
		ObjectInputStream ois = new ObjectInputStream(bais);
		Teacher teacher2 = (Teacher) ois.readObject();
		System.out.println(teacher == teacher2);

		System.out.println("老师1:" + teacher.getNo() + ",学科:" + teacher.getBook().getName());
		System.out.println("老师2:" + teacher2.getNo() + ",学科:" + teacher2.getBook().getName());
		
		teacher.setNo(2222);
		teacher.getBook().setName("数学");
		System.out.println("老师1:" + teacher.getNo() + ",学科:" + teacher.getBook().getName());
		System.out.println("老师2:" + teacher2.getNo() + ",学科:" + teacher2.getBook().getName());
	}
}

测试结果

false
老师1:10001,学科:语文
老师2:10001,学科:语文
老师1:2222,学科:数学
老师2:10001,学科:语文

常用序列化框架

公共依赖

		<!-- https://mvnrepository.com/artifact/org.codehaus.jackson/jackson-mapper-asl -->
		<dependency>
			<groupId>org.codehaus.jackson</groupId>
			<artifactId>jackson-mapper-asl</artifactId>
			<version>1.9.13</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.54</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.baidu/jprotobuf -->
		<dependency>
			<groupId>com.baidu</groupId>
			<artifactId>jprotobuf</artifactId>
			<version>2.2.7</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.caucho/hessian -->
		<dependency>
			<groupId>com.caucho</groupId>
			<artifactId>hessian</artifactId>
			<version>4.0.51</version>
		</dependency>
bean

Person

public class Person {
	
	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

Person2

public class Person2 {
	
	@Protobuf(fieldType = FieldType.STRING, order = 1)
	private String name;
	@Protobuf(fieldType = FieldType.INT32, order = 2)
	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

Person3

public class Person3 implements Serializable{
	
	private static final long serialVersionUID = 3237645377924591122L;
	
	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}
FastSon
public class FastSonSerialize {

	public static void main(String[] args) throws Exception {
		Person person = new Person();
		person.setName("张三");
		person.setAge(12);

		String text = JSON.toJSONString(person);
		System.out.println(text);
		System.out.println(text.getBytes().length);
		Person person2 = JSON.parseObject(text, Person.class);

		System.out.println(person == person2);
		System.out.println(person2);
	}

}
JackSon
public class JackSonSerialize {

	public static void main(String[] args) throws Exception {
		Person person = new Person();
		person.setName("张三");
		person.setAge(12);
		
		ObjectMapper mapper = new ObjectMapper();
		byte[] bytes = mapper.writeValueAsBytes(person);
		System.out.println(new String(bytes));
		System.out.println(bytes.length);
		
		Person person2 = mapper.readValue(bytes, Person.class);
		
		System.out.println(person == person2);
		System.out.println(person2);
	}

}
protobuf
/**
 * 对应github链接： https://github.com/jhunters/jprotobuf
 * 
 * @author it
 */
public class JprotobufSerialize {

	public static void main(String[] args) throws Exception {
		Codec<Person2> simpleTypeCodec = ProtobufProxy.create(Person2.class);

		Person2 person = new Person2();
		person.setName("张三");
		person.setAge(12);
		try {
			// 序列化
			byte[] bb = simpleTypeCodec.encode(person);
			System.out.println(bb.length);
			// 反序列化
			Person2 person2 = simpleTypeCodec.decode(bb);
			System.out.println(person == person2);
			System.out.println(person2);
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

}
Hessian
public class HessianSerialize {

	public static void main(String[] args) throws Exception {
		Person3 Person = new Person3();
		Person.setName("张三");
		Person.setAge(12);
		
		ByteArrayOutputStream buffers = new ByteArrayOutputStream();
		HessianOutput output = new HessianOutput(buffers);
		
		output.writeObject(Person);
		
		byte[] byteArray = buffers.toByteArray();
		System.out.println(byteArray.length);
		HessianInput input = new HessianInput(new ByteArrayInputStream(byteArray));
		Person3 person2 = (Person3) input.readObject(Person3.class);
		
		System.out.println(Person == person2);
		System.out.println(person2);
	}

}
dengjili
关注
专栏目录
0729分布式通信框架-RMI1
08-08
在分布式通信中，序列化是将对象转换为字节流以便在网络中传输的关键步骤。Java中，SerialVersionUID用于版本控制，静态变量不参与序列化，Transient关键字标记不需序列化的成员。此外，还有多种序列化库，如Kryo、...
java序列化和反序列化，面试必备
12-21
三、使用`Serializable`接口实现序列化 1. 示例代码： ```java public class Person implements Serializable { private String name; private String age; // 构造函数和toString方法省略... public static...
【分布式基础】3.分布式通信-序列化
左耳听风的博客
07-28 411
1.java序列化机制Serialize接口 java本身的序列化机制存在的问题 1. 序列化数据结果比较大、传输效率比较低 2. 不能跨语言对接 以至于在后来的很长一段时间，基于XML格式编码的对象序列化机制成为了主流，一方面解决了多语言兼容问题，另一方面比二进制的序列化方式更容易理解。以至于基于XML的SOAP协议及对应的WebService框架在很长一段时间内成为各个主流开发语言的必...
01.分布式之序列化
masteryourself
01-04 197
1. 序列化 Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。但在现实应用中，就可能要求在 JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java 对象序列化就能够帮助我们实现该功能 简单来说 序列化是把对象的状态信息转化为可存储或...
分布式通讯-序列化
糖豆包子的博客
08-02 264
一、定义以及相关概念 分布式系统的产生带了系统间通讯的需求，而互联通讯的双方需要采用约定的协议， 序列化和反序列化是约定协议的一部分。通讯协议往往采用分层模型，在OSI七层协议模 型中表示层的主要功能就是序列化与反序列化。• 序列化： 将数据结构或对象转换成二进制串的过程。 • 反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。 序列化 二、序列化协议特性
分布式通信——初探序列化
荆州长江大学 余攀(Java学生)
07-23 219
初探序列化 我们还是按部就班地进行wwh： 什么是序列化（what） 为什么使用序列化（why） 如何使用序列化（how） 什么是序列化 序列化是将对象的状态信息进行转换可以存储或传递的形式的过程。序列化使其他代码可以查看或修改，那些不序列化便无法访问的对象实例数据。 为什么使用序列化 1.以某种存储形式使自定义对象持久化； 2.将对象由...
分布式系统基础--序列化
zy345293721的博客
01-14 768
1. 序列化的意义 2. 如何实现一个序列化操作 3. 序列化的高阶认识 4. 常见的序列化技术及应用 5. Protobuf 实现原理分析 6. 序列化框架的选型 序列化 Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 J...
一种渔业分布式通信系统的天线选择算法.pdf
08-09
在深入探讨《一种渔业分布式通信系统的天线选择算法》的知识点之前，需要首先明确几个基本概念和背景信息。移动自组织网络（MANET）是一种没有固定基础设施、通过移动节点之间的直接通信构成网络的无线通信模式。在...
网络游戏-无线主从分布式通信网络.zip
09-20
通常采用的是基于时间戳的序列化技术，保证了不同设备之间的数据一致性。 7. **安全通信**：无线通信中，数据的安全性至关重要。网络游戏通常使用加密技术（如SSL/TLS）保护玩家信息，防止数据被窃取或篡改，确保...
opentsdb：可扩展的分布式时间序列数据库
02-28
OpenTSDB是一个基于HBase的开源、分布式的时序数据库，设计用于存储和查询大量的时间序列数据。在本文中，我们将深入探讨OpenTSDB的核心特性、架构、与Java的关联，以及如何部署和使用它。 一、OpenTSDB概述 ...
Java序列化常见的三个问题
08-18
主要介绍了Java序列化常见的三个问题，帮助大家更好的理解和学习JAVA，感兴趣的朋友可以了解下
分布式：序列化和反序列化详解
Brave_heart4pzj的博客
01-03 3748
一、定义及常用实现方式 1、序列化，反序列化的定义 序列化：序列化就是把一个对象变成二进制或者是一个有序的字节数组进行序列化来。 反序列化：把一个有序的字节流的对象重新加载为一个对象。 在分布式的中对程序的优化是非常重要的，只要在网络中进行 传输的话物理层之间的交互都需要序列化。 2、java中自带的序列化 让其序列化的类实现Serializable接口：缺点：1：它是不能实现跨语言的。2...
分布式基础之序列化与反序列化
qq_35909080的博客
12-05 377
  目录 序列化与反序列化，Why？ 序列化的意义 一个简单实例 JAVA序列化的高阶认识 serialVersionUID 的作用 静态变量序列化 父类的序列化 Transient 关键字 序列化的存储规则 序列化实现深克隆 常见的序列化技术 XML 序列化框架 JSON 序列化框架 Hessian 序列化框架 Protobuf 序列化框架 序列化技术的选型 ...
分布式应用中java对象序列化问题
百岁
07-10 263
  ██ 在分布式应用中，通常会以RMI协议作为分布式服务的对象传输协议，在不同服务器之间传输对象之前需要先将对象序列化，java底层sdk中已经将对象的序列化机制实现了。几乎可以兼容所有java类型的序列化（Serialize）   ██在实际应用中需要注意以下几点：       ◢◢1 需要序列化的对象需要实现java.io.Serializable 接口，如果在传输对象的对象的类...
分布式系列三: 对象序列化
weixin_33968104的博客
09-17 122
序列化可以解决分布式系统节点间复杂对象传输的问题. 将对象状态转化为可存储或可传输的过程叫序列化, 而反序列化是将其还原成对象的过程. 几种序列化机制 JDK的序列化 Java默认的序列化要求实现Serializable接口. 缺点: 序列化的结果比较大, 占用字节多, 传输效率低 仅Java实现, 不能跨语言 WebService 基于XML格式的...
分布式通信协议-序列化（分布式笔记）
Nicholas.S的博客
05-23 928
Java序列化机制Serializable接口 Java的序列化机制存在的问题 1、序列化数据结果比较大、传输效率比较低 2、不能跨语言对接 影响：以至于在后来的很长一段时间，基于XML格式编码的对象序列化机制成为了主流，一方面解决了多语言兼容问题，另一方面比二进制的序列化方式更容易理解。以至于基于XML的SOAP协议及对应的WebService框架在很长一段时间内成为各个主流开发语言的必备的技术...
分布式计算中序列化的范例
程序员的痛苦人生
02-22 114
今天粗略地看了[url=http://hadoop.apache.org/avro/docs/current/index.html]Apache Avro[/url]的资料， 这是一种类似于Thrift和ProtocolBuffer的数据序列化工具，看起来不错。主要特点是：有schema定义以及动态类型。 schema定义的好处是能减少数据大小，如果没有schema定义，那么协议处理器不可...
分布式系统中的序列化与反序列化
bitcarmanlee的博客
12-17 2707
1.定义以及相关概念作者 刘丁 发布于 2015年5月7日 | 3 讨论 分享到： 微博 微信 Facebook Twitter 有道云笔记 邮件分享 稍后阅读我的阅读清单 简介文章作者服务于美团推荐与个性化组，该组致力于为美团用户提供每天billion级别的高质量个性化推荐以及排序服务。从Terabyte级别的用户行为数据，到Gigabyte级别的Deal/Poi数据；从对实时性要求毫秒以
分布式架构基础-序列化和反序列化
长风破浪会有33的博客
06-07 981
了解序列化的意义 Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当 JVM处于运行时，这些对象才可能存在，即这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象，Java 对象序列化就能够帮助我们实现该功能。 简单来说，序列化是把对象的状态信息转化为可存储或传输的形式，也...
分布式通信框架-RMI深入剖析：RPC协议、序列化、加密与网络IO
分布式通信框架-RMI介绍 在分布式系统中，通信框架扮演着至关重要的角色。今天，我们将要讨论的是RMI（Remote Method Invocation，远程方法调用）分布式通信框架。 **什么是分布式架构？** 分布式架构是指将系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值