学习笔记-序列化和反序列化

本文主要是介绍学习笔记-序列化和反序列化，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 序列化是干什么的？
• 什么情况下需要序列化？
• 当对一个对象实现序列化时，究竟发生了什么？
  • 相关注意事项
• 什么是Java对象序列化
• 简单 实例
• Serializable的作用
• 默认序列化机制
• 影响序列化
  • transient`关键字
  • writeObject()方法与readObject()方法
  • Externalizable接口
  • readResolve(解析)

源文章：https://blog.csdn.net/dreamtdp/article/details/15378329

序列化是干什么的？

为了保存内存中的各种对象的状态（实例变量，不是方法），并且可以把保存的对象状态再读出来。

虽然你可以用你自己的各种各样的方法来保存Object states,但是Java给你提供一种深思熟虑的机制--序列化。

什么情况下需要序列化？

• 当你想把内存中的对象状态保存到一个文件中或者数据库中的时候
• 当你想用套接字在网络上传送对象的时候
• 当你想通过RMI传输对象的时候

当对一个对象实现序列化时，究竟发生了什么？

• 序列化：把对象转换为字节序列的过程称为对象的序列化。
• 反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

在没有序列化前，每个保存在堆heep中的对象都有相应的状态state,即实例变量instance ariable。

Foo MyFoo =new Foo();
myFoo.setWidth(37);
myFoo.setHeigth(70);

当通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37,70）斗保存到foo.ser文件中，这样以后又可以把它从文件中读取出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对象。

实现序列化（保存到一个文件）的步骤:

//1,Make a FileOutputStream
FileOutputStream fs=new FileOutStream("foo.ser");
//2,Make a ObjectOutputStream
ObjectOutputStream os=new ObjectOutputStream(fs);
//3,Write a Object
os.writeObject(myFoo);
//4,Close the ObjectOutputStream
os.close();

public class Box implements Serializable{
	private int width;
	private int height;
	//
	public void setWidth(int width) {
		this.width=width;
	}
	public void setHeight(int height) {
		this.height=height;
	}
	public static void main(String[] args) throws Exception {
		Box myBox=new Box();
		myBox.setHeight(50);
		myBox.setWidth(30);
		//
		FileOutputStream fos=new FileOutputStream("foo.ser");
		ObjectOutputStream oos=new ObjectOutputStream(fos);
		oos.writeObject(myBox);
		oos.close();
		System.out.println(myBox.hashCode());
		FileInputStream fis=new FileInputStream("foo.ser");
		ObjectInputStream ois=new ObjectInputStream(fis);
		//
		Box b=(Box) ois.readObject();
		System.out.println(b.hashCode());
		fis.close();
		ois.close();
	}
}

相关注意事项

• 序列化时，只对对象的状态进行保存，而不管对象的方法
• 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口
• 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
• 并非所有的对象都可以序列化
  • 安全方面原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件中或者进行RMI传输时，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
  • 资源分配方面原因，比如socket,thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配。

序列化的作用就是为了不同JVM之间共享实例对象的一种解决方案，由JAVA提供此机制，效率之高非其他方案可比拟的。

什么是Java对象序列化

Java平台允许我们在内存中创建可复用的对象，但一般情况下，只有当JVM运行时这些对象才能存在，它们的生命周期不会比JVM的声明周期更长。而在现实应用中，有可能要求在JVM停止运行之后还能够保存（持久化）某些对象，并在将来重新读取被保存的对象。而java对象序列化就能够帮助我们实现这样的需求。

使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意的是，对象序列化保存的是对象的“状态”——即成员变量，而不会关注类中的静态变量。

除了 持久化对象时会用到对象序列化之外，当使用RMI（远程方法调用），或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用。

简单 实例

在Java中，只要一个类实现了java.io.Serializable接口，那么它就可以被序列化。此处将创建一个可序列化的类Person,下文中所有示例将围绕着该类或其修改版部署。

创建一个Gender类，一个枚举类型，用来表示性别

public enum Gender{
    MALE,FEMALE
}

如果熟悉Java枚举类型的话，应该知道每个枚举类型都会默认继承类Java.lang.Enum,而该类实现了Serializable接口，所以枚举类型对象都是默认可以被序列化的。

Person类，实现了Serializable接口，包含三个字段：String name; Integer age; Gender gender;顺便重写该类的toString()方法方便我们观察Person实例中的属性状态。

public class Person implements Serializable{
	private String name;
	private Integer age;
	private Gender gender;
	public Person(String name, Integer age, Gender gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public Person() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Gender getGender() {
		return gender;
	}
	public void setGender(Gender gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}

SimpleSerial，一个简单的序列化程序，它先将一个Person对象保存到文件person.out中，然后再从改文件读出被储存的Person对象，并打印该对象。

public class SimpleSerial {
	public static void main(String[] args) throws IOException, IOException, ClassNotFoundException {
		File file=new File("Person.out");
		ObjectOutputStream oout=new ObjectOutputStream(new FileOutputStream(file));
		Person person=new Person("John",101,Gender.MALE);
		oout.writeObject(person);
		oout.close();
		ObjectInputStream oin=new ObjectInputStream(new FileInputStream(file));
		System.out.println(oin.readObject());
		oin.close();
	}
}

此时必须注意的是，当重新读取被保存的Person对象时，并没有调用Person的任何构造器，看起来就像是直接使用字节将Person对象还原出来的。

当Person对象被保存到person.out文件中之后，我们还可以在其它地方去读取改文件以还原对象，但必须确保该读取程序的CLASSPATH中包含有Person.class，否则会抛出ClassNotFoundException.

Serializable的作用

为什么一个类实现了Serializable接口就可以被序列化？

下面是ObjectOutputStream的一部分源码

private void wirteObject0(Object obj,boolean unshared)throws IOExcetpion{
    ...
    if(obj instanceof String){
        writeString(Stringobj,unshared);
    }else if(cl.isArray()){
        writeArray(obj,desc,unshared);
    }else if(obj instanceof Enum){
        writeEnum((Enum)obj,desc,unshared);
    }else if(obj instanceof Serializable){
        writeOrdinaryObject(obj,desc,unshared);
    }else{
        if(extendedDebugInfo){
            throw new NotSerializableException(cl.getName()+"\n"
                     +debugInfoStack.toString());
        }else{
            throw new NotSerializableException(cl.getName());
        }
    }
}

从那上述代码克制，如果被写对象类型是String,或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializabeException.

默认序列化机制

如果仅仅只是让某个类实现Serializable接口，而没有任何其它处理电话，则就是使用默认序列化机制。使用默认机制，在序列化对象时，不仅会序列化当前对象本身，还会对该对象引用的其它对象也进行序列化，同样的，这些其它对象引用的另外对象也将被序列化，以此类推。所以，如果一个对象包含的成员变量是容器类的对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。

影响序列化

在现实应用中，有些时候不能使用默认序列化机制。比如，希望在序列化过程中忽略掉敏感数据，或者简化序列化过程。下面将介绍若干影响序列化的方法。

transient`关键字

