(每日持续更新）jdk api之NotSerializableException基础、应用、实战

博主18年的互联网软件开发经验，从一名程序员小白逐步成为了一名架构师，我想通过平台将经验分享给大家，因此博主每天会在各个大牛网站点赞量超高的博客等寻找该技术栈的资料结合自己的经验，晚上进行用心精简、整理、总结、定稿，每天都会整理到12点，为了就是能让大家能够真正了解该技术栈的真正原理，最终从程序员成为一名真正的架构师，写的不一定是全站做好的，但是是全站最用心的~。

以后我会推出一些列的文章，每天都会更新，每天进步一点点，发布顺序【java的api基础、应用、实战】->【java开源技术栈及源码分析】->【java开源技术栈整合】->【java低代码开发平台的建设】

关注【架构师成长之道】 输入“架构师视频课程”，即可免费获得全套架构师全套课程

一、java.io

1.38 NotSerializableException

NotSerializableException 是 Java 中的异常类，它属于 java.io 包。当试图对一个非序列化的对象进行序列化时，或者在序列化或反序列化过程中涉及不可序列化的对象时，可能会抛出这个异常。

以下是 NotSerializableException 的基本介绍：

NotSerializableException 介绍：

所有字段：

• private static final long serialVersionUID：序列化版本 ID。

构造方法：

• NotSerializableException()： 创建一个新的 NotSerializableException 对象，其中没有详细消息。

• NotSerializableException(String s)： 使用指定的详细消息创建一个新的 NotSerializableException 对象。

方法摘要：

• 无特定的方法，继承自父类。

简单使用例子：

以下是一个简单的例子，演示了在试图序列化一个非序列化的对象时可能会抛出 NotSerializableException：

javaCopy code
import java.io.*;
​
public class NotSerializableExceptionExample {
​
    public static void main(String[] args) {
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("data.bin"))) {
​
            // 尝试序列化一个非序列化的对象，抛出 NotSerializableException
            NonSerializableObject nonSerializableObject = new NonSerializableObject();
            outputStream.writeObject(nonSerializableObject);
​
        } catch (IOException e) {
            if (e instanceof NotSerializableException) {
                System.err.println("NotSerializableException: Object is not serializable.");
            } else {
                e.printStackTrace();
            }
        }
    }
​
    static class NonSerializableObject {
        private String data;
​
        public NonSerializableObject() {
            this.data = "This object is not serializable.";
        }
    }
}

在这个例子中，我们创建了一个 NonSerializableObject 类，该类没有实现 Serializable 接口。然后，我们尝试使用 ObjectOutputStream 对这个非序列化的对象进行序列化，这时会抛出 NotSerializableException。在实际项目中，确保需要序列化的对象实现 Serializable 接口是非常重要的。

应用场景

NotSerializableException 的主要应用场景是在序列化或反序列化过程中，当试图对一个非序列化的对象进行序列化时，或者涉及不可序列化的对象时，抛出这个异常。以下是一些可能的应用场景及相应的代码实现：

应用场景 1: 序列化过程中抛出 NotSerializableException

javaCopy code
import java.io.*;
​
public class NotSerializableExceptionExample {
​
    public static void main(String[] args) {
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("data.bin"))) {
​
            // 尝试序列化一个非序列化的对象，抛出 NotSerializableException
            NonSerializableObject nonSerializableObject = new NonSerializableObject();
            outputStream.writeObject(nonSerializableObject);
​
        } catch (IOException e) {
            if (e instanceof NotSerializableException) {
                System.err.println("NotSerializableException: Object is not serializable.");
            } else {
                e.printStackTrace();
            }
        }
    }
​
    static class NonSerializableObject {
        private String data;
​
        public NonSerializableObject() {
            this.data = "This object is not serializable.";
        }
    }
}

在这个例子中，NonSerializableObject 类没有实现 Serializable 接口，因此尝试对其进行序列化时会抛出 NotSerializableException。

应用场景 2: 处理反序列化时的 NotSerializableException

javaCopy code
import java.io.*;
​
public class NotSerializableExceptionDeserializationExample {
​
    public static void main(String[] args) {
        String fileName = "data.bin";
​
        // 模拟从文件加载对象
        loadObjectFromFile(fileName);
    }
​
    private static void loadObjectFromFile(String fileName) {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName))) {
            try {
                // 尝试反序列化对象，处理可能的 NotSerializableException
                Object object = inputStream.readObject();
                System.out.println("Deserialization successful: " + object);
            } catch (ClassNotFoundException | NotSerializableException e) {
                if (e instanceof NotSerializableException) {
                    System.err.println("NotSerializableException: Object is not serializable during deserialization.");
                } else {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，loadObjectFromFile 方法尝试从文件中加载对象，如果文件包含不可序列化的对象，则会抛出 NotSerializableException。在实际项目中，处理这种异常通常需要更复杂的逻辑，例如记录日志或提供用户友好的错误消息。

请注意，确保需要序列化的对象实现 Serializable 接口是预防 NotSerializableException 的一种有效方式。

实战例子

在实际项目中，NotSerializableException 主要涉及到对象的序列化和反序列化操作。以下是一个简单的项目实战例子，演示了在保存和加载用户数据时可能会遇到 NotSerializableException 的情况：

项目实战例子：保存和加载用户数据

假设你的项目需要保存和加载用户数据，你可能会创建一个 User 类来表示用户信息。在保存用户数据时，如果某些字段不可序列化，可能会引发 NotSerializableException。以下是一个示例：

javaCopy code
import java.io.*;
​
public class UserSerializationProject {
​
    public static void main(String[] args) {
        String fileName = "users.ser";
​
        // 模拟保存用户数据到文件
        saveUsersToFile(fileName);
​
        // 模拟从文件加载用户数据
        loadUsersFromFile(fileName);
    }
​
    private static void saveUsersToFile(String fileName) {
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(fileName))) {
            User user1 = new User("John", 25);
            User user2 = new User("Alice", 30);
​
            outputStream.writeObject(user1);
            outputStream.writeObject(user2);
​
            System.out.println("Users saved to file successfully.");
        } catch (IOException e) {
            if (e instanceof NotSerializableException) {
                System.err.println("NotSerializableException: Object is not serializable.");
            } else {
                e.printStackTrace();
            }
        }
    }
​
    private static void loadUsersFromFile(String fileName) {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName))) {
            try {
                while (true) {
                    User user = (User) inputStream.readObject();
                    System.out.println("Loaded user: " + user);
                }
            } catch (ClassNotFoundException | NotSerializableException e) {
                if (e instanceof NotSerializableException) {
                    System.err.println("NotSerializableException: Object is not serializable during deserialization.");
                } else {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            if (e instanceof EOFException) {
                System.out.println("End of file reached.");
            } else {
                e.printStackTrace();
            }
        }
    }
​
    static class User implements Serializable {
        private String name;
        private transient int age; // transient 关键字标记 age 字段不参与序列化
​
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
​
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

在这个例子中，User 类实现了 Serializable 接口，但 age 字段被标记为 transient，表示该字段不参与序列化。当我们尝试保存 User 对象到文件时，NotSerializableException 不会被抛出。然而，在加载用户数据时，由于 age 字段不可序列化，会触发 NotSerializableException。

在实际项目中，你可能需要更复杂的数据处理逻辑以及更强大的异常处理机制，例如记录日志或提供用户友好的错误信息。