Java基础教程——序列化

序列化

序列化：Serialize，将Java对象写入IO流（可以保存在数据库，文件等）
反序列化：Deserialize，从IO流中读取并恢复Java对象。

这么理解：序列化就是把对象封印起来，反序列化就是解封。

对象中包含的不仅仅是字符，更多的是非字符，因此需要使用字节流。

所有能在网上传输的对象的类都应该是可序列化的，否则程序就会出现异常。

实现Serializable接口

这个接口里面什么都没有，是一个标记接口，表明一个对象是可以序列化的。

public interface Serializable {
}

transient：瞬态关键字
|--transient变量---不参与序列化（有些变量可能属于敏感信息，如银行账户密码等）

transient：短暂的。

import java.io.*;
public class 序列化1 {
	public static void main(String[] args) throws Exception {
		int r_w = 3;
		if (r_w == 1) {
			on序列化();
		} else if (r_w == 2) {
			on反序列化();
		} else {
			on序列化();
			on反序列化();
		}
	}
	private static void on序列化() throws Exception {
		Dog _d = new Dog("狗", "金毛");
		File f = new File("myObj.txt");
		System.out.println("序列化：" + f.getAbsolutePath());
		FileOutputStream fos = new FileOutputStream(f);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(_d);
		oos.close();
		fos.close();
	}
	private static void on反序列化() throws Exception {
		// 前提：1.类必须可序列化，2.必须有对应的类文件
		File f = new File("myObj.txt");
		FileInputStream fis = new FileInputStream(f);
		ObjectInputStream ois = new ObjectInputStream(fis);
		Dog d = (Dog) ois.readObject();
		System.out.println("反序列化：" + d + ": name = " + d.name);
		ois.close();
		fis.close();
	}
}
class Dog implements Serializable {
	private static final long serialVersionUID = 1L;
	public Dog(String name, String type) {
		super();
		this.name = name;
		this.type = type;
	}
	String name;
	transient String type;
	@Override
	public String toString() {
		System.out.println("type:没参与序列化");
		return "【狗狗:name = " + name + "， type = " + type + "】";
	}
}

运行结果：

序列化：C:\Users\Administrator\git\Ah01JspJavaHtml\myObj.txt
type:没参与序列化
反序列化：【狗狗:name = 狗， type = null】: name = 狗

序列号: serialVersionUID
|--修改类的定义，可能生成新的序列号
|--|--改构造器:变
|--|--改字段:变(包括transient字段)
|--|--改方法体里的实现，不变;

序列化和反序列化时的序列号如果不同，会抛出异常java.io.InvalidClassException
可以显示声明一个固定的序列号。如：

private static final long serialVersionUID = 1L;

---

*另一种序列化方法：实现Externalizable接口

Externalizable接口可以替代Serializable接口。

需要手提供一个无参构造方法，否则在反序列化的时候会抛出异常

java.io.InvalidClassException: ……; no valid constructor

同时还需要定义两个方法(writeExternal()和readExternal())来控制要序列化的字段。

下列示例，只有Dog类的实现和上例不一样，其余代码可以一样。

package ah.externalizable;
import java.io.*;
public class 序列化2 {
	public static void main(String[] args) throws Exception {
		on序列化();
		on反序列化();
	}
	private static void on序列化() throws Exception {
		Dog _d = new Dog("狗", "金毛");
		File f = new File("myObj.txt");
		System.out.println(f.getAbsolutePath());
		FileOutputStream fos = new FileOutputStream(f);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(_d);
		oos.close();
		fos.close();
	}
	private static void on反序列化() throws Exception {
		File f = new File("myObj.txt");
		FileInputStream fis = new FileInputStream(f);
		ObjectInputStream ois = new ObjectInputStream(fis);
		Dog d = (Dog) ois.readObject();
		System.out.println(d + ": name = " + d.name);
		ois.close();
		fis.close();
	}
}
class Dog implements Externalizable {
	public Dog() {
		// 不写空构造,读不出来(可以写)
	}
	public Dog(String name, String type) {
		super();
		this.name = name;
		this.type = type;
	}
	String name;
	String type;
	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		// 不写的Field就不序列化
		out.writeUTF(name);
		out.writeUTF(type);
	}
	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		// 读取顺序务必和写入顺序相同
		name = in.readUTF();
		type = in.readUTF();
	}
	@Override
	public String toString() {
		return "【狗狗:" + name + "， 是一只" + type + "】";
	}
}