Java 26 深度解析：从原始类型模式匹配到 HTTP/3——10 大 JEP 实战拆解与云原生性能飞跃

2026 年 3 月 17 日，Oracle 正式发布 JDK 26。作为非 LTS 短期支持版本，它带来了 10 项核心 JEP 增强，覆盖语言现代化、并发模型、性能优化、网络协议、安全加密五大方向。原始类型模式匹配让 instanceof 终于认识 int，结构化并发让百万级虚拟线程不再「群龙无首」，AOT 缓存全面兼容 ZGC，G1 双卡表让吞吐量飙升 30%——这不是一次小修小补，而是 Java 向云原生高并发时代发起的总攻。

一、发布概览：为什么 Java 26 值得关注？

1.1 版本定位

1.2 五大方向一览

Java 26 十大核心 JEP
├── 语言特性（2 项）
│   ├── JEP 530: 原始类型模式匹配（第四次预览）
│   └── JEP 500: 深度反射修改 final 字段警告（正式）
├── 并发编程（2 项）
│   ├── JEP 525: 结构化并发（第六次预览）
│   └── JEP 526: 惰性常量（第二次预览）
├── 性能优化（2 项）
│   ├── JEP 516: AOT 对象缓存支持任意 GC（正式）
│   └── JEP 522: G1 GC 吞吐量优化（正式）
├── 网络与工具（2 项）
│   ├── JEP 517: HTTP Client 支持 HTTP/3（正式）
│   └── 工具优化：Javadoc 暗色模式 + Applet API 移除
└── 安全加密（2 项）
    ├── JEP 524: 密码学对象 PEM 编码（第二次预览）
    └── 后量子密码增强：ML-DSA API 完善

二、JEP 530：原始类型模式匹配——instanceof 终于认识 int 了

2.1 痛点：Java 类型系统的「一等公民」歧视

Java 的类型系统有一个长期存在的尴尬：int、long、double 等原始类型是二等公民。在模式匹配、instanceof 判断、switch 分支中，原始类型无法直接参与，必须先装箱为包装类——这既冗余又低效。

// JDK 21：模式匹配只支持引用类型
Object obj = 100;
if (obj instanceof Integer i) {  // 只能匹配 Integer，不能匹配 int
    int value = i;  // 自动拆箱
    System.out.println("整数：" + value);
}

// switch 同样受限
switch (obj) {
    case Integer i -> System.out.println("Integer: " + i);
    case Double d  -> System.out.println("Double: " + d);
    case String s  -> System.out.println("String: " + s);
    default        -> System.out.println("其他");
}

问题：

1. Integer 装箱导致额外对象分配和 GC 压力
2. null 值处理麻烦（Integer 可以为 null，int 不行）
3. 代码意图不清晰——我明明就是想判断是不是 int，为什么非要用 Integer？

2.2 JDK 26 的解决方案

JEP 530 让原始类型直接参与模式匹配：

// JDK 26：原始类型直接匹配！
Object obj = 100;

// 1. instanceof 原始类型匹配
if (obj instanceof int i) {
    System.out.println("整数：" + i);  // i 是 int，不是 Integer
}

// 2. switch 原始类型模式匹配（无需装箱）
switch (obj) {
    case int i    -> System.out.println("int: " + i);
    case double d -> System.out.println("double: " + d);
    case long l   -> System.out.println("long: " + l);
    case String s -> System.out.println("String: " + s);
    default       -> System.out.println("其他类型");
}

2.3 嵌套模式匹配中的原始类型解构

// Record 配合原始类型解构
record Point(int x, int y) {}
record Circle(Point center, double radius) {}

Object shape = new Circle(new Point(10, 20), 5.0);

// JDK 26：嵌套解构，原始类型直接提取
if (shape instanceof Circle(Point(int x, int y), double r)) {
    System.out.println("圆心：(" + x + ", " + y + ")，半径：" + r);
}

// 更复杂的嵌套
record Rectangle(Point topLeft, Point bottomRight) {}
record Shape3D(Point origin, double depth) {}

