Go语言视频零基础入门到精通

javalearner

java中处处体现着简单的程序设计风格，序列化作为最常用的功能之一，在java中的设计尤为“简单”。在ObjectInputStream 和ObjectOutputStream的帮助下，我们可以轻松的实现序列化。

      只要我们的class 实现了java.io.Serializable接口，就可以利用ObjectOutputStream的writeObject（）方法将一个对象序列化；利用ObjectInputStream的readObject()方法，可以返回读出的object对象。Serializable接口不需要我们实现任何方法。

以下是一个例子，它能给我们一个感性的认识：

      Serial实现了就java.io.Serializable接口，是需要序列化的类。我们首先构造一个Serial的对象serial1然后将其保存(序列化)在一个文件中，而后再将其读出（反序列化），并打印其内容。
                                                                                       
package Stream;
/**
  * @author favo yang
  */
  
  
    import java.io.*;
public class Serial implements Serializable {
     int company_id;
     String company_addr;
     boolean company_flag;
     public Serial(){}//不同于c++,没有也可以
     public Serial(int company_id,String company_addr,boolean company_flag) {
         this.company_id=company_id;
         this.company_addr=company_addr;
         this.company_flag=company_flag;
     }
     public static void main(String[] args) {
         Serial serial1 = new Serial(752,"dayer street #5 building 02-287",false);
         //构造一个新的对象
         FileInputStream in=null;
         FileOutputStream out=null;
         ObjectInputStream oin=null;
         ObjectOutputStream oout=null;
         try {
             out = new FileOutputStream("5.txt");
             oout = new ObjectOutputStream(out);
             serial1.serialize(oout);//序列化
             oout.close();
             oout=null;
             in = new FileInputStream("5.txt");
             oin = new ObjectInputStream(in);
             Serial serial2 = Serial.deserialize(oin);//反序列化
             System.out.println(serial2);//打印结果
         } catch (Exception ex){
             ex.printStackTrace();
         } finally{
             try {
                 if (in != null) {
                     in.close();
                 }
                 if (oin != null) {
                     oin.close();
                 }
                 if (out != null) {
                     out.close();
                 }
                 if (oout != null) {
                     oout.close();
                 }
             } catch (IOException ex1) {
                 ex1.printStackTrace();
             }
         }
     }

     /**
      * deserialize
      */
     public static Serial deserialize(ObjectInputStream oin) throws Exception{
         Serial s=(Serial)oin.readObject();
         return s;
     }

     public String toString() {
         return "DATA: "+company_id+" "+company_addr+" "+company_flag;
     }

     /**
      * serialize
      */
     public void serialize(ObjectOutputStream oout) throws Exception{
         oout.writeObject(this);
     }
}

运行结果：

DATA: 752 dayer street #5 building 02-287 false
正确打印了结果。

     现在序列化的功能还没有被j2me支持，所以我们在j2me中是使用DataInputStream、DataoutputStream配合rms或者网络实现序列化。

了解序列化带来的风险与问题

     我们已经看到了序列化的优点，就是简单的序列化的实现成本很低，或者说没有什么实现成本，只要实现一个接口就行了。但如果你将上文中的那个例子简单的套用在你的程序中，然后发表的话，你可有苦头了。你将会很快发现序列化带来问题：

1.实现了Serializable接口的类的改动变得很难（兼容性问题）。
     如果你想保持向下兼容性的话，这意味着要求新版本反序列化老版本序列化的数据流；如果你想保持向上兼容性的话，这意味着要求老版本反序列化新版本的数据流。尤其是向下兼容性的问题带来了让我们的代码实现很难改动的问题，为了能在新版本中反序列化老版本的数据流，类的实现必须要保留老版本的实现过程。这无疑是我们给自己加带上的一副枷锁。

2.实现了Serializable接口的类的测试成本大大增加了
     可以想象，当新版本发布时，为了保持兼容性，你的测试量将是版本数的平方！

3.草率的接受默认的序列化方式可能会带来性能问题，甚至更糟。
     序列化作为额外的一种“构造函数”可能破坏数据的完整性、约束性，甚至，一个精心伪造的数据流所序列化出的对象可能带来安全隐患。

了解了这些可能的风险后，我们在序列化的时候遇到了难题，如何避免这些风险呢？我将这些风险概括为以下几个方面：

1.    当序列化遇到继承时引发的问题？
2.    何时接受默认的java序列化？
3.    兼容性问题
4.    数据一致性问题与数据约束问题
5.    安全性问题

如何应对这些风险呢？请关注接下来的内容。