传递实体类对象_Java I/O 流之对象流中的序列化和反序列化

一、概念

当两个进程远程通信时，彼此可以发送各种类型的数据。 无论是何种类型的数据，都会以二进制序列的形式在网络上传送。比如，我们可以通过 http 协议发送字符串信息；我们也可以在网络上直接发送 Java 对象。发送方需要把这个 Java 对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为 Java 对象才能正常读取。把 Java 对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为 Java 对象的过程称为对象的反序列化。

对象序列化的作用有如下两种：

1. 持久化： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中，比如：休眠的实现。以后服务器 session 管理，hibernate 将对象持久化实现。
2. 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。

序列化和反序列化要素：

1、序列化能保存的元素

a) 只能保存对象的非静态成员变量

b) 不能保存任何成员方法和静态的成员变量

c) 不保存 transient 修饰的成员变量

d) 如果一个对象的成员变量是一个对象，这个对象的成员变量也会保存

e) 序列化保存的只是变量的值，对于变量的任何修饰符不能保存

2、使用对象流把一个对象写到文件时不仅保证该对象是序列化的，而且该对象的成员对象也必须是可序列化的。

3、如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个 NotSerializableException 异常。我们可以将这个引用标记为 transient，那么对象仍然可以序列化。

二、对象序列化注意事项

1、同一个对象多次序列化的处理

a) 所有保存到磁盘中的对象都有一个序列化编号

b) 序列化一个对象中，首先检查该对象是否已经序列化过

c) 如果没有，进行序列化

d) 如果已经序列化，将不再重新序列化，而是输出编号即可

2、如果不希望某些属性（敏感）序列化，或不希望出现递归序列

a) 为属性添加 transient 关键字（完成排除在序列化之外）

b) 自定义序列化（不仅可以决定哪些属性不参与序列化， 还可以定义属性具体如何序列化）

3、序列化版本不兼容

a) 修改了实例属性后，会影响版本号，从而导致反序列化不成功

b) 解决方案：为 Java 对象指定序列化版本号 serialVersionUID。为了防止读和写的序列化 ID 不一致，一般指定一个固定的序列化 ID。

序列化ID的作用：
其实，这个序列化 ID 起着关键的作用，它决定着是否能够成功反序列化！简单来说，java 的序列化机制是通过在运行时判断类的 serialVersionUID 来验证版本一致性的。 在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地实体类中的 serialVersionUID 进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。

三、序列化和反序列化案例

将 Student 类的实例进行序列化和反序列化：

Student 类：

public class Student implements Serializable{
	private static final long serialVersionUID = 2582122878311435520L;
	private String name;
	private int age;
	public static String schoolName;
	private transient String pwd;//属性值将不再被序列化
	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;
	}
	public String getPwd() {
		return pwd;
	}
	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
	public Student(String name, int age, String pwd) {
		this.name = name;
		this.age = age;
		this.pwd = pwd;
	}
	public Student() {
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", pwd=" 
                  + pwd + ", schoolName=" + schoolName + "]";
	}
}

测试 Student 类：

public class TestStudent {
	public static void main(String[] args) {
//		write();
		read();
	}
	public static void write() {
		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(new BufferedOutputStream(
                               new FileOutputStream("E:/student.txt")));
			Student stu = new Student("Jack", 22, "888888");
			Student.schoolName = "北清大学";
			oos.writeObject(stu);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(oos != null)
					oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public static void read() {
		ObjectInputStream ois = null;
		try {
			ois = new ObjectInputStream(new BufferedInputStream(
                               new FileInputStream("E:/student.txt")));
			Student stu = (Student) ois.readObject();
			System.out.println(stu);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(ois != null)
					ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

运行结果：

注意：一定要写运行 write() 方法，将 write() 方法注释掉再运行 read() 方法，否则反序列化会读取到静态变量 schoolName 的值！！！