Java序列化、反序列化以及反射

Sherlock2024-10-182025-05-08

引用

java序列化，看这篇就够了

大白话说Java反射：入门、使用、原理 - 陈树义 - 博客园

序列化的含义、意义及使用场景

序列化：将对象写入到IO流中
反序列化：从IO流中恢复对象
意义：序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。
使用场景：所有可在网络上传输的对象都必须是可序列化的，比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：程序创建的每个JavaBean类都实现Serializeable接口。

序列化实现的方式

如果需要将某个对象保存到磁盘上或者通过网络传输，那么这个类应该实现Serializable接口或者Externalizable接口之一。

Serializable

普通序列化

Serializable接口是一个标记接口，不用实现任何方法。一旦实现了此接口，该类的对象就是可序列化的；不实现此接口的类将不会
使任何状态序列化或反序列化，会抛出 NotSerializableException

序列化步骤：

步骤一：创建一个ObjectOutputStream输出流；
步骤二：调用ObjectOutputStream对象的writeObject输出可序列化对象

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

// Person类，实现Serializable接口
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;  // 确保序列化版本一致
    private String name;
    private int age;

    // 无参构造器未提供，必须通过此构造器创建对象
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    // 测试写入对象的主方法
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
            // 将Person对象序列化并写入文件
            Person person = new Person("John", 23);
            oos.writeObject(person);
            System.out.println("对象已成功序列化并写入文件。");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

反序列化步骤：

步骤一：创建一个ObjectInputStream输入流；
步骤二：调用ObjectInputStream对象的readObject()得到序列化的对象。

我们将上面序列化到person.txt的person对象反序列化回来

import java.io.*;