当某个字段被声明为transient，默认序列化机制会忽略该字段。下面将Person类中的age字段声明为transient,如下所示：

transient private Integer age=null;

再执行SimpleSerial应用程序，就会输出为

Person [name=John, age=null, gender=MALE]

可见，age字段未被序列化。

writeObject()方法与readObject()方法

对于上述已被声明为transitive的字段age，除了将transitive关键字去掉之外，是否还存在其他方法使他再次可被序列化？

方法之一就是在Person类中添加两个方法：wirteObject()与readObject()

如下所示

	private void writeObject(ObjectOutputStream out) throws IOException {
		out.defaultWriteObject();//先执行默认序列化机制（忽略了transient字段）
		out.writeInt(age);//再显式地将transient字段写入流中
	}
	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();//先执行默认序列化机制（忽略了transient字段）
		age=in.readInt();//再显式地将transient字段从流中取出。
	}

再次执行SimpleSerial应用程序，输出结果又不同了：

Person [name=John, age=101, gender=MALE]

必须注意的是，writeObject()与readObject()都是private方法，那么它们是如何被调用的呢？

是使用反射。详情可见ObjectOutputStream中的writeSerialData()方法，以及ObjectInputStream中的readSerialData（）方法

Externalizable接口

无论是使用transient关键字，还是使用writeObject()和readObject(),其实都是基于Serializable接口的序列化。JDK中提供了另一种序列化接口--externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就失效。此时将Person类修改如下：