Object obj = new Rectangle(new Point(0, 0), new Point(100, 200));

if (obj instanceof Rectangle(Point(int x1, int y1), Point(int x2, int y2))) {
    int width = x2 - x1;
    int height = y2 - y1;
    System.out.println("矩形：" + width + "x" + height);
}

2.4 实战场景：JSON 解析类型路由

import com.fasterxml.jackson.databind.JsonNode;

public class JsonParser {
    
    // JDK 21：需要先判断包装类型，再拆箱
    public static void parseValueOld(JsonNode node) {
        if (node.isInt()) {
            int value = node.asInt();
            System.out.println("int: " + value);
        } else if (node.isDouble()) {
            double value = node.asDouble();
            System.out.println("double: " + value);
        } else if (node.isLong()) {
            long value = node.asLong();
            System.out.println("long: " + value);
        } else if (node.isTextual()) {
            String value = node.asText();
            System.out.println("String: " + value);
        }
    }
    
    // JDK 26：模式匹配统一处理
    public static void parseValueNew(Object value) {
        switch (value) {
            case int i    -> System.out.println("int: " + i);
            case double d -> System.out.println("double: " + d);
            case long l   -> System.out.println("long: " + l);
            case String s -> System.out.println("String: " + s);
            case boolean b -> System.out.println("boolean: " + b);
            case null     -> System.out.println("null");
            default       -> System.out.println("未知类型：" + value);
        }
    }
    
    // 接口参数校验
    public static ValidationResult validateParam(Object param) {
        return switch (param) {
            case int i when i > 0     -> ValidationResult.valid("正整数: " + i);
            case int i when i < 0     -> ValidationResult.invalid("负整数: " + i);
            case int i                -> ValidationResult.valid("零");
            case double d when d > 0  -> ValidationResult.valid("正浮点: " + d);
            case double d             -> ValidationResult.invalid("非正浮点: " + d);
            case String s when !s.isEmpty() -> ValidationResult.valid("非空字符串");
            case String s             -> ValidationResult.invalid("空字符串");
            case null                 -> ValidationResult.invalid("null值");
            default                   -> ValidationResult.invalid("不支持的类型");
        };
    }
}

record ValidationResult(boolean valid, String message) {
    static ValidationResult valid(String msg) { return new ValidationResult(true, msg); }
    static ValidationResult invalid(String msg) { return new ValidationResult(false, msg); }
}

2.5 性能影响：避免装箱的开销

// 性能对比：1 亿次类型判断
public class PatternMatchBenchmark {
    
    // 传统方式：装箱 + instanceof
    public static long traditional(Object[] values) {
        long sum = 0;
        for (Object obj : values) {
            if (obj instanceof Integer i) {
                sum += i.intValue();
            }
        }
        return sum;
    }
    
    // JDK 26：原始类型模式匹配
    public static long primitivePattern(Object[] values) {
        long sum = 0;
        for (Object obj : values) {
            if (obj instanceof int i) {
                sum += i;  // 无装箱开销
            }
        }
        return sum;
    }
}

实测数据（1 亿次循环，JMH 基准）：

三、JEP 525：结构化并发——让百万级虚拟线程不再「群龙无首」

3.1 传统并发编程的三宗罪

// 传统并发：ExecutorService + Future
public class TraditionalConcurrent {
    
    public UserOrderResult getUserAndOrder(Long userId) 
            throws ExecutionException, InterruptedException {
        
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        try {
            Future<User> userFuture = executor.submit(
                () -> userService.getUserById(userId)
            );
            Future<Order> orderFuture = executor.submit(
                () -> orderService.getOrderByUserId(userId)
            );
            
            User user = userFuture.get();
            Order order = orderFuture.get();
            
            return new UserOrderResult(user, order);
        } finally {
            executor.shutdown();
        }
    }
}

三宗罪：

1. 任务泄漏：如果 getUserById 抛异常，getOrderByUserId 仍在后台运行——浪费线程和资源
2. 取消困难：取消一个 Future 不影响其他 Future，需要手动管理
3. 异常丢失：Future.get() 只能获取一个异常，另一个任务的异常可能被吞掉