// Person类，实现Serializable接口
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;  // 确保序列化版本一致
    private String name;
    private int age;

    // 无参构造器未提供，使用此构造器创建对象
    public Person(String name, int age) {
        System.out.println("反序列化，你调用我了吗？");
        this.name = name;
        this.age = age;
    }

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

    // WriteObject类：将Person对象序列化到文件
    public static class WriteObject {
        public static void main(String[] args) {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
                Person person = new Person("John", 23);
                oos.writeObject(person);
                System.out.println("对象已成功序列化并写入文件。");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    // ReadObject类：从文件反序列化Person对象
    public static class ReadObject {
        public static void main(String[] args) {
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) {
                Person brady = (Person) ois.readObject();
                System.out.println(brady);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

////输出结果
//Person{name='John', age=23}

输出告诉我们，反序列化并不会调用构造方法。反序列的对象是由JVM自己生成的对象，不通过构造方法生成

成员是引用的序列化

如果一个可序列化的类的成员不是基本类型，也不是String类型，那这个引用类型也必须是可序列化的；否则，会导致此类不能序列化。

看例子，我们新增一个Teacher类。将Person去掉实现Serializable接口代码。

import java.io.*;

// Person类
class Person {
	//省略
    }
}

// Teacher类，实现Serializable接口
public class Teacher implements Serializable {
    private static final long serialVersionUID = 1L;  // 序列化版本ID
    private String name;
    private Person person;

    // 构造器
    public Teacher(String name, Person person) {
        this.name = name;
        this.person = person;
    }

    @Override
    public String toString() {
        return "Teacher{name='" + name + "', person=" + person + "}";
    }

    // 主方法：进行序列化
    public static void main(String[] args) throws Exception {
        // 将Teacher对象序列化到teacher.txt文件
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher teacher = new Teacher("雷利", person);
            oos.writeObject(teacher);
            System.out.println("对象已成功序列化并写入文件。");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 从teacher.txt文件反序列化Teacher对象
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
            Teacher deserializedTeacher = (Teacher) ois.readObject();
            System.out.println("反序列化结果：" + deserializedTeacher);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上述代码会序列化失败，报错如下：

这是因为Person类的对象是不可序列化的，这导致了Teacher的对象不可序列化

同一对象序列化多次的机制

同一对象序列化多次，会将这个对象序列化多次吗？答案是否定的。

public class WriteTeacher {
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher t1 = new Teacher("雷利", person);
            Teacher t2 = new Teacher("红发香克斯", person);
            //依次将4个对象写入输入流
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(person);
            oos.writeObject(t2);
        }
    }
}

依次将t1、t2、person、t2对象序列化到文件teacher.txt文件中。

注意：反序列化的顺序与序列化时的顺序一致。

public class ReadTeacher {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
            Teacher t1 = (Teacher) ois.readObject();
            Teacher t2 = (Teacher) ois.readObject();
            Person p = (Person) ois.readObject();
            Teacher t3 = (Teacher) ois.readObject();
            System.out.println(t1 == t2);
            System.out.println(t1.getPerson() == p);
            System.out.println(t2.getPerson() == p);
            System.out.println(t2 == t3);
            System.out.println(t1.getPerson() == t2.getPerson());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//输出结果
//false
//true
//true
//true
//true

从输出结果可以看出，Java序列化同一对象，并不会将此对象序列化多次得到多个对象。

Java序列化算法

所有保存到磁盘的对象都有一个序列化编码号
当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。
如果此对象已经序列化过，则直接输出编号即可

下图表示上述序列化过程

可选的自定义序列化

有些时候，我们有这样的需求，某些属性不需要序列化。使用transient关键字选择不需要序列化的字段。（说明该属性是瞬态的）

public class Person implements Serializable {
   //不需要序列化名字与年龄
   private transient String name;
   private transient int age;
   private int height;
   private transient boolean singlehood;
   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }
   //省略get,set方法
}

public class TransientTest {
   public static void main(String[] args) throws Exception {
       try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
            ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
           Person person = new Person("John", 23);
           person.setHeight(185);
           System.out.println(person);
           oos.writeObject(person);
           Person p1 = (Person)ios.readObject();
           System.out.println(p1);
       }
   }
}
//输出结果
//Person{name='John', age=23', singlehood=true', height=185cm}
//Person{name='null', age=0', singlehood=false', height=185cm}

从输出我们看到，使用transient修饰的属性，java序列化时，会忽略掉此字段，所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false

使用transient虽然简单，但将此属性完全隔离在了序列化之外。java提供了可选的自定义序列化。可以进行控制序列化的方式，或者对序列化数据进行编码加密等。

1
2
3

private void writeObject(java.io.ObjectOutputStream out) throws IOException；
private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;

通过重写writeObject与readObject方法，可以自己选择哪些属性需要序列化，哪些属性不需要。如果writeObject使用某种规则序列化，则相应的readObject需要相反的规则反序列化，以便能正确反序列化出对象。这里展示对名字进行反转加密。

public class Person implements Serializable {
   private String name;
   private int age;
   //省略构造方法，get及set方法

   private void writeObject(ObjectOutputStream out) throws IOException {
       //将名字反转写入二进制流
       out.writeObject(new StringBuffer(this.name).reverse());
       out.writeInt(age);
   }

   private void readObject(ObjectInputStream ins) throws IOException,ClassNotFoundException{
       //将读出的字符串反转恢复回来
       this.name = ((StringBuffer)ins.readObject()).reverse().toString();
       this.age = ins.readInt();
   }
}

当序列化流不完整时，readObjectNoData()方法可以用来正确地初始化反序列化的对象。例如，使用不同类接收反序列化对象，或者序列化流被篡改时，系统都会调用readObjectNoData()方法来初始化反序列化的对象。

可选的自定义序列化

1
2
3

rivate void writeObject(java.io.ObjectOutputStream out) throws IOException；
private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;

public class Person implements Serializable {
   private String name;
   private int age;
   //省略构造方法，get及set方法

   private void writeObject(ObjectOutputStream out) throws IOException {
       //将名字反转写入二进制流
       out.writeObject(new StringBuffer(this.name).reverse());
       out.writeInt(age);
   }

   private void readObject(ObjectInputStream ins) throws IOException,ClassNotFoundException{
       //将读出的字符串反转恢复回来
       this.name = ((StringBuffer)ins.readObject()).reverse().toString();
       this.age = ins.readInt();
   }
}

更彻底的自定义序列化

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

writeReplace：在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象

java

 代码解读
复制代码public class Person implements Serializable {
  private String name;
  private int age;
  //省略构造方法，get及set方法

  private Object writeReplace() throws ObjectStreamException {
      ArrayList<Object> list = new ArrayList<>(2);
      list.add(this.name);
      list.add(this.age);
      return list;
  }

   public static void main(String[] args) throws Exception {
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
           ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
          Person person = new Person("John", 23);
          oos.writeObject(person);
          ArrayList list = (ArrayList)ios.readObject();
          System.out.println(list);
      }
  }
}
//输出结果
//[John, 23]

readResolve：反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。

java

 代码解读
复制代码public class Person implements Serializable {
    private String name;
    private int age;
    //省略构造方法，get及set方法
     private Object readResolve() throws ObjectStreamException{
        return new ("brady", 23);
    }
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = new Person("John", 23);
            oos.writeObject(person);
            HashMap map = (HashMap)ios.readObject();
            System.out.println(map);
        }
    }
}
//输出结果
//{brady=23}

