JavaSE---对象序列化与反序列化

/**
     * 【对象的序列化与反序列化】
     *      1、当 2个进程 远程通信时，彼此都可以发送各种类型的数据，如文本、图片、语音、视频等；
     *          无论是何种类型的数据，都会以 二进制序列 的形式在网络上传送；
     *
     *      2、对象的序列化：
     *          把Java对象 转换为 字节序列；
     *
     *         对象的反序列化：
     *          把字节序列 转为 为 Java对象；
     *
     *      3、对象序列化的用途：
     *          把对象的字节序列 永久 保存在磁盘，通常放在一个文件中；
     *          在网络上 传送 对象的字节序列；
     */

　　

 /**
     * 【JDK类库的序列化API】
     *
     *      只有实现了 java.io.Serializable或java.io.Externalizable 接口的对象 才能被 序列化，否则 将会 抛出 IOException；
     *
     *      java.io.ObjectOutputStream:
     *          对象输出流；
     *          writeObject 对指定的对象 进行序列化，将 得到的字节序列 写入到目标输出流中；
     *
     *      java.io.ObjectInputStream:
     *          对象输入流；
     *          readObject 从输入流中 读取字节序列，将字节序列 反序列化为 Java对象；
     *
     *      java.io.Serializable：
     *          仅实现Serializable的类 采用 默认的序列化方式；
     *              默认序列化方式：
     *                  对实现类的非transient实例变量进行序列化；
     *                  static 变量也不会序列化；
     *              默认反序列化方式：
     *                  对实现类的非transient实例变量进行反序列化；
     *
     *      java.io.Externalizable：
     *          继承自Serializable，实现Externalizable的类 完全 由自身 控制 序列化的行为；
     *
     */

　　

/**
     * 【控制序列化行为】
     *          1、自定义类型 实现 java.io.Serializable
     *              自定义
     *                  private void writeObject(ObjectOutputStream stream)throws IOException {}
     *                  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {}
     *
     *                  【修饰符必须为private】
     *
     *          2、自定义类型 实现 java.io.Externalizable
     *              重写
     *                  void writeExternal(ObjectOutput out) throws IOException;
     *                  void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
     *
     *          3、自定义类型 实现 java.io.Serializable
     *              自定义
     *                  private Object readResolve() throws ObjectStreamException{}
     *                      重新指定反序列化得到的对象；
     *                  private Object writeReplace(){}
     *                      重新指定序列化的对象，此方法返回的对象才是 真正的序列化对象
     *
     *                  【修饰符可以为private、protected、默认】
     *
     */

　　

/**
     * 【可序列化类的版本】
     *      凡是实现java.io.Serializable接口的类，都有一个表示 序列化版本的常量 private static final long serialVersionUID（Java运行时环境 根据类的内部细节 自动生成的）；
     *          如果源码做了修改，需要重新编译，新生成的class文件的serialVersionUID也会变化；
     *
     *      为了提高serialVersionUID的独立性和确定性，建议在可序列化类中 显式指定 serialVersionUID；
     */

　　

import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * @author apy
 * @description
 * @date 2022/2/23 15:12
 */
public class Test {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

//        User user = new User();
//        user.setAge(1);
//        user.setName("jack");
//        User.setJob("teacher");

        BUser bUser = new BUser();
        bUser.setName("rose");
        bUser.setAge(2);


        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("/Users/an/IdeaProjects/demo/javase/src/main/java/com/an/serilaizedeserilaize/user.obj"));
        objectOutputStream.writeObject(bUser);

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("/Users/an/IdeaProjects/demo/javase/src/main/java/com/an/serilaizedeserilaize/user.obj"));
        Object object = objectInputStream.readObject();
        System.out.println(object);
    }
}

class User implements Serializable{

    private static final long serialVersionUID = 1L;

    transient int age;
    String name;

    static String job;

    public static String getJob() {
        return job;
    }

    public static void setJob(String job) {
        User.job = job;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    private void writeObject(ObjectOutputStream stream)throws IOException {
        System.out.println("my  writeObject");
    }

    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
        System.out.println("my  readObject");
    }

    private Object readResolve() throws ObjectStreamException {
        System.out.println("my  readResolve");
        return this;
    }

    private Object writeReplace(){
        System.out.println("my writeReplace");
        return this;
    }
}

class BUser implements Externalizable{

    public BUser(){

    }

    public BUser(int age, String name){
        this.age = age;
        this.name = name;
    }

    transient int age;
    String name;

    static String job;

    public static String getJob() {
        return job;
    }

    public static void setJob(String job) {
        User.job = job;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("my writeExternal");
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        System.out.println("my readExternal");
    }
}