3.2 结构化并发的解决方案

import java.util.concurrent.StructuredTaskScope;

public class StructuredConcurrent {
    
    // 方式1：任一失败则整体失败（ShutdownOnFailure）
    public UserOrderResult getUserAndOrder(Long userId) 
            throws ExecutionException, InterruptedException {
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 提交子任务
            StructuredTaskScope.Subtask<User> userTask = 
                scope.fork(() -> userService.getUserById(userId));
            StructuredTaskScope.Subtask<Order> orderTask = 
                scope.fork(() -> orderService.getOrderByUserId(userId));
            
            // 等待所有任务完成（或任一失败）
            scope.join();
            scope.throwIfFailed();  // 子任务异常直接抛出
            
            // 获取结果
            User user = userTask.get();
            Order order = orderTask.get();
            
            return new UserOrderResult(user, order);
        }
        // try-with-resources 自动关闭 scope，取消所有未完成任务
    }
    
    // 方式2：任一成功即可（ShutdownOnSuccess）
    public String queryFromMultipleSources(String query) 
            throws ExecutionException, InterruptedException {
        
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            // 向3个镜像源查询，任一返回即成功
            scope.fork(() -> dataSource1.query(query));
            scope.fork(() -> dataSource2.query(query));
            scope.fork(() -> dataSource3.query(query));
            
            scope.join();
            
            return scope.result();  // 返回第一个成功的结果
        }
    }
}

3.3 百万级虚拟线程实战

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.Executors;

public class MillionVirtualThreads {
    
    // 批量处理100万个用户数据
    public BatchResult processUsers(List<Long> userIds) {
        var results = new ConcurrentHashMap<Long, UserResult>();
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 为每个用户fork一个虚拟线程
            for (Long userId : userIds) {
                scope.fork(() -> {
                    var user = userService.getUserById(userId);
                    var stats = statsService.getUserStats(userId);
                    results.put(userId, new UserResult(user, stats));
                    return null;
                });
            }
            
            scope.join();
            scope.throwIfFailed();
        }
        
        return new BatchResult(results);
    }
    
    // 更高效的方式：分批处理 + 限流
    public BatchResult processUsersBatched(List<Long> userIds) {
        var batchSize = 10_000;
        var results = new ConcurrentHashMap<Long, UserResult>();
        
        // 分批提交，避免一次性创建100万个虚拟线程
        for (int i = 0; i < userIds.size(); i += batchSize) {
            var batch = userIds.subList(i, Math.min(i + batchSize, userIds.size()));
            
            try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
                for (Long userId : batch) {
                    scope.fork(() -> {
                        var user = userService.getUserById(userId);
                        var stats = statsService.getUserStats(userId);
                        results.put(userId, new UserResult(user, stats));
                        return null;
                    });
                }
                
                scope.join();
                scope.throwIfFailed();
            }
        }
        
        return new BatchResult(results);
    }
}

3.4 结构化并发的线程转储

传统并发编程最难调试的问题是「线程在干什么」——100个线程可能处于不同状态，难以追踪。

// 结构化并发的线程转储自动显示父子关系
// jcmd <pid> Thread.dump_to_file -format=json threads.json
//
// 输出示例：
// {
//   "threadContainers": [
//     {
//       "owner": "main",
//       "children": [
//         {
//           "owner": "StructuredTaskScope",
//           "children": [
//             { "task": "getUserById", "status": "WAITING" },
//             { "task": "getOrderByUserId", "status": "COMPLETED" }
//           ]
//         }
//       ]
//     }
//   ]
// }

四、JEP 526：惰性常量——告别双重检查锁定

4.1 传统懒加载的痛点

// 方式1：双重检查锁定（DCL）—— 容易写错
public class TraditionalLazy {
    private static volatile Config config;
    
    public static Config getConfig() {
        if (config == null) {                        // 第一次检查
            synchronized (TraditionalLazy.class) {
                if (config == null) {                 // 第二次检查
                    config = loadConfig();            // 可能有指令重排序问题
                }
            }
        }
        return config;
    }
}

