什么是Java对象序列化异常「ObjectSerializationException」？
Java序列化是将对象转换为字节数据的过程，可以用于在网络中传输或者通过文件系统进行存储。但是，在某些情况下，对一个对象进行序列化时，可能会发生异常，其中一种异常就是「ObjectSerializationException」。当对象的类没有实现 java.io.Serializable 接口，或者对象包含无法序列化的对象时，就会出现此类异常。
解决Java对象序列化异常的方法
1. 实现 Serializable 接口
要想序列化一个对象，必须确保该对象的类实现了 Serializable 这个接口。如果对象的类没有实现该接口，那么当我们尝试对该对象进行序列化时，就会抛出「ObjectSerializationException」异常。因此，为了避免这个异常，我们需要检查被序列化的对象所属的类是否已经实现了 Serializable 接口。
以下是一个示例：
public class Student {
private String name;
private int age;
// 构造函数省略
// 省略 getter 和 setter 方法
@Override
public String toString() {
return String.format("Name:%s, Age:%d", name, age);
}
}
public class SerializationDemo {
public static void main(String[] args) {
Student student = new Student("Tom", 20);
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("student.data"))) {
outputStream.writeObject(student);
System.out.println("Object has been serialized successfully!");
} catch (IOException e) {
System.err.println("Failed to serialize object! Error: " + e.getMessage());
}
}
}
当我们运行以上代码时，就会抛出「NotSerializableException」异常，因为我们尝试对未实现 Serializable 接口的对象进行序列化。
为了解决这个问题，我们应该在 Student 类头上添加 implements Serializable：
public class Student implements Serializable {
private String name;
private int age;
// 构造函数省略
// 省略 getter 和 setter 方法
@Override
public String toString() {
return String.format("Name:%s, Age:%d", name, age);
}
}
public class SerializationDemo {
public static void main(String[] args) {
Student student = new Student("Tom", 20);
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("student.data"))) {
outputStream.writeObject(student);
System.out.println("Object has been serialized successfully!");
} catch (IOException e) {
System.err.println("Failed to serialize object! Error: " + e.getMessage());
}
}
}
再次运行以上代码，就会发现程序没有抛出异常，而是输出了 "Object has been serialized successfully!"。
2. 对象包含的所有对象都要实现 Serializable 接口
如果被序列化的对象包含其他对象，则这些对象也必须实现 Serializable 接口。如果包含的对象没有实现 Serializable 接口，则在序列化时仍会抛出「ObjectSerializationException」异常。
以下是一个示例：
public class Address {
private String street;
private String city;
private String zipCode;
// 构造函数和 getter/setter 方法省略
@Override
public String toString() {
return String.format("Street: %s, City: %s, ZipCode: %s", street, city, zipCode);
}
}
public class Student implements Serializable {
private String name;
private int age;
private Address address;
public Student(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
// 省略 getter/setter 方法
@Override
public String toString() {
return String.format("Name:%s, Age:%d, Address:%s", name, age, address);
}
}
public class SerializationDemo {
public static void main(String[] args) {
Address address = new Address("100 Main St", "Anytown", "12345");
Student student = new Student("Tom", 20, address);
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("student.data"))) {
outputStream.writeObject(student);
System.out.println("Object has been serialized successfully!");
} catch (IOException e) {
System.err.println("Failed to serialize object! Error: " + e.getMessage());
}
}
}
在运行以上代码时，会抛出「NotSerializableException: Address」异常，因为我们尝试序列化一个包含未实现 Serializable 接口的对象的对象。
为了解决这个问题，我们只需要让 Address 类也实现 Serializable 接口即可：
public class Address implements Serializable {
private String street;
private String city;
private String zipCode;
// 构造函数和 getter/setter 方法省略
@Override
public String toString() {
return String.format("Street: %s, City: %s, ZipCode: %s", street, city, zipCode);
}
}
public class Student implements Serializable {
private String name;
private int age;
private Address address;
public Student(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
// 省略 getter/setter 方法
@Override
public String toString() {
return String.format("Name:%s, Age:%d, Address:%s", name, age, address);
}
}
public class SerializationDemo {
public static void main(String[] args) {
Address address = new Address("100 Main St", "Anytown", "12345");
Student student = new Student("Tom", 20, address);
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("student.data"))) {
outputStream.writeObject(student);
System.out.println("Object has been serialized successfully!");
} catch (IOException e) {
System.err.println("Failed to serialize object! Error: " + e.getMessage());
}
}
}
再次运行以上代码，就能够成功地将对象进行序列化。
3. 使用 transient 关键字标记不需要序列化的字段
有时候，被序列化的对象中有一些字段是不需要序列化的，比如一些敏感信息或者计算结果。如果这些字段不是 transient 关键字标记的，那么在序列化的过程中，这些字段也会被序列化，不仅浪费了空间，还可能导致信息泄露的风险。如果你想避免这种情况，可以使用 transient 关键字标记那些不需要序列化的字段。
以下是一个示例：
public class Person implements Serializable {
private String name;
private int age;
private transient boolean isAdult;
public Person(String name, int age, boolean isAdult) {
this.name = name;
this.age = age;
this.isAdult = isAdult;
}
// 省略 getter/setter 方法
@Override
public String toString() {
return String.format("Name:%s, Age:%d, IsAdult:%s", name, age, isAdult);
}
}
public class SerializationDemo {
public static void main(String[] args) {
Person person = new Person("Tom", 20, true);
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("person.data"))) {
outputStream.writeObject(person);
System.out.println("Object has been serialized successfully!");
} catch (IOException e) {
System.err.println("Failed to serialize object! Error: " + e.getMessage());
}
try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("person.data"))) {
Person deserialized = (Person) inputStream.readObject();
System.out.println("Deserialized: " + deserialized);
} catch (IOException | ClassNotFoundException e) {
System.err.println("Failed to deserialize object! Error: " + e.getMessage());
}
}
}
在运行以上代码时，会发现对象在序列化和反序列化的过程中都没有发生异常，但是我们在反序列化后发现，isAdult 字段的值变成了 false。这是因为我们在序列化时，标记了这个字段为不需要序列化的，所以在反序列化得到的对象中，这个字段就没有被重建出来。
4. 使用自定义序列化 (Custom Serialization)
如果你需要更加精细地控制序列化和反序列化的过程，可以使用自定义序列化 (Custom Serialization)。通过实现 java.io.Serializable 接口的 readObject() 和 writeObject() 方法，你可以手动控制对象的序列化和反序列化过程，从而可以更好地表达对象的内部结构和状态。
以下是一个示例：
public class Person implements Serializable {
private String name;
private int age;
private boolean isAdult;
public Person(String name, int age, boolean isAdult) {
this.name = name;
this.age = age;
this.isAdult = isAdult;
}
// 省略 getter/setter 方法
// 自定义序列化
private void writeObject(ObjectOutputStream out) throws IOException {
out.writeUTF(name);
out.writeInt(age);
out.writeBoolean(isAdult);
}
// 自定义反序列化
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
name = in.readUTF();
age = in.readInt();
isAdult = in.readBoolean();
}
@Override
public String toString() {
return String.format("Name:%s, Age:%d, IsAdult:%s", name, age, isAdult);
}
}
public class SerializationDemo {
public static void main(String[] args) {
Person person = new Person("Tom", 20, true);
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("person.data"))) {
outputStream.writeObject(person);
System.out.println("Object has been serialized successfully!");
} catch (IOException e) {
System.err.println("Failed to serialize object! Error: " + e.getMessage());
}
try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("person.data"))) {
Person deserialized = (Person) inputStream.readObject();
System.out.println("Deserialized: " + deserialized);
} catch (IOException | ClassNotFoundException e) {
System.err.println("Failed to deserialize object! Error: " + e.getMessage());
}
}
}
在以上示例中，我们实现了 writeObject() 和 readObject() 方法，手动将对象的每个成员变量序列化和反序列化。
当这个对象被序列化时，会执行 writeObject() 方法，并将对象的成员变量写入到输出流中。而当这个对象被反序列化时，会执行 readObject() 方法，并从输入流中读取数据重建对象。
通过自定义序列化，我们可以更精细地控制对象的序列化和反序列化过程，从而保证在序列化和反序列化的过程中，对象的状态和行为都可以得到正确的恢复。
总结
Java对象序列化是将对象转换为字节数据的过程，可以用于在网络中传输或者通过文件系统进行存储。但是在某些情况下，对一个对象进行序列化时，可能会发生异常，其中一种异常就是「ObjectSerializationException」。为了避免这个异常，我们需要确保被序列化的对象所属的类已经实现了 java.io.Serializable 接口，包含在该对象中的所有对象都已经实现了 Serializable 接口，需要序列化的对象的所有字段都是可序列化的，对那些不需要序列化的字段使用 transient 关键字进行标记，以及可以使用自定义序列化来更加精细地控制对象的序列化和反序列化过程。