Java 自定义序列化、反序列化

1、如果某个成员变量是敏感信息，不希望序列化到文件/网络节点中，比如说银行密码，或者该成员变量所属的类是不可序列化的，

可以用 transient 关键字修饰此成员变量，序列化时会忽略此成员变量。

 class VipUser{
     private int id;
     private String name;
     //序列化时，此成员变量不会写入到磁盘文件/网络节点中。
     private transient String password;
     //如果User类是不可序列化的，用transient修饰，序列化时会忽略这个成员变量，不会抛出异常
     private transient User user;
     //.......
 }

transient只能修饰成员变量。

2、transient很方便，但是反序列化时，不能取得此成员变量的值。

如果要保证序列化后某些成员变量是安全的，不会被别人识别、破解，在反序列化时也可以读取该成员变量的值，这就需要自定义序列化了。

自定义序列化的类需要继承Serializable接口，并要写三个方法：

• private  void  writeObject(ObjectOutputStream  out)     //序列化时会调用此方法
• private  void  readObject(ObjectInputStream  in)      //反序列化时会调用此方法
• private  void  readObjectNoData()     //当序列化的类版本和反序列化的类版本不同时，或者ObjectInputStream流被修改时，会调用此方法。

Serializable接口中没有任何成员，上面3个方法都是我们自己写的。

三个方法都是可选的，不强制，但一般都要实现前2个方法。

示例：

 //implements Serializable
 class User implements Serializable{
     private int id;
     private String name;
     private String password;
     //......其他成员变量

     public User(int id,String name,String password){
         this.id=id;
         this.name=name;
         this.password=password;
     }

     public int getId() {
         return id;
     }

     public String getName() {
         return name;
     }

     public String getPassword() {
         return password;
     }

     //自定义序列化
     private void writeObject(ObjectOutputStream out) throws IOException {
         //只序列化以下3个成员变量
         out.writeInt(id);
         out.writeObject(name);
         //写入反序后的密码，当然我们也可以使用其他加密方式。这样别人打开文件，看到的就不是真正的密码，更安全。
         out.writeObject(new StringBuffer(password).reverse());
     }

     //自定义反序列化。注意：read()的顺序要和write()的顺序一致。比如说序列化时写的顺序是id、name、password，反序列化时读的顺序也要是id、name、password。
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
         this.id=in.readInt();
         //readObject()返回的是Object，要强制类型转换
         this.name=(String)in.readObject();
         //反序才得到真正的密码
         StringBuffer pwd=(StringBuffer)in.readObject();
         this.password=pwd.reverse().toString();
     }

 }

 public class Test {
     public static void main(String[] args) throws IOException, ClassNotFoundException {
         User zhangsan=new User(1,"张三","1234");

         //序列化
         ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
         //调用我们自定义的writeObject()方法
         out.writeObject(zhangsan);
         out.close();

         //反序列化
         ObjectInputStream in=new ObjectInputStream(new FileInputStream("./obj.txt"));
         //调用自定义的readObject()方法
         User user=(User)in.readObject();   //写掉了一句   in.close()

         //测试
         System.out.println(user.getId());   //1
         System.out.println(user.getName());   //张三
         System.out.println(user.getPassword());   //1234
     }
 }

3、我们甚至可以偷梁换柱，替换序列化的整个对象。

不写上面提到的3个方法，而是写writeReplace()方法:

private/default/protected/public  Object  writeReplace(){................}

访问权限可以是任意的。 返回一个Object类型的对象。

序列化时，会先自动调用writeReplace()方法，用返回的这个对象，替换要序列化的那个对象，再进行序列化。就是说，实际序列化的是writeReplace()返回的这个对象，并不是原来的对象。

示例：

 //implements Serializable
 class User implements Serializable{
     private int id;
     private String name;
     private String password;
     //......其他成员变量

     public User(int id,String name,String password){
         this.id=id;
         this.name=name;
         this.password=password;
     }

     public int getId() {
         return id;
     }

     public String getName() {
         return name;
     }

     public String getPassword() {
         return password;
     }

     //不用写writeObject()、readObject()，只写writeReplace(）
     private Object writeReplace(){
         User lisi=new User(2,"李四","qwer");
         return lisi;
     }

 }

 public class Test {
     public static void main(String[] args) throws IOException, ClassNotFoundException {
         User zhangsan=new User(1,"张三","1234");

         //序列化
         ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
         //执行writeObject(）时，会先自动调用writeReplace()，用返回的lisi替换原来的zhangsan，再序列化，实际序列化的对象是lisi
         out.writeObject(zhangsan);
         out.close();

         //反序列化
         ObjectInputStream in=new ObjectInputStream(new FileInputStream("./obj.txt"));
         User user=(User)in.readObject();   //写掉了一句  in.close()

         //测试
         System.out.println(user.getId());  //
         System.out.println(user.getName());   //李四
         System.out.println(user.getPassword());  //qwer
     }
 }

writeReplace()返回的是OBject，就是说任意类型均可。我们完全可以返回其他类型的对象，比如这样：

 private Object writeReplace(){
         //返回字符串ok
         return new String("ok");
     }

 public class Test {
     public static void main(String[] args) throws IOException, ClassNotFoundException {
         User zhangsan=new User(1,"张三","1234");

         //序列化
         ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
         //会自动调用writeReplace()，用字符串ok替换对象zhangsan，实际序列化的对象字符串ok
         out.writeObject(zhangsan);
         out.close();

         //反序列化
         ObjectInputStream in=new ObjectInputStream(new FileInputStream("./obj.txt"));
         String str=(String) in.readObject();
         in.close();

         //测试
         System.out.println(str);   //ok
     }
 }

