Java序列化的机制和原理

http://developer.51cto.com/art/200908/147650.htm

http://developer.51cto.com/art/201104/253112.htm

 

 

对象序列化就是把对象写入到输出流中，用来存储或者传输。
对象的反序列化就是从输入流中读取对象。
要序列化的对象应该实现Serializable接口。
Serializable接口是一个标识接口，没有抽象方法。
Serializable有一个子接口Externalizable，实现Externalizable接口的类可以自行控制对象序列化荷反序列化过程。
一般来说，没有必要自己实现序列化接口，直接交给Java虚拟机是上策。
实现了序列化接口的类，如果其成员不需要序列化进去，则使用transient关键字进行修饰。

 

下面给出个例子：

import java.io.*;

/**
* Java对象的序列化测试
* File: ObjectStreamTest.java
* User: leizhimin
* Date: 2008-3-12 20:41:43
*/
public class ObjectStreamTest {
     public static void main(String args[]) {
        testObjectSeri();
        testObjectInSeri();

    }

     /**
     * 对象序列化测试
     */
     public static void testObjectSeri() {
        Person person = new Person( "熔岩", "341022225562156", "lavasoft");
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
         try {
            fos = new FileOutputStream( "Q:\\study\\java5study\\src\\io\\person.dat");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(person);
        } catch (FileNotFoundException e) {
            System.out.println( "找不到指定的文件！");
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
             try {
                oos.flush();
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

     /**
     * 对象反序列化测试
     */
     public static void testObjectInSeri() {
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        Person person = null;
         try {
            fis = new FileInputStream( "Q:\\study\\java5study\\src\\io\\person.dat");
            ois = new ObjectInputStream(fis);
            person = (Person) ois.readObject();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
             try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        System.out.println(person.toString());
    }
}

/**
* 测试序列化所用的类
*/
class Person implements Serializable {
     private String username;
     private String cardNumber;
     private transient String password;

     public Person(String username, String cardNumber, String password) {
         this.username = username;
         this.cardNumber = cardNumber;
         this.password = password;
    }

     public String getUsername() {
         return username;
    }

     public void setUsername(String username) {
         this.username = username;
    }

     public String getCardNumber() {
         return cardNumber;
    }

     public void setCardNumber(String cardNumber) {
         this.cardNumber = cardNumber;
    }

     public String getPassword() {
         return password;
    }

     public void setPassword(String password) {
         this.password = password;
    }

     public String toString() {
        StringBuffer sb = new StringBuffer( this.getClass().getName());
        sb.append( "[");
        sb.append( "\n\t");
        sb.append( "username=" + this.username);
        sb.append( "\n\t");
        sb.append( "cardNumber=" + this.cardNumber);
        sb.append( "\n\t");
        sb.append( "password=" + this.password);
        sb.append( "]");
         return sb.toString();
    }
}

 

运行结果为:

io.Person[
    username=熔岩
    cardNumber=341022225562156
    password= null]

Process finished with exit code 0

 

属性password=null，说明在序列化过程中忽略了。

 

说到此，还有一个容易忽略的问题－－serialVersionUID ：

 

序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：

 ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
 

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

 

serialVersionUID 在Eclipse里可以自动生成，可是在其他大部分IDE工具里面都不能自动生成。但是这个long型值取多少，心里没底，与其写还不如不写。