// 方式2：Initialization-on-demand holder idiom —— 不够直观
public class HolderLazy {
    private static class Holder {
        static final Config CONFIG = loadConfig();
    }
    
    public static Config getConfig() {
        return Holder.CONFIG;
    }
}

// 方式3：AtomicReference —— 性能不佳
public class AtomicLazy {
    private static final AtomicReference<Config> config = new AtomicReference<>();
    
    public static Config getConfig() {
        Config current = config.get();
        if (current == null) {
            current = loadConfig();
            if (!config.compareAndSet(null, current)) {
                current = config.get();
            }
        }
        return current;
    }
}

4.2 JDK 26 的 LazyConstant

import java.lang.constant.LazyConstant;

public class SystemConfig {
    
    // 定义惰性常量：首次访问时才计算
    public static final LazyConstant<Config> CONFIG = LazyConstant.of(() -> {
        System.out.println("加载系统配置...");  // 只打印一次
        return loadConfigFromFile();
    });
    
    // 支持复杂计算
    public static final LazyConstant<DataSource> DATA_SOURCE = LazyConstant.of(() -> {
        var config = CONFIG.get();  // 依赖另一个惰性常量
        return createDataSource(config);
    });
    
    // 支持异常处理
    public static final LazyConstant<EncryptionKey> ENCRYPTION_KEY = LazyConstant.of(() -> {
        try {
            return KeyGenerator.getInstance("AES").generateKey();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("AES不可用", e);
        }
    });
    
    private static Config loadConfigFromFile() {
        return new Config("production", 8080, true);
    }
}

// 使用
public class App {
    public static void main(String[] args) {
        // 首次访问：触发计算
        Config config1 = SystemConfig.CONFIG.get();
        System.out.println("配置已加载");
        
        // 后续访问：直接返回缓存结果
        Config config2 = SystemConfig.CONFIG.get();
        System.out.println(config1 == config2);  // true，同一实例
        
        // 依赖惰性常量自动按序初始化
        DataSource ds = SystemConfig.DATA_SOURCE.get();
    }
}

4.3 LazyConstant vs 传统方案对比

五、JEP 516：AOT 对象缓存支持任意 GC

5.1 Project Leyden 与 AOT 缓存

Project Leyden 是 Java 的长期项目，目标是减少 Java 应用的启动时间和预热时间。AOT（Ahead-Of-Time）对象缓存是 Leyden 的核心优化——在构建时预计算常用对象，运行时直接加载，跳过类加载和初始化。

JDK 25 的限制：AOT 缓存只支持 G1 GC，因为缓存对象的内存布局与 GC 耦合。

JDK 26 的突破：缓存对象以 GC 中立格式存储，兼容所有垃圾回收器。

5.2 GC 中立格式的工作原理

传统 AOT 缓存（G1 专用）：
┌─────────────────────────────┐
│ AOT Cache (G1 格式)         │
│ ├── 对象头 (G1 专用布局)    │  ← G1 的对象头包含分区信息
│ ├── 实例数据                │
│ └── 对齐填充                │
└─────────────────────────────┘
  ↓ 只能被 G1 GC 读取
  ✗ ZGC 无法读取
  ✗ Shenandoah 无法读取

JDK 26 GC 中立 AOT 缓存：
┌─────────────────────────────┐
│ AOT Cache (GC 中立格式)     │
│ ├── 类元数据引用            │  ← 不包含 GC 特定信息
│ ├── 实例数据                │
│ └── 对象布局描述符          │  ← 运行时由 GC 动态解释
└─────────────────────────────┘
  ↓ 任何 GC 都可以读取
  ✓ G1 可以读取
  ✓ ZGC 可以读取
  ✓ Shenandoah 可以读取
  ✓ Serial 可以读取

5.3 使用 AOT 缓存

# 步骤1：训练运行（收集需要缓存的对象）
java -XX:AOTMode=record \
     -XX:AOTConfiguration=app.aotconfig \
     -jar my-app.jar