当然，常见的做法是，对原对象的成员变量做一些加工处理。

 //implements Serializable
 class User implements Serializable{
     private int id;
     private String name;
     private String password;

     public User(int id,String name,String password){
         this.id=id;
         this.name=name;
         this.password=password;
     }

     //......

     private Object writeReplace(){
         String info="请编号为"+id+"的客户"+name+"到1号柜台办理业务。";
         return info;
     }

 }

4、我们也可以替换掉反序列化得到的整个对象。

private/default/protected/public  Object  readResolve(){................}

在反序列化读取对象后，会自动调用此方法，将读取的对象替换为指定的对象。

 //implements Serializable
 class User implements Serializable{
     private int id;
     private String name;
     private String password;
     //......其他成员变量

     public User(int id,String name,String password){
         this.id=id;
         this.name=name;
         this.password=password;
     }

     //...........

     //用指定的对象替换掉反序列化读取的对象
     private Object readResolve(){
         String info="请编号为"+id+"的客户"+name+"到1号柜台办理业务。";
         return info;
     }

 }

 public class Test {
     public static void main(String[] args) throws IOException, ClassNotFoundException {
         User zhangsan=new User(1,"张三","1234");

         //序列化
         ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
         out.writeObject(zhangsan);
         out.close();

         //反序列化
         ObjectInputStream in=new ObjectInputStream(new FileInputStream("./obj.txt"));
         String str=(String) in.readObject();  //读取的对象zhangsan会被替换为字符串info
         in.close();

         //测试
         System.out.println(str);   //请编号为1的客户张三到1号柜台办理业务。
     }
 }

4和3的使用方式是相同的，只是作用的时间点不同，可以联合使用。

虽然访问权限没有限制，但为了防止子类重写这些方法，造成不必要的麻烦，我们一般使用private修饰。

说明：

这些方法都是在要序列化的类中写的，只对这个类的对象起作用。

比如，我在User类中写了个writeReplace()方法，此方法只在序列化User类的对象时起作用，在序列化其他类的对象时，此方法是不起作用的。

5、之前介绍的方式都是implements  Serializable，我们也可以implement  Externalizable来实现序列化、反序列化。

要实现Externalizable接口里的2个抽象方法：

• public void writeExternal(ObjectOutput  out)    //调用writeObject()时，会自动调用此方法来序列化对象
• public void readExternal(ObjectInput  in)     //调用readObject()时，会自动调用此方法来反序列化

示例：

 //implements Externalizable
 class User implements Externalizable{
     private int id;
     private String name;
     private String password;
     //......其他成员变量

     //必须要有无参的构造函数
     public User(){

     }

     public User(int id,String name,String password){
         this.id=id;
         this.name=name;
         this.password=password;
     }

     public int getId() {
         return id;
     }

     public String getName() {
         return name;
     }

     public String getPassword() {
         return password;
     }

     //自定义序列化
     @Override
     public void writeExternal(ObjectOutput out) throws IOException {
         out.writeInt(id);
         out.writeObject(name);
         out.writeObject(password);
     }

     //自定义反序列化。注意读的顺序要和写的顺序一致。
     @Override
     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
         this.id=in.readInt();
         this.name=(String)in.readObject();
         this.password=(String)in.readObject();
     }
 }

implements  Serializable不要求要有无参的构造函数，但implements  Externalizable要求必须要有无参的构造函数，没有无参的构造函数，会报错。

因为反序列化时，要先自动调用无参的构造函数创建一个未初始化的对象，再自动调用readExternal()给这个对象的成员变量赋值，初始化这个对象，然后才返回这个对象。

有无参的构造函数，但没有在readExternal()中初始化某些成员变量，会正常返回该对象，只是对应的成员变量的值会使用默认的初始值，比如int是0，引用型的是null。

String、StringBuffer、StringBuilder都是引用型的。

6、2种序列化机制的比较

实现Serializable接口	实现Externalizable接口
如果未自定义序列化、反序列化方式，则系统会自动保存所有的成员变量。 如果自定义了序列化、反序列化方式，则按自定义的方式处理。	只能自定义序列化、反序列化方式， 必须实现2个抽象方法。
有没有无参的构造函数都行。	必须要有无参的构造函数。
性能略低。	性能略高

对象的类名、成员变量中的实例变量（基本类型+引用类型）都会被序列化。

transient、static修饰的成员变量都不会被序列化。如果只是要不能序列化这个效果，尽量用transient，虽然static可以达到相同的效果，但static不是为这个而设计的。

7、版本问题

反序列化时，必须要有该对象所属类的class文件。

序列化时JVM会记录class文件的版本id（唯一标识此版本的class文件，默认由JVM指定），反序列化时，会根据这个版本id找到对应版本的class文件，用这个class文件来进行反序列化，获得原来的对象。

如果序列化了对象，之后随着项目版本的升级，该class文件可能会升级，class文件的版本id可能会变化（新的class文件的版本id可能会由JVM重新指定）。之后反序列化时，JVM根据原来的版本id找不到对应版本的class文件来进行反序列化，就会报错。

解决方法：显示指定class文件的版本id。显示指定后，此class文件的所有版本都使用此版本id，不再由JVM指定。

 class User implements Serializable/Externalizable{
     //固定写法，值可以是任意的long型值
    private static final long serialVersionUID=512L;
    //.......
 }