学习整理——Java序列化

最新推荐文章于 2023-09-12 18:30:00 发布
最新推荐文章于 2023-09-12 18:30:00 发布
阅读量494 收藏 1
点赞数 1
分类专栏： 学习整理 Java 文章标签： java 序列化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jeffery_Gong/article/details/52567187
版权

能否将一个对象持久化，下次启动的时候能够获得之前保存的状态，而不是需要对象从零开始？能否在网络上直接传送一个对象，接收方在接收对象后直接使用？Java为这种场景提供了原生的支持——序列化。通过序列化，对象可以被编译成字节码储存在文件中，同时也可以从文件中还原出一个对象。


Java序列化与反序列化

Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

通过对象输出流java.io.ObjectOutputStream可以将一个对象序列化，即编译成字节码输出去；

通过对象出入流java.io.ObjectInputStream可以对象的字节码流反序列化成对象。

注意异常抛出和捕获。


实现方法：

1.实现Serializable接口，该接口提供wirteObject(ObjectOutputStream)方法实现对象序列化，该接口提供readObject(ObjectInputStream)方法实现对象反序列化。

序列化

package cc.appweb.www;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class RedisTest {
	public static void main(String[] args){
		try{
			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			SerializableTest test = new SerializableTest(1, "123", 123.01, '3');
			oos.writeObject(test);
			oos.flush();
			oos.close();
			
//			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableTest test = (SerializableTest) ois.readObject();
//			test.printData();
//			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}

class SerializableTest implements Serializable{
	private int number;
	private String str;
	private double dou;
	private char ch;
	
	public SerializableTest(int n, String s, double d, char c){
		number = n;
		str = s;
		dou = d;
		ch = c;
	}
	
	public void printData(){
		System.out.println("Integer: "+number);
		System.out.println("String: "+str);
		System.out.println("Double: "+dou);
		System.out.println("Character: "+ch);
	}
}
可以看到，目标目录下test.txt保存了字节码数据。

将注释转过来，实现反序列。

package cc.appweb.www;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class RedisTest {
	public static void main(String[] args){
		try{
//			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableTest test = new SerializableTest(1, "123", 123.01, '3');
//			oos.writeObject(test);
//			oos.flush();
//			oos.close();
			
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			SerializableTest test = (SerializableTest) ois.readObject();
			test.printData();
			ois.close();
			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}

输出

Integer: 1
String: 123
Double: 123.01
Character: 3
Done!


2. 实现Serializable接口，同时在类里自定义writeObject(ObjectOutputStream)和readObject(ObjectInputStream)。

writeObject和readObject方法为JVM会在序列化和反序列化java对象时会分别调用的两个方法，修饰符都是private。

添加了writeObject()私有方法，将数值number向左移动一位。

class SerializableTest implements Serializable{
	private int number;
	private String str;
	private double dou;
	private char ch;
	
	public SerializableTest(int n, String s, double d, char c){
		number = n;
		str = s;
		dou = d;
		ch = c;
	}
	
	private void writeObject(ObjectOutputStream oos) throws Exception{
		number <<= 1;
		oos.defaultWriteObject();
	}
	
	public void printData(){
		System.out.println("Integer: "+number);
		System.out.println("String: "+str);
		System.out.println("Double: "+dou);
		System.out.println("Character: "+ch);
	}
}
明显字节码已经不一样


再次将注释转过来后，反序列出number=2

Integer: 2
String: 123
Double: 123.01
Character: 3
Done!


3.实现Externalizable接口，实现其中的writeExternal(ObjectOutput)和readExternal(ObjectInput)方法，自己去实现该对象的序列与反序列。

package cc.appweb.www;

import java.io.DataInput;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.Externalizable;

public class RedisTest {
	public static void main(String[] args){
		try{
//			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableTest test = new SerializableTest(1, "123", 123.01, '3');
//			oos.writeObject(test);
//			oos.flush();
//			oos.close();
			
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			SerializableTest test = (SerializableTest) ois.readObject();
			test.printData();
			ois.close();
			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}

class SerializableTest implements Externalizable{
	private int number;
	private String str;
	private double dou;
	private char ch;
	public SerializableTest(){
		
	}
	
	public SerializableTest(int n, String s, double d, char c){
		number = n;
		str = s;
		dou = d;
		ch = c;
	}
	 
	public void writeExternal(ObjectOutput oo) throws java.io.IOException{
		oo.writeObject(str);
		oo.writeChar(ch);
	}
	
	public void readExternal(ObjectInput oi)  throws java.io.IOException, java.lang.ClassNotFoundException{
		str = (String) oi.readObject();
		ch = oi.readChar();
	}
	
	public void printData(){
		System.out.println("Integer: "+number);
		System.out.println("String: "+str);
		System.out.println("Double: "+dou);
		System.out.println("Character: "+ch);
	}
}


Integer: 0
String: 123
Double: 0.0
Character: 3
Done!


以下参考：关于 Java 对象序列化您不知道的 5 件事

注意事项

1.序列化允许重构

可以表述为：

Java Object Serialization 规范可以自动管理的关键任务：

将新字段添加到类中

将字段从 static 改为非 static

将字段从 transient 改为非 transient

具体操作如下：

编写一个简单的类实现Serializable，将其序列化到文件中

package cc.appweb.www;

import java.io.Serializable;

public class SerializableTest implements Serializable{
	private int number;
	private String str;
	private double dou;
	private char ch;
	public SerializableTest(){
		
	}
	
	public SerializableTest(int n, String s, double d, char c){
		number = n;
		str = s;
		dou = d;
		ch = c;
	}
	
	public void printData(){
		System.out.println("Integer: "+number);
		System.out.println("String: "+str);
		System.out.println("Double: "+dou);
		System.out.println("Character: "+ch);
	}
}


package cc.appweb.www;

import java.io.DataInput;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.Externalizable;

public class RedisTest {
	public static void main(String[] args){
		try{
			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			SerializableTest test = new SerializableTest(1, "123", 123.01, '3');
			oos.writeObject(test);
			oos.flush();
			oos.close();
			
//			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableTest test = (SerializableTest) ois.readObject();
//			test.printData();
//			ois.close();
			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}

调用jdk的serialver程序获取该序列化的serialVersionUID


此时需要改变SerializableTest类（添加字段、删除字段），将该字段添加进新的类里可以将该序列化重构出来。

package cc.appweb.www;

import java.io.Serializable;

public class SerializableTest implements Serializable{
	
	private static final long serialVersionUID = -8634238426192165505L;
	private int number;
	private String str;
	private double dou;
	private char ch;
	private long l;
	public SerializableTest(){
		
	}
	
	public SerializableTest(int n, String s, double d, char c){
		number = n;
		str = s;
		dou = d;
		ch = c;
	}
	
	public void printData(){
		System.out.println("Integer: "+number);
		System.out.println("String: "+str);
		System.out.println("Double: "+dou);
		System.out.println("Character: "+ch);
		System.out.println("Long: "+l);
	}
}



package cc.appweb.www;

import java.io.DataInput;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.Externalizable;

public class RedisTest {
	public static void main(String[] args){
		try{
//			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableTest test = new SerializableTest(1, "123", 123.01, '3');
//			oos.writeObject(test);
//			oos.flush();
//			oos.close();
			
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			SerializableTest test = (SerializableTest) ois.readObject();
			test.printData();
			ois.close();
			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}
新添加的字段将被置为默认值 

Integer: 1
String: 123
Double: 123.01
Character: 3
Long: 0
Done!


2.自定义序列化与反序列化

由于一个对象的私有信息都储存在字节码流中，所以说对象的信息是很不安全的。如上面所说，可以为一个序列化的类添加writeObect()、readObject()，所以可以做到一些在序列序列化前加密与在反序列化解密的工作。

package cc.appweb.www;

import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;

public class SerializableTest implements Serializable{
	
	private int number;
	public SerializableTest(){
		
	}
	public SerializableTest(int num){
		number = num;
	}
	
	private void writeObject(ObjectOutputStream oos) throws Exception{
		number = number ^ 0xaaaaaaaa;
		oos.defaultWriteObject();
	}
	
	private void readObject(ObjectInputStream ois) throws Exception{
		ois.defaultReadObject();
		number = number ^ 0xaaaaaaaa;
	}
	
	public void printData(){
		System.out.println("Number:" + number);
	}
}


package cc.appweb.www;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class RedisTest {
	public static void main(String[] args){
		try{
//			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableTest test = new SerializableTest(123456789);
//			oos.writeObject(test);
//			oos.flush();
//			oos.close();
			
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			SerializableTest test = (SerializableTest) ois.readObject();
			test.printData();
			ois.close();
			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}


Number:123456789
Done!



3.数据加密与签名

jdk提供了更高安全性的可序列化对象供程序在序列化与反序列化是进行加密和签名的操作。当然原则上，通过使用 writeObject 和 readObject 也可以实现加密和签名。

如果需要对整个对象进行加密和签名，可以将它放在一个 javax.crypto.SealedObject 或 java.security.SignedObject 包装器中。两者都实现了序列化的，所以将对象包装在 SealedObject 中可以围绕原对象创建一种 “包装盒”。必须有对称密钥才能解密，而且密钥必须单独管理。同样，也可以将 SignedObject 用于数据验证，并且对称密钥也必须单独管理。结合使用这两种对象，便可以轻松地对序列化数据进行密封和签名，而不必强调关于数字签名验证或加密的细节。


4.序列化替换

private Object writeReplace();  // 置换对象，造成实际执行序列化的非this指向的对象

private Object readResolve(); //  置换反序列化出来的对象

通过这一层关系可以对对象进行代理序列化

实体

package cc.appweb.www;

import java.io.Serializable;

public class SerializableInstance implements Serializable {
	private int number;
	private String str;
	public SerializableInstance(int n, String s) {
		number = n;
		str = s; 
	}
	
	public int getInt(){
		return number;
	}
	
	public String getString(){
		return str;
	}
}

代理 

package cc.appweb.www;

import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;

public class SerializableProxy implements Serializable{
	
	private String str;
	private int n;
	
	public SerializableProxy(SerializableInstance instance) {
		str = instance.getString();
		n = instance.getInt();
	}
	
	private Object writeReplace() throws Exception{
		Integer i = new Integer(n);
		return i;         // 真正被序列化的为String s
	}
}
序列化和反序列化 

package cc.appweb.www;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.crypto.SealedObject;
import javax.crypto.Cipher;

public class RedisTest {
	public static void main(String[] args){
		try{
//			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
//			SerializableProxy test = new SerializableProxy(new SerializableInstance(123, "456789"));
//			oos.writeObject(test);
//			oos.flush();
//			oos.close();
			
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Eclipse\\workspace\\Test\\test.txt"));
			Integer i = (Integer) ois.readObject();
			System.out.println(i.intValue());
			ois.close();
			
			System.out.println("Done!");
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}
输出 

123
Done!


5. 验证

认为序列化流中的数据总是与最初写到流中的数据一致，这没有问题。但是，正如一位美国前总统所说的，“信任，但要验证”。对于序列化的对象，这意味着验证字段，以确保在反序列化之后它们仍具有正确的值，“以防万一”。为此，可以实现 ObjectInputValidation接口，并覆盖 validateObject() 方法。如果调用该方法时发现某处有错误，则抛出一个 InvalidObjectException。



Jeffery_Gong
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础学习总结（138）——Java API 设计规范整理
科技D人生
12-20 1093
1. 包设计清单 1.1. 共通 ▲1.1.1. 建议把API和实现放入不同的包 ▲1.1.2. 建议把API放进上层包，而把实现放进下层包 ▲1.1.3. strong&gt;考虑把一组大型的API分拆进不同的包 ▲1.1.4. 考虑把API和实现打包进不同的jar包 ▲1.1.5. 避免API的实现类之间的内部依赖 ▲1.1.6. 避免把API分拆了太细 ▲1.1.7. 避免把...
Redis学习总结（20）——Java 开发人员Redis 使用军规
科技D人生
03-02 328
一、缩短键值对的存储长度 键值对的长度是和性能成反比的，比如我们来做一组写入数据的性能测试，执行结果如下： 从以上数据可以看出，在 key 不变的情况下，value 值越大操作效率越慢，因为 Redis 对于同一种数据类型会使用不同的内部编码进行存储，比如字符串的内部编码就有三种：int（整数编码）、raw（优化内存分配的字符串编码）、embstr（动态字符串编码），这是因为 Redis 的作者是想通过不同编码实现效率和空间的平衡，然而数据量越大使用的内部编码就越复杂，而越是复杂的内部编码存储的
java中 serializable_java--Serializable理解与总结
weixin_32352621的博客
02-16 569
本来这一章打算探讨字节码中关于method的解析的，但是，这个周末都在看公主准则。而且在看hashmap的源码的时候，遇到了一个新的问题，所以这里先来讲一下在java中io流非常重要的一个环节，Serializable接口的理解与总结。1)什么是java对象的序列化。Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周...
java之Serializable
baiping1991的专栏
08-19 699
Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段，只是用于标识可序列化的语义。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流，同时也可以通过ObjectInputStream再将其解析为对象。例如，我们可以将序列化对象写入文件后，...
Java类的Serializable
Tiger_shl的博客
12-03 550
建立实体类的时候需要实现serializable，之前只知道这是实现序列化，一直不是很清楚原因，今天总结一下自己的理解。
java序列化（三） - 自定义readObject和writeObject
weixin_34163553的博客
10-22 1591
2019独角兽企业重金招聘Python工程师标准>>> ...
Java Serializable（序列化）
ckchenwei的专栏
09-05 528
1. 什么是Java Serializable（序列化） 为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以方便地把保存的对象状态再读出来。 2. 哪些情况下需要序列化 a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候； b）当你想用套接字在网络上传送对象的时候； c）当你想通过RMI传输对象的时候； 3. 如何进行序列化(序列化的方式) 3
2022.3.19 LeetCode —— 二叉树的序列化及反序列化
LGoGoGo的博客
03-19 158
String、StringBuffer与StringBuilder + String.split()用法
学习笔记09——Java基础（五）
m0_52248951的博客
04-07 977
Java基础——网络编程与邮件发送
告别脚本小子系列丨JAVA安全(6)——反序列化利用链（上）
最新发布
xnxqwzy的博客
09-12 315
我们通常把反序列化漏洞和反序列化利用链分开来看，有反序列化漏洞不一定有反序列化利用链（经常用shiro反序列化工具的人一定遇到过一种场景就是找到了key，但是找不到gadget，这也就是在这种场景下没有可利用的反序列化利用链）。如果我们向某个漏洞提交平台提交一个反序列化漏洞，但是不给反序列化利用链，那么平台大概率是不会接受这种漏洞的。反序列化利用链是整个反序列化利用过程中最关键的一环，通常反序列化利用链需要借助常用的第三方jar包，其中最有名的就是CommonCollections利用链（简称CC链）。
带你了解Java的序列化（Serializable）与反序列化
陈哈哈的菜园子
03-25 2883
这篇可帮助你大体了解Java中的序列化（Serializable）。包括为什么需要它，如何工作，何时使用它，相关概念（serialVersionUID和transient）以及有关序列化和反序列化的其他必要信息。本教程中的序列化示例保持简单，以帮助你理解要点。 目录1.为什么要进行Java序列化2.Java中的序列化如何工作2-1.什么是serialVersionUID常数2-2.什么是瞬时变...
java序列化之writeObject 和readObject
深海微澜
06-05 8454
什么是序列化和反序列化？ 序列化：将对象转化为字节的过程称为序列化过程。 反序列化：将字节转化为对象的过程称为反序列化。 序列化主要应用于网络传输和数据存储的场景。在java中，只有类实现了java.io.serializable接口，该类才能被序列化。 示例Demo1.java： package com.example.demo; import java.io.*; public class Demo1 { public static class Person implements S
对Java Serializable（序列化）的理解和总结
热门推荐
非淡泊无以明志，非宁静无以致远
11-11 8万+
我对Java Serializable（序列化）的理解和总结 博客分类：  Java技术 JavaOSSocketCC++  1、序列化是干什么的？        简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己
java序列化接口Serializable
蜗牛学习笔记
01-29 3357
类的可序列化性通过实现(implements) java.io.Serializable可序列化接口。 没有实现这个接口的类不会将其任何状态序列化或反序列化。 可序列化类的所有子类型本身可序列化。 序列化接口没有方法或字段只用于识别可序列化的语义。 为了允许序列化不可序列化类的子类型，子类型可以承担保存和还原父类型的公开状态(public)，受保护状态(protected)和（如果可以访问）包字段。 只有在以下情况下，子类型才能承担此责任：扩展的类具有可访问的无参(no-arg)构造函数，用于初始化类的状
关于Java中使用Serializable中readObject和readObject调用的问题
weixin_30484247的博客
06-22 927
我们都知道，序列化不会自动保存static和transient变量，因此我们若要保存它们，则需要通过writeObject()和readObject()去手动读写。(01) 通过writeObject()方法，写入要保存的变量。writeObject的原始定义是在ObjectOutputStream.java中，我们按照如下示例覆盖即可： private void writeObject(Obj...
java serializable用法_Serializable序列化用法
weixin_29008691的博客
02-24 535
在学习mybatis中缓存部分有提到序列化这一词，探索一下什么时候应该实现序列化接口，而什么时候可以不实现序列化接口1.Serializable作用是是实现将后台数据对象转化为字节流传输，一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化,将数据分解成字节流，以便存储在文件中或在网络上传输。现在需要将一个对象返回给前端，一般就需要实现 Serializable接口，并提供一个默认的s...
Java的Serializable序列化接口的readObject和writeObject方法
xiaoanian的专栏
06-09 6016
以前关于readObject()和writeObject()理解不深，不明白为什么两者要是private的。网上的很多文章都直接讲它们怎么用，没有清楚阐明其道理。 这篇文章很好的回答了这个问题：http://www.javablogging.com/what-are-writeobject-and-readobject-customizing-the-serialization-process/
关于Java中writeObject方法
QiuLingfeng
10-15 2万+
先说一下这个writeObject的使用方法。我们有时候需要把一个类的很多对象的信息写入文件中，方便二次读取，但是如果一个对象中所包含的属性太多，将这些属性信息依次写入文件所需要的代码比较繁杂，为了图省事可以用writeObject方法直接写入对象。读出来的时候可以用readObject方法直接读出来。但是需要注意的是，你用writeObject所写入的类必须要实现serilizebal接口，否则...
Java序列化详解：面试必备知识
“Java序列化与反序列化是Java开发中的重要概念，尤其在面试中常常被问及。本文主要探讨了这两个概念的定义、作用、应用场景以及实现方式。” Java序列化是指将一个对象的状态转换为字节序列的过程，这使得对象能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值