java 字符串列表的序列化和反序列化 java 序列化和反序列化例子

转载

mob64ca14061c9e 2024-07-12 17:03:58

文章标签 java 字符串列表的序列化和反序列化 java php 开发语言序列化 文章分类 Java 后端开发

在Java开发中，序列化和反序列化是两个非常重要的概念。无论是进行网络传输、持久化存储，还是其他需要将对象转换为字节流的场景，序列化和反序列化都是不可或缺的工具。本篇博客将详细解读Java中的序列化和反序列化，并通过源码和示例进行深入剖析。

什么是序列化?什么是反序列化?

定义

序列化：将数据结构或对象转换成二进制字节流的过程。
反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程。

应用场景

网络传输：比如远程方法调用（RPC）时，需要将对象进行序列化再通过网络传输。
持久化存储：将对象存储到文件系统、数据库或缓存中。
内存操作：将对象存储到内存中或从内存中读取对象。

序列化和反序列化的实现

Java 提供了 java.io.Serializable 接口来实现对象的序列化。一个类只有实现了 Serializable 接口，它的对象才能被序列化。下面是一个简单的例子：

java

import java.io.*;

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 class SerializationDemo {
    public static void main(String[] args) {
        Person person = new Person("John Doe", 30);

        // 序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("Deserialized Person: " + deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

源码解析

ObjectOutputStream

ObjectOutputStream 是Java提供的一个类，专门用于将对象转换为字节流。它的核心方法是 writeObject(Object obj)：

java

public final void writeObject(Object obj) throws IOException {
    if (obj == null) {
        writeNull();
        return;
    }
    ObjectOutputStream.PutField fields = writeObjectOverride(obj);
    if (fields != null) {
        writeFields();
        return;
    }
    writeOrdinaryObject(obj);
}

ObjectInputStream

ObjectInputStream 用于将字节流转换回对象。它的核心方法是 readObject()：

java

public final Object readObject() throws IOException, ClassNotFoundException {
    byte tc;
    while ((tc = readTC()) == TC_RESET) {
    }
    switch (tc) {
        case TC_NULL:
            return null;
        case TC_REFERENCE:
            return readHandle(tc);
        case TC_CLASS:
            return readClass(tc);
        case TC_OBJECT:
            return readOrdinaryObject(tc);
        default:
            throw new StreamCorruptedException(
                String.format("invalid type code: %02X", tc));
    }
}

深入探讨：transient关键字

在Java对象序列化过程中，某些字段不需要被序列化，比如敏感信息。这时可以使用 transient 关键字标记这些字段。被 transient 修饰的字段在序列化时会被忽略。

java

class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private transient String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{username='" + username + "', password='" + password + "'}";
    }
}

性能对比

对于大数据量的序列化和反序列化操作，选择合适的序列化机制非常重要。常见的序列化框架有 Java 原生序列化、Kryo、Protostuff 等。以下是一个简单的性能对比示例：

java

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class KryoSerializationDemo {
    public static void main(String[] args) {
        Kryo kryo = new Kryo();
        kryo.register(Person.class);

        Person person = new Person("Jane Doe", 25);

        // Kryo序列化
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Output output = new Output(baos);
        kryo.writeObject(output, person);
        output.close();

        // Kryo反序列化
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        Input input = new Input(bais);
        Person deserializedPerson = kryo.readObject(input, Person.class);
        input.close();

        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

通过对比可以看到，Kryo 序列化和反序列化的性能优于 Java 原生的序列化机制。

实际应用案例

分布式系统中的对象传输

在分布式系统中，服务之间需要频繁地传输对象，这时就需要用到序列化和反序列化。比如在微服务架构中，服务之间的通信通常是通过 REST API 或 RPC 实现的，这就需要将对象序列化为 JSON 或者其他格式，再进行传输。

缓存机制

在缓存机制中，比如使用 Redis 来缓存对象，通常需要将对象序列化为字节数组再进行存储。在读取缓存时，需要将字节数组反序列化为对象。

java

public class RedisCache {
    private RedisTemplate<String, Object> redisTemplate;

    public void cacheObject(String key, Object obj) {
        redisTemplate.opsForValue().set(key, obj);
    }

    public Object getObject(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}