序列化与反序列化

概念

序列化与反序列化

• Java序列化就是将Java对象转换成字节序列的过程
• Java反序列化就是将字节序列恢复为Java对象的过程

用途

• 数据的持久化，通过将数据对象序列化可以让数据对象脱离内存，可以写入物理磁盘或者数据库从而将数据持久的保存
• 远程数据传输，比如文件、图片、音频、视频等都是通过二进制序列的方式进行交换数据的。通过序列化，将Java对象转换为字节序列，就可以实现数据的远程通信。

JDK序列化与反序列化

只有实现了Serializable或者Externalizable接口的类的对象才能被序列化。Externalizable继承自Serializable接口，区别在于实现Externalizable可控制序列化的行为，而实现Serializable接口的类则采用默认的序列化方式

对象序列化步骤

1. 创建一个对象输出流，包装一个其他类型的输出流
2. 调用对象输出流的writeObject()方法写对象

对象反序列化步骤

1. 创建一个对象输入流，包装一个其他类型的输入流
2. 调用对象输入流的readObject()方法获取对象

提供两个序列化与反序列化示例

此处示例均略去Person类代码

示例一(将对象放入文件）

public class TestObjSerializeAndDeserialize {

    public static void main(String[] args) throws Exception {
        SerializePerson();//序列化Person对象
        Person p = DeserializePerson();//反序列Perons对象
        System.out.println(MessageFormat.format("name={0},age={1},sex={2}",
                                                 p.getName(), p.getAge(), p.getSex()));
    }

    /**
     * MethodName: SerializePerson 
     * Description: 序列化Person对象
     * @author xudp
     * @throws FileNotFoundException
     * @throws IOException
     */
    private static void SerializePerson() throws FileNotFoundException,
            IOException {
        Person person = new Person();
        person.setName("gacl");
        person.setAge(25);
        person.setSex("男");
        // ObjectOutputStream 对象输出流，将Person对象存储到E盘的Person.txt文件中，完成对Person对象的序列化操作
        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
                new File("E:/Person.txt")));
        oo.writeObject(person);
        System.out.println("Person对象序列化成功！");
        oo.close();
    }

    /**
     * MethodName: DeserializePerson 
     * Description: 反序列Perons对象
     * @author xudp
     * @return
     * @throws Exception
     * @throws IOException
     */
    private static Person DeserializePerson() throws Exception, IOException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                new File("E:/Person.txt")));
        Person person = (Person) ois.readObject();
        System.out.println("Person对象反序列化成功！");
        return person;
    }

}

示例二(将对象放入Redis缓存)

/**
     * 序列化
     */
public static byte[] serialize(Object obj){
        ObjectOutputStream oos = null;
        ByteArrayOutputStream bos = null;
        bos = new ByteArrayOutputStream();
        try {

            oos = new ObjectOutputStream(bos);//包装byte数组到输出流
            oos.writeObject(obj);
            byte[] bytes = bos.toByteArray();
            oos.flush();
            oos.close();
            bos.close();
            return bytes;
        } catch (IOException e) {
            e.printStackTrace();

        }
        return null;
    }

    /**
     * 反序列化
     */
    public static Object unserialize(byte[] bytes){
        ObjectInputStream ois = null;
        ByteArrayInputStream bis = null;
        bis = new ByteArrayInputStream(bytes);
        try {
            ois = new ObjectInputStream(bis);//将字节数组包装进输入流
            ois.close();
            bis.close();
            return ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 放入对象
     */
    @Test
    public void setObject(){
        Person p = new Person(100,"lucy");
        Jedis jedis = new Jedis("localhost");
        jedis.set("person:100".getBytes(), SerializableUtil.serialize(p));
        p = new Person(101,"rose");
        jedis.set("person:101".getBytes(), SerializableUtil.serialize(p));
    }

    /**
     * 取出对象
     */
    public Person getObject(int id){
        Jedis jedis = new Jedis("localhost");
        byte[] person = jedis.get(("person:"+id).getBytes());
        return (Person)SerializableUtil.unserialize(person);
    }

    public static void main(String[] args){
        SerializableUtil su = new SerializableUtil();
        Person p = su.getObject(100);
        System.out.println(p.toString());
    }
}