详解java序列化（一）

最新推荐文章于 2024-09-19 19:23:01 发布
最新推荐文章于 2024-09-19 19:23:01 发布
阅读量1.9w 收藏 33
点赞数 15
分类专栏： java 文章标签： java string class object constructor null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moreevan/article/details/6697777
版权

我们可以通过序列化来保存一个对象的状态（实例变量）到文件中，也可以从这个格式化的文件中很容易地读取对象的状态从而可以恢复我们保存的对象。

      用来实现序列化的类都在java.io包中，我们常用的类或接口有：ObjectOutputStream:提供序列化对象并把其写入流的方法

ObjectInputStream：读取流并反序列化对象

Serializable：一个对象想要被序列化，那么它的类就要实现 此接口

      下面我们先通过一个简单的例子演示一起序列化/反序列化的过程

Book.java

package kevin.seria;

import java.io.Serializable;

public class Book implements Serializable{
	private int isbn;
	
	public Book(int isbn) {
		super();
		this.isbn = isbn;
	}

	public int getIsbn() {
		return isbn;
	}

	public void setIsbn(int isbn) {
		this.isbn = isbn;
	}

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

Student.java

package kevin.seria;

import java.io.Serializable;

public class Student implements Serializable {
	private Book book;
	private String name;

	public Student(Book book, String name) {
		super();
		this.book = book;
		this.name = name;
	}

	public Book getBook() {
		return book;
	}

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

	public String getName() {
		return name;
	}

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

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

}

Simulator.java

package kevin.seria;

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

public class Simulator {
	public static void main(String[] args) {
		new Simulator().go();
	}
	
