LTS on 吾爱主机

Java 21 新特性详解：虚拟线程、Pattern Matching Switch 与现代并发

Thu, 25 Jun 2026 15:00:00 +0000

前言

Java 21 于 2023 年 9 月发布，是继 Java 17 之后的下一个长期支持版本（LTS）。它带来了 Java 并发编程的革命性变化——虚拟线程（Virtual Threads），以及一系列语法增强。对于需要处理高并发的后端开发者来说，Java 21 是一个里程碑式的版本。

1. 虚拟线程（Virtual Threads）

虚拟线程是 Project Loom 的核心成果，用极低的资源开销实现百万级并发。

1.1 传统线程 vs 虚拟线程

// 传统平台线程：每个线程占用约 1MB 内存
// 1 万个线程 ≈ 10GB 内存
Thread platformThread = new Thread(() -> System.out.println("Platform Thread"));

// 虚拟线程：每个虚拟线程仅占几 KB
// 100 万个虚拟线程也只需几 GB 内存
Thread virtualThread = Thread.ofVirtual().start(() -> System.out.println("Virtual Thread"));

// 创建虚拟线程（方式一：Builder）
Thread vt1 = Thread.ofVirtual()
 .name("my-vt", 0)
 .start(() -> doWork());

// 创建虚拟线程（方式二：工厂）
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> doWork());

// 创建虚拟线程（方式三：直接创建）
Thread.startVirtualThread(() -> doWork());

1.2 与传统线程池对比

// 传统方式：固定线程池，线程数受限
ExecutorService pool = Executors.newFixedThreadPool(200);
for (int i = 0; i < 100_000; i++) {
 pool.submit(() -> {
 Thread.sleep(Duration.ofSeconds(1)); // 阻塞
 return fetchData();
 });
}
// 问题：200 个线程只能同时处理 200 个请求，其余排队

// 虚拟线程：每个任务一个线程，百万级并发
ExecutorService vExecutor = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1_000_000; i++) {
 vExecutor.submit(() -> {
 Thread.sleep(Duration.ofSeconds(1)); // 阻塞不浪费资源
 return fetchData();
 });
}
// 100 万个任务几乎同时执行

1.3 实战：HTTP 服务

// 使用虚拟线程的 HTTP 服务器
public class VirtualThreadServer {
 public static void main(String[] args) throws IOException {
 // 传统方式需要线程池，虚拟线程直接创建
 var server = HttpServer.create(new InetSocketAddress(8080), 0);
 server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
 server.createContext("/api/users", exchange -> {
 // 每个请求一个虚拟线程，可以安全地阻塞
 String userId = extractUserId(exchange);
 User user = db.query(userId); // 阻塞 IO，虚拟线程自动让出
 Order order = fetchOrder(userId); // 阻塞 HTTP 调用
 String response = formatResponse(user, order);
 exchange.sendResponseHeaders(200, response.length());
 exchange.getResponseBody().write(response.getBytes());
 });
 server.start();
 }
}

1.4 虚拟线程注意事项

// ❌ 不要在虚拟线程中使用 synchronized（会导致载体线程被固定）
synchronized (lock) {
 // 这会阻止虚拟线程从载体线程上卸载
 doBlockingIO();
}

// ✅ 使用 ReentrantLock 替代
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
 doBlockingIO();
} finally {
 lock.unlock();
}

// ❌ 不要池化虚拟线程
// 虚拟线程的设计就是"用完即弃"，不需要池化
ExecutorService pool = Executors.newFixedThreadPool(100); // 不要这样做

// ✅ 正确用法
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

2. Pattern Matching for Switch

Java 21 正式特性。让 switch 支持类型模式匹配和解构。

2.1 类型模式匹配

// 传统写法
static String format(Object obj) {
 if (obj instanceof Integer i) {
 return String.format("int %d", i);
 } else if (obj instanceof Long l) {
 return String.format("long %d", l);
 } else if (obj instanceof Double d) {
 return String.format("double %f", d);
 } else if (obj instanceof String s) {
 return String.format("String %s", s);
 } else {
 return obj.toString();
 }
}

