Java序列化

最新推荐文章于 2022-01-29 12:43:11 发布
最新推荐文章于 2022-01-29 12:43:11 发布
阅读量1.2k 收藏 2
点赞数 4
分类专栏： Java进阶 Java进阶之道 文章标签： Java序列化 序列化 反序列化 保存对象 Java反序列化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lavor_zl/article/details/42423183
版权

1.概述

通过序列化机制，我们可以把Java内存中的对象转换成二进制字节流，这样就可以把Java对象存储到磁盘中，或者在网络中传输Java对象。

1.1序列化的含义和意义

序列化机制允许将实现序列化的Java对象转换成字节序列，这些自己序列可以保存在磁盘上，或通过网络传输，以备以后重新恢复原来的对象。序列化机制使得对象可以脱离程序的运行而单独存在。
对象的序列化(Serilize)指将一个Java对象写入IO流中，与此相反的是对象的反序列化(Deserialize)则指从IO流中恢复该Java对象。
如果需要让某个对象支持序列化机制，则必须让它的类实现下面两个接口之一：
Seriliazable
Externalizable
所有网络上传输的对象的类都应该是可序列化的，比如RMI(远程方法调用)过程中的参数和返回值。

所有需要保存在磁盘中的对象的类都必须是可序列化的，比如Web应用中需要保存到HttpSession或SevletContext属性中的应用。

2.使用对象流实现序列化

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

