序列化

转自几篇博文

博文1，点击打开链接

博文2，点击打开链接

1、什么是序列化和反序列化

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。

2、什么情况下需要序列化

a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；

b）当你想用套接字在网络上传送对象的时候；

c）当你想通过RMI传输对象的时候；

  

3、如何实现序列化

将需要序列化的类实现Serializable接口就可以了，Serializable接口中没有任何方法，可以理解为一个标记，即表明这个类可以序列化。

4.JDK类库中序列化API

(1)java.io.ObjectOutputStream：表示对象输出流

它的writeObject(Objectobj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

 (2)java.io.ObjectInputStream：表示对象输入流

它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。

public class Student implements Serializable{
    //序列化ID可选择默认，也可以自定义
	private static final long serialVersionUID = 1L;
    private String name;
	private char sex;
	private int year;
	private double gpa;

	 public Student(){
	
	 }
	 public Student(String name,char sex,int year,double gpa){
		  this.name = name;
		  this.sex = sex;
		  this.year = year;
		  this.gpa = gpa;
	 }
	
	 public void setName(String name){
	     this.name = name;
	 }	
	 public void setSex(char sex){
	     this.sex = sex;
	 }	
	 public void setYear(int year){
	     this.year = year;
	 }	
	 public void setGpa(double gpa){
	     this.gpa = gpa;
	 }
	
	 public String getName(){
	    return this.name;
	 }	 
	 public char getSex(){
	    return this.sex;
	 }
     public int getYear(){
	    return this.year;
	 }	
	 public double getGpa(){
	    return this.gpa;
	 }
	 
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "[" + name + ", " + sex + ", " + year + gpa + "]";
	}
}

public class UseStudent{
    
	public static void main(String[] args){
		  Student st = new Student("Tom",'M',20,3.6);
		  File file = new File("D:\\Javae\\student.txt");
		  try{
              file.createNewFile();
          }catch(IOException e){
              e.printStackTrace();
           }try{
			   //Student对象序列化过程
			   FileOutputStream fos = new FileOutputStream(file);
			   ObjectOutputStream oos = new ObjectOutputStream(fos);
			   oos.writeObject(st);
			   oos.flush();
			   oos.close();
			   fos.close();
			
			   //Student对象反序列化过程
			   FileInputStream fis = new FileInputStream(file);
			   ObjectInputStream ois = new ObjectInputStream(fis);
			   Student st1 = (Student) ois.readObject();			   
			   System.out.println("name = " + st1.getName());
			   System.out.println("sex = " + st1.getSex());
			   System.out.println("year = " + st1.getYear());
			   System.out.println("gpa = " + st1.getGpa());
			   System.out.println(st1);
			   ois.close();
			   fis.close();
           }catch(ClassNotFoundException e){
			       e.printStackTrace();
			}catch (IOException e){
			   e.printStackTrace();
			}				
	}
}

这里往外读取的时候，也可以用object类

FileInputStream fis = new FileInputStream(file);
			   ObjectInputStream ois = new ObjectInputStream(fis);
			   Object st1 = ois.readObject();			   
			   System.out.println("name = " + ((Student) st1).getName());
			   System.out.println("sex = " + ((Student) st1).getSex());
			   System.out.println("year = " + ((Student) st1).getYear());
			   System.out.println("gpa = " + ((Student) st1).getGpa());
			   System.out.println(st1);
			   ois.close();
			   fis.close();

5. 为什么一个类实现了Serializable接口，它就可以被序列化呢？在上节的示例中，使用ObjectOutputStream来持久化对象，在该类中有如下代码：

private void writeObject0(Object obj, boolean unshared) throws IOException {
    
    if (obj instanceof String) {
        writeString((String) obj, 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，那么就可以对该对象进行序列化，否则将抛出NotSerializableException。

6.    序列化前后对象的地址不同了，但是内容是一样的，而且对象中包含的引用也相同。换句话说，通过序列化操作,我们可以实现对任何可Serializable对象的”深度复制（deep copy）"——这意味着我们复制的是整个对象网，而不仅仅是基本对象及其引用。对于同一流的对象，他们的地址是相同，说明他们是同一个对象，但是与其他流的对象地址却不相同。也就说，只要将对象序列化到单一流中，就可以恢复出与我们写出时一样的对象网，而且只要在同一流中，对象都是同一个。

        另外，序列化会忽略静态变量，即序列化不保存静态变量的状态。静态成员属于类级别的，所以不能序列化。即序列化的是对象的状态不是类的状态。这里的不能序列化的意思，是序列化信息中不包含这个静态成员域。transient后的变量也不能序列化，但是情况稍复杂

7. 默认序列化机制

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

8.影响序列化

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

 8.1 transient关键字

       当某个字段被声明为transient后，默认序列化机制就会忽略该字段。此处将Person类中的age字段声明为transient

 8.2writeObject()方法与readObject()方法

        对于上述已被声明为transitive的字段age，除了将transitive关键字去掉之外，是否还有其它方法能使它再次可被序列化？方法之一就是在Person类中添加两个方法：writeObject()与readObject()

        在writeObject()方法中会先调用ObjectOutputStream中的defaultWriteObject()方法，该方法会执行默认的序列化机制，此时会忽略掉age字段。然后再调用writeInt()方法显示地将age字段写入到ObjectOutputStream中。readObject()的作用则是针对对象的读取，其原理与writeObject()方法相同。

        必须注意地是，writeObject()与readObject()都是private方法，那么它们是如何被调用的呢？毫无疑问，是使用反射。详情可见ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法。

 8.3 Externalizable接口

        无论是使用transient关键字，还是使用writeObject()和readObject()方法，其实都是基于Serializable接口的序列化。JDK中提供了另一个序列化接口--Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。

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

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

8.4 readResolve()方法

        当我们使用Singleton模式时，应该是期望某个类的实例应该是唯一的，但如果该类是可序列化的，那么情况可能会略有不同。

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