// Pattern Matching for Switch
static String format(Object obj) {
 return switch (obj) {
 case Integer i -> String.format("int %d", i);
 case Long l -> String.format("long %d", l);
 case Double d -> String.format("double %f", d);
 case String s -> String.format("String %s", s);
 case null -> "null";
 default -> obj.toString();
 };
}

2.2 Guarded Patterns（守卫模式）

static String classify(Object obj) {
 return switch (obj) {
 case String s && s.length() > 10 -> "长字符串: " + s.substring(0, 10) + "...";
 case String s && s.isEmpty() -> "空字符串";
 case String s -> "字符串: " + s;
 case Integer i && i > 0 -> "正整数: " + i;
 case Integer i && i < 0 -> "负整数: " + i;
 case Integer i -> "零";
 case null -> "null";
 default -> "其他: " + obj;
 };
}

2.3 配合 Sealed Classes

public sealed interface Shape permits Circle, Rectangle, Triangle {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double w, double h) implements Shape {}
public record Triangle(double a, double b, double c) implements Shape {}

static double area(Shape shape) {
 return switch (shape) {
 case Circle c -> Math.PI * c.radius() * c.radius();
 case Rectangle r -> r.w() * r.h();
 case Triangle t -> {
 double s = (t.a() + t.b() + t.c()) / 2;
 yield Math.sqrt(s * (s - t.a()) * (s - t.b()) * (s - t.c()));
 }
 // 不需要 default！编译器知道已经穷举
 };
}

3. Record Patterns（记录模式）

Java 21 正式特性。对 Record 进行解构匹配。

public record Point(int x, int y) {}
public record Line(Point start, Point end) {}
public record Triangle(Point a, Point b, Point c) {}

// Record 解构模式
static double length(Line line) {
 return switch (line) {
 case Line(Point(int x1, int y1), Point(int x2, int y2)) ->
 Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
 };
}

// 嵌套解构
static String describe(Object obj) {
 return switch (obj) {
 case Line(Point(var x1, var y1), Point(var x2, var y2)) ->
 "线段从 (%d,%d) 到 (%d,%d)".formatted(x1, y1, x2, y2);
 case Point(var x, var y) ->
 "点 (%d, %d)".formatted(x, y);
 default -> "未知形状";
 };
}

// 在 if 中使用
if (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
 System.out.printf("从 (%d,%d) 到 (%d,%d)%n", x1, y1, x2, y2);
}

4. Sequenced Collections（有序集合）

Java 21 引入了 SequencedCollection 接口，统一了有序集合的操作。

// 新接口层次
// SequencedCollection<E> extends Collection<E>
// - SequencedSet<E> extends Set<E>, SequencedCollection<E>
// - SequencedMap<K,V> extends Map<K,V>

// SequencedCollection 新方法
List<String> list = new ArrayList<>(List.of("a", "b", "c"));

list.getFirst(); // "a" — 获取第一个元素
list.getLast(); // "c" — 获取最后一个元素
list.addFirst("z"); // [z, a, b, c]
list.addLast("d"); // [z, a, b, c, d]
list.reversed(); // [d, c, b, a, z] — 返回反转视图

// SequencedMap 新方法
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("third", 3);

map.firstEntry(); // first=1
map.lastEntry(); // third=3
map.pollFirstEntry(); // 移除并返回 first=1
map.pollLastEntry(); // 移除并返回 third=3
map.putFirst("zero", 0); // 在最前面插入
map.putLast("four", 4); // 在最后面插入
map.reversed(); // 返回反转视图

// 适用类型
// ArrayList, LinkedList, ArrayDeque → SequencedCollection
// LinkedHashSet, TreeSet → SequencedSet
// LinkedHashMap, TreeMap → SequencedMap

5. Unnamed Patterns and Variables（未命名模式和变量）

Java 21 正式特性。用 _ 忽略不需要的变量。

// 未命名变量
if (obj instanceof Point(int x, int _)) {
 // 只关心 x，不关心 y
 System.out.println("x = " + x);
}

// 在 switch 中使用
switch (obj) {
 case Point(int x, _) -> System.out.println("x = " + x);
 case Line(_, Point(int x, _)) -> System.out.println("终点 x = " + x);
 default -> {}
}