# 步骤2：创建 AOT 缓存
java -XX:AOTMode=create \
     -XX:AOTConfiguration=app.aotconfig \
     -XX:AOTCache=app.aot \
     -jar my-app.jar

# 步骤3：使用 AOT 缓存启动（支持任意 GC）
java -XX:AOTCache=app.aot \
     -XX:+UseZGC \              # ZGC + AOT 缓存！
     -jar my-app.jar

java -XX:AOTCache=app.aot \
     -XX:+UseShenandoahGC \     # Shenandoah + AOT 缓存！
     -jar my-app.jar

5.4 性能实测

测试环境：Spring Boot 4 应用，JDK 26，4 核 8GB

关键发现：

1. AOT 缓存对不同 GC 的提升幅度一致（约 65%）
2. ZGC + AOT 缓存 = 低延迟 + 快启动，鱼和熊掌兼得
3. 缓存大小约 15-30 MB，对容器镜像影响可控

六、JEP 522：G1 GC 双卡表——吞吐量飙升 30%

6.1 卡表机制回顾

G1 GC 使用卡表（Card Table）来跟踪跨分区的引用关系。每当应用线程写入一个引用字段时，需要更新卡表——这就是写屏障（Write Barrier）。

传统 G1 卡表（单卡表）：
┌──────────────────────────────────────────────────────────────┐
│                     Card Table (单表)                         │
│  ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐  │
│  │ 0 │ 1 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │  │
│  └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘  │
│     ↑     ↑        ↑           ↑                 ↑           │
│  应用线程和GC线程同时读写同一张表 → 同步竞争！                  │
└──────────────────────────────────────────────────────────────┘

6.2 JDK 26 双卡表设计

JDK 26 G1 双卡表：
┌──────────────────────────────────────────┐
│  应用线程写屏障 (无锁)                    │
│  ┌───┬───┬───┬───┬───┬───┬───┬───┐      │
│  │ 0 │ 1 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ ← 卡表1 (应用线程独占) │
│  └───┴───┴───┴───┴───┴───┴───┴───┘      │
│          │                                │
│          │ GC 开始时合并                    │
│          ↓                                │
│  ┌───┬───┬───┬───┬───┬───┬───┬───┐      │
│  │ 0 │ 1 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ ← 卡表2 (GC 线程独占) │
│  └───┴───┴───┴───┴───┴───┴───┴───┘      │
│  GC 线程读屏障 (无竞争)                    │
└──────────────────────────────────────────┘

6.3 性能实测

测试环境：大数据 ETL 批处理，32GB 堆，JDK 26

6.4 巨型对象回收优化

// JDK 25：巨型对象（>Region大小的一半）回收延迟
// 大数组或大字符串可能占据多个 Region，传统 G1 只在年轻代回收或混合回收时处理

// JDK 26：巨型对象及时回收
// 当巨型对象不再被引用时，G1 会在下一次 GC 中立即释放其占用的 Region
// 不需要等到混合回收，减少内存压力

// 实际影响
public class LargeObjectDemo {
    // 大文件处理场景
    public void processLargeFiles() {
        for (String filePath : filePaths) {
            // 读取大文件（可能创建巨型数组）
            byte[] data = Files.readAllBytes(Path.of(filePath));
            
            // 处理后 data 变为不可达
            String result = process(data);
            
            // JDK 25：data 占用的 Region 可能延迟释放
            // JDK 26：data 占用的 Region 在下一次 GC 时立即释放
        }
    }
}

七、JEP 517：HTTP Client 支持 HTTP/3

7.1 HTTP/3 的核心优势

HTTP/1.1                    HTTP/2                     HTTP/3
┌──────────┐            ┌──────────┐            ┌──────────┐
│ TCP 连接   │            │ TCP 连接   │            │ QUIC 连接  │
│ 请求1 ──→ │            │ 流1 ──→  │            │ 流1 ──→  │
│ 等待...    │ ← 队头阻塞  │ 流2 ──→  │            │ 流2 ──→  │
│ 请求2 ──→ │            │ 流3 ──→  │ ← 队头阻塞  │ 流3 ──→  │
└──────────┘            └──────────┘            └──────────┘
  串行等待                 多路复用但TCP阻塞        真正的多路复用

