java 序列化和transient的用法

1.      序列化的目的是网络传输java对象(RMI)和对bean的序列化读写，实现轻量级的持久化

2.      序列化的实现是继承Serializable接口

3.      序列化后可以通过writeObject和readObject来实现对类的读写

4.      对于有些属性不需要序列化保存的，有两种方法：

a)  继承实现Externalizable接口，实现其方法，对指定的属性进行写入

b)        继承实现Serializable接口，使用关键字：transient来对不必要的属性进行排除

5.      transient关键字只能和Serializable同时使用

6.      想序列化static值，需要手动去实现

 

看实例：

 

class Date implements Serializable{

         privateint n;

         publicDate(int n){

                   this.n= n;

         }

         publicString toString(){

                   returnInteger.toString(n);

         }

}

/**

 *java序列化，用于网络传输和对beans的序列化，比如保存配置信息

 *cn.hibernate.test1.Worm.java

 *@author ffr

 *created at 2012-3-17

 */

public class Worm implements Serializable{

         privatestatic Random rand = new Random(47);

         privateDate[] d = {

                            newDate(rand.nextInt(10)),

                            newDate(rand.nextInt(10)),

                            newDate(rand.nextInt(10))                      

         };

         privateWorm next;

         privatechar c;

         publicWorm(int i, char x){

                   print("Wormconstructor: "+i);

                   c= x;

                   if(--i> 0){

                            next= new Worm(i, (char)(x+1));

                   }

         }

         publicWorm(){

                   print("Defaultconstructor");

         }

         publicString toString(){

                   StringBuilderresult = new StringBuilder(":");

                   result.append(c);

                   result.append("(");

                   for(Datedat : d){

                            result.append(dat);

                   }

                   result.append(")");

                   if(next!= null){

                            result.append(next);

                   }

                   returnresult.toString();

         }

        

         publicstatic void main(String[] args) throws ClassNotFoundException, IOException{

                   //初始化后输出

                   Wormw = new Worm(6,'a');

                   print("w= "+w);

                   //写入对象

                   ObjectOutputStreamout = new ObjectOutputStream(new FileOutputStream("worm.out"));

                   out.writeObject("Wormstorage\n");

                   out.writeObject(w);

                   out.close();

                   //读取对象

                   ObjectInputStreamin = new ObjectInputStream(new FileInputStream("worm.out"));

                   Strings = (String)in.readObject();

                   Wormw2 = (Worm)in.readObject();

                   //输出

                   print(s+"w2="+w2);

                   in.close();

                   //按字节写入

                   ByteArrayOutputStreambout = new ByteArrayOutputStream();

                   ObjectOutputStreamout2 = new ObjectOutputStream(bout);

                   out2.writeObject("Wormstorage\n");

                   out2.writeObject(w);

                   out2.close();

                   //按字节读取

                   ObjectInputStreamin2 = new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));

                   s= (String)in2.readObject();

                   Wormw3 = (Worm)in2.readObject();

                   //输出

                   print(s+"w3= " + w3);

                   in2.close();

                   //最后结果都一样，足以说明序列化的作用，如果没有序列化，写入对象会报异常

         }

         privatestatic void print (String str){

                   System.out.println(str);

         }

        

}/*Output

Worm constructor: 6

Worm constructor: 5

Worm constructor: 4

Worm constructor: 3

Worm constructor: 2

Worm constructor: 1

w =:a(853):b(119):c(802):d(788):e(199):f(881)

Worm storage

w2=:a(853):b(119):c(802):d(788):e(199):f(881)

Worm storage

w3 =:a(853):b(119):c(802):d(788):e(199):f(881)

*///:~

这样可以看出，对对象的读写，没有通过构造方法来实现，只是一个传输的过程

 

是怎么样读写和查找序列化类的，看代码：

public class Alien implements Serializable {

 

}

public class FreezeAlien {

    public static void main(String[] args) throws Exception{

       ObjectOutput out = new ObjectOutputStream(new FileOutputStream("Y.file"));

       Alien quellek = new Alien();

       out.writeObject(quellek);

    }

}

运行FreezeAlien会发现在项目根目录出现Y.file文件，这个就是产生的序列化文件，通过下面的方法恢复

public class ThwaAlien {

    public static void main(String[] args) throws Exception{

       ObjectInputStream in= new ObjectInputStream(new FileInputStream(new File(".","Y.file")));

       Object mystery = in.readObject();

       System.out.println(mystery.getClass());

    }

}

//注意，对于上面红色字体部分，经过测试，这里的路径是从根目录查找开始的，所以“.”是正确的，至于java编程思想(第四版，P575)上的“..”，怎么测试也实现不了这种结果。

 

Transient关键字的具体实例：

/**

 * 实现属性不序列化有两种方法：

 * 1.继承实现Externalizable接口，实现其方法，对指定的属性进行写入

 * 2.继承实现Serializable接口，使用关键字：transient来对不必要的属性进行排除

 * cn.hibernate.test1.Logon.java

 * @author ffr

 * created at 2012-3-17

 */

public class Logon implements Serializable {

    private java.util.Date date = new java.util.Date();

    private String username;

    private transient String password;

    public Logon(String name, String pwd){

       this.username = name;

       this.password = pwd;

    }

    public String toString(){

       return "logon info:\n username:"+username+"\ndate : "+date+"\n password:"+password;

    }

    public static void main(String[] args) throws Exception{

       Logon a = new Logon("zhangsan", "123");

       System.out.println("logon a =" + a);

       ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("logon.out"));

       o.writeObject(a);

       o.close();

       TimeUnit.SECONDS.sleep(1);//延迟

       //读取

       ObjectInputStream in = new ObjectInputStream(new FileInputStream("logon.out"));

       System.out.println("REcoveringobject ai " + new java.util.Date());

       a = (Logon)in.readObject();

       System.out.println("logon a =" + a);

    }

}/**output

//不带关键字：transient

logon a = logon info:

 username:zhangsan

 date : Sat Mar 17 15:22:22 CST 2012

 password :123

REcovering object ai Sat Mar 17 15:22:23 CST 2012

logon a = logon info:

 username:zhangsan

 date : Sat Mar 17 15:22:22 CST 2012

 password :123

 

//带关键字：transient

logon a = logon info:

 username:zhangsan

 date : Sat Mar 17 15:22:58 CST 2012

 password :123

REcovering object ai Sat Mar 17 15:22:59 CST 2012

logon a = logon info:

 username:zhangsan

 date : Sat Mar 17 15:22:58 CST 2012

 password :null

 */