public class SerializeTest {
	public static void main(String[] args) {
		try {
			ObjectOutputStream oos=new ObjectOutputStream(
			new FileOutputStream("src/com/t/color.txt"));
			Color color=new Color("Red");
			oos.writeObject(color);//将对象写入输出流
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			ObjectInputStream ois=new ObjectInputStream(
			new FileInputStream("src/com/t/color.txt"));
			//从输入流中读取对象并强制转换成Color类
			Color col=(Color)ois.readObject();
			System.out.println(col.getColor());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}
class Color implements Serializable{   
              private static final long serialVersionUID = -3398911857061187891L;
	private String color;
	public Color(String color) {
		this.color=color;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
}

PS:反序列化无须通过构造器来初始化Java对象。
如果使用序列化机制向文件中写入多个Java对象，使用反序列化机制恢复对象时必须按实际写入的顺序读取。

3.对象引用的序列化

如果一个类中的成员变量有引用类型(不是基本类型或String类型)，那么这个引用类型必须是可序列化的，否则该类不可以序列化，即使它实现了Seriliazable或Externalizable也不能序列化。
 

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

public class SerializeTest {
	public static void main(String[] args) {
		try {
			ObjectOutputStream oos=new ObjectOutputStream(
			new FileOutputStream("src/com/t/color.txt"));
			Color color=new Color("Red");
			Person person=new Person("lavor_zl", color);
			oos.writeObject(color);//将对象写入输出流
			oos.writeObject(person);//将对象写入输出流
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			ObjectInputStream ois=new ObjectInputStream(
			new FileInputStream("src/com/t/color.txt"));
			//从输入流中读取对象并强制转换成Color类
			Color col=(Color)ois.readObject();
			System.out.println(col.getColor());
                        Person per=(Person)ois.readObject();
                        System.out.println(per.getName());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}
class Color implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = -3398911857061187891L;
	private String color;
	public Color(String color) {
		this.color=color;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
}
class Person implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 3426878037487779564L;
	private String name;
	private Color color;
	public Person(String name,Color color) {
		this.name=name;
		this.color=color;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Color getColor() {
		return color;
	}
	public void setColor(Color color) {
		this.color = color;
	}
	
}

Color color=new Color("Red");
Person person=new Person("lavor_zl", color);
oos.writeObject(color);//将对象写入输出流
oos.writeObject(person);//将对象写入输出流
一般情况下，这里创建序列化的顺序是先序列化color对象，在序列化person对象并且将再次序列化person对象所引用的Color对象，但是这里person对象引用的Color类对象刚好是前面已经序列化了的color对象。情况会不一样。
那么Java序列化机制采用的序列化规则到底是怎么样的啊？
1、所有保存到磁盘中的对象都有一个序列化编号。
2、当程序试图序列化一个对象时，程序会检查该对象是否已经被序列化过，只有该对象从未在本次虚拟机中序列化过，系统才会将该对象转换成字节序列并输出。
3、如果每个对象已经被序列化过，程序只是直接输出一个序列化编号，而不是再次重新序列化该对象。
正是基于这些规则，多次序列化一个对象时，只有第一次序列化时才会把该Java对象转换成字节序列输出，即使后面改变了该对象的成员变量，反序列化时改变的成员变量的值也不会被输出。

4.自定义序列化

当我们序列化某个对象时，如果不想序列化该对象的某个成员变量时，可以用transient关键字修饰该成员变量，transient关键字只能修饰成员变量。用transient关键字修饰的成员变量将被完全隔离在序列化机制之外。这样导致在反序列化恢复Java对象时无法获取该变量的值，Java还提供一种自定义序列化机制，通过自定义序列化可以让程序控制如何序列化各成员变量，甚至完全不序列化某些成员变量（与使用transient关键字效果相同）。

4.1一种自定义序列化机制

在序列化和反序列化过程中需要特殊处理的类应该提供如下特殊的签名方法，这些特殊的签名方法用来来实现自定义序列化。

private void writeObject(java.io.ObjectOutputStream out)throws IOException
private void readObject(java.io.ObjectInputStream in)throws IOException,ClassNotFoundException
private void readObjectNoData()throws ObjectStreamException

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

public class Test implements Serializable{
	private static final long serialVersionUID = 6102026641912972144L;
	private int id;
	private String name;
	public Test(int id,String name) {
		this.id=id;
		this.name=name;
	}
	private void writeObject(ObjectOutputStream out)throws IOException{
		out.writeInt(id);
		out.writeChars(name);
	}
	private void readObject(ObjectInputStream in)throws IOException,ClassNotFoundException{
		this.id=in.readInt();
		//this.name=in.readLine()也可以，不过readLine()已经不推荐使用
		this.name=(String) in.readObject();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

PS:readObject()方法读取成员变量的顺序应该和writeObject()存储尘成员变量的顺序一致，否则不能正常恢复该Java对象。
static关键字修饰的成员变量也不可以被序列化，因为它是属于类的而不是属于对象的

还有一种更彻底的自定义序列化机制，它甚至可以在序列化该对象时将该对象替换成其他对象。可以通过一下方法实现
ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException
此方法有序列化机制在序列化之前调用，只要该方法存在。 

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.ArrayList;

public class Test implements Serializable{
	private int id;
	private String name;
	public Test(int id,String name) {
		this.id=id;
		this.name=name;
	}
	//重写writeReplace()方法，程序在序列化该类对象之前调用该方法
	private Object writeReplace()throws ObjectStreamException{
		ArrayList<Object> list=new ArrayList<Object>();
		list.add(id);
		list.add(name);
		return list;
	}
	public static void main(String[] args) {
		try{
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("replace.txt"));
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("replace.txt"));
			Test test=new Test(1, "lavor_zl");
			oos.writeObject(test);
			ArrayList<Object> list=(ArrayList<Object>) ois.readObject();
			System.out.println(list);//输出：[1, lavor_zl]
		}catch(Exception e){
			e.printStackTrace();	
		}
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

与writeReplace()相对，序列化机制还有一个特殊的方法，它可以实现保护性的复制整个对象
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException
该方法紧跟着readObject()方法之后调用，该方法返回值将会替代原来的反序列化对象。
readResolve()方法在序列化单例类、枚举类时尤其有用。

4.2另一种自定义序列化机制

Java还提供另一种自定义序列化机制，这种序列化方式完全由程序员决定存储和恢复对象数据。要实现该目标，Java类必须实现Externalizable接口。
void writeExternal(ObjectOutput out)：需要序列化的类实现该方法来保存对象的状态
void readExternal(ObjectInput in)：需要序列化的类通过该方法来实现反序列化

lavor_zl
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Serilizable理解
Javy的专栏
08-13 1185
所谓的Serializable,就是java提供的通用数据保存和读取的接口。至于从什么地方读出来和保存到哪里去都被隐藏在函数参数的背后了。这样子，任何类型只要实现了Serializable接口，就可以被保存到文件中，或者作为数据流通过网络发送到别的地方。也可以用管道来传输到系统的其他程序中。这样子极大的简化了类的设计。只要设计一个保存一个读取功能就能解决上面说得所有问题。 Serializabl...
java中Serializable问题
u011393781的博客
10-10 403
如果一个类是Seriabliazble的，那么里面的属性域必须也是可Seriabliazble的或者思transient的，即便这个类不需要序列化或者反序列化，因为在加载的时候，大部分j2EE应用框架都会把对象flush到磁盘上，而一个可以序列化的对象却有一个成员是不能序列化的，也不是暂时的，那么就会造成程序crash。 所以上面的Address要么把Address类设置为Seriablazbl
java 的serializable 理解和总结
yinlell的博客
09-17 1万+
目录 serializable 理解和总结 序列化是做什么的 什么情况下需要序列化 注意事项 为什么java需要进行序列化 transient关键字 序列化是做什么的    对象的生命周期常随着生成该对象的程序的终止而终止,有时候需要把内存中的各种对象状态 (也就是实例变量,不是方法)保存下来并且可以在需要时再将对象恢复.虽然你可以用你自己的 方法保存对象的状态,但是java提...
Java-Serializable
lwgzj的博客
08-30 1164
Serializable关键字平时我们应该很少有机会去使用到，平时的业务中不需要我们去做对象状态的保存，而且一般都是中间件或者框架内才使用到。但是关于Serializable应该要去理解和学习。 1. 怎么理解序列化 1.首先，在我们平时运行项目时，JVM处于运行中，此时工程内的对象是存活状态，因此这些对象的生命周期是会比JVM的生命周期短的。然后有的情况下，我们需要持久化一些特殊对象，以便将...
对Java Serializable（序列化）的理解和总结
热门推荐
非淡泊无以明志，非宁静无以致远
11-11 8万+
我对Java Serializable（序列化）的理解和总结 博客分类：  Java技术 JavaOSSocketCC++  1、序列化是干什么的？        简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己
Java序列化_Java序列化结构_
09-29
大家请看Java的序列化结构有不足的地方请指教也希望指出不足的地方。
Java序列化与反序列化三种格式存取
12-22
　Java中的序列化（serialization）机制能够将一个实例对象的状态信息写入到一个字节流中，使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中；然后在需要的时候，可以根据字节流中的信息来重构一个...
java序列化
05-02
Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM（Java Virtual Machine（Java虚拟机））处于运行时，这些对象才可能存在（即，这些对象的生命...Java对象序列化就能够帮助我们实现该功能。
java 序列化
06-21
java 序列化，java 序列化，java 序列化，java 序列化，java 序列化，java 序列化
java Serializable
youandme520的专栏
01-29 533
最近在阅读JDK源码中的集合，看到很多集合类实现了Serializable接口,Cloneable接口。在阅读了很多关于Serializable接口的博客后，浅谈下我对Serializable接口的理解。
Java泛型
lavor_zl的专栏
11-21 1876
1.Java泛型概述 1.1什么是泛型 泛型（Generics）是对Java语言的类型系统的一种扩展，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 1.2为什么要使用泛型 在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行强制类型转换，转换到特定的类型。这个强制类型转换可能会引起运行时的错误。 在使用泛型前，要
Java枚举类
lavor_zl的专栏
11-11 1345
1.枚举类概述 enum关键字，用来定义枚举类，它与class，interface关键字的地位相同。枚举类是一种特殊的类。 但枚举类终究不是普通类，它与普通类有以下几个区别： ①枚举类不可以继承类，但可以继承接口，使用enum定义的枚举类默认继承了java.lang.Enum类。 ②使用enum定义非抽象的枚举类默认会使用final修饰，因此枚举类不能派生子类。如果是抽象枚举也不能用"ab
Java多线程
lavor_zl的专栏
01-11 853
1.线程的创建与启动 在Java中，多线程的实现有两种方式： 继承java.lang.Thread类 实现java.lang.Runnable接口 1.1继承Thread类创建线程 继承Thread类创建并启动线程的步骤： 1、定义Thread的子类，并重写该类的run()方法，run()方法的方法体就表示线程需要完成的任务。run()被称为线程执行体。 2、创建Thread的子
Java的File类
lavor_zl的专栏
11-25 818
1.File类概述 File类是java.io包下代表与平台无关的文件和目录。File能新建，删除，重命名文件盒目录，但是File不能访问文件内容本身。如果要访问文件内容本身，就需要使用输入，输出流。 2.访问文件和目录 File类可以使用文件路径字符串来创建File实例，该路径可以是绝对路径也可以是相对路径。在默认情况下，系统总是依据用户的工作路径来解释相对路径，这个路径由系统属性"u
Java集合
lavor_zl的专栏
11-18 738
1.集合概述 集合类主要负责保存，盛装其他数据，因此集合类被称为容器类。所有集合类都位于java.util包下。 集合类和数组不一样，数组元素可以是基本类型的值也可以是对象。而集合里面只可以是对象。 Iterator接口是所有集合的超级接口，它有两个主要的子接口Collection和Map，Java集合类主要从这两个接口派生而来。 2.Collection构成的集合体系 Collec
Java的IO流
lavor_zl的专栏
12-07 675
1.概述 Java的IO通过java.io包下面的接口和类来实现的，在java.io包下包括输入，输出两种IO流，每种输入和输出流又可以分为字节流和字符流两大类。其中字节流以字节为单位来处理输入输出操作，其中字符流以字符为单位来处理输入输出操作。 Java的IO流分为底层节点流和上层处理流，其中节点流用于和底层的物理节存储点直接关联——不同的物理节点获取节点流的方式可能存在差异，但程序可以把不
Python基于PyQt5和SMTP协议实现邮件发送程序案例源码.7z
最新发布
04-17
该程序采用了Python的smtplib模块和pyqt5模块，实现了自动登录QQ邮箱的功能，并且支持向其他QQ邮箱或如网易邮箱等其他类型的邮箱发送文本邮件和附带文件的邮件。
java序列化面试题
08-27
当面试中被问到关于Java序列化的问题时，你可以准备以下问题和答案： 问题1：什么是Java序列化？ 答：Java序列化是指将Java对象转换为字节流的过程。通过将对象序列化为字节流，我们可以将其持久化保存在文件中或...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值