Java 对象序列化和反序列化 （实现 Serializable 接口）

序列化和反序列化的概念

　　把对象转换为字节序列的过程称为对象的序列化。

  　 把字节序列恢复为对象的过程称为对象的反序列化。

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

 

JDK类库中的序列化API

　　java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
　　java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
　　只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为,

　　而仅实现Serializable接口的类可以 采用默认的序列化方式 。

　　对象序列化包括如下步骤：　

   　1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
　　2） 通过对象输出流的writeObject()方法写对象。

　　对象反序列化的步骤如下：

　　1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
　　2） 通过对象输入流的readObject()方法读取对象。

示例：

 新建一个Car 类

package com.oukele.redis2.entity;

import java.io.Serializable;

public class Car implements Serializable {

    /*
     * 编号
     */
    private int id;
    /*
     * 车名
     */
    private String name;
    /*
     * 车速
     */
    private double speed;

    public Car(String name,double speed ){
        this.name = name;
        this.speed = speed;
    }

    public Car(int id, String name, double speed) {
        this.id = id;
        this.name = name;
        this.speed = speed;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSpeed() {
        return speed;
    }

    public void setSpeed(double speed) {
        this.speed = speed;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", speed=" + speed +
                '}';
    }
}

新建一个 SerializeUtil 类 （封装 序列化 和 反序列化 的方法，便于调用 ）

package com.oukele.redis2.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {

    /*
    * 序列化
    * */
    public static byte[] serialize(Object object){
        //序列化流 （输出流） --> 表示向一个目标 写入数据
        ObjectOutputStream objectOutputStream =null;
        //字节数组输出流
        ByteArrayOutputStream byteArrayOutputStream = null;
        try{
            //创建一个缓冲区
            byteArrayOutputStream = new ByteArrayOutputStream();
            //将 对象 序列化成 字节后  输入缓冲区中
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            //序列化 对象
            objectOutputStream.writeObject(object);
            //得 到 序列化字节
            byte[] bytes = byteArrayOutputStream.toByteArray();

            //清空输出流
            objectOutputStream.flush();
            //释放资源
            objectOutputStream.close();

            return bytes;
        }catch (Exception e){
            System.out.println("出现异常:"+e.getMessage());
        }
        return null;
    }

    /*
    * 反序列化
    * */

    public static  <T> T deserialize(byte[] bytes,Class<T> clazz){
       //字节数组
        ByteArrayInputStream byteArrayInputStream = null;
        try{
            //将 得到的序列化字节 丢进 缓冲区
            byteArrayInputStream = new ByteArrayInputStream(bytes);
            //反序列化流 （输入流）--> 表示着从 一个 源头 读取 数据 ， （读取 缓冲区中 的字节）
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            //反序化成 一个对象
            return (T)objectInputStream.readObject();
        }catch (Exception e){
            System.out.println("出现异常:"+e.getMessage());
        }
        return null;
    }


}

 

测试：

        //序列化一个对象
        byte[] serialize = SerializeUitl.serialize(new Car(2,"宝马",88.8));
        //反序列化
        Car deserialize = SerializeUitl.deserialize(serialize, Car.class);
        System.out.println(deserialize);

测试结果：

示例源码地址：