	private void go(){
		Student student = new Student(new Book(2011),"kevin");
		
		try {
			ObjectOutputStream out  = new ObjectOutputStream(new FileOutputStream("seria"));
			out.writeObject(student); //
			System.out.println("object has been written..");
			out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		try{
			ObjectInputStream in = new ObjectInputStream(new FileInputStream("seria"));
			Student studentRead = (Student) in.readObject();
			System.out.println("object read here:");
			System.out.println(studentRead);
		}catch(FileNotFoundException e){
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

这个程序运行的结果如下：

 


我们可以看到，读取到的对象与保存的对象状态一样。这里有几点需要说明一下：

1、        基本类型 的数据可以直接序列化

2、        对象要被序列化，它的类必须要实现Serializable接口;如果一个类中有引用类型的实例变量，这个引用类型也要实现Serializable接口。比如上面 的例子中，Student类中有一个Book类型 的实例就是，要想让Student的对象成功序列化，那么Book也必须要实现Serializable接口。

3、        我们看这个语句：

ObjectOutputStreamout  = newObjectOutputStream(new FileOutputStream("seria"));

 

我们知道 FileOutputStream类有一个带有两个参数的重载Constructor——FileOutputStream(String,boolean),其第二个参数如果为true且String代表的文件存在，那么将把新的内容写到原来文件的末尾而非重写这个文件，这里我们不能用这个版本的构造函数，也就是说我们必须重写这个文件，否则在读取这个文件反序列化的过程中就会抛出异常，导致只有我们第一次写到这个文件中的对象可以被反序列化，之后程序就会出错。

 

下面的问题是如果 我们上面 用到的Book类没有实现Serializable接口，但是我们还想序列化Student类的对象 ，怎么办。

Java为我们提供了transient这个关键字。如果一个变量被声明成transient，那么 在序列化的过程 中，这个变量是会被无视的。我们还是通过对上面的代码进行小的修改来说明 这个问题。

新的Book类不实现Serializable接口

package kevin.seria;

public class Book{
	private int isbn;
	
	public Book(int isbn) {
		super();
		this.isbn = isbn;
	}

	public int getIsbn() {
		return isbn;
	}

	public void setIsbn(int isbn) {
		this.isbn = isbn;
	}

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

因为我们要序列化Student类的对象，所以我们必须实现Serializable接口，然而Book是Student的一个实例变量，它的类没有实现Serializable接口，所以为了顺序完成序列化，我们把这个实例变量声明为transient以在序列化的过程中跳过它。

package kevin.seria;

import java.io.Serializable;

public class Student implements Serializable {
	private transient Book book;
	private String name;

	public Student(Book book, String name) {
		super();
		this.book = book;
		this.name = name;
	}

	public Book getBook() {
		return book;
	}

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

	public String getName() {
		return name;
	}

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

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

}

Simulator.java和上面的一样，我们看一下运行结果：


可以看到，student对象被成功的序列化了。因为序列化过程中跳过了Book实例，所以当恢复对象状态的时候 ，它被赋予了默认值null，这也就意味着我们不能使用它。那如果Book类没有实现Serializable接口，但我们还想对它的状态进行保存，这可以实现 吗？答案是肯定的，到底如何肯定，请听小弟我慢慢道来。。。

Java针对这种情况有一种特殊的机制—— 一组私有（回调）方法（这个我们马上在代码中看到），可以在要被序列化的类中实现它们，在序列化和的序列化的过程中它们会被自动调用。所以在这组方法中我们可以调用ObjectOutputStream/ObjectInputStream的一些有用方法来实现对象状态的保存。下面还是通过例子来说明：

Book类和Simulator类都不变，我们来看 一下新的Student类：

package kevin.seria;

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

public class Student implements Serializable {
	private transient Book book;
	private String name;

	public Student(Book book, String name) {
		super();
		this.book = book;
		this.name = name;
	}

	public Book getBook() {
		return book;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//下面这两个方法就是那组特殊的私有方法，它们会在序列化、反序列化的过程 中被自动调用 
	//我们必须保证方法的签名和下面的两个方法完全相同
	
	//这个方法会在序列化的过程中被调用 
	private void writeObject(ObjectOutputStream out){
		try {
			out.defaultWriteObject(); //这个方法会把这当前中非静态变量和非transient变量写到流中
									  //在这里我们就把name写到了流中。
			//因为我们要保存Book的状态，所以我们还要想办法把其状态写入流中
			out.writeInt(book.getIsbn());//ObjectOutputStream中提供了写基本类型数据的方法
			//out.close();//注意，这句千万不能有，否刚将直接导致写入失败
		} catch (IOException e) {
			e.printStackTrace();
		} 
	}
	
	//这个方法会在反序列化的过程中被调用
	private void readObject(ObjectInputStream in){
		try {
			in.defaultReadObject(); //和defaultWriteObject()方法相对应，默认的反序列化方法，会从流中读取
									//非静态变量和非transient变量
			int isbn  = in.readInt(); //用这个方法来读取一个int型值，这里我们是读取书号
			book  = new Book(isbn); //这里我们就通过读取的 保存的状态构造 了一个和原来一样的Book对象
			//in.close();同样的这句也不能有
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public String toString() {
		return "Student [book=" + book + ", name=" + name + "]";
	}

}

好，看下程序运行的结果，我们这次期望的是Book的状态得到了保存，ok ,come on guys, check it out



OH YES！正如预料 的一样，我们成功了。呵呵 。要注意的点我在代码的注释中有说明，请好好看下代码。

还有一点我在代码 中没写出来 ，就是一定要注意写入和读取的顺序一定要对应。像上面如果你是先写基本类型数据的话，那在读取的时候也一定要先读取基本类型的数据，这个原因我想大家都清楚，文件是有position的。

最后，还有两个问题：

1、        如果一个类没有实现Serializable接口，但是它的基类实现 了，这个类可不可以序列化？

2、        和上面相反，如果一个类实现了Serializable接口，但是它的父类没有实现 ，这个类可不可以序列化？

 

第1个问题：一个类实现 了某接口，那么它的所有子类都间接实现了此接口，所以它可以被 序列化。

第2个问题：Object是每个类的超类，但是它没有实现 Serializable接口，但是我们照样在序列化对象，所以说明一个类要序列化，它的父类不一定要实现Serializable接口。但是在父类中定义 的状态能被正确 的保存以及读取吗？这个我将在下一篇文章中用一个例子来说明（马上就更新），请列位看官多多关注 ，呵呵。

 

还有一点，序列化保存对象的状态，而静态（static）变量不是对象的 状态，所以它们不会被序列化。

8/18/2011 By Kevin(MoreeVan)

(END)

关于第2个问题的解答我已经更新到此：详解java序列化（二）http://blog.csdn.net/moreevan/article/details/6698529


MoreeVan
关注
专栏目录
深度详解Java序列化
weixin_43178406的博客
09-24 6万+
 对象序列化是将对象转换为字节序列的过程，使其可以在网络上进行传输或者保存到磁盘上。本文将详细介绍Java对象序列化的实现机制、工作原理和注意事项。希望能对学习Java的同学们有所帮助。 文章目录 1. Java对象序列化的作用 2. Java对象序列化实现机制 3. 序列化的注意事项 4. 常用的序列化协议 4.1 Java标准序列化 4.2 JSON 4.3 Protobuf 4.4 Thrift 5. 总结
Java 序列化详解及简单实现实例
08-31
主要介绍了 Java 序列化详解及简单实现实例的相关资料,使用序列化目的：以某种存储形式使自定义对象持久化，将对象从一个地方传递到另一个地方，需要的朋友可以参考下
JAVA 序列化和反序列化
最新发布
nonagontech的博客
09-19 421
序列化Person成功后在E盘生成了一个Person.txt文件，而反序列化Person是读取E盘的Person.txt后生成了一个Person对象。，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。把字节序列转换为对象的过程称为对象的反序列化。把对象转换为字节序列的过程称为对象的序列化。2）在网络上传送对象的字节序列。
java序列化详解
热门推荐
文盲青年的博客
08-13 4万+
一、序列化与反序列化 序列化：指堆内存中的java对象数据，通过某种方式把对存储到磁盘文件中，或者传递给其他网络节点（网络传输）。这个过程称为序列化，通常是指将数据结构或对象转化成二进制的过程。 即将对象转化为二进制，用于保存，或者网络传输。 反序列化：把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者...
Java序列化详解
小轩的博客
05-11 282
Serializable接口 序列化与反序列化 网络IO和磁盘IO都是靠二进制数据进行传输和持久化到硬盘的，我们的对象无法直接进行传输和持久化到硬盘，想要做到就必须将对象的所有数据按照一定规则转化为二进制表示的数据，这样才能进行传输和持久化到硬盘，而这个转化过程就叫序列化。序列化之后我们想要重新获取到这个对象就只需要按照之前的规则反过来把二进制数据转化为我们对应的对象即可，这就是反序列化。 实现Serializable接口的作用 一个对象实现了这个接口后在进行传输或持久化到硬盘时Java就会用它自己
详解Java 序列化与反序列化（Serialization）
08-26
Java 序列化与反序列化是 Java 语言中的一种机制，用于将对象的状态信息转化为可以存储或者传输的形式的过程。序列化（Serialization）是将对象的状态信息转化为可以存储或者传输的形式的过程，反序列化则为其逆过程...
java 序列化与反序列化的实例详解
08-29
ObjectOutputStream 类包含很多写方法来写各种数据类型，而 ObjectInputStream 类包含反序列化一个对象的方法。 为了演示序列化在 Java 中是怎样工作的，我们定义了 Employee 类，该类实现了 Serializable 接口。...
Java 序列化和反序列化实例详解
08-31
我们还通过一个实例详解了序列化和反序列化的过程，希望能够帮助读者更好地理解 Java 序列化和反序列化。 知识点： * 序列化是指将对象转换为字节流的过程。 * 反序列化是指将字节流恢复为对象的过程。 * 序列化和...
Java 序列化详解
m0_68064743的博客
04-20 1万+
序列化和反序列化相关概念 什么是序列化?什么是反序列化? 如果我们需要持久化Java对象比如将Java对象保存在文件中，或者在网络传输Java对象，这些场景都需要用到序列化。 简单来说： 序列化： 将数据结构或对象转换成二进制字节流的过程 反序列化：将在序列化过程中所生成的二进制字节流的过程转换成数据结构或者对象的过程 对于Java这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型
JAVA序列化详解
u013983450的博客
12-14 423
什么是JAVA序列化 Java序列化是指把Java对象转换为字节序列的过程； Java反序列化是指把字节序列恢复为Java对象的过程。 采用Java序列化与反序列化技术，一是可以实现数据的持久化，在MVC模式中很是有用；二是可以对象数据的远程通信。 在大部分情况下，开发人员只需要了解被序列化的类需要实现 Serializable 接口，使用 ObjectInputStream 和
Java 序列化 详解
chenshun123的博客
09-30 432
序列化，简单来讲，就是以“流”的方式来保存对象，至于保存的目标地址，可以是文件，可以是数据库，也可以是网络，即通过网络将对象从一个节点传递到另一个节点。在 Java 的 I/O结构中，有 ObjectOutputStream 和 ObjectInputStream，它们可以实现将对象输出为二进制流，并从二进制流中获取对象，那为什么还需要序列化呢？这需要从 Java变量 的存储结构谈起，对Java来
java序列化_Java序列化详解
weixin_39667080的博客
11-14 116
什么是序列化？在Java中，对象序列化表示将对象表示为字节序列。字节包括对象的数据和信息。可以将序列化的对象写入文件/数据库，然后从文件/数据库中读取并反序列化。代表对象及其数据的字节可用于在内存中重新创建对象。为什么我们需要序列化？当您需要通过网络发送对象或存储在文件中时，通常使用序列化。网络基础结构和硬盘只能理解位和字节，而不能理解Java对象。序列化将Java对象转换为字节，然后通过网络发送...
Java序列化详解与应用
Java序列化是Java平台提供的一种持久化机制，它允许将对象的状态转换为字节流，以便可以存储或在网络上传输。这个过程对于实现数据持久化、跨网络通信（如RMI和EJB）以及对象在分布式环境中的传输非常关键。当一个...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值