// 在 lambda 中使用（忽略不需要的参数）
map.forEach((key, _) -> System.out.println(key)); // 不关心 value

// try-with-resources（资源需实现 AutoCloseable，这里忽略其引用）
try (var _ = acquireResource()) {
 // 不需要引用资源变量
}

// for 循环
for (var _ : range) {
 doSomething(); // 不需要迭代变量
}

6. String Templates（字符串模板）

预览特性。类似其他语言的字符串插值。

// STR 处理器（自动处理转义和格式化）
String name = "Alice";
int age = 30;
String message = STR."Hello, \{name}! You are \{age} years old.";
// "Hello, Alice! You are 30 years old."

// 嵌入表达式
String result = STR."The result is \{2 * 3 + 1}.";
// "The result is 7."

// 方法调用
String upper = STR."Name: \{name.toUpperCase()}";

// 多行
String html = STR."""
 <div class="user">
 <h1>\{name}</h1>
 <p>Age: \{age}</p>
 </div>
 """;

// RAW 处理器（不转义）
String raw = RAW."<script>alert('hello')</script>";

// FMT 处理器（支持格式化）
String formatted = FMT."%.2f\{3.14159}"; // "3.14"

7. Scoped Values（作用域值）

Java 21 预览特性。替代 ThreadLocal 的更安全方案。

// ThreadLocal 的问题：需要手动清理，容易内存泄漏
// Scoped Values：自动随作用域结束而清理

// 定义
private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

// 使用
ScopedValue.where(CURRENT_USER, user).run(() -> {
 // 在这个作用域内可以访问 CURRENT_USER
 processRequest();
 handleOrder();
});

// 读取
void processRequest() {
 User user = CURRENT_USER.get(); // 获取当前用户
 // ...
}

8. Structured Concurrency（结构化并发）

Java 21 预览特性。将多线程任务组织为结构化的任务树。

// 传统方式：手动管理多个 Future
Future<User> userFuture = executor.submit(() -> fetchUser(id));
Future<Order> orderFuture = executor.submit(() -> fetchOrder(id));
User user = userFuture.get();
Order order = orderFuture.get();

// 结构化并发
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
 Subtask<User> userTask = scope.fork(() -> fetchUser(id));
 Subtask<Order> orderTask = scope.fork(() -> fetchOrder(id));

 scope.join(); // 等待所有任务完成
 scope.throwIfFailed(); // 如果有失败则抛出异常

 return new UserOrder(userTask.get(), orderTask.get());
}
// 自动关闭 scope，取消未完成的任务

// ShutdownOnSuccess：任一成功即取消其他
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
 scope.fork(() -> queryFromDB());
 scope.fork(() -> queryFromCache());
 scope.fork(() -> queryFromAPI());

 scope.join(); // 等待所有任务完成
 return scope.result(); // 返回第一个成功的结果
}

9. Generational ZGC（分代 ZGC）

Java 21 引入分代 ZGC，性能显著提升。

# 启用分代 ZGC（Java 21 中需显式开启，默认仍为非分代；分代模式自 JDK 24 起成为默认）
java -XX:+UseZGC -XX:+ZGenerational -Xmx4g MyApp

# 特点：
# - 吞吐量提升约 25%
# - 停顿时间仍然 < 1ms
# - 内存占用更低
# - 更好的大堆支持

10. 从 Java 17 迁移到 Java 21

特性	Java 17	Java 21
Record	✅	✅
Sealed Classes	✅	✅
Pattern Matching (instanceof)	✅	✅
Pattern Matching (switch)	预览	✅ 正式
Record Patterns	❌	✅
虚拟线程	预览	✅ 正式
Sequenced Collections	❌	✅
String Templates	❌	预览
Scoped Values	❌	预览
结构化并发	❌	预览
分代 ZGC	❌	✅

总结

Java 21 的核心特性：

虚拟线程 — 革命性并发模型，百万级线程不再是梦
Pattern Matching Switch — 类型匹配 + 守卫模式 + 穷举检查
Record Patterns — Record 的解构匹配
Sequenced Collections — 统一有序集合的操作
未命名变量 — 用 _ 忽略不需要的变量
分代 ZGC — 更强的低延迟垃圾收集

