java序列化那些事儿

java序列化作用

在说java序列化的作用之前，先说下什么是java序列化吧。java序列化是指把java对象转换为字节序列的过程；而java反序列化是指把字节序列恢复为java对象的过程。java序列化主要有2个作用：1，对象持久化，对象生存在内存中，想把一个对象持久化到磁盘，必须已某种方式来组织这个对象包含的信息，这种方式就是序列化；2，远程网络通信，内存中的对象不能直接进行网络传输，发送端把对象序列化成网络可传输的字节流，接收端再把字节流还原成对象。

序列化示意图

对象序列化和反序列化

对象A1序列化成字节序列A的过程，是把一个存在于内存中的对象转化为一个可以被持久化和网络传输的字节序列的过程，字节序列A反序列化成A2就是逆过程。注意： A1和A2的关系，应该是equals，而不是==（如果包含transient属性或者自定义了序列化和反序列化方法，可能equals都不是）。

序列化反序列化代码示例

用户信息类：

package com.podongfeng;

import java.io.Serializable;

/**
 * Title: User.class

 * Description: 用户信息类

 * Create DateTime: 2016年04月18日 下午10:20 

 *
 * @author podongfeng
 */
public class User implements Serializable {

    private static final long serialVersionUID = 9058870178716533905L;
    public static String TAG = "java";

    private String name;
    private int age;
    transient private int salary;

    public User(String name, int age, int salary) {
        this.name = name;
        this.salary = salary;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

序列化和反序列化测试类：

package com.podongfeng;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Title: SerializableTest.class

 * Description: 序列化和反序列化测试

 * Create DateTime: 2016年04月18日 下午10:33 

 *
 * @author podongfeng
 */
public class SerializableTest {

    public static void main(String[] args) {
        User user = new User("jack", 20, 10000);
        System.out.println(user);

        // 序列化
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("jack.txt"));
            oos.writeObject(user);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.flush();
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        // 反序列化
        ObjectInputStream ois = null;
        User user2 = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("jack.txt"));
            user2 = (User)ois.readObject();
            System.out.println(user2);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println("user equals user2 : " + user.equals(user2));
        System.out.println("user == user2 : " + (user == user2));
    }
}

运行结果：

User{name='jack', age=20, salary=10000}
User{name='jack', age=20, salary=0}
user equals user2 : false
user == user2 : false

Serializable

Serializable接口是在java序列化中最常用的。一个实体类想要被序列化，只要实现Serializable接口即可，而且并不需要实现任何方法，实现这个接口更像是一种象征性的声明。其实也并不完全是这样，当你的实体类实现这个接口的时候，你的IDE（eclipse或者idea）应该会给你一个警告，提示你serialVersionUID这个成员变量，接下来我们就来说说它的作用。serialVersionUID可以理解为类的版本号，只有版本号相同，反序列化才能成功。serialVersionUID可以不显式设置，那么就会有一个默认的serialVersionUID，这个是通过你的类定义信息计算所得，也就是说，如果这个类进行了修改，就会产生一个不同的serialVersionUID，那么之前序列化的字节流就不能正常反序列化了。但是，在某些情况下，我们对实体类进行了修改，比如增加了一个成员变量，但我还是希望可以反序列成功，其实就可以通过显示定义一个serialVersionUID，只要增加成员变量的时候没有修改serialVersionUID，那么之前序列化好的字节流可以被反序列化成新的对象。

自定义序列化

实际的开发过程中，可能会有这样的需求，一个实体类中，某些属性需要序列化，某些属性不需要，如果能自己控制，可以有效减少系列化的长度，提高序列化和反序列话的效率。比较便捷的方式是通过transient关键字，声明为transient的成员变量不会被序列化。正如上面样例代码中输出的结果，salary字段被定义为transient，在user对象中有值为10000，但是序列化反序列化后user2对象中salary为0，即int类型的初始值。如果觉得这还不够，需要进一步自定义，那么可以考虑覆写writeObject(ObjectOutput out)和readObject(ObjectInput in)方法，如果你的实体类实现了Serializable接口并且覆写了这2个方法，jvm就会调用这2个方法进行序列化和反序列化了，你可以完全控制需要序列化的属性和过程了。

Externalizable

除了Serializable接口，想要序列化的类还可以选择实现Externalizable接口，与writeObject(ObjectOutput out)和readObject(ObjectInput in)方法对应，有这样2个方法：writeExternal(ObjectOutput out)和readExternal(ObjectInput in)。不同的是，在反序列的过程中，还是调用序列化的类的无参构造方法，而实现Serializable接口并不会。

other

1、序列化的是对象而不是类，所以静态变量并不会被序列化，因为静态变量归属于类
2、序列化采用深拷贝，即反序列化后得到的对象与原始对象不是同一个，其实也很好理解，持久化到磁盘或者网络传输后，再反序列化出来，都可能在另外一台机器的内存空间了。
3、对于某些单例的对象，可以在类定义的时候加上readResolve()方法，返回单例的实体类，这样在同一内存空间反序列化出来，会调用readResolve()方法获得原单例对象的引用，避免因为序列化和反序列化破坏了单例。