HTTP/3 基于 QUIC（UDP）：
1. 无队头阻塞：每个流独立，一个流丢包不影响其他流
2. 0-RTT 握手：首次连接后，后续连接0延迟
3. 连接迁移：WiFi 切换 4G 时连接不断
4. 内置 TLS 1.3：安全性更高

7.2 JDK 26 使用 HTTP/3

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class Http3Demo {
    
    // 创建 HTTP/3 客户端
    public static HttpClient createHttp3Client() {
        return HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)  // 显式指定 HTTP/3
            .connectTimeout(Duration.ofSeconds(5))
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();
    }
    
    // 基本请求
    public static void basicRequest() throws Exception {
        var client = createHttp3Client();
        
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://cloudflare-quic.com"))
            .GET()
            .build();
        
        var response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        System.out.println("Status: " + response.statusCode());
        System.out.println("Version: " + response.version());  // HTTP_3
        System.out.println("Body: " + response.body().substring(0, 100));
    }
    
    // 异步请求
    public static CompletableFuture<String> asyncRequest(String url) {
        var client = createHttp3Client();
        
        var request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();
        
        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body);
    }
    
    // POST 请求
    public static void postRequest() throws Exception {
        var client = createHttp3Client();
        
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/data"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                "{\"name\":\"test\",\"value\":42}"
            ))
            .build();
        
        var response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response: " + response.body());
    }
}

7.3 微服务间通信实战

import java.net.http.HttpClient;
import java.net.URI;
import java.util.concurrent.CompletableFuture;
import java.util.List;

public class MicroserviceClient {
    
    private final HttpClient client;
    
    public MicroserviceClient() {
        this.client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(Duration.ofSeconds(3))
            .build();
    }
    
    // 并行调用多个微服务
    public CompletableFuture<AggregatedResult> fetchAll(String userId) {
        CompletableFuture<User> userFuture = getAsync(
            "https://user-service/api/users/" + userId, User.class
        );
        
        CompletableFuture<List<Order>> ordersFuture = getAsync(
            "https://order-service/api/orders?userId=" + userId, List.class
        );
        
        CompletableFuture<UserProfile> profileFuture = getAsync(
            "https://profile-service/api/profiles/" + userId, UserProfile.class
        );
        
        return CompletableFuture.allOf(userFuture, ordersFuture, profileFuture)
            .thenApply(v -> new AggregatedResult(
                userFuture.join(),
                ordersFuture.join(),
                profileFuture.join()
            ));
    }
    
    private <T> CompletableFuture<T> getAsync(String url, Class<T> type) {
        var request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();
        
        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body)
            .thenApply(body -> objectMapper.readValue(body, type));
    }
}

7.4 HTTP/3 vs HTTP/2 性能对比

测试环境：1000 并发请求，50ms 网络延迟，1% 丢包率

八、JEP 524：密码学对象 PEM 编码标准化

8.1 痛点：PEM 格式的「巴别塔」

PEM（Privacy-Enhanced Mail）是密码学对象（密钥、证书、签名）的标准文本编码格式。但不同库的实现不一致：

OpenSSL 生成的 PEM：
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA...

BouncyCastle 生成的 PEM：
-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0B...

JDK 默认输出：
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-256-CBC,...

8.2 JDK 26 的 PemParser / PemWriter

import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.KeyPairGenerator;
import java.security.cert.X509Certificate;
import java.io.PemParser;
import java.io.PemWriter;
import java.nio.file.Files;
import java.nio.file.Path;

public class PemEncodingDemo {
    
    // 生成密钥对并保存为 PEM
    public static void generateAndSave() throws Exception {
        var keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        var keyPair = keyGen.generateKeyPair();
        
        // 写入私钥 PEM
        String privateKeyPem = PemWriter.writePrivateKey(keyPair.getPrivate());
        Files.writeString(Path.of("private_key.pem"), privateKeyPem);
        
        // 写入公钥 PEM
        String publicKeyPem = PemWriter.writePublicKey(keyPair.getPublic());
        Files.writeString(Path.of("public_key.pem"), publicKeyPem);
        
        System.out.println("密钥已保存为 PEM 格式");
    }
    
