Java序列化（一）

系统管理员 2021-09-15 13:36 227阅读 0赞

所有分布式应用常常需要跨平台，跨网络，因此要求所有传的参数、返回值都必须实现序列化。

# 一、定义 #

序列化：把Java对象转换为字节序列的过程。   
　　   
　　反序列化：把字节序列恢复为Java对象的过程。

# 二、用途 #

对象的序列化主要有两种用途：   
　　   
　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；（持久化对象）   
　　   
　　2） 在网络上传送对象的字节序列。（网络传输对象）

# 三、实现 #

实现了如下两个接口之一的类的对象才能被序列化：   
　　   
　　1） Serializable   
　　   
　　2） Externalizable

序列化：ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

反序化：ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

注：使用writeObject() 和readObject()方法的对象必须已经被序列化

# 四、深入理解 #

### 一、为什么要序列化？ ###

Java平台允许我们在内存中创建可复用的Java对象，但只有当JVM（Java虚拟机）处于运行时，这些对象才可能存在，也就是这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存指定的对象(持久化对象)，并在将来重新读取被保存的对象。Java对象序列化就实现了该功能。   
　　   
　　网络通信时，无论是何种类型的数据，都会转成字节序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。Java对象序列化也实现了该功能。

所以序列化机制会把内存中的Java对象转换成与平台无关的二进制流，从而永久地保存在磁盘上或是通过网络传输到另一个网络节点。

### 二、序列化的意义 ###

客户端访问了某个能开启会话功能的资源， web服务器就会创建一个与该客户端对应的HttpSession对象，每个HttpSession对象都要站用一定的内存空间。如果在某一时间段内访问站点的用户很多，web服务器内存中就会积累大量的HttpSession对象，消耗大量的服务器内存，即使用户已经离开或者关闭了浏览器，web服务器仍要保留与之对应的HttpSession对象，在他们超时之前，一直占用web服务器内存资源。

web服务器通常将那些暂时不活动但未超时的HttpSession对象转移到文件系统或数据库中保存，服务器要使用他们时再将他们从文件系统或数据库中装载入内存，这种技术称为Session的持久化。

将HttpSession对象保存到文件系统或数据库中，需要采用序列化的方式将HttpSession对象中的每个属性对象保存到文件系统或数据库中；将HttpSession对象从文件系统或数据库中装载如内存时，需要采用反序列化的方式，恢复HttpSession对象中的每个属性对象。所以存储在HttpSession对象中的每个属性对象必须实现Serializable接口

### 三、Session的持久化的作用 ###

1.提高服务器内存的利用率，保证那些暂停活动的客户端在会话超时之前继续原来的会话

2，在多台web服务器协同对外提供服务的集群系统中，使用Session的持久化技术，某台服务器可以将其中发生改变的Session对象复制给其他服务器。保证了在某台服务器停止工作后可以由其他服务器来接替它与客户端的会话

3，在一个web应用程序重启时，服务器也会持久化该应用程序中所有HttpSession对象，保证客户端的会话活动仍可以继续。

Tomcat使用Session Manager 类来管理Session的持久化，他提供了两个SessionManager类

org.apache.catalina.session.StandardManager

org.apache.catalina.session.PersistentManager

*  1
 *  2

StandardManager是tomcat默认使用的，在web应用程序关闭时，对内存中的所有HttpSession对象进行持久化，把他们保存到文件系统中。默认的存储文件为

### 四、serialVersionUID ###

如果serialVersionUID没有显式生成，系统就会自动生成一个。此时，如果在序列化后我们将该类作添加或减少一个字段等的操作，系统在反序列化时会重新生成一个serialVersionUID然后去和已经序列化的对象进行比较，就会报序列号版本不一致的错误。为了避免这种问题， 一般系统都会要求实现serialiable接口的类显式的生明一个serialVersionUID。   
　显式定义serialVersionUID的两种用途：   
　　　1、 希望类的不同版本对序列化兼容时，需要确保类的不同版本具有相同的serialVersionUID；   
　　　2、 不希望类的不同版本对序列化兼容时，需要确保类的不同版本具有不同的serialVersionUID。

