序列化与反序列化_28

序列化 / 反序列化：

常用于多台服务器之间进行java对象的数据传递

Java 序列化就是指将对象转换为字节序列的过程，而反序列化则是只将字节序列转换成目标对象的过程。

序列化：是指把 程序中准备好的 java对象 永久的保存在磁盘中，这个过程其实是一个out动作。

• ObjectOutputStream:
  * 通过在流中使用文件可以实现对象的持久存储。

• 创建对象:
  * ObjectOutputStream(OutputStream out)

• 常用方法:
  * void writeObject(Object obj)

• 将指定的对象写入: ObjectOutputStream。

反序列化：是指 把磁盘中已经序列化好的文件 读取到程序中，恢复成java对象的动作，是一个in的过程。

• ObjectInputStream：
  * 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

• 创建对象
  * ObjectInputStream(InputStream in)

• 常用方法
  * Object readObject()

• 从 ObjectInputStream 读取对象。

实现序列化与反序列化(第一种方式)

不管序列化与反序列化都需要实现 Seriaizable 接口

第一步:创建一个封装类去实现 Seriaizable 接口:

• Seriaizable 接口 只是用来标识这个hospital类需要进行序列化

class hospital implements Serializable {
    String name = "苏州广慈医院";
    int    num  = 88 ;
    String position = "doctor";

    @Override
    public String toString() {
        return "hospital{" +
                "name='" + name + '\'' +
                ", num=" + num +
                ", position='" + position + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }
}

第二步:序列化这个hospital类,将对象数据转换成二进制字节写入到文本文档中

public static void main(String[] args) {
        File file = new File("D://qwer//qwer.txt");
        serializeMethod(file);          //序列化
        deserializationMethod(file);    //反序列化
    }

private static void serializeMethod(File file) {

        hospital hp = new hospital("苏州广慈医院",88,"doctor");
        ObjectOutputStream out = null;
        try{
            out = new ObjectOutputStream(new FileOutputStream(file));
            out.writeObject(hp);
            out.close();
        }catch (IOException err){
            err.printStackTrace();
        }
    }

序列化的执行结果:将对象数据转换成机器可识别的二进制文件

第三步:反序列化这个磁盘中的文件,将其恢复成java对象并打印出来

public static void main(String[] args) {
        File file = new File("D://qwer//qwer.txt");
        serializeMethod(file);          //序列化
        deserializationMethod(file);    //反序列化
    }

private static void deserializationMethod(File file) {
        ObjectInputStream in = null;
        try{
            in = new ObjectInputStream(new FileInputStream(file));
            hospital hp = (hospital) in.readObject();
            System.out.println(hp.toString());
        }catch (IOException | ClassNotFoundException err){
            err.printStackTrace();
        }
    }

输出结果:

实现序列化与反序列化(第二种方式)

实现接口Externalizable, Externalizable 是 Serializable 的子类,由于实现了 Externalizable 接口,在 writeExternal() 里定义哪些属性可以被序列化,哪些属性不可以被序列化,在反序列化时获得的对象的属性也是被选择的.

第一步:创建一个封装类去实现 Externalizable接口:

/**
 * 测试的实体类
 */
class hospital02 implements Externalizable {
    private String name ;
    private int    num  ;
    private String position ;


    public hospital02(String name, int num, String position) {
        super();
        this.name =name;
        this.num = num;
        this.position=position;
    }
    public hospital02 (){
        super();
    }

    @Override
    public String toString() {
        return "hospital{" +
                "name='" + name + '\'' +
                ", num=" + num +
                ", position='" + position + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(num);
        out.writeObject(position);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        num= (int)in.readObject();
        position = (String) in.readObject();
    }
}

封装序列化与反序列化的相关操作

/**
 * 序列化与反序列化的相关操作
 */
class Operate{
    public void serializable(hospital02 hp) throws IOException,FileNotFoundException{
        ObjectOutputStream out =new ObjectOutputStream(new FileOutputStream("D://qwer//qwer02.txt"));
        out.writeObject(hp);
    }

    public hospital02 deSerializable() throws IOException, FileNotFoundException, ClassNotFoundException {
        ObjectInputStream in =new ObjectInputStream(new FileInputStream("D://qwer//qwer02.txt"));
        return (hospital02) in.readObject();

    }
}

实现序列化与反序列化

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        hospital02 hp = new hospital02("GC",86,"doctor");
        System.out.println("序列化之前对象hp的数据:"+hp.toString());

        Operate op =new Operate();
        op.serializable(hp);                    //序列化

        hospital02 hp02 = op.deSerializable();  //反序列化
        System.out.println("反序列化之后的hp02的数据:"+hp02.toString());


    }

执行结果: