Java Serializable总结

来源：互联网发布：js获取上传文件的md5 编辑：程序博客网时间：2024/06/09 16:06

一.序列化简介

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主要来判断不同版本的兼容性。

0 0