序列化和反序列化

序列化和反序列化

序列化简介

Java序列化,一个日常开发中比较少用到的技术。正常情况下,JVM启动后,我们可以创建对象,JVM关闭后,我们创建过的对象都随之销毁,资源释放。但有些时候可能要求在JVM停止之后,某些对象需要保存起来,以便将来再重新读取它们。

举个例子,应用服务器的HttpSession对象,Session是指浏览器与服务器之间的一次会话,对应的是服务器中的一个Session对象,而客户端中保存一个jsessionid。那么当某种情况下,我们不得不重启服务器的时候,就需要把之前所有的Session对象保存起来,服务器重启之后,将这些Session对象再重新加载过来,这样避免了之前浏览器与服务器建立的会话失效,在浏览器那看来,就好象服务器没有关闭过一样(假设服务器重启期间用户没有操作)。这就用到了Java序列化技术,关于这个例子,我们可以拿Tomcat来测试一下,注意要用正常的手段来关闭服务器(shutdown.bat),而非强制关闭,强制关闭没有序列化的过程。

Java序列化

首先创建一个可序列化的JavaBean类:Name.java

import java.io.Serializable;  
  
/** 
 * 可序列化的类,需要实现Serializable接口 
 */  
public class Name implements Serializable {  
  
    private String firstname;  
      
    private String lastname;  
      
    public Name() {  
        System.out.println("无参构造器");  
    }  
  
    public Name(String firstname, String lastname) {  
        System.out.println("全参构造器");  
        this.firstname = firstname;  
        this.lastname = lastname;  
    }  
  
    //省略getter和setter

    @Override  
    public String toString() {  
        return "我的名字是" + firstname + "," + lastname;  
    }  
      
}  

再实现一个序列化的工具类:Serializations.java

import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
/** 
 * 序列化工具类 
 */  
public class Serializations {  
  
    /** 
     * 序列化对象到指定路径文件 
     * @param outPath 文件路径 
     * @param outObj 需要序列化的对象 
     * @throws IOException 当I/O发生异常时 
     */  
    public static void serialize(String outPath, Object outObj) 
        throws IOException {  
        ObjectOutputStream oos = null;  
        try {  
            oos = new ObjectOutputStream(new FileOutputStream(outPath));  
            oos.writeObject(outObj);  
        } finally {  
            if(oos != null)    oos.close();  
        }  
    }  
      
    /** 
     * 从文件中逆序列化出对象 
     * @param inPath 文件路径 
     * @return 你序列化出的对象 
     * @throws IOException 当I/O发生异常时 
     * @throws ClassNotFoundException 当文件中不存在序列化的对象时 
     */  
    public static Object deserialize(String inPath) 
        throws IOException, ClassNotFoundException {  
        ObjectInputStream ois = null;  
        try {  
            ois = new ObjectInputStream(new FileInputStream(inPath));  
            return ois.readObject();  
        } finally {  
            if(ois != null)    ois.close();  
        }  
    }  
}  

最后创建两个个测试类,来使用一下序列化方法和逆序列化方法:WriteObject.java。

import java.io.IOException;  
  
public class WriteObject {  
  
    public static void main(String[] args) throws IOException {  
        Name name = new Name("科比", "布莱恩特");  
        Serializations.serialize(args[0], name);  
    }  
}  

运行后,指定目录下会生成相应文件,其内包含了name对象信息。

ReadObject.java:

import java.io.IOException;  
  
public class ReadObject {  
  
    public static void main(String[] args) 
        throws ClassNotFoundException, IOException {  
        Object obj = Serializations.deserialize(args[0]);  
        System.out.println(obj);  
    }  

运行后,输出:我的名字是科比,布莱恩特

我们成功的将name对象序列化到了指定文件中,并且通过逆序列化得到一个和原对象属性相同的对象。注意,逆序列化出的对象没有使用该对象的构造器(由输出结果可以证明),并且和原对象不相等。

对象的默认序列化机制
序列化时,对象的类、类的签名,以及类及其所有超类型的非瞬态(non-transient)和非静态(non-static)字段的值都将被写入。逆序列化时,对象的类、类的签名,以及类及其所有超类型的非瞬态(non-transient)和非静态(non-static)字段的值都将被读取。如果我们想某个成员变量不被序列化,可以在其前面加入transient关键字。如:

private transient String lastname;  

序列化版本号

如果对象所属类在对象序列化之后做了修改,比如修改属性名称、类型、修饰符等等,再次逆序列化就会发生异常,如我们将lastname前加入transient,使用ReadObject.java进行逆序列化, 将会抛出如下异常:

Exception in thread "main" java.io.InvalidClassException: Name; local class incompatible: stream classdesc serialVersionUID = 3999552307707967101, local class serialVersionUID = -4860856635192050881  
    at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:604)  
    at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1601)  
    at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1514)  
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1750)  
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1347)  
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:369)  
    at Serializations.deserialize(Serializations.java:43)  
    at ReadObject.main(SerializationsTest.java:14)  

