序列化学习(1)

参考Java对象的序列化与反序列化 和 深入分析Java的序列化与反序列化

序列化 和 反序列化

序列化是将对象转换为可传输格式的过程，是一种数据的持久化手段。一般是以字节码或XML格式传输。
将对象转化为字节码和xml编码的过程称作为序列化。而字节码或XML编码格式可以还原为完全相等的对象，这个相反的过程称为反序列化 。一般广泛应用于网络传输，RMI和RPC等场景中

需要特别注意，原来我以为序列化结果只能是字节码，原来变成xml形式也算序列化

如何实现序列化

实现Serializable 接口

类通过实现 java.io.Serializable接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
可序列化类的所有子类型本身都是可序列化的。

1. 当试图对一个对象进行序列化的时候，如果遇到不支持 Serializable 接口的对象。在此情况下，将抛出 NotSerializableException。
2. 如果要序列化的类有父类，要想同时将在父类中定义过的变量持久化下来，那么父类也应该集成java.io.Serializable接口。

需要特别注意，对象序列化不会关注类中的静态变量。

Externalizable接口

该接口定义如下,是Serializable的子接口

public interface Externalizable extends java.io.Serializable 



public class User1 implements Externalizable {

	private String name;
    private int age;

    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;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		// TODO Auto-generated method stub
		//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();
		
	}
}


public class SerializableDemo1 {
	public static void main(String[] args) {
		// Initializes The Object
		User1 user = new User1();
		user.setName("whp404");
		user.setAge(27);
		System.out.println(user);

		// Write Obj to File
		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
			oos.writeObject(user);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(oos);
		}

		// Read Obj from File
		File file = new File("tempFile");
		ObjectInputStream ois = null;
		try {
			ois = new ObjectInputStream(new FileInputStream(file));
			User1 newUser = (User1) ois.readObject();
			System.out.println(newUser);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(ois);
			try {
				FileUtils.forceDelete(file);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}
}
结果：
User{name='whp404', age=27}
User{name='null', age=0}

观察上例，看到user1实例没有被保存下来

那是因为Externalizable继承了Serializable，该接口中定义了两个抽象方法：writeExternal()与readExternal()。当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写writeExternal()与readExternal()方法

由于上面的代码中，并没有在这两个方法中定义序列化实现细节，所以输出的内容为空。注释打开，就可以得到正确的结果

还有一点值得注意：在使用Externalizable进行序列化的时候，在读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。所以，实现Externalizable接口的类必须要提供一个public的无参的构造器 这也会导致反序列化会破坏单例对象的单一性

readObject方法 和 writeObject方法

最后提一下 这两个方法，先来网上的结论：

在序列化过程中，如果被序列化的类中定义了writeObject 和 readObject 方法，
虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。

如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法
以及 ObjectInputStream 的 defaultReadObject 方法。

用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。

ok，来测试一下

public class User1  implements Serializable{

	private Address adr;
	public Address getAdr() {
		return adr;
	}

	public void setAdr(Address adr) {
		this.adr = adr;
	}

	private String name;
	private int age;

	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;
	}

	@Override
	public String toString() {
		return "User1 [adr=" + adr + ", name=" + name + ", age=" + age + "]";
	}


	private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { 
		//s.defaultReadObject();
		adr = (Address)s.readObject();
		name = (String)s.readObject();
		age = s.readInt();
	}

	private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
		//s.defaultWriteObject();
		adr.setCity("北京");
		s.writeObject(adr);
		s.writeObject(name);
		s.writeInt(age);
	}

}


public class Address implements Serializable{
	
	public Address() {
		super();
	}

	public Address(String city) {
		super();
		this.city = city;
	}

	private String city;

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

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


//测试程序节本没变
public class SerializableDemo1 {
	public static void main(String[] args) {
		// Initializes The Object
		User1 user = new User1();
		user.setName("whp404");
		user.setAge(27);
		user.setAdr(new Address("南京"));
		System.out.println(user);

		// Write Obj to File
		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
			oos.writeObject(user);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(oos);
		}

		// Read Obj from File
		File file = new File("tempFile");
		ObjectInputStream ois = null;
		try {
			ois = new ObjectInputStream(new FileInputStream(file));
			User1 newUser = (User1) ois.readObject();
			System.out.println(newUser);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(ois);
			try {
				FileUtils.forceDelete(file);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}
}

结果：
User1 [adr=Address [city=南京], name=whp404, age=27]
User1 [adr=Address [city=北京], name=whp404, age=27]
果然自定义了序列化过程，将南京变成了北京