Java如何实现Serializable序列化？手把手教你轻松搞定

想知道Java如何实现Serializable序列化吗？本文用通俗易懂的语言，带你快速入门！序列化是把Java对象转换成字节流，方便存储和网络传输；反序列化则是将字节流还原成Java对象。实现序列化只需让类实现Serializable接口，并建议显式声明serialVersionUID以保证版本兼容。文章还讲解了如何使用transient关键字忽略特定字段，以及如何通过自定义writeObject和readObject方法精细控制序列化过程。同时，本文也重点提示了反序列化可能存在的安全风险，并提供了实用的防御建议，助你写出更健壮的Java代码。即使是小白，也能轻松掌握Java序列化的核心概念和应用技巧！

序列化是将Java对象转换为字节流以便存储或传输的过程，反序列化则是将其还原为对象。要实现序列化，类需实现Serializable接口，如public class MyObject implements Serializable，并可显式声明serialVersionUID以保证版本一致性。可通过transient关键字忽略某些字段，或通过自定义writeObject和readObject方法控制序列化逻辑。反序列化存在安全风险，应避免反序列化不受信任的数据、使用安全框架、白名单机制、升级Java版本及利用工具检测漏洞。

序列化，简单来说，就是把Java对象转换成字节流的过程，方便存储或者网络传输。反序列化则是反过来，把字节流还原成Java对象。要让一个Java对象可以被序列化，就得让它的类实现 Serializable 接口。

Serializable 接口本身是个标记接口，里面没有任何方法需要实现。它的作用就像盖了个章，告诉JVM：“嘿，这个类的对象可以被序列化！”

解决方案

1. 实现 Serializable 接口:

   import java.io.Serializable;
   
   public class MyObject implements Serializable {
       private String name;
       private int age;
   
       public MyObject(String name, int age) {
           this.name = name;
           this.age = age;
       }
   
       // Getters and setters (optional, but recommended)
       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 +
                   '}';
       }
   }

2. 序列化对象:

   import java.io.*;
   
   public class SerializationExample {
       public static void main(String[] args) {
           MyObject obj = new MyObject("Alice", 30);
   
           try (FileOutputStream fileOut = new FileOutputStream("myobject.ser");
                ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
               out.writeObject(obj);
               System.out.println("Serialized data is saved in myobject.ser");
           } catch (IOException i) {
               i.printStackTrace();
           }
       }
   }

3. 反序列化对象:

   import java.io.*;
   
   public class DeserializationExample {
       public static void main(String[] args) {
           MyObject obj = null;
           try (FileInputStream fileIn = new FileInputStream("myobject.ser");
                ObjectInputStream in = new ObjectInputStream(fileIn)) {
               obj = (MyObject) in.readObject();
               System.out.println("Deserialized MyObject...");
               System.out.println(obj); // Output: MyObject{name='Alice', age=30}
           } catch (IOException i) {
               i.printStackTrace();
               return;
           } catch (ClassNotFoundException c) {
               System.out.println("MyObject class not found");
               c.printStackTrace();
               return;
           }
       }
   }

什么是 serialVersionUID，为什么需要它？

serialVersionUID 是一个序列化版本号。如果你的类在序列化之后进行了修改（比如新增了字段），那么在反序列化的时候，JVM会检查这个版本号。如果版本号不一致，就会抛出 InvalidClassException 异常。

简单来说，就是为了保证序列化和反序列化的一致性。 建议显式地声明一个 serialVersionUID，即使类结构发生变化，只要这个ID不变，反序列化就能成功（当然，前提是修改不是特别剧烈）。

import java.io.Serializable;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L; // 显式声明

    private String name;
    private int age;

    // ... (rest of the class)
}

如何控制序列化过程，比如忽略某些字段？

有时候，你可能不想序列化某个字段，比如密码或者一些敏感信息。这时候，你可以使用 transient 关键字来标记这个字段。被 transient 标记的字段在序列化的时候会被忽略，反序列化后会变成默认值（比如 null 对于对象，0 对于 int）。

import java.io.Serializable;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private transient String password; // 不会被序列化
    private int age;

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

    // ... (rest of the class)
}

你还可以通过实现 writeObject 和 readObject 方法来完全控制序列化和反序列化的过程。这允许你自定义序列化的逻辑，比如加密某些字段，或者进行一些数据转换。

import java.io.*;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private String password;
    private int age;

    // ... (constructor and getters/setters)

    private void writeObject(ObjectOutputStream out) throws IOException {
        // 自定义序列化逻辑，比如加密 password
        String encryptedPassword = encrypt(password);
        out.defaultWriteObject(); // 先序列化其他字段
        out.writeObject(encryptedPassword); // 序列化加密后的密码
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 自定义反序列化逻辑，比如解密 password
        in.defaultReadObject(); // 先反序列化其他字段
        String encryptedPassword = (String) in.readObject(); // 读取加密后的密码
        this.password = decrypt(encryptedPassword); // 解密密码
    }

    private String encrypt(String password) {
        // 实际的加密逻辑
        return "ENCRYPTED_" + password;
    }

    private String decrypt(String encryptedPassword) {
        // 实际的解密逻辑
        return encryptedPassword.substring(10); // 简单地移除 "ENCRYPTED_" 前缀
    }
}

序列化与反序列化有哪些安全风险，如何避免？

序列化和反序列化最大的安全风险在于反序列化漏洞。攻击者可以构造恶意的序列化数据，在反序列化过程中执行任意代码。

避免反序列化漏洞的一些方法：

• 尽量避免反序列化不受信任的数据: 这是最有效的防御手段。
• 使用安全的序列化框架: 比如 JSON 或者 Protocol Buffers，它们没有反序列化漏洞。
• 使用白名单机制: 只允许反序列化特定的类。
• 升级到最新版本的Java: 新版本的Java通常会修复一些已知的反序列化漏洞。
• 使用工具检测潜在的漏洞: 比如 ysoserial，可以生成各种payload来测试你的应用是否存在反序列化漏洞。

总而言之，理解序列化的机制，以及潜在的安全风险，才能更好地保护你的应用。

以上就是《Java如何实现Serializable序列化？手把手教你轻松搞定》的详细内容，更多关于安全风险,反序列化,Java序列化,Serializable接口,serialVersionUID的资料请关注golang学习网公众号！