Java 21（2023 年正式发布）在语言级别与标准库层面进行了多项重要升级，旨在提升开发效率、减少样板代码，并进一步强化 Java 生态系统的现代化能力。本文将重点阐述三个关键新特性：记录（Records）、模式匹配（Pattern Matching）以及序列化（Serialization）的改进，并给出实际代码示例，帮助开发者快速上手。

1. 记录（Records）——更简洁的数据结构

记录是一种不可变的数据载体，专为存储数据而设计。自 Java 16 起就已正式成为 JDK，Java 21 在其基础上进一步完善。

1.1 基础用法

public record Person(String firstName, String lastName, int age) { }

• 自动生成构造器、equals、hashCode、toString。
• 字段默认是 private final。
• 可以在记录体内添加方法或实现接口。

1.2 继承与嵌套记录

Java 21 允许记录实现接口并支持抽象记录。

public interface Identifiable { String id(); }

public record Employee(String id, String name, double salary) implements Identifiable { }

1.3 与 JSON 的无缝集成

通过 Jackson 的 @JsonProperty 或 Lombok 的 @Data，记录可与现有 JSON 序列化框架无缝配合。

public record User(@JsonProperty("user_id") String id, String name) { }

2. 模式匹配（Pattern Matching）——提升类型安全

Java 21 在 switch 语句与 instanceof 表达式上引入了完整的模式匹配功能，显著简化了类型检查与转换的代码。

2.1 instanceof 的模式匹配

Object obj = getObject();
if (obj instanceof String s && s.length() > 10) {
    System.out.println("Long string: " + s);
}

• instanceof 自动执行类型转换，避免显式强制转换。
• 可结合逻辑运算符实现多重匹配。

2.2 switch 的增强式模式

switch (obj) {
    case String s -> System.out.println("String: " + s);
    case Integer i && i > 100 -> System.out.println("Large integer: " + i);
    default -> System.out.println("Unknown type");
}

• 支持 record、class、enum 的模式匹配。
• -> 语法简化了分支逻辑。

2.3 组合模式与多分支

利用 instanceof 与 switch，可以轻松实现类似多态的行为：

public void process(Object o) {
    switch (o) {
        case List<?> l -> handleList(l);
        case Set<?> s -> handleSet(s);
        case Map<?, ?> m -> handleMap(m);
        default -> throw new IllegalArgumentException("Unsupported type");
    }
}

3. 序列化改进——安全与性能双提升

Java 21 在 Serializable 接口与 ObjectInputStream 上做了若干优化，主要包括：

3.1 强化安全检查

• 引入 SerializableFilter，可在 deserialization 过程中动态拒绝不安全的类。
• 默认启用 java.io.objectStreamClass 的安全检查，降低反序列化漏洞风险。

ObjectInputStream.Filter filter = new ObjectInputFilter() {
    @Override
    public Status checkInput(FilterInfo filterInfo) {
        Class<?> clazz = filterInfo.serialClass();
        return clazz.getName().startsWith("com.myapp.") ? Status.ALLOWED : Status.REJECTED;
    }
};
ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.ser")) {
    @Override
    protected void setFilter(ObjectInputFilter f) {
        super.setFilter(f);
    }
};
in.setFilter(filter);

3.2 性能优化

• 对 ObjectOutputStream 采用更高效的 BlockDataOutputStream 实现，减少 I/O 负载。
• 引入 SerializationProxy 模式的自动支持，简化序列化代码。

private static final class SerializationProxy implements Serializable {
    private final String data;
    SerializationProxy(MyClass obj) { this.data = obj.getData(); }
    private Object readResolve() { return new MyClass(data); }
}

4. 实战案例：构建一个安全且高效的缓存

结合上述特性，下面给出一个完整的缓存实现示例，演示如何利用记录、模式匹配与安全序列化。

import java.io.*;
import java.time.Duration;
import java.util.concurrent.*;

public class CacheDemo {
    private final ConcurrentHashMap<String, CacheEntry> store = new ConcurrentHashMap<>();

    public void put(String key, Object value, Duration ttl) {
        if (value instanceof Serializable) {
            store.put(key, new CacheEntry(key, value, ttl));
        } else {
            throw new IllegalArgumentException("Value must be serializable");
        }
    }

    public Object get(String key) {
        CacheEntry entry = store.get(key);
        if (entry == null || entry.isExpired()) return null;
        return entry.getValue();
    }

    private record CacheEntry(String key, Object value, Duration ttl) {
        private boolean isExpired() {
            // 简化的过期检查逻辑
            return false;
        }

        private Object getValue() {
            return value;
        }
    }
}

该实现使用 record 简化缓存条目结构，利用 instanceof 检查序列化能力，确保缓存值安全可序列化。

5. 结语

Java 21 的新增特性显著提升了语言的表达力与安全性。记录让数据类更轻量、模式匹配使类型检查更直观、序列化改进增强了安全性与性能。掌握这些特性后，开发者可以写出更简洁、可维护且安全的 Java 代码。希望本文能为你在项目中快速落地这些新特性提供帮助。