异常的大概描述是说流中的类的版本号和本地类的版本号不一致,这里要引入一个序列化版本号(serialVersionUID)的概念, serialVersionUID 是一个64位的值,在类中需要声明为private static final long,它可以人为来维护,也可以通过JVM实现的算法来生成,安装JDK后,可以过%JAVA_HOME%/bin/serialver.exe来生成serialVersionUID。在逆序列化时,会将从对象流中读取的类信息和当前classpath下的相应类的类信息(Name.class)进行比对,比对的媒介就是serialVersionUID,如果对象中没有声明serialVersionUID,那么该值就会通过默认的算法生成,两端不一致时,就会抛出上面的异常,逆序列化失败。

当编写一个可序列化的类时(Name.java),可以给serialVersionUID赋一个即简单又易理解的值,如:

private static final long serialVersionUID = 1L;  

如果对该类进行了更改,可能需要同时更新serialVersionUID,如:

private static final long serialVersionUID = 2L;  

但有时我们可能即使更改了类之后,仍然要保持之前序列化的可逆性,也就是对之前的序列化文件做个兼容,那么就不能更新serialVersionUID的值,这时更改前生成的序列化文件依然可逆序列化,那么其更新的字段会以字段类型的预设值逆序列化,避开不兼容的问题。

复合类序列化

上文中实现了序列化和逆序列化一个简单的Name对象,下面来看一个稍复杂的情况,Name类中复合了其它类。

import java.io.Serializable;  
  
/** 
 * 可序列化的类,需要实现Serializable接口 
 */  
public class Name implements Serializable {  
  
    private static final long serialVersionUID = 1L;  
  
    private String firstname;  
      
    private String lastname;  
      
    private Nickname nickname;  
      
    public Name() {}  
  
    public Name(String firstname, String lastname) {  
        this.firstname = firstname;  
        this.lastname = lastname;  
    }  
      
    public Name(String firstname, String lastname, Nickname nickname) {  
        this.firstname = firstname;  
        this.lastname = lastname;  
        this.nickname = nickname;  
    }  
  
    public String getFirstname() {  
        return firstname;  
    }  
  
    public void setFirstname(String firstname) {  
        this.firstname = firstname;  
    }  
  
    public String getLastname() {  
        return lastname;  
    }  
  
    public void setLastname(String lastname) {  
        this.lastname = lastname;  
    }  
      
    public Nickname getNickname() {  
        return nickname;  
    }  
  
    public void setNickname(Nickname nickname) {  
        this.nickname = nickname;  
    }  
  
    @Override  
    public String toString() {  
        return "我的名字是" + firstname + "," + lastname + "\n我的昵称是" + nickname;  
    }  
      
}  

Nickname.java:

import java.io.Serializable;  
  
/** 
 * 昵称类 
 */  
public class Nickname implements Serializable {  
  
    private static final long serialVersionUID = 1L;  
      
    private String name;  
      
    public Nickname() {}  
  
    //省略getter和setter
  
    @Override  
    public String toString() {  
        return name;  
    }  
      
}  

WriteObject.java:

import java.io.IOException;  
  
import com.runqianapp.test.bean.Name;  
import com.runqianapp.test.bean.Nickname;  
  
public class WriteObject {  
  
    public static void main(String[] args) throws IOException {  
        Nickname nickname = new Nickname("黑曼巴");  
        Name name = new Name("科比", "布莱恩特", nickname);  
        Serializations.serialize(args[0], name);  
    }  
}  

运行后,指定目录下会生成相应文件,再次运行ReadObject.java,会得到如下输出信息:

我的名字是科比,布莱恩特  
我的昵称是黑曼巴  

在序列化对象时,不仅会序列化当前对象本身,还会对该对象引用的其它对象也进行序列化,同样地,这些其它对象引用的另外对象也将被序列化,以此类推。在序列化过程中,可能会遇到不支持可序列化接口的对象,在此情况下,将抛出 NotSerializableException,并将标识不可序列化对象的类。如将Nickname.java去掉Serializable接口,再次运行WriteObject.java,会抛出如下异常:

Exception in thread "main" java.io.NotSerializableException: Nickname  
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1180)  
    at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1528)  
    at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1493)  
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1416)  
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1174)  
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:346)  
    at Serializations.serialize(Serializations.java:26)  
    at WriteObject.main(WriteObject.java:13)  

我们可以用transient来修饰nickname属性,这样该类就可以正常序列化了,但是nickname中的属性也就无法序列化了,那我们如何让不能序列化的类NickName中的name属性可以序列化和反序列化呢?在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法:

public class Name implements Serializable {  
    ...  
    transient private Nickname nickname; 
    ...   
  
    private void writeObject(ObjectOutputStream out) throws IOException {  
        // 默认序列化机制  
        out.defaultWriteObject();  
        // 序列化nickname中的name属性  
        out.writeObject(nickname.getName());  
    }  
  
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
        // 默认逆序列化机制  
        in.defaultReadObject();  
        // 逆序列化一个nickname对象  
       nickname = new Nickname(in.readObject().toString()); 
    }  
}  

这样就可以处理其不可序列化的复合类Nickname中的name属性序列化及反序列化。运行WriteObject和ReadObject,序列化和反序列化成功。这两个方法如何实现取决于最终的需求。


作者:不知名的蛋挞
链接:https://www.jianshu.com/p/7d1fdef62b20
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。