如果你在用 Spring Boot 3.2+/4.x，可以直接使用 Java 21。虚拟线程是最大的卖点——对于 IO 密集型服务，性能提升非常可观。

💡 Java 25 LTS 已于 2025 年 9 月发布，新增了 Scoped Values 正式版（JEP 506）、Compact Object Headers 正式版（JEP 519）等特性；Structured Concurrency 在 Java 25 中仍为预览特性（JEP 505，第五次预览）。如果是全新项目，建议直接上 Java 25。

Java 17 新特性详解：Record、Sealed Classes、Pattern Matching 与现代 Java

Thu, 25 Jun 2026 14:30:00 +0000

前言

Java 17 于 2021 年 9 月发布，是继 Java 8 和 Java 11 之后的第三个长期支持版本（LTS）。Spring Boot 3.x 最低要求 Java 17，这使得 Java 17 成为当前企业开发的主流版本。相比 Java 8，Java 17 引入了大量语法糖和现代化改进，显著提升了开发效率。

1. Record（记录类型）

Record 是一种特殊的类，专门用于存储不可变数据，自动生成 equals()、hashCode()、toString() 和 getter。

1.1 基本用法

// 定义 Record
public record Point(int x, int y) {}

// 使用
Point p = new Point(10, 20);
System.out.println(p.x()); // 10（注意：不是 getX()）
System.out.println(p.y()); // 20
System.out.println(p); // Point[x=10, y=20]

// 自动实现
p.equals(new Point(10, 20)) // true
p.hashCode() // 基于 x, y 计算

1.2 自定义方法和构造器

public record Point(int x, int y) {
 // 紧凑构造器（验证参数）
 public Point {
 if (x < 0 || y < 0) {
 throw new IllegalArgumentException("坐标不能为负数");
 }
 }

 // 自定义方法
 public double distanceTo(Point other) {
 return Math.sqrt(Math.pow(this.x - other.x, 2) + Math.pow(this.y - other.y, 2));
 }

 // 静态方法
 public static Point origin() {
 return new Point(0, 0);
 }
}

Point p1 = new Point(3, 4);
Point p2 = new Point(6, 8);
System.out.println(p1.distanceTo(p2)); // 5.0

1.3 实战场景

// DTO / VO
public record UserDTO(String name, String email, int age) {}

// API 响应
public record ApiResponse<T>(int code, String message, T data) {
 public static <T> ApiResponse<T> success(T data) {
 return new ApiResponse<>(200, "OK", data);
 }
 public static <T> ApiResponse<T> error(String message) {
 return new ApiResponse<>(500, message, null);
 }
}

// Map 的 Entry
public record KeyValue<K, V>(K key, V value) implements Map.Entry<K, V> {
 @Override
 public V setValue(V value) {
 throw new UnsupportedOperationException();
 }
}

2. Sealed Classes（密封类）

密封类限制哪些类可以继承或实现它，提供更精确的类型控制。

2.1 基本用法

// 定义密封类
public sealed class Shape permits Circle, Rectangle, Triangle {
 // 公共方法
}

// 子类必须是 final、sealed 或 non-sealed
public final class Circle extends Shape {
 double radius;
}

public final class Rectangle extends Shape {
 double width, height;
}

public non-sealed class Triangle extends Shape {
 double a, b, c;
 // non-sealed 允许任意类继承
}

2.2 与 Record 结合

// 配合 Record 实现代数数据类型（ADT）
public sealed interface Expression
 permits Number, Add, Multiply, Negate {
}

public record Number(double value) implements Expression {}
public record Add(Expression left, Expression right) implements Expression {}
public record Multiply(Expression left, Expression right) implements Expression {}
public record Negate(Expression operand) implements Expression {}

2.3 与 Pattern Matching 结合

// 模式匹配 + sealed = 穷举检查
public static double evaluate(Expression expr) {
 return switch (expr) {
 case Number n -> n.value();
 case Add a -> evaluate(a.left()) + evaluate(a.right());
 case Multiply m -> evaluate(m.left()) * evaluate(m.right());
 case Negate n -> -evaluate(n.operand());
 // 不需要 default，编译器知道已穷举所有子类
 };
}

