`
teamojiao
  • 浏览: 344692 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

为什么使用Serializable（序列化）

Java网络应用JVMBeanEJB
阅读更多

经常看到有些类调用了Serializable接口，而有些类又没有调用Serializable接口。那么什么情况下要调用Serializable接口。

    首先来了解一下Serializable。（类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。序列化接口Serializable没有方法或字段，仅用于标识可序列化的语义）


    实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。


    serialization主要用来支持2种主要的特性：
    1、RMI(Remote method invocation)。RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象和调用远程方法时，就需要用到serializaiton机制来发送参数和接收返回值。
    2、保存信息。在某个时候把状态信息保存起来，以便以后某个时候能恢复这些状态信息。
    Hibernaet和EJB中的实体Bean就用到了上面两个特性。


    另外：保存的时候不仅能保存对象的副本，而且还会把对象里面所引用的对象也保存起来，以此类推。就像在编译某个类一样，会涉及到所用到的所有类。但是所引用的对象也必须是可序列化的，不然会抛NotSerializableException异常。

    
    下面来写个例子：(A和B类都是可序列化的，WriteObj：将A序列化，ReadObj：将A反序列化) 

 

Java代码 复制代码
  1. package woxingwosu;   
  2.   
  3. import java.io.Serializable;   
  4.   
  5. public class A implements Serializable{   
  6.     private String name="my name is a";   
  7.     private B b=null;   
  8.     A(){   
  9.         b=new B();   
  10.     }   
  11.     public B getB() {   
  12.         return b;   
  13.     }   
  14.     public void setB(B b) {   
  15.         this.b = b;   
  16.     }   
  17.     public String getName() {   
  18.         return name;   
  19.     }   
  20.     public void setName(String name) {   
  21.         this.name = name;   
  22.     }   
  23.     public String show(){   
  24.         return "a.toString <a.name=\""+this.name+"\" a.b.name=\""+this.b.getName()+"\">"  
  25.             +"\na="+this.toString()+" b="+this.b.toString();   
  26.     }   
  27. }  
package woxingwosu;

import java.io.Serializable;

public class A implements Serializable{
    private String name="my name is a";
    private B b=null;
    A(){
        b=new B();
    }
    public B getB() {
        return b;
    }
    public void setB(B b) {
        this.b = b;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String show(){
        return "a.toString <a.name=\""+this.name+"\" a.b.name=\""+this.b.getName()+"\">"
            +"\na="+this.toString()+" b="+this.b.toString();
    }
}

 

Java代码 复制代码
  1. package woxingwosu;   
  2.   
  3. import java.io.Serializable;   
  4.   
  5. public class B implements Serializable{   
  6.     private String name="my name is B";   
  7.     B(){}   
  8.     public String getName() {   
  9.         return name;   
  10.     }   
  11.     public void setName(String name) {   
  12.         this.name = name;   
  13.     }   
  14. }  
package woxingwosu;

import java.io.Serializable;

public class B implements Serializable{
    private String name="my name is B";
    B(){}
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

 

Java代码 复制代码
  1. package woxingwosu;   
  2.   
  3. import java.io.FileOutputStream;   
  4. import java.io.ObjectOutputStream;   
  5. /**  
  6.  * 写Object(系列化)  
  7.  * @author 我行我素  
  8.  */  
  9. public class WriteSeri {   
  10.     public static void main(String[] args) {   
  11.         ObjectOutputStream outObj=null;   
  12.         try{   
  13.             FileOutputStream outStr=new FileOutputStream("obj.txt");   
  14.             outObj=new ObjectOutputStream(outStr);   
  15.             A a=new A();   
  16.             outObj.writeObject(a);   
  17.             System.out.println("write obj :"+a.show());   
  18.             outObj.flush();   
  19.         }catch(Exception e){   
  20.             e.printStackTrace();   
  21.         }finally{   
  22.             try{   
  23.                 if(outObj!=null)   
  24.                     outObj.close();   
  25.             }catch(Exception e){   
  26.                 e.printStackTrace();   
  27.             }   
  28.         }   
  29.     }   
  30. }  
package woxingwosu;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/**
 * 写Object(系列化)
 * @author 我行我素
 */
public class WriteSeri {
    public static void main(String[] args) {
        ObjectOutputStream outObj=null;
        try{
            FileOutputStream outStr=new FileOutputStream("obj.txt");
            outObj=new ObjectOutputStream(outStr);
            A a=new A();
            outObj.writeObject(a);
            System.out.println("write obj :"+a.show());
            outObj.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(outObj!=null)
                    outObj.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

 

Java代码 复制代码
  1. package woxingwosu;   
  2.   
  3. import java.io.FileInputStream;   
  4. import java.io.ObjectInputStream;   
  5. /**  
  6.  * 读Object(反系列化)  
  7.  * @author 我行我素  
  8.  */  
  9. public class ReadSeri {   
  10.     public static void main(String[] args) {   
  11.         ObjectInputStream inObj=null;   
  12.         try{   
  13.             FileInputStream inStr=new FileInputStream("obj.txt");   
  14.             inObj=new ObjectInputStream(inStr);   
  15.             A a=(A)inObj.readObject();   
  16.             System.out.println("read Object :"+a.show());   
  17.         }catch(Exception e){   
  18.             e.printStackTrace();   
  19.         }finally{   
  20.             try{   
  21.                 if(inObj!=null)   
  22.                     inObj.close();   
  23.             }catch(Exception e){   
  24.                 e.printStackTrace();   
  25.             }   
  26.         }   
  27.     }   
  28. }  
package woxingwosu;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
 * 读Object(反系列化)
 * @author 我行我素
 */
public class ReadSeri {
    public static void main(String[] args) {
        ObjectInputStream inObj=null;
        try{
            FileInputStream inStr=new FileInputStream("obj.txt");
            inObj=new ObjectInputStream(inStr);
            A a=(A)inObj.readObject();
            System.out.println("read Object :"+a.show());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(inObj!=null)
                    inObj.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

首先，我们运行WriteObj，实现序列化，得到输出结果

 

write obj :a.toString <a.name="my name is a" a.b.name="my name is B">
a=woxingwosu.A@a90653 b=woxingwosu.B@de6ced

 然后我们再运行ReadObj，实现反序列化，得到输出结果

 

read Object :a.toString <a.name="my name is a" a.b.name="my name is B">
a=woxingwosu.A@a90653 b=woxingwosu.B@de6ced

 

   官方文档：如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修改器显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处。

    刚才写的例子中就没有用到serialVersionUID，这时JVM会根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段作为serialVersionUID。但是如果序列化和反序列化的JVM版本不一样的话，还是显示写上serialVersionUID安全。

分享到：
| Builder设计模式的学习
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics