Java Serializable总结

一.序列化简介

1.什么是序列化

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。

使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的"状态"，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。

除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用，在本文的后续章节中将会陆续讲到。

2.序列化和持久化

序列化 :  把对象转存为二进制数据(如网络传输,存储数据库等),必须实现序列化接口 (Java.io.Serializable).
持久化 :  把对象保存在介质上(如写文件,读文件不是), 没有接口实现,一般指方法调用. 

解释说明： 
       如果按照存储介质和生命周期的长短划分，所有的数据都以两种形式存在，其中：
         一种是保存于内存中的运行时对象；另一种则是存储于持久化物理介质中的文件，比如数据库文件等。
        数据的持久化关注于相同的数据在不同形态数据之间的转化，解决的是如何将内存对象持久化存储，以及从物理介质中加载数据并创建内存对象。
        数据的持久化是序列化的又一个典型的应用，对象只有在序列化之后才能进行持久化存储，从持久化存储介质加载的数据通过反序列化转变成运行时对象。

二.什么情况需要序列化

a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；

b）当你想用套接字在网络上传送对象的时候；

c）当你想通过RMI传输对象的时候；

三.序列化和反序列化实例

java序列化主要使用ObjectOutputStream.write()方法，反序列化使用ObjectInputStream.read()方法。

package com.java.serializable.test2;

import java.io.*;

/**
 * Created by laobo on 2016/1/6.
 */
public class TestSerializable {

    public static void main(String[] arg) throws IOException, ClassNotFoundException {
        SerializablePerson();
        DeserializablePerson();
    }

    private static void SerializablePerson() throws IOException {
        Person person = new Person();
        person.setName("laobo");
        person.setAge(27);
        person.setSex("男");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("/Users/duanxiangchao/java_test/person.txt")));
        objectOutputStream.writeObject(person);
        System.out.println("Person序列化成功！");
        objectOutputStream.close();
    }

    private static void DeserializablePerson() throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("/Users/duanxiangchao/java_test/person.txt")));
        Person person = (Person)objectInputStream.readObject();
        System.out.println("Person反序列化成功！");
        System.out.println("姓名：" + person.getName());
        System.out.println("性别：" + person.getSex());
        System.out.println("年龄：" + person.getAge());
    }

}

package com.java.serializable.test2;

import java.io.Serializable;

/**
 * Created by duanxiangchao on 2016/1/6.
 */
public class Person implements Serializable {

    private static final long serialVersionUID = -5809782578272943999L;

    private String name;
    private String sex;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

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

执行程序，会在java_test文件夹下生成person.txt   

console输出如下

Person序列化成功！
Person反序列化成功！
姓名：laobo
性别：男
年龄：27

四.序列化常见问题

1. Serializable的作用

    为什么一个类实现了Serializable接口，它就可以被序列化呢？在上节的示例中，使用ObjectOutputStream来持久化对象，在该类中有如下代码：

private void writeObject0(Object obj, boolean unshared)
        throws IOException
    {
        boolean oldMode = bout.setBlockDataMode(false);
        depth++;
        try {
            ......省略
            // remaining cases
            if (obj instanceof String) {
                writeString((String) obj, unshared);
            } else if (cl.isArray()) {
                writeArray(obj, desc, unshared);
            } else if (obj instanceof Enum) {
                writeEnum((Enum<?>) obj, desc, unshared);
            } else if (obj instanceof Serializable) {
                writeOrdinaryObject(obj, desc, unshared);
            } else {
                if (extendedDebugInfo) {
                    throw new NotSerializableException(
                        cl.getName() + "\n" + debugInfoStack.toString());
                } else {
                    throw new NotSerializableException(cl.getName());
                }
            }
        } finally {
            depth--;
            bout.setBlockDataMode(oldMode);
        }
    }

从上述代码可知， 如果被写对象的类型是String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializableException。

2.默认序列化机制和transient关键字

默认机制:在序列化对象时，不仅会序列化当前对象本身，还会对该对象引用的其它对象也进行序列化，同样地，这些其它对象引用的另外对象也将被序列化，以此类推。

       所以，如果一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。

  transient关键字

      被transient修饰的属性，不会序列化到指定的目标中。

      例如：上面Person中的属性sex设置为 transient

transient private String sex;

则输出结果为：

Person序列化成功！
Person反序列化成功！
姓名：laobo
性别：null
年龄：27

3.Java对象序列化成字符串和反序列化

     上边的例子，是把对象序列化到文件中；更多的时候，我们需要把序列化的对象保存的数据库或者缓存，这就需要把序列化的对象义字符串的形式返回。这就需要用到ByteArrayOutputStream和ByteArrayInputStream作为ObjectOutputStream、ObjectInputStream的缓冲区，具体使用如下：

/**
 * Created by laobo on 16/11/10.
 */
public class SerializableToString {

    private static final String TEMP_ENCODING = "ISO-8859-1";
    private static final String DEFAULT_ENCODING = "UTF-8";

    public static void main(String[] args) {

        Person person = new Person("zhangsan", "男", 25);
        String str = writeToStr(person);
        System.out.println(str);

        Person person1 = (Person) writeToObject(str);
        System.out.println("姓名：" + person1.getName());
        System.out.println("性别：" + person1.getSex());
        System.out.println("年龄：" + person1.getAge());

    }

    private static String writeToStr(Object obj) {
        //使用ByteArrayOutputStream缓冲区接收序列化对象
        //缓冲区会随着数据的不断写入而自动增长；可使用toByteArray()和toString()获取数据
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        //专门用于序列化对象的流
        ObjectOutputStream oos = null;
        String serializableStr = null;
        try {
            oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            //使用ByteArrayOutputStream.toString()方法，返回字符串
            serializableStr = bos.toString(TEMP_ENCODING);
            serializableStr = URLEncoder.encode(serializableStr, DEFAULT_ENCODING);
            return serializableStr;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private static Object writeToObject(String str) {
        ByteArrayInputStream bais = null;
        ObjectInputStream ois = null;

        try {
            String str1 = URLDecoder.decode(str, DEFAULT_ENCODING);
            byte[] bytes = str1.getBytes(TEMP_ENCODING);
            bais = new ByteArrayInputStream(bytes);
            ois = new ObjectInputStream(bais);
            Person person = (Person) ois.readObject();
            return person;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

}

4.Java序列化版本serialVersionUID的作用

       通常在需要序列化的类中回生命如下属性

private static final long serialVersionUID = -5809782578272943999L;

       简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。

      当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，只有同一次编译生成的class才会生成相同的serialVersionUID 。

      如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。 

      serialVersionUID主要来判断不同版本的兼容性。