手把手教学！Java对象流使用详解，轻松搞定对象序列化与反序列化

想知道Java对象流怎么用吗？本文将手把手教你掌握Java对象序列化读写技巧，助你轻松实现对象的持久化和传输。Java对象流主要用于序列化和反序列化Java对象，即将对象转换为字节流，以便存储到磁盘或通过网络传输，再将字节流转换回对象。文章详细介绍了如何实现Serializable接口、使用ObjectOutputStream和ObjectInputStream进行序列化和反序列化，以及transient关键字的作用。此外，还深入探讨了自定义序列化逻辑、实际应用场景（如数据持久化、分布式系统通信）以及潜在风险（如安全漏洞、性能消耗），助你全面掌握Java对象流的使用，提升开发效率。

Java对象流用于序列化和反序列化，即将对象转换为字节流以实现存储或传输。1. 要实现序列化，类需实现Serializable接口并建议显式声明serialVersionUID；2. 使用ObjectOutputStream将对象写入输出流完成序列化；3. 使用ObjectInputStream从输入流读取对象完成反序列化，需强制类型转换并处理ClassNotFoundException；4. transient关键字标记的字段不会被序列化，反序列化后值为默认值；5. 可通过自定义writeObject()和readObject()方法实现个性化序列化逻辑；6. 应用场景包括数据持久化、分布式系统通信、缓存及会话管理；7. 风险包括安全漏洞、性能消耗及版本兼容问题，应避免反序列化不可信数据并选择高效框架以优化性能。

Java中对象流主要用于序列化和反序列化Java对象，简单来说，就是把对象转换成字节流，可以存储到磁盘或者通过网络传输，然后再把字节流转换回对象。这在很多场景下都很有用，比如持久化数据，或者在分布式系统中传递对象。

序列化和反序列化。

如何实现Java对象的序列化？

要实现Java对象的序列化，首先需要让你的类实现 java.io.Serializable 接口。这个接口是一个标记接口，没有任何方法需要实现，它的作用仅仅是告诉JVM，这个类的对象是可以被序列化的。

import java.io.Serializable;

public class MyObject implements Serializable {

    private static final long serialVersionUID = 1L; // 建议显示的声明 serialVersionUID

    private String name;
    private int age;

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

    // getter 和 setter 方法
    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 "MyObject{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

注意 serialVersionUID 的声明。 serialVersionUID 是序列化版本号，用于在反序列化时验证类的版本一致性。 如果类结构发生改变，但 serialVersionUID 没有改变，反序列化可能会失败。 建议显式声明，避免JVM自动生成带来的潜在问题。

接下来，使用 ObjectOutputStream 将对象写入到输出流中：

import java.io.*;

public class SerializationExample {

    public static void main(String[] args) {
        MyObject myObject = new MyObject("Alice", 30);

        try (FileOutputStream fileOutputStream = new FileOutputStream("myobject.ser");
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream)) {

            objectOutputStream.writeObject(myObject);
            System.out.println("对象已序列化");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里使用了try-with-resources语句，确保流在使用完毕后会被自动关闭。

如何反序列化Java对象？

反序列化就是将字节流转换回对象。 使用 ObjectInputStream 从输入流中读取对象：

import java.io.*;

public class DeserializationExample {

    public static void main(String[] args) {
        try (FileInputStream fileInputStream = new FileInputStream("myobject.ser");
             ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream)) {

            MyObject myObject = (MyObject) objectInputStream.readObject();
            System.out.println("对象已反序列化: " + myObject);

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

注意， readObject() 方法返回的是 Object 类型，需要强制类型转换成目标类型。 另外，还需要处理 ClassNotFoundException，因为反序列化时可能会找不到对应的类定义。

序列化时遇到 transient 关键字会发生什么？

如果在类的字段上使用了 transient 关键字，那么在序列化时，这个字段的值会被忽略。 也就是说，在反序列化后，这个字段的值会是默认值（例如，int 类型的默认值是0，String 类型的默认值是null）。

import java.io.Serializable;

public class MyObjectWithTransient implements Serializable {

    private static final long serialVersionUID = 2L;

    private String name;
    private transient int age; // age 字段被标记为 transient

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

    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 "MyObjectWithTransient{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在序列化和反序列化 MyObjectWithTransient 对象后，age 字段的值会变成0。 transient 关键字通常用于标记那些不应该被持久化或者不方便持久化的字段，例如密码或者敏感信息。

如何自定义序列化和反序列化过程？

如果默认的序列化和反序列化过程不能满足需求，可以自定义序列化和反序列化过程。 在类中实现 writeObject() 和 readObject() 方法，这两个方法会在序列化和反序列化时被自动调用。

import java.io.*;

public class MyObjectWithCustomSerialization implements Serializable {

    private static final long serialVersionUID = 3L;

    private String name;
    private int age;

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

    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;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        // 自定义序列化逻辑
        out.writeObject("Custom: " + name);
        out.writeInt(age + 100); // 为了演示，将 age 加 100
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 自定义反序列化逻辑
        name = (String) in.readObject();
        age = in.readInt() - 100; // 恢复 age 的原始值
    }

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

在 writeObject() 方法中，可以自定义序列化逻辑，例如加密敏感数据或者压缩数据。 在 readObject() 方法中，需要按照 writeObject() 方法的顺序读取数据，并进行相应的处理。 需要注意的是，这两个方法的签名必须是 private，并且抛出 IOException 和 ClassNotFoundException 异常。

序列化在实际项目中有哪些应用场景？

序列化在实际项目中有很多应用场景：

• 持久化数据： 将对象存储到磁盘或者数据库中，以便以后使用。
• 分布式系统： 在不同的JVM之间传递对象，例如在RPC框架中。
• 缓存： 将对象存储到缓存中，提高访问速度。
• 会话管理： 在Web应用中，将用户的会话信息存储到服务器上。

例如，在Spring Session中，可以使用序列化将用户的会话信息存储到Redis或者其他存储介质中，实现会话共享。 另外，在Dubbo等RPC框架中，也需要使用序列化将请求和响应对象在不同的服务提供者和消费者之间传递。

序列化有哪些潜在的风险和注意事项？

序列化虽然很方便，但也存在一些潜在的风险和注意事项：

• 安全风险： 反序列化可能会导致安全漏洞，例如反序列化漏洞。 攻击者可以构造恶意的序列化数据，利用反序列化过程执行任意代码。 为了避免这种风险，应该尽量避免反序列化不受信任的数据，或者使用安全的序列化框架。
• 性能问题： 序列化和反序列化会消耗一定的CPU和内存资源。 对于大型对象或者高并发场景，可能会影响性能。 可以考虑使用更高效的序列化框架，例如Protobuf或者Kryo。
• 版本兼容性： 如果类的结构发生改变，可能会导致反序列化失败。 应该尽量保持类的结构稳定，或者使用 serialVersionUID 来保证版本兼容性。

总的来说，Java对象流是处理对象序列化的重要工具，理解其使用方法和注意事项，可以帮助你更好地在实际项目中应用序列化技术。

本篇关于《手把手教学！Java对象流使用详解，轻松搞定对象序列化与反序列化》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！