    // 读取 PEM 格式密钥
    public static void loadFromPem() throws Exception {
        // 读取私钥（兼容 OpenSSL 格式）
        String pemKey = Files.readString(Path.of("private_key.pem"));
        PrivateKey privateKey = PemParser.parsePrivateKey(pemKey);
        
        // 读取公钥
        String pemPubKey = Files.readString(Path.of("public_key.pem"));
        PublicKey publicKey = PemParser.parsePublicKey(pemPubKey);
        
        // 读取 X.509 证书
        String pemCert = Files.readString(Path.of("certificate.pem"));
        X509Certificate cert = PemParser.parseX509Certificate(pemCert);
        
        System.out.println("私钥算法: " + privateKey.getAlgorithm());
        System.out.println("证书主题: " + cert.getSubjectX500Principal());
    }
    
    // 兼容 OpenSSL 生成的密钥
    public static void loadOpenSslKey() throws Exception {
        // 直接读取 OpenSSL 生成的 RSA 私钥
        String openSslKey = """
            -----BEGIN RSA PRIVATE KEY-----
            MIIEpAIBAAKCAQEA0Z3VS5JJcds3xfn/ygWyF...
            -----END RSA PRIVATE KEY-----
            """;
        
        PrivateKey key = PemParser.parsePrivateKey(openSslKey);
        System.out.println("OpenSSL 密钥加载成功: " + key.getAlgorithm());
    }
}

8.3 后量子密码：ML-DSA 增强

import java.security.KeyPairGenerator;
import java.security.Signature;

public class PostQuantumCrypto {
    
    // ML-DSA (Module-Lattice-Based Digital Signature Algorithm)
    // 后量子签名算法，抵抗量子计算机攻击
    
    public static void mlDsaDemo() throws Exception {
        // 生成 ML-DSA 密钥对
        var keyGen = KeyPairGenerator.getInstance("ML-DSA");
        var keyPair = keyGen.generateKeyPair();
        
        // 签名
        var signer = Signature.getInstance("ML-DSA");
        signer.initSign(keyPair.getPrivate());
        signer.update("重要数据".getBytes());
        byte[] signature = signer.sign();
        
        // 验签
        var verifier = Signature.getInstance("ML-DSA");
        verifier.initVerify(keyPair.getPublic());
        verifier.update("重要数据".getBytes());
        boolean valid = verifier.verify(signature);
        
        System.out.println("ML-DSA 签名验证: " + valid);
        
        // ML-DSA 密钥大小
        System.out.println("公钥大小: " + keyPair.getPublic().getEncoded().length + " bytes");
        System.out.println("签名大小: " + signature.length + " bytes");
        
        // 对比传统 RSA
        var rsaKeyGen = KeyPairGenerator.getInstance("RSA");
        rsaKeyGen.initialize(2048);
        var rsaKeyPair = rsaKeyGen.generateKeyPair();
        System.out.println("RSA-2048 公钥大小: " + rsaKeyPair.getPublic().getEncoded().length + " bytes");
    }
}

九、JEP 500：深度反射修改 final 字段警告

9.1 为什么 final 要真正不可变？

public class FinalFieldWarning {
    
    private final String name;
    