public class Person implements Externalizable{
	private String name;
	private transient Integer age;
	private Gender gender;
	public Person(String name, Integer age, Gender gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public Person() {
		System.out.println("none-arg constructor");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Gender getGender() {
		return gender;
	}
	public void setGender(Gender gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	private void writeObject(ObjectOutputStream out) throws IOException {
		out.defaultWriteObject();//先执行默认序列化机制（忽略了transient字段）
		out.writeInt(age);//再显式地将transient字段写入流中
	}
	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		age=in.readInt();
	}
	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		// TODO Auto-generated method stub
		
	}
}

此时再执行SimpleSerial程序之后会得到如下结果：

none-arg constructor//调用了无参构造器
Person [name=null, age=null, gender=null]

从该结果，一方面可以看出Person对象中任何一个字段都没有被序列化。另一方面，如果细心的话，还可以发现这次序列化过程中调用了Person类的无参构造器。

Externalization继承与Serializable，当使用该接口时，序列化的细节需要由程序员去完成。如上述代码，由于writeExternal(）与readExternal方法未做任何处理，那么该序列化行为将不会保存/读取任何一个字段。这也就是为什么输出结果中所有字段的值均为空。

另外，若使用xternalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且访问权限为public

对上述Person类进一步的修改，使其能够对name与age字段进行序列，但要忽略掉gender字段，代码如下所示：

public void writeExternal(ObjectOutput out) throws IOException {
		out.writeObject(name);
		out.writeInt(age);
	}
	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		// TODO Auto-generated method stub
		name=(String)in.readObject();
		age=in.readInt();
	}

执行SimpleSerial之后会有如下结果：

none-arg constructor
Person [name=John, age=101, gender=null]

readResolve(解析)

当我们使用Singleton模式时，应该是期望某个类的实例应该是唯一的，但如果该类是可序列化的，那么情况可能会略有不同。此时对第2节使用的Person类进行修改，使其实现Singleton模式，如下所示：

public class Person implements Serializable{
	private static class InstanceHolder{
		private static final Person instance=new Person("John",31,Gender.MALE);
	}
	 public   static  Person getInstance() {
         return  InstanceHolder.instatnce;
    }
	private String name;
	private transient Integer age;
	private Gender gender;
	
	...
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	private void writeObject(ObjectOutputStream out) throws IOException {
		out.defaultWriteObject();//先执行默认序列化机制（忽略了transient字段）
		out.writeInt(age);//再显式地将transient字段写入流中
	}
	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		age=in.readInt();
	}
}

同时要修改SimpleSeril应用，使得能够保存/获取上述单例对象，并进行对象相等性比较，代码如下所示：

public class SimpleSerial {
	public static void main(String[] args) throws IOException, IOException, ClassNotFoundException {
		File file=new File("Person.out");
		ObjectOutputStream oout=new ObjectOutputStream(new FileOutputStream(file));
		oout.writeObject(Person.getInstance());
		oout.close();
		
		
		ObjectInputStream oin=new ObjectInputStream(new FileInputStream(file));
		Object newPerson=oin.readObject();
		oin.close();
		System.out.println(newPerson);
		
		System.out.println(Person.getInstance()==newPerson);
	}
}

执行上述应用程序后会得到如下结果：

Person [name=John, age=31, gender=MALE]
false

值得注意的是，从文件person.out中获取的Person对象与Person类中的单例对象并不相等。为了能在序列化过程仍能保持单例的特性，可以在Person类中添加一个readResolve()方法，在该方法中直接返回Person的单例对象，如下所示

private  Object readResolve()  throws  ObjectStreamException {
         return  InstanceHolder.instatnce;
    }

再次执行本节的SimpleSerial应用后将有如下输出：

Person [name=John, age=31, gender=MALE]
true

无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到，实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象，而被创建的对象则会被垃圾回收掉。

这篇关于学习笔记-序列化和反序列化的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！