sql

package File;
/*【序列化和反序列化对象】
 *
 *    一个大的应用程序需要很多的对象，由于虚拟机内存有限，有时不可能将所有有用的对象都放在内存中，
 * 因此需要将不常用的对象暂时持久化到文件中，当需要使用该对象时，再从文件中把对象恢复到内存，这
 * 就是对象的序列化和反序列化。本节实例介绍如何实现兑现的序列化和反序列化，把对象序列化到文件，
 * 然后再从文件反序列化到对象。
 *
 * 【关键技术剖析】
 *
 * 1、需要被序列化的对象需要实现java.io.Serialization接口，尽管该接口没有定义任何方法。
 *
 * 2、对象输出流ObjectOutputStream可以将对象写入到流中，通过文件输出流FileOutputStream
 *   可以构造ObjectOutputStream对象。写对象到文件时调用writeObject()方法。
 *
 * 3、对象输入流ObjectInputStream可以从流中读取对象到内存，通过文件输入流FileInputStream
 *   可以构造ObjectInputStream对象。从文件读对象到内存时调用readObject方法，返回一个
 *   Object对象
 *
 * 4、序列化时，transient变量和类变量会被序列化。
 *
 * 5、序列化时，对象按照writeObject方法的调用顺序存储在文件中，先被序列化的对象的数据在文件
 *   的前面，后被序列化的对象的数据在文件的后面。因此，在反序列化时，先读到的对象肯定是先被
 *   序列化的对象。
 *
 * 【实例演示：】 *
 * */

import java.io.Serializable;
import java.io.File;
import java.util.Date;
import java.io.IOException;

import java.io.ObjectOutputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

import java.io.ObjectInputStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 序列化和反序列化对象
 *
 * @author hbzhang
 *
 */
public class SerializeObject {
 /**
  * 一个内部类，用于被序列化和反序列化
  *
  * 一定要实现Serializable接口才能被序列化和反序列化
  */
 public static class MyClass implements Serializable {
  // Private Varialbes
  private int a, b;
  private transient int c;
  private static int d;
  
  // Constructor
  public MyClass() {
   
  }
  public MyClass(int a, int b, int c, int d) {
   this.a = a;
   this.b = b;
   this.c = c;
   MyClass.d = d;
  }
  
  // Overrides toString()
  public String toString() {
   
   return this.a + " " + this.b + " " + this.c + " " + MyClass.d;
  }  
 }
 
 /**
  * 序列化对象到文件
  */
 
 public static void serialize(String fileName) {
  ObjectOutputStream out = null;
  File file = new File(fileName);  
  
  try {
   // 创建一个文件输出流，将对象输出到文件
   out = new ObjectOutputStream(
          new BufferedOutputStream(
           new FileOutputStream(file)));
   
   out.writeObject("Today"); // 序列化一个字符串对象到文件
   out.writeObject(new Date());// 序列化当前日期对象到对象
   
   MyClass my = new MyClass(5, 6, 7, 8);
   out.writeObject(my);  // 序列化一个自定义对象   
   
   System.out.println("序列化对象到文件 成功！");
  } catch (IOException ex) {
   ex.printStackTrace();
  } finally {
   if (out != null) {
    try {
     out.close();
    } catch (IOException ex) {
     ex.printStackTrace();
    }    
   }
  }  
 }
 
 /**
  * 从文件反序列化到对象
  */
 public static void deSerialize(String fileName) {
  File file = new File(fileName);
  // 创建一个文件输入流，从文件读取对象
  ObjectInputStream in = null;
  
  try {
   in = new ObjectInputStream(
     new BufferedInputStream(
      new FileInputStream(file)));
   // 注意读取对象时必须按照序列化对象时的顺序读，否则会出错
   
   String today = (String)in.readObject();  // 读取字符串字符
   System.out.println(today);
   
   Date date = (Date)in.readObject();  // 读取日期对象
   System.out.println(date.toString());
   
   MyClass mc = (MyClass)in.readObject();  // 读取自定义对象
   System.out.println(mc.toString());
   
  } catch (IOException ex) {
   ex.printStackTrace();
  } catch (ClassNotFoundException ex) {
   ex.printStackTrace();
  } finally {
   if (in != null) {
    try {
     in.close();
    } catch (IOException ex) {
     ex.printStackTrace();
    }    
   }
  }  
  
 }
 
 public static void main(String[] args) {
  
  String fileName = "e:\\a\\serializble.txt";
  
  //SerializeObject.serialize(fileName);
  
  SerializeObject.deSerialize(fileName);
 }
}

/*【源码分析：】 *

 * 1、MyClass内部类是被序列化的对象，它实现了java.io.Serializable接口
 *
 * 2、serialize()方法实现了对象的序列化功能，将对象序列化到文件，使用了对象输出流
 *   ObjectOutputStream，writeObject方法一次写入一个对象，对象在文件中按写入顺序存放。
 *
 * 3、deSerialize()方法实现了对象的反序列化功能，从文件中将对象反序列化到内存，使用了对象
 *   输入流ObjectInputStream，readObject方法一次读入一个对象。因为，在序列化对象
 *   时是按写入顺序存储的，所以，在反序列化时，必须按写入的顺序读取对象。
 *
 * 4、类变量不属于一个对象，因此不能被序列化和反序列化。transient实例变量也不会序列化和反序列化。
 *
 *
 *
 */