# 五、序列化机制算法 #

1. 所有保存到磁盘中的对象都有一个序列化编号   
　　   
　　2. 当程序试图序列化一个对象时，程序先检查该对象是否已经被序列化过。如果从未被序列化过，系统就会将该对象转换成字节序列并输出；如果已经序列化过，将直接输出一个序列化编号。

# 六、示例 #

要被序列化的对象对应的类的代码：

public class Person implements Serializable {   
    
        private String name = null;  
    
        private Integer age = null;   
    
        public Person(){
            System.out.println("无参构造");
        }
        public Person(String name, Integer age) {  
            this.name = name;  
            this.age = age;  
        }  
        //getter setter方法省略...
        @Override 
        public String toString() {  
            return "[" + name + ", " + age+"]";  
        }  
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

MySerilizable 是一个简单的序列化程序，它先将一个Person对象保存到文件person.txt中，然后再从该文件中读出被存储的Person对象，并打印该对象。

public class MySerilizable {
    
        public static void main(String[] args) throws Exception {  
            File file = new File("person.txt");  
    
            //序列化持久化对象
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));  
            Person person = new Person("Peter", 27);  
            out.writeObject(person);  
            out.close();  
    
            //反序列化，并得到对象
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));  
            Object newPerson = in.readObject(); // 没有强制转换到Person类型 
            in.close();  
            System.out.println(newPerson);  
        }  
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

输出结果：

[Peter, 27]

*  1

结果没有打印“无参构造”，说明反序列化机制无需通过构造器来初始Java对象。   
　　注：   
　　   
　　1.） 反序列化读取的仅仅是Java对象的数据，而不是Java类，所以在反序列化时必须提供该Java对象所属类的class文件（这里是Person.class），否则会引发ClassNotFoundException异常。   
　　   
　　2）.当重新读取被保存的Person对象时，并没有调用Person的任何构造器，说明反序列化机制无须通过构造器来初始化对象。

# 七、选择序列化 #

## transient ##

当对某个对象进行序列化时，系统会自动将该对象的所有属性依次进行序列化，如果某个属性引用到别一个对象，则被引用的对象也会被序列化。如果被引用的对象的属性也引用了其他对象，则被引用的对象也会被序列化。 这就是递归序列化。

有时候，我们并不希望出现递归序列化，或是某个存敏感信息（如银行密码）的属性不被序列化，我们就可通过transient关键字修饰该属性来阻止被序列化。

将上面的Person类的age属性用transient修饰：

transient private Integer age = null;

*  1

再去执行MySerilizable的结果为：

[Peter, null] //返序列化时没有值，说明age字段未被序列化

*  1

## writeObject()方法与readObject()方法 ##

使用transient关键字阻止序列化虽然简单方便，但被它修饰的属性被完全隔离在序列化机制之外，导致了在反序列化时无法获取该属性的值，而通过在需要序列化的对象的Java类里加入writeObject()方法与readObject()方法可以控制如何序列化各属性，甚至完全不序列化某些属性（此时就transient一样）。   
　　   
　　如果我们想要上面的Person类里的name属性在序列化后存在文件里不让别人知道具体是什么（加密），我们就可在Person类里加如下代码：

//自定义序列化
     private void writeObject(ObjectOutputStream out) throws IOException {          
        // out.defaultWriteObject(); // 将当前类的非静态和非瞬态字段写入此流。
        //如果不写，如果还有其他字段，则不会被序列化
    
        out.writeObject(new StringBuffer(name).reverse());
         //将name简单加密（反转），这样别人就知道是怎么回事，当然实际应用不可能这样加密。
    
         out.writeInt(age);  
     }  
    
    //反序列化
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
        //in.defaultReadObject();// 从此流读取当前类的非静态和非瞬态字段。
        //如果不写，其他字段就不能被反序列化
    
         name = ((StringBuffer)in.readObject()).reverse().toString();  //解密
    
         age = in.readInt();  
     }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20

