java 序列化，

java 序列化，

          序列化机制允许将实现序列化的Java对象转换为字节序列，字节序列可以保存在磁盘，或通过网络传输，以备以后重新恢复原来的对象，序列化机制使得对象可以脱离程序的运行而独立存在。

        对象的序列化指讲一个Java对象写入IO流中，对象的反序列化指从IO流恢复Java对象，为了让某类是可序列化的，该类必须实现如下两个接口之一  Serializable ,Externalizable.

         使用对象流实现序列化

      

public class UserSqlPrivoder {

	private static final int _1MB = 1024 * 1024;
	
	public static void main(String[] args) throws Exception {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
		Person p = new Person("whl", 11);
		oos.writeObject(p);
		Person po = (Person) ois.readObject();
	}
}

class Person implements Serializable{ // 继承Serializable
	private String name;
	private int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}
	
}

      Person 类只有一个有参数的构造器，没有无参数的构造器，当我们反序列化读取Java对象时，无需通过构造器来初始化Java对象。

     当序列化创建子类实例时，系统隐式地为他的所有父类都创建实例（并建立与子类实例的关联），当反序列化子类实例时，反序列化机制需要恢复其关联的父类实例。恢复父类实例有两种方式，1 反序列机制，2 使用父类无参构造器。如果父类既不可序列化，有没有无参构造器，则子类抛出异常

      对象引用的序列化，如果某个类的属性类性不是基本类型，或String类型，而是另一个引用类型，则引用类必须可序列化，否则拥有该属性的类不可序列化。

      当多个实例的属性引用同一个实例时如下所示，

		Person p = new Person("whl", 11);
		Teacher t1 = new Teacher(p);
		Teacher t2 = new Teacher(p);

     t1 引用p，t2也引用p，我们对他么3个进行序列化，然后在进行反序列化，是创建3个Person还是一个，他们的引用关系改变吗，如果反序列化后引用关系发生了变化，就违反了Java 序列化初衷。

       所以Java序列化机制采用了一种特殊的序列化算法：

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

       2 当程序试图序列化一个对象时，程序将检查对象是否已经被序列化过，只有当对象从未被序列化过，系统才会将对象转换成字节序列输出。

       3 如果对象已经被序列化过，只输出一个序列化编号。

        同过在属性前面加上transient关键字，指定Java序列化时无需理会该属性值。

       Java提供了一种自定义序列化机制，可以让程序控制如何序列化个属性，如需自定义序列化，需要在类中提供如下方法，

         private void writeObject(ObjectOutputStream out) throws IOException   序列化

         private void readObject(ObjectInputStream out) throws IOException, ClassNotF诶oundException 反序列化
         private void writeObjectNoData() throws ObjectStreamException      正确的初始化反序列化对象（接收方使用的反序列化版本不同于发送方，可能被篡改）

	private void writeObject(ObjectOutputStream out) throws IOException{
		out.writeObject(new StringBuffer(name).reverse());
		out.writeInt(age);
	}
	private void readObject(ObjectInputStream out) throws IOException, ClassNotFoundException{
		this.name = ((StringBuffer)out.readObject()).reverse().toString();
		this.age = out.readInt();
	}

 
         java还提供了另一种序列化机制，这种序列化方式完全由程序员决定存储和恢复对象数据，要实现该目标，java类必须实现Externalizable接口，接口定义了两个方法。

              void writeExternal(ObjectOutput out) throws IOException;  序列化

               void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; 反序列化

            

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

         什么样的类不可以序列化

                 1   一个类与本地代码有紧密的关系  java.util.zip.Deflater

                 2 对象的内部状态依赖Java虚拟机或运行环境，从而在每一次t运行时这个状态都有可能不同  java.lang.Thread   Java.io.InputStream

                3 可能带来潜在的安全隐患    

                4 仅仅是一些静态方法的存放地，并没有任何内部状态   Math

                3  串行化可能带来潜在的安全隐患