3. Pattern Matching for instanceof

Java 14 引入、Java 16 转正。在 instanceof 判断的同时完成类型转换。

// 传统写法
if (obj instanceof String) {
 String s = (String) obj;
 System.out.println(s.length());
}

// Java 16+ 写法
if (obj instanceof String s) {
 System.out.println(s.length()); // s 已经是 String 类型
}

// 可以在条件中直接使用变量
if (obj instanceof String s && s.length() > 5) {
 System.out.println(s.toUpperCase());
}

// 在 equals 中的典型应用
@Override
public boolean equals(Object obj) {
 return this == obj
 || (obj instanceof Point p && this.x == p.x && this.y == p.y);
}

4. Text Blocks（文本块）

Java 15 转正。多行字符串不再需要转义和拼接。

// 传统写法
String json = "{\n" +
 " \"name\": \"Alice\",\n" +
 " \"age\": 30\n" +
 "}";

// Text Block 写法
String json = """
 {
 "name": "Alice",
 "age": 30
 }
 """;

// SQL
String sql = """
 SELECT u.name, u.email, o.total
 FROM users u
 JOIN orders o ON u.id = o.user_id
 WHERE u.status = 'ACTIVE'
 ORDER BY o.created_at DESC
 """;

// HTML
String html = """
 <html>
 <body>
 <h1>Hello, World!</h1>
 </body>
 </html>
 """;

// 支持格式化占位符
String greeting = """
 Hello, %s!
 Welcome to %s.
 """.formatted("Alice", "Java 17");

// 行尾空格处理
String text = """
 Line 1 \s
 Line 2 \s
 """;

5. Switch 表达式

Java 14 转正。Switch 不仅是语句，还可以是表达式。

// 传统写法
String result;
switch (day) {
 case MONDAY:
 case FRIDAY:
 case SUNDAY:
 result = "好好工作";
 break;
 case TUESDAY:
 result = "继续努力";
 break;
 default:
 result = "未知";
 break;
}

// Switch 表达式
String result = switch (day) {
 case MONDAY, FRIDAY, SUNDAY -> "好好工作";
 case TUESDAY -> "继续努力";
 case WEDNESDAY, THURSDAY -> "快到周末了";
 case SATURDAY -> "休息日";
};

// yield 返回值（多行时使用）
int numLetters = switch (day) {
 case MONDAY, FRIDAY, SUNDAY -> {
 System.out.println("工作日");
 yield 6;
 }
 case TUESDAY -> {
 System.out.println("又是工作日");
 yield 7;
 }
 default -> {
 String s = day.toString();
 yield s.length();
 }
};

// 穷举检查（配合 enum 或 sealed class）
// 不需要 default，编译器会检查是否覆盖所有情况

6. 新的 HttpClient API

Java 11 引入、Java 15 完善。替代老旧的 HttpURLConnection。

HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

// GET 请求
HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create("https://api.example.com/users"))
 .header("Accept", "application/json")
 .GET()
 .build();

// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());

// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
 .thenApply(HttpResponse::body)
 .thenAccept(System.out::println)
 .join();

// POST JSON
HttpRequest postRequest = HttpRequest.newBuilder()
 .uri(URI.create("https://api.example.com/users"))
 .header("Content-Type", "application/json")
 .POST(HttpRequest.BodyPublishers.ofString("""
 {"name": "Alice", "age": 30}
 """))
 .build();

// POST 文件
HttpRequest fileRequest = HttpRequest.newBuilder()
 .uri(URI.create("https://api.example.com/upload"))
 .POST(HttpRequest.BodyPublishers.ofFile(Path.of("file.txt")))
 .build();

7. 其他重要特性

7.1 instanceof 模式的反模式

// 不推荐：多余的变量作用域
if (obj instanceof String s) {
 // s 可用
} else {
 // s 不可用
 // 如果在 else 中使用 s 会编译错误
}

// 推荐：在最窄的作用域中使用

7.2 NullPointerException 增强消息

# Java 14+ 增强了 NPE 的错误信息
# 之前: Cannot invoke method on null
# 之后: Cannot invoke "String.length()" because the return value of "User.getName()" is null