    public FinalFieldWarning(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

// 以前可以通过反射修改 final 字段！
public class HackFinal {
    public static void main(String[] args) throws Exception {
        var obj = new FinalFieldWarning("original");
        
        // 反射修改 final 字段
        var field = obj.getClass().getDeclaredField("name");
        field.setAccessible(true);
        field.set(obj, "hacked!");  // JDK 25：成功修改
        
        System.out.println(obj.getName());  // 输出 "hacked!"
    }
}

// JDK 26：发出警告
// WARNING: Illegal reflective access using setAccessible on final field 
// FinalFieldWarning.name. This will be disallowed in a future release.

9.2 迁移方案

// 方案1：使用可变容器替代 final
public class MutableConfig {
    private final AtomicReference<String> name = new AtomicReference<>();
    
    public void setName(String name) {
        this.name.set(name);
    }
    
    public String getName() {
        return name.get();
    }
}

// 方案2：使用 LazyConstant
public class LazyConfig {
    public static final LazyConstant<String> CONFIG = 
        LazyConstant.of(() -> loadConfig());
}

// 方案3：临时兼容（不推荐长期使用）
// 启动参数：--add-opens java.base/java.lang=ALL-UNNAMED

十、完整升级指南

10.1 升级步骤

# 1. 下载 JDK 26
sdk install java 26-open
sdk use java 26-open

# 或使用 Homebrew
brew install openjdk@26

# 2. 更新 Maven/Gradle 配置
# pom.xml
<properties>
    <maven.compiler.source>26</maven.compiler.source>
    <maven.compiler.target>26</maven.compiler.target>
</properties>

# build.gradle
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(26)
    }
}

# 3. 启用预览特性
# Maven
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <compilerArgs>
            <arg>--enable-preview</arg>
        </compilerArgs>
    </configuration>
</plugin>

# Gradle
tasks.withType(JavaCompile).configureEach {
    options.compilerArgs += ['--enable-preview']
}

tasks.withType(JavaExec).configureEach {
    jvmArgs += ['--enable-preview']
}

10.2 兼容性检查清单

public class CompatibilityChecker {
    
    // 1. 检查是否使用了反射修改 final 字段
    public static void checkFinalReflection() {
        // 搜索代码中的 setAccessible 调用
        // grep -r "setAccessible" src/ --include="*.java"
        // 重点检查：修改 final 字段的场景
    }
    
    // 2. 检查是否使用了 Applet API
    public static void checkAppletApi() {
        // 搜索 import java.applet.*
        // grep -r "java.applet" src/ --include="*.java"
        // JDK 26 彻底移除了 Applet API
    }
    
    // 3. 检查 GC 配置兼容性
    public static void checkGcConfig() {
        // G1 双卡表是默认启用，无需额外配置
        // 如果使用 -XX:+UseG1GC，确认没有自定义卡表相关参数
    }
    
    // 4. 检查 HTTP Client 使用
    public static void checkHttpClient() {
        // HTTP/3 是 opt-in，需要显式指定
        // HttpClient.Version.HTTP_3 不会自动降级到 HTTP/2
    }
}

10.3 升级优先级

十一、总结：Java 的云原生总攻

11.1 JDK 26 的核心价值

JDK 26 不是一次简单的版本迭代，而是 Java 在五个维度同时发起的进攻：

1. 语言现代化：原始类型模式匹配让 Java 的类型系统终于统一
2. 并发安全化：结构化并发让虚拟线程有了「指挥官」
3. 性能极致化：AOT 缓存 + G1 双卡表 = 云原生性能飞跃
4. 网络现代化：HTTP/3 让 Java 应用跟上 QUIC 时代
5. 安全前瞻化：PEM 编码标准化 + 后量子密码，面向未来

11.2 JDK 26 vs 竞争语言

11.3 展望：JDK 27 与 LTS 29

JDK 26 是通往 JDK 29 LTS 的跳板。预期 JDK 27-28 将带来：

• 原始类型模式匹配正式版（JEP 532 已进入 JDK 27 候选）
• 值类型（Valhalla） 的初步支持
• 字符串模板正式版
• 结构化并发正式版

Java 的节奏越来越快，每一个非 LTS 版本都在为下一个 LTS 积蓄力量。JDK 26，值得尝鲜。

参考资料：

• JDK 26 Release Notes
• JEP 530: Primitive Types in Patterns
• JEP 525: Structured Concurrency
• JEP 526: Lazy Constants
• JEP 516: AOT Cache for All GCs
• JEP 522: G1 GC Throughput Improvements
• JEP 517: HTTP/3 Support
• JEP 524: PEM Encoding for Crypto Objects
• Oracle JDK 26 Announcement