readResolve常用来反序列单例类，保证单例类的唯一性。

注意：readResolve与writeReplace的访问修饰符可以是private、protected、public，如果父类重写了这两个方法，子类都需要根据自身需求重写，这显然不是一个好的设计。通常建议对于final修饰的类重写readResolve方法没有问题；否则，重写readResolve使用private修饰。

Externalizable：强制自定义序列化

通过实现Externalizable接口，必须实现writeExternal、readExternal方法。

public interface Externalizable extends java.io.Serializable {
     void writeExternal(ObjectOutput out) throws IOException;
     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

public class ExPerson implements Externalizable {

    private String name;
    private int age;
    //注意，必须加上pulic 无参构造器
    public ExPerson() {
    }

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //将name反转后写入二进制流
        StringBuffer reverse = new StringBuffer(name).reverse();
        System.out.println(reverse.toString());
        out.writeObject(reverse);
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //将读取的字符串反转后赋值给name实例变量
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        System.out.println(name);
        this.age = in.readInt();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
            oos.writeObject(new ExPerson("brady", 23));
            ExPerson ep = (ExPerson) ois.readObject();
            System.out.println(ep);
        }
    }
}
//输出结果
//ydarb
//brady
//ExPerson{name='brady', age=23}

注意：Externalizable接口不同于Serializable接口，实现此接口必须实现接口中的两个方法实现自定义序列化，这是强制性的；特别之处是必须提供pulic的无参构造器，因为在反序列化的时候需要反射创建对象。

在 Java 中，当你使用 ObjectOutputStream 和 ObjectInputStream 来序列化和反序列化实现了 Externalizable 接口的类时：

writeObject() 会自动调用对象的 writeExternal() 方法。
readObject() 会自动调用对象的 readExternal() 方法。

因此，即使我们在代码里没有显式调用 writeExternal() 和 readExternal()，它们会在序列化和反序列化过程中被 Java 底层自动触发

序列化版本号serialVersionUID

我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？

java序列化提供了一个private static final long serialVersionUID 的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。

serialVersionUID有两种显示的生成方式：

一是默认的1L，比如：private static final long serialVersionUID = 1L;
二是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如:private static final long serialVersionUID = xxxxL;

public class Person implements Serializable {
    //序列化版本号
    private static final long serialVersionUID = 1111013L;
    private String name;
    private int age;
    //省略构造方法及get,set
}

如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常

序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。

什么情况下需要修改serialVersionUID呢？分三种情况。