# 启用（默认开启）
-XX:+ShowCodeDetailsInExceptionMessages

7.3 强封装 JDK 内部 API

// Java 17 默认禁止反射访问 JDK 内部 API
// 如果必须使用，需要添加 JVM 参数：
// --add-opens java.base/java.lang=ALL-UNNAMED
// --add-opens java.base/sun.nio.ch=ALL-UNNAMED

7.4 新的随机数生成器 API

// Java 17 引入了 RandomGenerator 接口
RandomGenerator generator = RandomGeneratorFactory.of("L128X1024MixRandom").create();
int random = generator.nextInt(100);

// 获取所有可用算法
RandomGeneratorFactory.all()
 .map(f -> f.name() + " (" + f.group() + ")")
 .forEach(System.out::println);

7.5 ZGC（生产就绪）

# Java 15 转正的低延迟垃圾收集器
java -XX:+UseZGC -Xmx4g MyApp

# 特点：
# - 停顿时间 < 1ms（不随堆大小增长）
# - 支持 TB 级堆
# - 吞吐量下降不超过 15%

7.6 Shenandoah GC（生产就绪）

# Java 15 转正
java -XX:+UseShenandoahGC -Xmx4g MyApp

# 特点：
# - 与 ZGC 类似的低延迟
# - 更早进入生产就绪状态
# - 适合对延迟敏感的应用

8. 从 Java 8 迁移到 Java 17

8.1 主要变化清单

变化	说明
删除 `--release 8` 兼容性	确保代码不使用已删除的 API
删除 `javax.*` 包	部分迁移到 `jakarta.*`（EE 相关）
强封装内部 API	`sun.misc.*` 等不再可直接访问
Nashorn 移除	Java 15 移除了 JavaScript 引擎
安全管理器弃用	`SecurityManager` 将在未来版本移除

8.2 迁移检查清单

# 1. 编译检查
javac --release 17 YourClass.java

# 2. 检查对 JDK 内部 API 的非法访问（如有反射访问内部 API，运行时会报警告或异常）
# 注意：--illegal-access 选项自 JDK 17 起已失效（JEP 403 强封装），改用下列方式按需开放
java --add-opens java.base/java.lang=ALL-UNNAMED -jar app.jar

# 3. 依赖检查
# Spring Boot 3.x 需要 Java 17
# 检查所有第三方库是否支持 Java 17

# 4. JVM 参数调整
# 移除已废弃的 GC 参数
# 更新反射访问参数

8.3 Spring Boot 3.x 迁移

<!-- pom.xml -->
<properties>
 <java.version>17</java.version>
</properties>

<!-- jakarta 命名空间迁移 -->
<!-- javax.servlet.* → jakarta.servlet.* -->
<!-- javax.persistence.* → jakarta.persistence.* -->

9. 版本对比

特性	Java 8	Java 17
Lambda/Stream	✅	✅
Optional	✅	✅
新日期 API	✅	✅
Record	❌	✅
Sealed Classes	❌	✅
Pattern Matching	❌	✅
Text Blocks	❌	✅
Switch 表达式	❌	✅
新 HttpClient	❌	✅
ZGC/Shenandoah	❌	✅ (生产就绪)
LTS 支持截止	Extended 2030 年	Premier 2026.9，Extended 2029.9

总结

Java 17 的核心特性：

Record — 不可变数据类的简洁声明，自动生成样板代码
Sealed Classes — 限制类的继承层次，配合 switch 实现穷举检查
Pattern Matching — instanceof + 类型转换一步到位
Text Blocks — 多行字符串不再痛苦
Switch 表达式 — 更简洁、更安全的 switch
新 HttpClient — 现代化的 HTTP 客户端
ZGC/Shenandoah — 低延迟垃圾收集器正式可用

如果你的项目还在 Java 8，现在是升级到 Java 17 的好时机。Spring Boot 3.x/4.x、Spring Cloud 2022+ 都要求 Java 17 最低版本。

⚠️ 注意：Java 17 Premier Support 将于 2026 年 9 月 到期，建议新项目直接使用 Java 21 或 Java 25 LTS。