详细的自定义序列化与反序列化可参见ObjectOutputStream 和ObjectInputStream 类的JDK文档。

## Externalizable接口 ##

Externalizable接口 与Serializable 接口类似，只是Externalizable接口需要强制自定义序列化。   
要序列化对象的代码：

public class Teacher implements Externalizable{ 
    
        private String name;
        private Integer age;
    
        public Teacher(){
            System.out.println("无参构造");
        }
    
        public Teacher(String name,Integer age){
            System.out.println("有参构造");
            this.name = name;
            this.age = age;
        }
    
        //setter、getter方法省略
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeObject(new StringBuffer(name).reverse()); //将name简单加密
            //out.writeInt(age); //注掉这句后，age属性将不能被序化
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException,
                ClassNotFoundException {
            name = ((StringBuffer) in.readObject()).reverse().toString();
            //age = in.readInt(); 
        }
    
        @Override 
        public String toString() {  
            return "[" + name + ", " + age+ "]";  
        } 
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37

主函数代码改为：

public class MySerilizable {
    
        public static void main(String[] args) throws Exception {  
            File file = new File("person.txt");  
    
            //序列化持久化对象
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));  
            Teacher person = new Teacher("Peter", 27);  
            out.writeObject(person);  
            out.close();  
    
            //反序列化，并得到对象
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));  
            Object newPerson = in.readObject(); // 没有强制转换到Person类型 
            in.close();  
            System.out.println(newPerson);  
    
        }  
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

打印结果：

有参构造
    无参构造 //与Serializable 不同的是，还调用了无参构造
    [Peter, null] //age未被序列化，所以未取到值

*  1
 *  2
 *  3

# 八、单例模式的序列化 #

当我们使用Singleton模式时，应该是期望某个类的实例应该是唯一的，但如果该类是可序列化的，那么情况可能略有不同。此时对第2节使用的Person类进行修改，使其实现Singleton模式，如下所示：

public class Person implements Serializable {   
    
        private static class InstanceHolder {   
            private static final Person instatnce = new Person("John", 31, "男");  
        }  
    
        public static Person getInstance() {  
            return InstanceHolder.instatnce;  
        }  
    
        private String name = null;  
    
        private Integer age = null;  
    
        private Gender gender = null;  
    
        private Person() {  
            System.out.println("无参构造");  
        }  
    
        private Person(String name, Integer age, String gender) {  
            System.out.println("有参构造");  
            this.name = name;  
            this.age = age;  
            this.gender = gender;  
        }  
        ...  
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28

同时要修改MySerilizable 应用，使得能够保存/获取上述单例对象，并进行对象相等性比较，如下代码所示：

public class MySerilizable {  
    
        public static void main(String[] args) throws Exception {  
            File file = new File("person.txt");  
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));  
            out.writeObject(Person.getInstance()); // 保存单例对象 
            out.close();  
    
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));  
            Object newPerson = in.readObject();  
            in.close();  
            System.out.println(newPerson);  
    
            System.out.println(Person.getInstance() == newPerson); // 将获取的对象与Person类中的单例对象进行相等性比较 
        }  
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16

打印结果：

有参构造  
    [John, 31, 男]  
    true  //说明是同一个对象

*  1
 *  2
 *  3

# 九、序列化对象注意事项 #

1.  对象的类名、属性都会被序列化；而方法、static属性（静态属性）、transient属性（即瞬态属性）都不会被序列化（这也就是第4条注意事项的原因）
2.  虽然加static也能让某个属性不被序列化，但static不是这么用的
3.  要序列化的对象的引用属性也必须是可序列化的，否则该对象不可序列化，除非以transient关键字修饰该属性使其不用序列化。
4.  反序列化地象时必须有序列化对象生成的class文件（很多没有被序列化的数据需要从class文件获取）
5.  当通过文件、网络来读取序列化后的对象时，必须按实际的写入顺序读取。