如果只是修改了方法，反序列化不容影响，则无需修改版本号；
如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
如果修改了非瞬态变量，则可能导致反序列化失败。如果新类中实例变量的类型与序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID。如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量

反射

基本使用

了解反射之前我们先来了解一下什么是正射

一般情况下，我们使用某个类的时候必然知道它是什么类，用来干什么的，于是我们就可以直接对它进行实例化，然后使用其对象操作

1 2	Apple apple = new Apple(); //直接初始化，「正射」 apple.setPrice(4);

像上面这样的就叫做正射

那么反射顾名思义就是我们并不知道要初始化的类对象是什么，也就无法使用new来创建新对象

这时候，就要用JDK提供的反射API进行反射调用：

Class clz = Class.forName("com.chenshuyi.reflect.Apple"); //加载该类
Method method = clz.getMethod("setPrice", int.class); //获取Apple类中的setPrice方法，该方法的参数是int类型
Constructor constructor = clz.getConstructor(); //获取无参构造方法
Object object = constructor.newInstance(); //创建实例
method.invoke(object, 4); //调用方法

上面两段代码的执行结果，其实是完全一样的。但是其思路完全不一样，第一段代码在未运行时就已经确定了要运行的类（Apple），而第二段代码则是在运行时通过字符串值才得知要运行的类（com.chenshuyi.reflect.Apple）。

所以说什么是反射？

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法

，一般情况下我们使用反射获取一个对象的步骤：

获取类的 Class 对象实例

1	Class clz = Class.forName("com.zhenai.api.Apple");

根据 Class 对象实例获取 Constructor 对象

1	Constructor appleConstructor = clz.getConstructor();

使用 Constructor 对象的 newInstance 方法获取反射类对象

1	Object appleObj = appleConstructor.newInstance();

而如果要调用某一个方法，则需要经过下面的步骤：

获取方法的 Method 对象

1	Method setPriceMethod = clz.getMethod("setPrice", int.class);

利用 invoke 方法调用方法

1	setPriceMethod.invoke(appleObj, 14);

反射常用API

获取反射的Class对象

在 Java API 中，获取 Class 类对象有三种方法：

第一种，使用 Class.forName 静态方法。当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象。

1	Class clz = Class.forName("java.lang.String");

第二种，使用 .class 方法。

这种方法只适合在编译前就知道操作的 Class。

1	Class clz = String.class;

第三种，使用类对象的 getClass() 方法。

1 2	String str = new String("Hello"); Class clz = str.getClass();

通过反射创建类对象

通常有以下两种方法

第一种：通过 Class 对象的 newInstance() 方法。

1 2	Class clz = Apple.class; Apple apple = (Apple)clz.newInstance();

第二种：通过 Constructor 对象的 newInstance() 方法

1
2
3

Class clz = Apple.class;
Constructor constructor = clz.getConstructor();
Apple apple = (Apple)constructor.newInstance();

通过 Constructor 对象创建类对象可以选择特定构造方法，而通过 Class 对象则只能使用默认的无参数构造方法。下面的代码就调用了一个有参数的构造方法进行了类对象的初始化。

1
2
3

Class clz = Apple.class;
Constructor constructor = clz.getConstructor(String.class, int.class);
Apple apple = (Apple)constructor.newInstance("红富士", 15);

通过反射获取类属性、方法、构造器

我们通过 Class 对象的 getFields() 方法可以获取 Class 类的属性，但无法获取私有属性。

Class clz = Apple.class;
Field[] fields = clz.getFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

输出结果是：

price

而如果使用 Class 对象的 getDeclaredFields() 方法则可以获取包括私有属性在内的所有属性：

Class clz = Apple.class;
Field[] fields = clz.getDeclaredFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

输出结果是：

1 2	name price

与获取类属性一样，当我们去获取类方法、类构造器时，如果要获取私有方法或私有构造器，则必须使用有 declared 关键字的方法。