diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000..7d05e99
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,10 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
+# 基于编辑器的 HTTP 客户端请求
+/httpRequests/
+# 依赖于环境的 Maven 主目录路径
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/AugmentWebviewStateStore.xml b/.idea/AugmentWebviewStateStore.xml
new file mode 100644
index 0000000..20eae4a
--- /dev/null
+++ b/.idea/AugmentWebviewStateStore.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/JavaHome.iml b/.idea/JavaHome.iml
new file mode 100644
index 0000000..d6ebd48
--- /dev/null
+++ b/.idea/JavaHome.iml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000..ee9f695
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,68 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..31e1ebc
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..f8fcfea
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..8306744
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java10\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java10\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..25c959b
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java10\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,60 @@
+# Java 10 新特性
+
+Java 10 于 2018 年 3 月发布，是 Java 采用新的、更快的半年发布周期后的第一个版本。它带来了一些实用的新功能，其中最著名的是局部变量类型推断。
+
+## 1. 局部变量类型推断 (Local-Variable Type Inference)
+
+这是 Java 10 最核心的特性。通过使用 `var` 关键字，可以让编译器推断出局部变量的类型，从而简化代码。
+
+- **目的**：减少样板代码，提高代码的可读性。
+- **注意**：`var` 只能用于局部变量（方法内、循环中等），不能用于成员变量、方法参数或返回类型。
+
+**使用前：**
+```java
+String message = "Hello, Java 10!";
+ArrayList list = new ArrayList();
+```
+
+**使用后：**
+```java
+var message = "Hello, Java 10!"; // 推断为 String
+var list = new ArrayList(); // 推断为 ArrayList
+
+for (var item : list) {
+ System.out.println(item); // item 推断为 String
+}
+```
+
+## 2. 不可变集合的增强
+
+`List`, `Set`, `Map` 接口新增了 `copyOf`静态方法，用于创建一个不可修改的集合副本。
+
+```java
+var originalList = new ArrayList();
+originalList.add("a");
+originalList.add("b");
+
+// 创建一个不可修改的副本
+var copy = List.copyOf(originalList);
+
+// 尝试修改副本会导致 UnsupportedOperationException
+// copy.add("c");
+```
+
+## 3. `Optional` 的 `orElseThrow()` 方法
+
+`Optional` 类新增了 `orElseThrow()` 方法。当 `Optional` 为空时，它会抛出 `NoSuchElementException`。这与 `get()` 方法的行为完全相同，但方法名更能体现其作用。
+
+```java
+// 如果 Optional 为空，则抛出 NoSuchElementException
+var value = optional.orElseThrow();
+```
+
+## 4. 垃圾收集器 (GC) 改进
+
+- **G1 垃圾收集器的并行 Full GC**：在之前的版本中，G1 的 Full GC 是单线程的，可能导致较长的停顿。Java 10 将其改为了多线程，从而减少了最坏情况下的停顿时间。
+- **垃圾收集器接口 (GC Interface)**：引入了一个干净的 GC 接口，使得在 JVM 中集成新的垃圾收集器变得更加容易。
+
+## 5. 应用类数据共享 (Application Class-Data Sharing)
+
+扩展了现有的类数据共享（CDS）功能，允许将应用程序的类也包含在共享归档中。这可以减少多个 JVM 实例之间的内存占用，并缩短启动时间。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java11\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java11\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..90ce0bb
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java11\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,100 @@
+# Java 11 (LTS) 新特性
+
+Java 11 于 2018 年 9 月发布，是一个长期支持（LTS）版本。它带来了许多实用的 API 增强和一些重要的平台更新。
+
+## 1. 标准化的 HTTP Client API
+
+在 Java 9 和 10 中作为孵化功能的 HTTP Client API，在 Java 11 中被正式标准化。它位于 `java.net.http` 包中，提供了对 HTTP/1.1 和 HTTP/2 的支持，并完全取代了旧的 `HttpURLConnection`。
+
+- **核心类**：`HttpClient`, `HttpRequest`, `HttpResponse`。
+- **特点**：支持同步和异步操作，使用 `CompletableFuture` 处理异步请求。
+
+**示例：发送一个 GET 请求**
+```java
+var client = HttpClient.newHttpClient();
+var request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.github.com/"))
+ .build();
+
+// 异步方式
+client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
+ .thenApply(HttpResponse::body)
+ .thenAccept(System.out::println)
+ .join();
+
+// 同步方式
+// HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
+// System.out.println(response.body());
+```
+
+## 2. String 类的增强
+
+`String` 类增加了几个非常方便的新方法：
+
+- **`isBlank()`**: 判断字符串是否为空白（只包含空格、制表符等）。
+- **`lines()`**: 将字符串按行分隔符转换为一个 `Stream`。
+- **`strip()`**, **`stripLeading()`**, **`stripTrailing()`**: 去除字符串首尾或单边的空白字符，功能比 `trim()` 更强大，能识别 Unicode 空白字符。
+- **`repeat(int)`**: 将字符串重复指定的次数。
+
+```java
+// isBlank
+System.out.println(" \t ".isBlank()); // true
+
+// lines
+"Hello\nWorld".lines().forEach(System.out::println);
+
+// strip
+String s = "\u2005 Hello \u2005"; // \u2005 是一个 Unicode 空白符
+System.out.println("'" + s.trim() + "'"); // ' Hello '
+System.out.println("'" + s.strip() + "'"); // 'Hello'
+
+// repeat
+System.out.println("Java ".repeat(3)); // "Java Java Java "
+```
+
+## 3. 直接运行单个 Java 源文件
+
+从 Java 11 开始，你可以直接使用 `java` 命令来运行一个单个的 `.java` 源文件，无需先手动使用 `javac` 编译。
+
+```bash
+# 创建一个 HelloWorld.java 文件
+# public class HelloWorld {
+# public static void main(String[] args) {
+# System.out.println("Hello, Java 11!");
+# }
+# }
+
+# 直接运行
+$ java HelloWorld.java
+Hello, Java 11!
+```
+
+## 4. Lambda 参数的局部变量类型推断
+
+`var` 关键字现在可以用于 Lambda 表达式的参数声明中。这在需要给参数添加注解时非常有用。
+
+```java
+// Java 10 中不允许
+// (var x, var y) -> x.process(y)
+
+// Java 11 中允许
+Predicate predicate = (@Nonnull var s) -> s.length() > 0;
+```
+
+## 5. 文件读写 API 增强
+
+`java.nio.file.Files` 类增加了 `writeString()` 和 `readString()` 方法，可以更方便地读写文件内容。
+
+```java
+Path path = Files.writeString(Files.createTempFile("test", ".txt"), "Hello, world!");
+String content = Files.readString(path);
+System.out.println(content); // Hello, world!
+```
+
+## 6. ZGC (Z Garbage Collector)
+
+引入了 ZGC，这是一个可伸缩的、低延迟的垃圾收集器，作为一项实验性功能。它的设计目标是将 GC 停顿时间控制在 10ms 以内，即使是对于非常大的堆（TB 级别）。
+
+## 7. 移除 Java EE 和 CORBA 模块
+
+Java 11 从 JDK 中移除了过去被废弃的 Java EE 和 CORBA 模块（例如 `java.xml.ws`, `java.corba`）。如果你的应用需要这些模块，必须从外部库（如 Maven Central）中添加依赖。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java12\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java12\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..bbd32ae
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java12\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,91 @@
+# Java 12 新特性
+
+Java 12 于 2019 年 3 月发布。它引入了一些预览功能和 API 增强，其中最受关注的是 Switch 表达式的预览。
+
+## 1. Switch 表达式 (Switch Expressions - 预览功能)
+
+Java 12 首次引入了 Switch 表达式作为预览功能，极大地增强了 `switch` 语句的能力。
+
+- **目的**：简化 `switch` 结构，使其可以作为表达式返回值，避免了繁琐的 `break` 和临时变量。
+- **新语法**：使用 `case L -> ...` 标签，无需 `break`，并且可以保证穷尽所有可能的情况。
+
+**传统 `switch` 语句：**
+```java
+String dayName;
+switch (day) {
+ case MONDAY:
+ case FRIDAY:
+ case SUNDAY:
+ dayName = "Work Day";
+ break;
+ case TUESDAY:
+ dayName = "Rest Day";
+ break;
+ default:
+ dayName = "Unknown";
+}
+```
+
+**使用 Switch 表达式 (Java 12 预览版)：**
+```java
+String dayName = switch (day) {
+ case MONDAY, FRIDAY, SUNDAY -> "Work Day";
+ case TUESDAY -> "Rest Day";
+ default -> "Unknown";
+};
+```
+
+## 2. Shenandoah: 低暂停时间的垃圾收集器 (实验性)
+
+引入了一个新的垃圾收集器 Shenandoah，其主要目标是通过与正在运行的 Java 线程同时执行更多的 GC 工作来减少 GC 暂停时间。这对于需要低延迟和高响应性的应用程序特别有价值。
+
+## 3. `String` 类的新方法
+
+`String` 类增加了两个有用的方法：`indent()` 和 `transform()`。
+
+- **`indent(int n)`**: 对字符串进行缩进。如果 `n` > 0，则在每行开头添加 `n` 个空格；如果 `n` < 0，则尝试从每行开头删除最多 `|n|` 个空格。
+- **`transform(Function)`**: 将一个函数应用于字符串，可以方便地进行链式转换。
+
+```java
+// indent
+String text = "Hello\nWorld";
+System.out.println(text.indent(2));
+// 输出:
+// Hello
+// World
+
+// transform
+String result = "12345".transform(s -> new StringBuilder(s).reverse().toString());
+System.out.println(result); // "54321"
+```
+
+## 4. `Files.mismatch()` 方法
+
+`java.nio.file.Files` 中添加了 `mismatch()` 方法，用于比较两个文件的内容是否相同。它会返回第一个不匹配字节的位置，如果文件内容完全相同，则返回 -1L。
+
+```java
+Path path1 = Files.createTempFile("file1", ".txt");
+Path path2 = Files.createTempFile("file2", ".txt");
+Files.writeString(path1, "Java 12");
+Files.writeString(path2, "Java 12");
+
+long mismatch = Files.mismatch(path1, path2);
+System.out.println(mismatch); // -1 (文件内容相同)
+```
+
+## 5. Teeing Collector
+
+Stream API 增加了一个新的收集器 `Collectors.teeing()`。它可以将一个流的元素同时传递给两个下游收集器，然后将它们的结果合并成一个最终结果。
+
+**示例：计算平均值**
+```java
+// 计算流中数字的总和和计数，然后计算平均值
+double average = Stream.of(1, 2, 3, 4, 5)
+ .collect(Collectors.teeing(
+ Collectors.summingDouble(i -> i), // 第一个收集器：求和
+ Collectors.counting(), // 第二个收集器：计数
+ (sum, count) -> sum / count // 合并函数
+ ));
+
+System.out.println(average); // 3.0
+```
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java13\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java13\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..1bb3730
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java13\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,63 @@
+# Java 13 新特性
+
+Java 13 于 2019 年 9 月发布。此版本对 Java 12 引入的一些预览功能进行了改进，并重新实现了一些底层 API。
+
+## 1. 文本块 (Text Blocks - 预览功能)
+
+Java 13 引入了文本块作为一项预览功能，旨在简化多行字符串的编写。
+
+- **目的**：避免在字符串中大量使用转义字符（如 `\n`），使 SQL、JSON、HTML 等嵌入代码更易于读写。
+- **语法**：使用三个双引号 `"""` 作为开始和结束分隔符。
+
+**传统方式：**
+```java
+String html = "\n" +
+ " \n" +
+ " Hello, World
\n" +
+ " \n" +
+ "\n";
+```
+
+**使用文本块：**
+```java
+String html = """
+
+
+ Hello, World
+
+
+ """;
+```
+
+## 2. Switch 表达式增强 (预览功能)
+
+Java 12 的 Switch 表达式在 Java 13 中得到了改进。最主要的变化是引入了 `yield` 关键字，用于从 `switch` 表达式中返回一个值，以替代之前的 `break` 用法。
+
+```java
+String text = switch (day) {
+ case MONDAY:
+ case FRIDAY:
+ case SUNDAY:
+ yield "Work Day";
+ case TUESDAY:
+ yield "Rest Day";
+ default:
+ yield "Unknown";
+};
+```
+
+**注意**：在 Java 14 中，`yield` 被最终确定下来，而 `break` 的返回值方式被移除。
+
+## 3. 重新实现旧版 Socket API
+
+`java.net.Socket` 和 `java.net.ServerSocket` 的底层实现被替换为一个更现代化、更易于维护和调试的实现。这个变化对开发者是透明的，旧的代码无需修改即可运行。
+
+- **目的**：消除历史遗留的技术债，为未来的网络编程（如 Project Loom 的虚拟线程）提供更好的基础。
+
+## 4. ZGC: 取消提交未使用的内存
+
+ZGC 垃圾收集器得到了增强，现在可以将未使用的堆内存返还给操作系统。这对于需要关心内存占用的云原生和容器化环境非常有用。
+
+## 5. 动态 CDS 归档 (Dynamic CDS Archives)
+
+在 Java 10 引入的应用类数据共享（AppCDS）基础上进行了扩展。现在，可以在应用程序执行结束时动态生成共享归档，简化了 AppCDS 的使用流程。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java14\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java14\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..4005139
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java14\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,107 @@
+# Java 14 新特性
+
+Java 14 于 2020 年 3 月发布。此版本将之前的一些预览功能转正，并引入了像 Records 这样的重量级新预览功能。
+
+## 1. Switch 表达式 (标准版)
+
+在经过 Java 12 和 13 两轮预览后，Switch 表达式在 Java 14 中被正式确定下来。
+
+- **最终语法**：使用 `case L -> ...` 的箭头语法，或者在代码块中使用 `yield` 关键字返回值。
+
+```java
+int numLetters = switch (day) {
+ case MONDAY, FRIDAY, SUNDAY -> 6;
+ case TUESDAY -> 7;
+ case THURSDAY, SATURDAY -> 8;
+ case WEDNESDAY -> 9;
+ default -> {
+ System.out.println("Invalid day");
+ yield 0;
+ }
+};
+```
+
+## 2. Records (预览功能)
+
+Java 14 引入了 `record` 关键字作为预览功能，旨在创建不可变的数据聚合类（Data Carrier）。
+
+- **目的**：极大地减少创建 POJO (Plain Old Java Object) 所需的样板代码。
+- **自动生成**：编译器会自动为 `record` 生成构造函数、`equals()`, `hashCode()`, `toString()` 以及字段的 `getter` 方法。
+
+**传统方式：**
+```java
+// 需要手动编写构造函数、getter、equals、hashCode、toString
+class Point {
+ private final int x;
+ private final int y;
+ // ... 大量样板代码
+}
+```
+
+**使用 Record：**
+```java
+// 一行代码即可
+public record Point(int x, int y) {}
+
+// 使用
+var point = new Point(1, 2);
+System.out.println(point.x()); // 访问器方法，不是 getX()
+System.out.println(point); // Point[x=1, y=2]
+```
+
+## 3. 更实用的 NullPointerExceptions
+
+JVM 改进了 `NullPointerException` 的提示信息，可以精确地指出哪个变量是 `null`，极大地提高了调试效率。
+
+**示例代码：**
+```java
+a.b.c.doSomething();
+```
+
+**Java 14 之前的异常信息：**
+```
+Exception in thread "main" java.lang.NullPointerException
+ at MyClass.main(MyClass.java:10)
+```
+
+**Java 14 之后的异常信息：**
+```
+Exception in thread "main" java.lang.NullPointerException:
+ Cannot read field "c" because "a.b" is null
+ at MyClass.main(MyClass.java:10)
+```
+
+## 4. instanceof 的模式匹配 (预览功能)
+
+简化了 `instanceof` 的使用，允许在检查类型的同时声明一个绑定变量，避免了显式的类型转换。
+
+**传统方式：**
+```java
+if (obj instanceof String) {
+ String s = (String) obj;
+ System.out.println(s.toUpperCase());
+}
+```
+
+**使用模式匹配：**
+```java
+if (obj instanceof String s) { // s 在 if 块内可用
+ System.out.println(s.toUpperCase());
+}
+```
+
+## 5. 文本块功能增强
+
+文本块（在 Java 13 中预览）增加了两个新的转义序列：
+
+- **`\` (反斜杠)**：用于在行尾取消换行符，可以将多行写成一行。
+- **`\s`**: 表示一个单个的空格。
+
+```java
+String text = """
+ line 1 \
+ line 2 \
+ line 3
+ """;
+// 实际内容是 "line 1 line 2 line 3"
+```
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java15\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java15\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..d798292
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java15\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,68 @@
+# Java 15 新特性
+
+Java 15 于 2020 年 9 月发布。它带来了新的预览功能，如密封类，并让一些重要的功能（如 ZGC）进入了生产就绪阶段。
+
+## 1. 密封类 (Sealed Classes - 预览功能)
+
+密封类和接口用于限制哪些其他类或接口可以扩展或实现它们。
+
+- **目的**：为类库作者提供更精细的控制，允许对类层次结构进行建模，这在模式匹配中特别有用。
+- **关键字**：`sealed`, `permits`, `non-sealed`。
+
+**示例：**
+```java
+// Shape 接口只允许 Circle 和 Square 实现
+public sealed interface Shape permits Circle, Square {
+ double area();
+}
+
+// final class, 终止继承
+public final class Circle implements Shape {
+ public final double radius;
+ public Circle(double radius) { this.radius = radius; }
+ public double area() { return Math.PI * radius * radius; }
+}
+
+// non-sealed class, 允许任何类继承它
+public non-sealed class Square implements Shape {
+ public final double side;
+ public Square(double side) { this.side = side; }
+ public double area() { return side * side; }
+}
+
+// 由于 Square 是 non-sealed, 任何类都可以继承它
+public class SpecialSquare extends Square {
+ public SpecialSquare(double side) { super(side); }
+}
+```
+
+## 2. Records (第二次预览) & instanceof 模式匹配 (第二次预览)
+
+在 Java 14 中引入的 Records 和 `instanceof` 模式匹配在 Java 15 中进入了第二次预览。它们的功能基本保持不变，主要是根据社区反馈进行了一些微调，为最终定稿做准备。
+
+## 3. 文本块 (标准版)
+
+经过两轮预览，文本块在 Java 15 中被正式确定下来，成为标准功能。现在可以放心在生产代码中使用多行字符串了。
+
+```java
+String json = """
+ {
+ "name": "John Doe",
+ "age": 30
+ }
+ """;
+```
+
+## 4. ZGC 和 Shenandoah 垃圾收集器 (生产就绪)
+
+在之前版本中作为实验性或预览功能的 ZGC 和 Shenandoah 低延迟垃圾收集器，在 Java 15 中被标记为生产就绪（Production Ready）。这意味着它们已经足够稳定，可以在生产环境中使用。
+
+## 5. 隐藏类 (Hidden Classes)
+
+这是一个主要面向框架和工具开发者的功能。隐藏类是一种不能被其他类的字节码直接使用的类。它们只能通过反射被发现和使用。
+
+- **目的**：允许框架在运行时生成和加载类，而不会污染应用程序的类命名空间，并且可以独立卸载，从而减少内存占用。
+
+## 6. 移除 Nashorn JavaScript 引擎
+
+在 Java 11 中被标记为废弃的 Nashorn JavaScript 引擎及其相关 API，在 Java 15 中被正式移除。如果需要，可以考虑使用 GraalVM 等替代方案。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java16\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java16\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..7113efd
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java16\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,57 @@
+# Java 16 新特性
+
+Java 16 于 2021 年 3 月发布。此版本将 Java 14 和 15 中广受欢迎的几个预览功能（如 Records 和模式匹配）正式确定下来。
+
+## 1. Records (标准版)
+
+经过两轮预览，Records 在 Java 16 中被正式确定下来。现在，你可以放心地在生产代码中使用 `record` 来定义不可变的数据载体类，从而极大地减少样板代码。
+
+```java
+// Records 已成为标准功能
+public record Point(int x, int y) {}
+```
+
+## 2. instanceof 的模式匹配 (标准版)
+
+`instanceof` 的模式匹配也在此版本中被正式确定下来。这使得类型检查和转换的代码更加简洁和安全。
+
+```java
+// 模式匹配已成为标准功能
+Object obj = "Hello, Java 16";
+if (obj instanceof String s) {
+ // s可以直接使用，无需强制转换
+ System.out.println(s.length());
+}
+```
+
+## 3. 密封类 (第二次预览)
+
+密封类（Sealed Classes）在 Java 16 中进入了第二次预览。根据社区的反馈进行了一些改进，例如放宽了对 `sealed` 类所在包的限制。
+
+## 4. Vector API (孵化器)
+
+引入了一个新的 Vector API 作为孵化功能。这个 API 旨在提供一种表达向量计算的方式，这些计算在运行时可以可靠地编译为 CPU 架构上的最佳向量指令（如 SIMD 指令），从而获得优于等效标量计算的性能。
+
+```java
+// 示例：使用 Vector API 对两个数组进行求和
+// int[] a = { ... };
+// int[] b = { ... };
+// int[] c = new int[a.length];
+// var SPECIES = IntVector.SPECIES_PREFERRED;
+//
+// for (int i = 0; i < a.length; i += SPECIES.length()) {
+// var mask = SPECIES.indexInRange(i, a.length);
+// var va = IntVector.fromArray(SPECIES, a, i, mask);
+// var vb = IntVector.fromArray(SPECIES, b, i, mask);
+// var vc = va.add(vb);
+// vc.intoArray(c, i, mask);
+// }
+```
+
+## 5. 默认启用 C++14 语言特性
+
+在 JVM 的 C++ 源代码中，现在可以使用 C++14 版本的语言特性。这对 Java 开发者是透明的，但有助于 JVM 开发人员利用更现代的 C++ 特性来改进和维护 JVM。
+
+## 6. 将 JDK 移植到 Alpine Linux
+
+JDK 被成功移植到使用 musl 作为主要 C 库的 Alpine Linux 以及其他 Linux 发行版上。这对于构建轻量级容器镜像非常重要，因为 Alpine Linux 是容器化环境中的热门选择。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java17\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java17\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..0388b7d
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java17\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,64 @@
+# Java 17 (LTS) 新特性
+
+Java 17 于 2021 年 9 月发布，是继 Java 11 之后的又一个长期支持（LTS）版本。它将一些重要的预览功能（如密封类）转正，并带来了对未来 Java 编程风格有深远影响的新预览功能。
+
+## 1. 密封类 (Sealed Classes - 标准版)
+
+经过两轮预览，密封类在 Java 17 中被正式确定下来。它允许库作者精确控制哪些类可以继承或实现一个 `sealed` 的类或接口，这对于构建安全的、可预测的 API 非常重要。
+
+```java
+// Sealed Classes 已成为标准功能
+public sealed interface Shape permits Circle, Rectangle {}
+
+public final class Circle implements Shape {}
+public final class Rectangle implements Shape {}
+```
+
+## 2. Switch 的模式匹配 (预览功能)
+
+这是 Java 17 中最令人兴奋的预览功能。它极大地增强了 `switch` 语句，使其可以对类型进行匹配，并安全地执行类型转换。
+
+- **目的**：简化复杂的、基于类型的条件判断，使代码更具可读性和安全性。
+
+**传统方式：**
+```java
+static double getArea(Shape shape) {
+ if (shape instanceof Circle c) {
+ return Math.PI * c.radius() * c.radius();
+ } else if (shape instanceof Rectangle r) {
+ return r.length() * r.width();
+ } else {
+ throw new IllegalArgumentException("Unknown shape");
+ }
+}
+```
+
+**使用 Switch 模式匹配：**
+```java
+static double getArea(Shape shape) {
+ return switch (shape) {
+ // case 后面直接跟类型和变量名
+ case Circle c -> Math.PI * c.radius() * c.radius();
+ case Rectangle r -> r.length() * r.width();
+ // default 分支处理其他情况
+ default -> throw new IllegalArgumentException("Unknown shape
+");
+ };
+}
+```
+
+## 3. 外部函数和内存 API (孵化器)
+
+引入了一个新的 API，旨在替代老旧且脆弱的 JNI (Java Native Interface)。这个 API 提供了一种更安全、更高效的方式来调用 Java 运行时之外的本地代码（如 C 库）和操作本地内存。
+
+## 4. 强封装 JDK 内部 API
+
+从 Java 9 开始，JDK 就试图限制对内部 API 的访问。在 Java 17 中，这一限制变得更加严格。默认情况下，无法再通过反射等“黑客”手段访问 JDK 的内部模块，除非通过特定的命令行参数显式授权。这有助于提高平台的安全性和可维护性。
+
+## 5. 移除 RMI 激活机制
+
+远程方法调用（RMI）的激活机制（Activation）是一个过时且很少使用的功能，已在此版本中被正式移除。
+
+## 6. 废弃 Applet API
+
+古老的 Applet API 在此版本中被正式标记为“废弃，并准备在未来移除”。这标志着 Applet 技术时代的终结。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java18\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java18\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..d8f22c5
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java18\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,49 @@
+# Java 18 新特性
+
+Java 18 于 2022 年 3 月发布。此版本带来了一个非常实用的开箱即用工具，并继续推进了多个重要的孵化和预览功能。
+
+## 1. 默认编码为 UTF-8
+
+这是一个重要的全局性变更。从 Java 18 开始，所有标准的 Java API 都将默认使用 UTF-8 编码，而不再依赖于操作系统、用户语言环境等外部因素。这解决了长期以来困扰开发者的编码不一致问题，大大提高了跨平台开发的可靠性。
+
+## 2. 简单的 Web 服务器
+
+JDK 内置了一个开箱即用的、最小化的静态 HTTP 文件服务器。它不是为了在生产环境替代 Tomcat、Jetty 等服务器，而是为了在开发、测试和教学场景中快速启动一个服务来共享文件。
+
+**启动一个服务器：**
+```bash
+# 在你的项目目录下运行
+# 默认监听 8000 端口
+$ jwebserver
+
+# 也可以指定端口和目录
+$ jwebserver -p 8080 -d /path/to/files
+```
+
+## 3. Java API 文档中的代码片段
+
+这是一个针对文档工具 (Javadoc) 的改进。现在可以使用 `@snippet` 标签在 API 文档中包含更丰富、更健壮的示例代码。这使得示例代码更容易被验证、高亮和维护。
+
+## 4. Switch 的模式匹配 (第二次预览)
+
+Java 17 引入的 Switch 模式匹配在此版本中进入了第二次预览。主要根据社区反馈进行了一些改进，例如在处理 `null` 情况时更加完善。
+
+```java
+static String formatter(Object o) {
+ return switch (o) {
+ case Integer i -> String.format("int %d", i);
+ case Long l -> String.format("long %d", l);
+ // ...
+ case null -> "null"; // 可以直接处理 null case
+ default -> o.toString();
+ };
+}
+```
+
+## 5. 外部函数和内存 API (第二次孵化)
+
+这个旨在替代 JNI 的 API 在此版本中进入了第二次孵化，API 设计上有了显著的改进，使其更加易用和强大。
+
+## 6. Vector API (第三次孵化)
+
+用于高性能向量计算的 Vector API 也进入了第三次孵化阶段，继续根据反馈进行完善。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java19\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java19\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..3ad93aa
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java19\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,74 @@
+# Java 19 新特性
+
+Java 19 于 2022 年 9 月发布。此版本带来了 Java 平台一个里程碑式的预览功能：虚拟线程（Virtual Threads），它有望彻底改变 Java 的并发编程模型。
+
+## 1. 虚拟线程 (Virtual Threads - 预览功能)
+
+虚拟线程是 Project Loom 的核心成果。它是一种轻量级的线程，由 JVM 管理，而不是直接映射到操作系统线程。
+
+- **目的**：极大地提高高吞吐量并发应用程序的性能和可伸缩性。开发者可以用传统的“一个请求一个线程”的同步阻塞式代码，来达到异步非阻塞代码的性能。
+- **特点**：创建成本极低，可以轻松创建数百万个虚拟线程。
+
+**创建和使用虚拟线程：**
+```java
+// 直接创建并启动
+Thread.startVirtualThread(() -> {
+ System.out.println("Hello from a virtual thread!");
+});
+
+// 使用 Executors 创建
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+ Future future = executor.submit(() -> System.out.println("Running in a virtual thread"));
+ future.get();
+}
+```
+
+## 2. 结构化并发 (Structured Concurrency - 孵化功能)
+
+这是一个新的并发编程模型，旨在简化多线程错误处理和任务协调。它将并发任务的生命周期视为一个单元，如果一个子任务失败，整个任务组可以被可靠地取消。
+
+```java
+// 示例：使用 StructuredTaskScope
+// try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+// Future user = scope.fork(() -> findUser());
+// Future order = scope.fork(() -> fetchOrder());
+//
+// scope.join(); // 等待所有子任务完成
+// scope.throwIfFailed(); // 如果有任何子任务失败，则抛出异常
+//
+// // 两个任务都成功后，处理结果
+// String userInfo = user.resultNow();
+// int orderInfo = order.resultNow();
+// // ...
+// }
+```
+
+## 3. Record 模式 (Record Patterns - 预览功能)
+
+扩展了模式匹配，使其可以用于解构 `record` 类型。这在 `instanceof` 和 `switch` 语句中非常有用。
+
+**使用 Record 模式：**
+```java
+public record Point(int x, int y) {}
+
+static void printSum(Object obj) {
+ // 检查 obj 是否是 Point，如果是，则将其 x 和 y 解构到变量 ix 和 iy
+ if (obj instanceof Point(int ix, int iy)) {
+ System.out.println(ix + iy);
+ }
+}
+
+// 也可以与 switch 模式匹配结合使用
+// switch (obj) {
+// case Point(int x, int y) -> System.out.printf("Point at %d, %d%n", x, y);
+// ...
+// }
+```
+
+## 4. Switch 的模式匹配 (第三次预览)
+
+Switch 模式匹配在此版本中进入了第三次预览，继续根据反馈进行改进，例如增加了对 `when` 子句的支持，用于更复杂的条件判断。
+
+## 5. 外部函数和内存 API (第二次预览)
+
+此 API 在 Java 19 中进入了第二次预览阶段（注意：Java 18 是第二次孵化，Java 19 是第二次预览），API 设计更加精炼，朝着最终定稿又迈进了一步。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java20\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java20\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..d2b5513
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java20\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,41 @@
+# Java 20 新特性
+
+Java 20 于 2023 年 3 月发布。此版本的主要工作是继续推进和完善在 Java 19 中引入的多个重要预览和孵化功能。
+
+## 1. 虚拟线程 (Virtual Threads - 第二次预览)
+
+虚拟线程在此版本中进入了第二次预览。API 方面没有重大变化，主要是根据社区反馈进行了一些小的改进和错误修复，使其更加稳定和可靠。
+
+## 2. 结构化并发 (Structured Concurrency - 第二次孵化)
+
+结构化并发在此版本中进入了第二次孵化。一个重要的变化是 `StructuredTaskScope` 进行了更新，可以支持在任务作用域内跨线程继承作用域值（Scoped Values），这对于在并发任务之间传递上下文信息非常有用。
+
+## 3. 作用域值 (Scoped Values - 孵化功能)
+
+这是一个新的孵化功能，旨在提供一种在线程内部以及线程之间共享不可变数据的现代化方法，尤其是在使用虚拟线程时。
+
+- **目的**：替代 `ThreadLocal`，特别是在虚拟线程场景下。`ThreadLocal` 在虚拟线程环境下存在一些问题（如内存泄漏风险、数据继承成本高）。
+- **特点**：数据是不可变的，并且只在特定的代码作用域内有效，可以安全地跨线程传递。
+
+```java
+// public final static ScopedValue LOGGED_IN_USER = ScopedValue.newInstance();
+//
+// // 在一个作用域内设置值
+// ScopedValue.where(LOGGED_IN_USER, currentUser)
+// .run(() -> {
+// // 在这里，LOGGED_IN_USER.get() 会返回 currentUser
+// processRequest();
+// });
+```
+
+## 4. Record 模式 (Record Patterns - 第二次预览)
+
+Record 模式也进入了第二次预览。此版本的一个主要改进是允许在 Record 模式中进行类型参数的推断，并支持与 `for` 循环等语句结合使用。
+
+## 5. Switch 的模式匹配 (第四次预览)
+
+Switch 的模式匹配在此版本中进入了第四次预览，API 已经非常稳定，主要进行了一些语法上的微调和对泛型模式匹配的增强，为在下一个 LTS 版本中最终定稿做好了准备。
+
+## 6. 外部函数和内存 API (第二次预览)
+
+这个旨在替代 JNI 的 API 也进入了第二次预览，API 更加精炼，并统一了 `MemorySegment` 和 `MemoryAddress` 的接口，使其更易于使用。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java21\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java21\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..fd08ead
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java21\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,103 @@
+# Java 21 (LTS) 新特性
+
+Java 21 于 2023 年 9 月发布，是继 Java 17 之后的最新一个长期支持（LTS）版本。它正式确定了虚拟线程、记录模式、Switch 模式匹配等一系列里程碑式的功能，标志着现代 Java 开发进入了一个新阶段。
+
+## 1. 虚拟线程 (Virtual Threads - 标准版)
+
+经过两轮预览，虚拟线程在 Java 21 中被正式确定下来。开发者现在可以在生产环境中大规模使用轻量级线程，用同步的方式写出高并发、高吞吐量的应用程序，而无需复杂的异步编程。
+
+```java
+// 虚拟线程已成为标准功能
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+ for (int i = 0; i < 10_000; i++) {
+ executor.submit(() -> {
+ Thread.sleep(Duration.ofSeconds(1));
+ return i;
+ });
+ }
+} // executor.close() 会隐式地等待所有任务完成
+```
+
+## 2. 记录模式 (Record Patterns - 标准版)
+
+记录模式也在此版本中被正式确定下来。它允许在 `instanceof` 和 `switch` 中对 `record` 进行解构，使代码更加简洁和富有表现力。
+
+```java
+public record Point(int x, int y) {}
+
+// 记录模式已成为标准功能
+static void printSum(Object obj) {
+ if (obj instanceof Point(int x, int y)) {
+ System.out.println(x + y);
+ }
+}
+```
+
+## 3. Switch 的模式匹配 (标准版)
+
+经过多轮预览，Switch 的模式匹配终于在 Java 21 中转正。它极大地增强了 `switch` 的能力，使其可以根据类型和 `record` 结构进行分支判断，并支持 `when` 子句进行更精细的控制。
+
+```java
+// Switch 模式匹配已成为标准功能
+static String formatter(Object o) {
+ return switch (o) {
+ 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 Point(int x, int y) -> String.format("Point at %d, %d", x, y);
+ default -> o.toString();
+ };
+}
+```
+
+## 4. 序列化集合 (Sequenced Collections)
+
+引入了一套新的集合接口，用于表示具有确定出现顺序的集合。`List` 和 `Deque` 等都实现了新的 `SequencedCollection` 接口。
+
+- **核心接口**：`SequencedCollection`, `SequencedSet`, `SequencedMap`。
+- **新方法**：提供了如 `getFirst()`, `getLast()`, `addFirst()`, `addLast()`, `reversed()` 等统一的 API。
+
+```java
+List list = new ArrayList<>();
+list.add("A");
+list.add("B");
+
+// 新 API
+System.out.println(list.getFirst()); // A
+System.out.println(list.getLast()); // B
+
+// 获取一个反向视图
+List reversedList = list.reversed();
+System.out.println(reversedList); // [B, A]
+```
+
+## 5. 字符串模板 (String Templates - 预览功能)
+
+这是一个新的预览功能，旨在简化包含运行时表达式的字符串的编写，比传统的字符串拼接或 `String.format()` 更安全、更强大。
+
+```java
+// 使用 STR 模板处理器
+String name = "Joan";
+String info = STR."My name is \{name}";
+System.out.println(info); // My name is Joan
+```
+
+## 6. 未命名模式和变量 (Unnamed Patterns and Variables - 预览功能)
+
+允许使用下划线 `_` 来表示未使用的模式变量或局部变量，以减少代码冗余。
+
+```java
+// 忽略 record 模式中的某个组件
+// if (obj instanceof Point(int x, int _)) { ... }
+
+// 忽略 switch case 中的变量
+// case Point(int x, int _) -> ...
+
+// 忽略 try-with-resources 中的资源变量
+// try (var _ = ScopedValue.where(...)) { ... }
+```
+
+## 7. 结构化并发 (Structured Concurrency - 预览功能) & 作用域值 (Scoped Values - 预览功能)
+
+这两个在之前版本中孵化的功能，在 Java 21 中都进入了预览阶段，API 更加成熟，离最终定稿更近一步。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java9\346\226\260\347\211\271\346\200\247.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java9\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..d1ed4d1
--- /dev/null
+++ "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/Java9\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,108 @@
+# Java 9 新特性
+
+Java 9 在 2017 年 9 月发布，带来了许多重大变化，其中最引人注目的是 Java 平台模块化系统（JPMS）。
+
+## 1. 模块化系统 (Project Jigsaw)
+
+模块化是 Java 9 的核心功能。它将 JDK 划分为一组模块，并允许开发者将自己的代码也打包成模块。
+
+- **目的**：解决 JAR Hell 问题，提高安全性（隐藏内部实现），提升性能。
+- **核心**：`module-info.java` 文件。
+
+一个简单的模块定义如下：
+
+```java
+// module-info.java
+module com.example.mymodule {
+ // 声明依赖于 java.sql 模块
+ requires java.sql;
+
+ // 声明将 com.example.mypackage 包导出，其他模块可以使用
+ exports com.example.mypackage;
+}
+```
+
+## 2. JShell (交互式命令行)
+
+Java 9 引入了 `jshell`，这是一个交互式的 Read-Eval-Print Loop (REPL) 工具，可以快速测试代码片段，无需创建完整的类。
+
+启动 `jshell`：
+```bash
+$ jshell
+| 欢迎使用 JShell -- 版本 9
+| 要大致了解该版本, 请键入: /help intro
+
+jshell> int x = 10;
+x ==> 10
+
+jshell> System.out.println("Hello, JShell!");
+Hello, JShell!
+```
+
+## 3. 接口的私有方法
+
+Java 8 允许在接口中使用 `default` 和 `static` 方法。Java 9 更进一步，允许定义 `private` 方法。这有助于在接口内部重用代码，避免将实现细节暴露给外部。
+
+```java
+public interface MyInterface {
+
+ void normalMethod();
+
+ default void method1() {
+ init();
+ System.out.println("Executing default method 1");
+ }
+
+ default void method2() {
+ init();
+ System.out.println("Executing default method 2");
+ }
+
+ // 私有方法，用于在默认方法之间共享代码
+ private void init() {
+ System.out.println("Initializing...");
+ }
+}
+```
+
+## 4. Stream API 的改进
+
+Stream API 增加了四个有用的新方法：`takeWhile`, `dropWhile`, `ofNullable`, `iterate`。
+
+- **`takeWhile(Predicate)`**: 返回从流的开头开始，满足谓词条件的元素。一旦遇到不满足条件的元素，立即停止。
+- **`dropWhile(Predicate)`**: `takeWhile` 的反操作。丢弃从流的开头开始，满足谓词条件的元素，然后返回剩余的流。
+
+```java
+Stream.of(1, 2, 3, 4, 5, 1, 2)
+ .takeWhile(n -> n < 4)
+ .forEach(System.out::print); // 输出: 123
+
+Stream.of(1, 2, 3, 4, 5, 1, 2)
+ .dropWhile(n -> n < 4)
+ .forEach(System.out::print); // 输出: 4512
+```
+
+## 5. Try-With-Resources 语法的改进
+
+Java 9 中，如果资源已经是 `final` 或等效于 `final` 的变量，则可以在 `try-with-resources` 语句中直接使用，而无需在 `try()` 中声明一个新变量。
+
+```java
+// Java 8
+Reader reader = new StringReader("test");
+try (Reader r = reader) {
+ // ...
+}
+
+// Java 9
+Reader reader = new StringReader("test");
+try (reader) { // 更简洁
+ // ...
+}
+```
+
+## 6. 其他重要特性
+
+- **`Optional` 类增强**：增加了 `ifPresentOrElse()`, `or()`, `stream()` 等方法。
+- **多版本兼容 JAR 包**：允许一个 JAR 文件包含针对不同 Java 版本的类文件。
+- **HTTP/2 客户端 API (孵化)**：引入了新的、现代的 HTTP 客户端 API，用于替代旧的 `HttpURLConnection`。
+- **`ProcessHandle` API**：提供了管理和查询操作系统进程的能力。
diff --git "a/Java\347\211\210\346\234\254\346\233\264\346\226\260/README.md" "b/Java\347\211\210\346\234\254\346\233\264\346\226\260/README.md"
new file mode 100644
index 0000000..e69de29
diff --git "a/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/spring \351\235\242\350\257\225\351\242\230/SpringBoot2\344\270\216SpringBoot3\345\214\272\345\210\253\350\257\246\350\247\243.md" "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/spring \351\235\242\350\257\225\351\242\230/SpringBoot2\344\270\216SpringBoot3\345\214\272\345\210\253\350\257\246\350\247\243.md"
new file mode 100644
index 0000000..c5698f1
--- /dev/null
+++ "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/spring \351\235\242\350\257\225\351\242\230/SpringBoot2\344\270\216SpringBoot3\345\214\272\345\210\253\350\257\246\350\247\243.md"
@@ -0,0 +1,893 @@
+# Spring Boot 2 与 Spring Boot 3 区别详解
+
+## 📋 目录
+- [版本概述](#版本概述)
+- [核心依赖变化](#核心依赖变化)
+- [Java版本要求](#java版本要求)
+- [配置变化](#配置变化)
+- [API变化](#api变化)
+- [性能改进](#性能改进)
+- [迁移指南](#迁移指南)
+- [面试重点](#面试重点)
+
+## 🎯 版本概述
+
+### Spring Boot 2.x vs 3.x 基本信息
+
+| 特性 | Spring Boot 2.x | Spring Boot 3.x |
+|------|----------------|----------------|
+| 发布时间 | 2018年3月 | 2022年11月 |
+| Spring Framework | 5.x | 6.x |
+| 最低Java版本 | Java 8 | Java 17 |
+| Jakarta EE | 不支持 | 支持 |
+| GraalVM原生镜像 | 实验性支持 | 生产就绪 |
+| 可观测性 | Micrometer | Micrometer + OpenTelemetry |
+| 支持周期 | 2023年11月结束 | 2025年11月结束 |
+
+## 🔧 核心依赖变化
+
+### 1. Spring Framework版本升级
+
+```java
+// Spring Boot 2.x 基于 Spring Framework 5.x
+@Configuration
+public class SpringBoot2Config {
+
+ // 使用传统的Servlet API
+ @Bean
+ public FilterRegistrationBean myFilter() {
+ FilterRegistrationBean registration = new FilterRegistrationBean<>();
+ registration.setFilter(new MyFilter());
+ registration.addUrlPatterns("/*");
+ return registration;
+ }
+}
+
+// Spring Boot 3.x 基于 Spring Framework 6.x
+@Configuration
+public class SpringBoot3Config {
+
+ // 支持更现代的配置方式
+ @Bean
+ public FilterRegistrationBean myFilter() {
+ FilterRegistrationBean registration = new FilterRegistrationBean<>();
+ registration.setFilter(new MyFilter());
+ registration.addUrlPatterns("/*");
+ // 新增的配置选项
+ registration.setAsyncSupported(true);
+ return registration;
+ }
+}
+```
+
+### 2. Jakarta EE迁移
+
+```java
+// Spring Boot 2.x - 使用 javax.* 包
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.validation.constraints.NotNull;
+
+@Entity
+public class User {
+ @Id
+ private Long id;
+
+ @NotNull
+ private String name;
+
+ // getter/setter
+}
+
+// Spring Boot 3.x - 使用 jakarta.* 包
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.validation.constraints.NotNull;
+
+@Entity
+public class User {
+ @Id
+ private Long id;
+
+ @NotNull
+ private String name;
+
+ // getter/setter
+}
+```
+
+## ☕ Java版本要求
+
+### 1. 最低版本要求变化
+
+```java
+// Spring Boot 2.x - 支持Java 8+
+public class SpringBoot2Features {
+
+ // 可以使用Java 8特性
+ public Optional processData(List data) {
+ return data.stream()
+ .filter(s -> s.length() > 5)
+ .findFirst();
+ }
+
+ // 但不能使用Java 17+的新特性
+}
+
+// Spring Boot 3.x - 要求Java 17+
+public class SpringBoot3Features {
+
+ // 可以使用Java 17的新特性
+ public sealed interface Shape permits Circle, Rectangle {
+ double area();
+ }
+
+ public record Circle(double radius) implements Shape {
+ @Override
+ public double area() {
+ return Math.PI * radius * radius;
+ }
+ }
+
+ public record Rectangle(double width, double height) implements Shape {
+ @Override
+ public double area() {
+ return width * height;
+ }
+ }
+
+ // 使用文本块
+ public String getJsonTemplate() {
+ return """
+ {
+ "name": "%s",
+ "age": %d,
+ "active": %b
+ }
+ """;
+ }
+}
+```
+
+### 2. 性能优化
+
+```java
+// Spring Boot 3.x 利用Java 17的性能改进
+@Service
+public class PerformanceOptimizedService {
+
+ // 利用Java 17的向量API（预览特性）
+ public void processLargeDataset(int[] data) {
+ // 向量化操作，性能更好
+ IntVector.SPECIES_256.fromArray(data, 0)
+ .add(IntVector.SPECIES_256.broadcast(10))
+ .intoArray(data, 0);
+ }
+
+ // 利用改进的垃圾收集器
+ @EventListener
+ public void handleLargeDataProcessing(DataProcessingEvent event) {
+ // ZGC和G1GC的改进使得大内存应用性能更好
+ processLargeDataInMemory(event.getData());
+ }
+}
+```
+
+## ⚙️ 配置变化
+
+### 1. 配置属性变化
+
+```yaml
+# Spring Boot 2.x 配置
+spring:
+ datasource:
+ url: jdbc:mysql://localhost:3306/db
+ username: user
+ password: pass
+ jpa:
+ hibernate:
+ ddl-auto: update
+ security:
+ user:
+ name: admin
+ password: secret
+
+# Spring Boot 3.x 配置变化
+spring:
+ datasource:
+ url: jdbc:mysql://localhost:3306/db
+ username: user
+ password: pass
+ jpa:
+ hibernate:
+ ddl-auto: update
+ # 安全配置方式改变
+ security:
+ user:
+ name: admin
+ password: secret
+ roles: ADMIN
+ # 新增的可观测性配置
+ management:
+ tracing:
+ sampling:
+ probability: 1.0
+ metrics:
+ distribution:
+ percentiles-histogram:
+ http.server.requests: true
+```
+
+### 2. 自动配置变化
+
+```java
+// Spring Boot 2.x 安全配置
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+ http.authorizeRequests()
+ .antMatchers("/public/**").permitAll()
+ .anyRequest().authenticated()
+ .and()
+ .formLogin();
+ }
+}
+
+// Spring Boot 3.x 安全配置（WebSecurityConfigurerAdapter已废弃）
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+ @Bean
+ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+ http.authorizeHttpRequests(authz -> authz
+ .requestMatchers("/public/**").permitAll()
+ .anyRequest().authenticated()
+ )
+ .formLogin(Customizer.withDefaults());
+
+ return http.build();
+ }
+}
+```
+
+## 🔄 API变化
+
+### 1. 废弃的API
+
+```java
+// Spring Boot 2.x 中可用但在3.x中废弃的API
+public class DeprecatedAPIs {
+
+ // 1. WebSecurityConfigurerAdapter 已废弃
+ // @Deprecated in Spring Boot 3.x
+ public class OldSecurityConfig extends WebSecurityConfigurerAdapter {
+ // 不再推荐使用
+ }
+
+ // 2. 一些Actuator端点变化
+ @Deprecated
+ public void oldActuatorUsage() {
+ // 某些端点路径和响应格式发生变化
+ }
+
+ // 3. 配置属性绑定方式变化
+ @ConfigurationProperties(prefix = "app")
+ public class OldConfigProperties {
+ // 某些绑定方式在3.x中不再支持
+ }
+}
+
+// Spring Boot 3.x 推荐的新API
+public class NewAPIs {
+
+ // 1. 新的安全配置方式
+ @Bean
+ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+ return http.build();
+ }
+
+ // 2. 改进的配置属性绑定
+ @ConfigurationProperties(prefix = "app")
+ @ConstructorBinding
+ public record AppProperties(
+ String name,
+ Duration timeout,
+ List features
+ ) {}
+}
+```
+
+### 2. 新增功能
+
+```java
+// Spring Boot 3.x 新增功能
+@RestController
+public class SpringBoot3NewFeatures {
+
+ // 1. 改进的问题详情支持（RFC 7807）
+ @GetMapping("/error-demo")
+ public ResponseEntity errorDemo() {
+ ProblemDetail problemDetail = ProblemDetail.forStatusAndDetail(
+ HttpStatus.BAD_REQUEST,
+ "Invalid request parameter"
+ );
+ problemDetail.setTitle("Validation Error");
+ problemDetail.setProperty("timestamp", Instant.now());
+
+ return ResponseEntity.badRequest().body(problemDetail);
+ }
+
+ // 2. 原生镜像支持改进
+ @GetMapping("/native-ready")
+ public String nativeReady() {
+ // 更好的GraalVM原生镜像支持
+ return "This endpoint works well in native image";
+ }
+
+ // 3. 可观测性改进
+ @GetMapping("/traced-endpoint")
+ @Timed(name = "custom.endpoint.timer", description = "Custom endpoint timer")
+ public String tracedEndpoint() {
+ // 自动集成OpenTelemetry追踪
+ return "This request is automatically traced";
+ }
+}
+```
+
+## 📈 性能改进
+
+### 1. 启动性能
+
+```java
+// Spring Boot 3.x 启动性能优化
+@SpringBootApplication
+public class OptimizedApplication {
+
+ public static void main(String[] args) {
+ // 1. 改进的类路径扫描
+ SpringApplication app = new SpringApplication(OptimizedApplication.class);
+
+ // 2. 更快的Bean初始化
+ app.setLazyInitialization(true);
+
+ // 3. 原生镜像支持
+ app.run(args);
+ }
+}
+
+// 原生镜像配置
+@Configuration
+@ImportRuntimeHints(MyRuntimeHints.class)
+public class NativeImageConfig {
+
+ // 为原生镜像提供运行时提示
+ static class MyRuntimeHints implements RuntimeHintsRegistrar {
+ @Override
+ public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+ hints.reflection().registerType(MyService.class,
+ MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
+ MemberCategory.INVOKE_DECLARED_METHODS);
+ }
+ }
+}
+```
+
+### 2. 内存使用优化
+
+```java
+// Spring Boot 3.x 内存优化
+@Configuration
+public class MemoryOptimization {
+
+ // 1. 改进的Bean定义处理
+ @Bean
+ @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+ public ExpensiveService expensiveService() {
+ // 更高效的原型Bean创建
+ return new ExpensiveService();
+ }
+
+ // 2. 优化的自动配置
+ @ConditionalOnClass(name = "com.example.OptionalDependency")
+ @Bean
+ public OptionalService optionalService() {
+ // 更智能的条件判断，减少不必要的类加载
+ return new OptionalService();
+ }
+}
+```
+
+## 🔄 迁移指南
+
+### 1. 依赖迁移
+
+```xml
+
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 2.7.18
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter-data-jpa
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 3.2.1
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter-data-jpa
+
+
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+```
+
+### 2. 代码迁移步骤
+
+```java
+// 迁移检查清单
+public class MigrationChecklist {
+
+ /*
+ * 1. 更新Java版本到17+
+ * 2. 替换javax.*包为jakarta.*包
+ * 3. 更新Spring Security配置
+ * 4. 检查废弃的API使用
+ * 5. 更新测试代码
+ * 6. 验证第三方库兼容性
+ * 7. 更新配置文件
+ * 8. 测试原生镜像构建（可选）
+ */
+
+ // 自动化迁移工具使用
+ public void useOpenRewriteMigration() {
+ /*
+ * 使用OpenRewrite自动迁移工具：
+ *
+ * 1. 添加OpenRewrite插件到pom.xml
+ * 2. 运行迁移命令：
+ * mvn org.openrewrite.maven:rewrite-maven-plugin:run
+ * -Drewrite.recipeArtifactCoordinates=org.openrewrite.recipe:rewrite-spring:LATEST
+ * -Drewrite.activeRecipes=org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_0
+ */
+ }
+}
+```
+
+## 🎯 面试重点
+
+### Q1: Spring Boot 3相比Spring Boot 2有哪些重大变化？
+
+**答案：**
+```java
+public class MajorChanges {
+
+ /*
+ * 1. 基础要求变化
+ * - 最低Java版本：Java 8 → Java 17
+ * - Spring Framework：5.x → 6.x
+ * - Jakarta EE：javax.* → jakarta.*
+ *
+ * 2. 性能改进
+ * - 原生镜像支持从实验性变为生产就绪
+ * - 启动时间和内存使用优化
+ * - 更好的GraalVM集成
+ *
+ * 3. 可观测性增强
+ * - 内置OpenTelemetry支持
+ * - 改进的Micrometer集成
+ * - 更丰富的监控指标
+ *
+ * 4. API现代化
+ * - 废弃WebSecurityConfigurerAdapter
+ * - 改进的配置属性绑定
+ * - 新的问题详情支持（RFC 7807）
+ */
+}
+```
+
+### Q2: 为什么Spring Boot 3要求Java 17？
+
+**答案：**
+```java
+public class Java17Requirements {
+
+ // 1. 性能优势
+ public void performanceBenefits() {
+ /*
+ * - JVM性能改进：ZGC、G1GC优化
+ * - 编译器优化：更好的JIT编译
+ * - 内存管理：改进的垃圾收集算法
+ */
+ }
+
+ // 2. 语言特性
+ public sealed interface ModernJavaFeatures permits Record, TextBlock {
+ // 密封类、记录类、文本块等新特性
+ }
+
+ public record ConfigurationData(String name, int port, boolean enabled)
+ implements ModernJavaFeatures {
+ // 记录类简化数据传输对象
+ }
+
+ // 3. 长期支持
+ public void longTermSupport() {
+ /*
+ * - Java 17是LTS版本，支持周期长
+ * - 企业级应用的稳定性保证
+ * - 安全更新和bug修复
+ */
+ }
+}
+```
+
+### Q3: Jakarta EE迁移有什么影响？
+
+**答案：**
+```java
+// 迁移影响分析
+public class JakartaEEMigrationImpact {
+
+ // 1. 包名变化
+ // Spring Boot 2.x
+ // import javax.servlet.http.HttpServletRequest;
+ // import javax.persistence.Entity;
+ // import javax.validation.constraints.NotNull;
+
+ // Spring Boot 3.x
+ import jakarta.servlet.http.HttpServletRequest;
+ import jakarta.persistence.Entity;
+ import jakarta.validation.constraints.NotNull;
+
+ // 2. 第三方库兼容性
+ public void libraryCompatibility() {
+ /*
+ * 影响的库：
+ * - Hibernate 6.x+
+ * - Jackson 2.14+
+ * - Tomcat 10.x+
+ * - 需要检查所有使用javax.*的依赖
+ */
+ }
+
+ // 3. 迁移策略
+ public void migrationStrategy() {
+ /*
+ * 1. 使用IDE的全局替换功能
+ * 2. 使用OpenRewrite自动迁移工具
+ * 3. 逐步迁移，先更新核心模块
+ * 4. 充分测试，特别是集成测试
+ */
+ }
+}
+```
+
+### Q4: Spring Boot 3的原生镜像支持有什么优势？
+
+**答案：**
+```java
+@SpringBootApplication
+public class NativeImageAdvantages {
+
+ public static void main(String[] args) {
+ SpringApplication.run(NativeImageAdvantages.class, args);
+ }
+
+ /*
+ * 原生镜像优势：
+ *
+ * 1. 启动速度
+ * - 传统JVM：2-5秒
+ * - 原生镜像：50-200毫秒
+ *
+ * 2. 内存占用
+ * - 传统JVM：100-500MB
+ * - 原生镜像：20-100MB
+ *
+ * 3. 部署优势
+ * - 无需JVM环境
+ * - 容器镜像更小
+ * - 冷启动更快
+ *
+ * 4. 云原生友好
+ * - 适合Serverless
+ * - 适合微服务
+ * - 适合容器化部署
+ */
+}
+
+// 原生镜像配置示例
+@Configuration
+public class NativeImageConfig {
+
+ @Bean
+ @RegisterReflectionForBinding(UserDto.class)
+ public UserService userService() {
+ return new UserService();
+ }
+
+ // 运行时提示
+ @ImportRuntimeHints(CustomRuntimeHints.class)
+ static class CustomRuntimeHints implements RuntimeHintsRegistrar {
+ @Override
+ public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+ // 注册反射、资源、代理等提示
+ hints.reflection().registerType(UserDto.class);
+ hints.resources().registerPattern("static/**");
+ }
+ }
+}
+```
+
+### Q5: Spring Boot 3的可观测性改进体现在哪里？
+
+**答案：**
+```java
+@RestController
+public class ObservabilityImprovements {
+
+ // 1. 自动追踪
+ @GetMapping("/api/users/{id}")
+ @Timed(name = "user.get", description = "Get user by ID")
+ public User getUser(@PathVariable Long id) {
+ // 自动生成追踪信息，无需手动配置
+ return userService.findById(id);
+ }
+
+ // 2. 改进的指标
+ @EventListener
+ public void handleUserCreated(UserCreatedEvent event) {
+ // 自动记录业务指标
+ Metrics.counter("user.created",
+ "type", event.getUser().getType()).increment();
+ }
+
+ // 3. 分布式追踪
+ @Async
+ public CompletableFuture processAsync() {
+ // 追踪信息自动传播到异步线程
+ return CompletableFuture.completedFuture("processed");
+ }
+}
+
+// 配置示例
+/*
+management:
+ tracing:
+ sampling:
+ probability: 1.0
+ metrics:
+ distribution:
+ percentiles-histogram:
+ http.server.requests: true
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus
+*/
+```
+
+## 🔧 实际迁移案例
+
+### 案例1：电商系统迁移
+
+```java
+// 迁移前（Spring Boot 2.x）
+@RestController
+@RequestMapping("/api/orders")
+public class OrderControllerV2 {
+
+ @Autowired
+ private OrderService orderService;
+
+ @PostMapping
+ public ResponseEntity createOrder(@Valid @RequestBody OrderRequest request,
+ HttpServletRequest httpRequest) {
+ try {
+ Order order = orderService.createOrder(request);
+ return ResponseEntity.ok(order);
+ } catch (ValidationException e) {
+ return ResponseEntity.badRequest()
+ .body(Map.of("error", e.getMessage()));
+ }
+ }
+}
+
+// 迁移后（Spring Boot 3.x）
+@RestController
+@RequestMapping("/api/orders")
+public class OrderControllerV3 {
+
+ private final OrderService orderService;
+
+ // 构造函数注入（推荐）
+ public OrderControllerV3(OrderService orderService) {
+ this.orderService = orderService;
+ }
+
+ @PostMapping
+ public ResponseEntity createOrder(@Valid @RequestBody OrderRequest request,
+ HttpServletRequest httpRequest) {
+ try {
+ Order order = orderService.createOrder(request);
+ return ResponseEntity.ok(order);
+ } catch (ValidationException e) {
+ // 使用RFC 7807问题详情
+ ProblemDetail problemDetail = ProblemDetail.forStatusAndDetail(
+ HttpStatus.BAD_REQUEST, e.getMessage());
+ problemDetail.setTitle("Order Validation Failed");
+ problemDetail.setProperty("timestamp", Instant.now());
+
+ return ResponseEntity.badRequest().body(problemDetail);
+ }
+ }
+}
+```
+
+### 案例2：安全配置迁移
+
+```java
+// Spring Boot 2.x 安全配置
+@Configuration
+@EnableWebSecurity
+public class SecurityConfigV2 extends WebSecurityConfigurerAdapter {
+
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+ http.csrf().disable()
+ .authorizeRequests()
+ .antMatchers("/api/public/**").permitAll()
+ .antMatchers("/api/admin/**").hasRole("ADMIN")
+ .anyRequest().authenticated()
+ .and()
+ .oauth2ResourceServer()
+ .jwt();
+ }
+
+ @Override
+ protected void configure(AuthenticationManagerBuilder auth) throws Exception {
+ auth.inMemoryAuthentication()
+ .withUser("admin")
+ .password("{noop}password")
+ .roles("ADMIN");
+ }
+}
+
+// Spring Boot 3.x 安全配置
+@Configuration
+@EnableWebSecurity
+public class SecurityConfigV3 {
+
+ @Bean
+ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+ http.csrf(csrf -> csrf.disable())
+ .authorizeHttpRequests(authz -> authz
+ .requestMatchers("/api/public/**").permitAll()
+ .requestMatchers("/api/admin/**").hasRole("ADMIN")
+ .anyRequest().authenticated()
+ )
+ .oauth2ResourceServer(oauth2 -> oauth2
+ .jwt(Customizer.withDefaults())
+ );
+
+ return http.build();
+ }
+
+ @Bean
+ public InMemoryUserDetailsManager userDetailsService() {
+ UserDetails admin = User.builder()
+ .username("admin")
+ .password("{noop}password")
+ .roles("ADMIN")
+ .build();
+
+ return new InMemoryUserDetailsManager(admin);
+ }
+}
+```
+
+## 📊 性能对比
+
+### 启动时间对比
+
+```java
+// 性能测试结果
+public class PerformanceComparison {
+
+ /*
+ * 启动时间对比（相同应用）：
+ *
+ * Spring Boot 2.7.x:
+ * - 传统JVM启动：3.2秒
+ * - 内存占用：280MB
+ *
+ * Spring Boot 3.2.x:
+ * - 传统JVM启动：2.8秒（12%提升）
+ * - 原生镜像启动：0.08秒（97%提升）
+ * - 内存占用：220MB（21%减少）
+ * - 原生镜像内存：45MB（84%减少）
+ */
+
+ // 构建时间对比
+ /*
+ * Maven构建时间：
+ * - Spring Boot 2.x：45秒
+ * - Spring Boot 3.x：38秒
+ * - 原生镜像构建：3分钟
+ */
+}
+```
+
+## 🚀 升级建议
+
+### 升级时机选择
+
+```java
+public class UpgradeStrategy {
+
+ /*
+ * 建议升级的场景：
+ *
+ * 1. 新项目
+ * - 直接使用Spring Boot 3.x
+ * - 享受最新特性和性能
+ *
+ * 2. 现有项目升级条件
+ * - Java版本可以升级到17+
+ * - 第三方依赖支持Jakarta EE
+ * - 有充足的测试时间
+ *
+ * 3. 暂缓升级的场景
+ * - 大量遗留代码
+ * - 关键第三方库不兼容
+ * - 生产环境稳定性要求极高
+ */
+
+ // 渐进式升级策略
+ public void gradualUpgrade() {
+ /*
+ * 1. 先升级开发环境
+ * 2. 升级测试环境
+ * 3. 小范围生产验证
+ * 4. 全面生产部署
+ */
+ }
+}
+```
+
+---
+
+*Spring Boot 2与3的详细对比分析完成，这些信息将帮助开发者做出明智的升级决策，并在面试中展现对技术演进的深入理解。*
diff --git "a/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/spring \351\235\242\350\257\225\351\242\230/SpringBoot2\345\256\214\346\225\264\345\255\246\344\271\240\346\214\207\345\215\227.md" "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/spring \351\235\242\350\257\225\351\242\230/SpringBoot2\345\256\214\346\225\264\345\255\246\344\271\240\346\214\207\345\215\227.md"
new file mode 100644
index 0000000..aa572c2
--- /dev/null
+++ "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/spring \351\235\242\350\257\225\351\242\230/SpringBoot2\345\256\214\346\225\264\345\255\246\344\271\240\346\214\207\345\215\227.md"
@@ -0,0 +1,1303 @@
+# Spring Boot 2 完整学习指南 - 生命周期、加载方式、运行流程
+
+## 📋 目录
+- [Spring Boot 2 概述](#spring-boot-2-概述)
+- [Spring Boot 生命周期](#spring-boot-生命周期)
+- [自动配置原理](#自动配置原理)
+- [启动流程详解](#启动流程详解)
+- [Bean加载机制](#bean加载机制)
+- [配置加载顺序](#配置加载顺序)
+- [核心注解解析](#核心注解解析)
+- [面试常见问题](#面试常见问题)
+
+## 🎯 Spring Boot 2 概述
+
+### 什么是Spring Boot？
+
+Spring Boot是Spring团队提供的全新框架，设计目的是简化Spring应用的初始搭建以及开发过程。
+
+**核心特性：**
+- **约定优于配置**：提供默认配置，减少样板代码
+- **自动配置**：根据classpath自动配置Spring应用
+- **嵌入式服务器**：内置Tomcat、Jetty等服务器
+- **生产就绪**：提供监控、健康检查等功能
+
+### Spring Boot 2.x 主要改进
+
+```java
+// Spring Boot 2.x 主要变化
+public class SpringBoot2Changes {
+
+ // 1. 基于Spring Framework 5.x
+ // 2. 最低JDK版本要求：Java 8
+ // 3. 支持响应式编程（WebFlux）
+ // 4. 配置属性绑定改进
+ // 5. Actuator端点重构
+ // 6. 安全配置简化
+}
+```
+
+## 🔄 Spring Boot 生命周期
+
+### 1. 应用生命周期概览
+
+```java
+@SpringBootApplication
+public class Application {
+
+ public static void main(String[] args) {
+ // 1. 创建SpringApplication实例
+ SpringApplication app = new SpringApplication(Application.class);
+
+ // 2. 运行应用
+ ConfigurableApplicationContext context = app.run(args);
+
+ // 3. 应用运行中...
+
+ // 4. 关闭应用
+ context.close();
+ }
+}
+```
+
+### 2. 详细生命周期阶段
+
+```java
+@Component
+public class ApplicationLifecycleListener {
+
+ // 阶段1：应用启动前
+ @EventListener
+ public void handleApplicationStartingEvent(ApplicationStartingEvent event) {
+ System.out.println("1. 应用开始启动");
+ }
+
+ // 阶段2：环境准备完成
+ @EventListener
+ public void handleApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
+ System.out.println("2. 环境准备完成");
+ }
+
+ // 阶段3：上下文准备完成
+ @EventListener
+ public void handleApplicationContextInitializedEvent(ApplicationContextInitializedEvent event) {
+ System.out.println("3. 上下文初始化完成");
+ }
+
+ // 阶段4：上下文准备完成
+ @EventListener
+ public void handleApplicationPreparedEvent(ApplicationPreparedEvent event) {
+ System.out.println("4. 上下文准备完成");
+ }
+
+ // 阶段5：应用启动完成
+ @EventListener
+ public void handleApplicationStartedEvent(ApplicationStartedEvent event) {
+ System.out.println("5. 应用启动完成");
+ }
+
+ // 阶段6：应用就绪
+ @EventListener
+ public void handleApplicationReadyEvent(ApplicationReadyEvent event) {
+ System.out.println("6. 应用就绪，可以接收请求");
+ }
+
+ // 阶段7：应用启动失败
+ @EventListener
+ public void handleApplicationFailedEvent(ApplicationFailedEvent event) {
+ System.out.println("7. 应用启动失败");
+ }
+}
+```
+
+### 3. Bean生命周期
+
+```java
+@Component
+public class BeanLifecycleDemo implements InitializingBean, DisposableBean {
+
+ private String name;
+
+ // 1. 构造函数
+ public BeanLifecycleDemo() {
+ System.out.println("1. 构造函数执行");
+ }
+
+ // 2. 属性注入
+ @Autowired
+ public void setName(@Value("${app.name:demo}") String name) {
+ this.name = name;
+ System.out.println("2. 属性注入完成: " + name);
+ }
+
+ // 3. BeanNameAware
+ @Override
+ public void setBeanName(String name) {
+ System.out.println("3. BeanNameAware: " + name);
+ }
+
+ // 4. BeanFactoryAware
+ @Override
+ public void setBeanFactory(BeanFactory beanFactory) {
+ System.out.println("4. BeanFactoryAware");
+ }
+
+ // 5. ApplicationContextAware
+ @Override
+ public void setApplicationContext(ApplicationContext applicationContext) {
+ System.out.println("5. ApplicationContextAware");
+ }
+
+ // 6. @PostConstruct
+ @PostConstruct
+ public void postConstruct() {
+ System.out.println("6. @PostConstruct执行");
+ }
+
+ // 7. InitializingBean
+ @Override
+ public void afterPropertiesSet() {
+ System.out.println("7. InitializingBean.afterPropertiesSet()");
+ }
+
+ // 8. @PreDestroy
+ @PreDestroy
+ public void preDestroy() {
+ System.out.println("8. @PreDestroy执行");
+ }
+
+ // 9. DisposableBean
+ @Override
+ public void destroy() {
+ System.out.println("9. DisposableBean.destroy()");
+ }
+}
+```
+
+## ⚙️ 自动配置原理
+
+### 1. @SpringBootApplication注解解析
+
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@SpringBootConfiguration // 等同于@Configuration
+@EnableAutoConfiguration // 启用自动配置
+@ComponentScan(excludeFilters = { // 组件扫描
+ @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
+ @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
+})
+public @interface SpringBootApplication {
+ // ...
+}
+```
+
+### 2. @EnableAutoConfiguration工作原理
+
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AutoConfigurationPackage
+@Import(AutoConfigurationImportSelector.class) // 关键：导入自动配置选择器
+public @interface EnableAutoConfiguration {
+ // ...
+}
+
+// 自动配置导入选择器
+public class AutoConfigurationImportSelector implements DeferredImportSelector {
+
+ @Override
+ public String[] selectImports(AnnotationMetadata annotationMetadata) {
+ // 1. 检查自动配置是否启用
+ if (!isEnabled(annotationMetadata)) {
+ return NO_IMPORTS;
+ }
+
+ // 2. 获取自动配置条目
+ AutoConfigurationEntry autoConfigurationEntry =
+ getAutoConfigurationEntry(annotationMetadata);
+
+ return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
+ }
+
+ protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
+ // 3. 加载spring.factories中的配置类
+ List configurations = getCandidateConfigurations(annotationMetadata, attributes);
+
+ // 4. 去重
+ configurations = removeDuplicates(configurations);
+
+ // 5. 排除不需要的配置
+ Set exclusions = getExclusions(annotationMetadata, attributes);
+ configurations.removeAll(exclusions);
+
+ // 6. 过滤（根据条件注解）
+ configurations = getConfigurationClassFilter().filter(configurations);
+
+ return new AutoConfigurationEntry(configurations, exclusions);
+ }
+}
+```
+
+### 3. 条件注解机制
+
+```java
+// 示例：Redis自动配置
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass(RedisOperations.class) // 类路径存在RedisOperations
+@EnableConfigurationProperties(RedisProperties.class) // 启用配置属性
+@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
+public class RedisAutoConfiguration {
+
+ @Bean
+ @ConditionalOnMissingBean(name = "redisTemplate") // 不存在redisTemplate bean
+ @ConditionalOnSingleCandidate(RedisConnectionFactory.class) // 存在唯一的连接工厂
+ public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
+ RedisTemplate template = new RedisTemplate<>();
+ template.setConnectionFactory(redisConnectionFactory);
+ return template;
+ }
+
+ @Bean
+ @ConditionalOnMissingBean // 不存在StringRedisTemplate bean
+ @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
+ public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
+ return new StringRedisTemplate(redisConnectionFactory);
+ }
+}
+```
+
+## 🚀 启动流程详解
+
+### 1. SpringApplication.run()方法解析
+
+```java
+public class SpringApplication {
+
+ public ConfigurableApplicationContext run(String... args) {
+ // 1. 创建启动时间监控
+ StopWatch stopWatch = new StopWatch();
+ stopWatch.start();
+
+ // 2. 声明应用上下文和异常报告器
+ DefaultBootstrapContext bootstrapContext = createBootstrapContext();
+ ConfigurableApplicationContext context = null;
+ Collection exceptionReporters = new ArrayList<>();
+
+ // 3. 设置系统属性
+ configureHeadlessProperty();
+
+ // 4. 获取运行监听器
+ SpringApplicationRunListeners listeners = getRunListeners(args);
+ listeners.starting(bootstrapContext, this.mainApplicationClass);
+
+ try {
+ // 5. 准备应用参数
+ ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
+
+ // 6. 准备环境
+ ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
+ configureIgnoreBeanInfo(environment);
+
+ // 7. 打印Banner
+ Banner printedBanner = printBanner(environment);
+
+ // 8. 创建应用上下文
+ context = createApplicationContext();
+ context.setApplicationStartup(this.applicationStartup);
+
+ // 9. 准备上下文
+ prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
+
+ // 10. 刷新上下文（核心）
+ refreshContext(context);
+
+ // 11. 刷新后处理
+ afterRefresh(context, applicationArguments);
+
+ // 12. 停止计时
+ stopWatch.stop();
+
+ // 13. 发布启动完成事件
+ listeners.started(context);
+
+ // 14. 调用ApplicationRunner和CommandLineRunner
+ callRunners(context, applicationArguments);
+
+ } catch (Throwable ex) {
+ handleRunFailure(context, ex, listeners);
+ throw new IllegalStateException(ex);
+ }
+
+ try {
+ // 15. 发布就绪事件
+ listeners.running(context);
+ } catch (Throwable ex) {
+ handleRunFailure(context, ex, null);
+ throw new IllegalStateException(ex);
+ }
+
+ return context;
+ }
+}
+```
+
+### 2. 上下文刷新过程
+
+```java
+// AbstractApplicationContext.refresh()方法
+@Override
+public void refresh() throws BeansException, IllegalStateException {
+ synchronized (this.startupShutdownMonitor) {
+ StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
+
+ // 1. 准备刷新
+ prepareRefresh();
+
+ // 2. 获取BeanFactory
+ ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
+
+ // 3. 准备BeanFactory
+ prepareBeanFactory(beanFactory);
+
+ try {
+ // 4. 后置处理BeanFactory
+ postProcessBeanFactory(beanFactory);
+
+ StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
+
+ // 5. 调用BeanFactoryPostProcessor
+ invokeBeanFactoryPostProcessors(beanFactory);
+
+ // 6. 注册BeanPostProcessor
+ registerBeanPostProcessors(beanFactory);
+
+ beanPostProcess.end();
+
+ // 7. 初始化MessageSource
+ initMessageSource();
+
+ // 8. 初始化事件多播器
+ initApplicationEventMulticaster();
+
+ // 9. 刷新特定上下文（模板方法）
+ onRefresh();
+
+ // 10. 注册监听器
+ registerListeners();
+
+ // 11. 完成BeanFactory初始化
+ finishBeanFactoryInitialization(beanFactory);
+
+ // 12. 完成刷新
+ finishRefresh();
+ } catch (BeansException ex) {
+ // 销毁已创建的Bean
+ destroyBeans();
+ cancelRefresh(ex);
+ throw ex;
+ } finally {
+ resetCommonCaches();
+ contextRefresh.end();
+ }
+ }
+}
+```
+
+## 📦 Bean加载机制
+
+### 1. Bean定义注册
+
+```java
+@Configuration
+public class BeanLoadingDemo {
+
+ // 方式1：@Bean注解
+ @Bean
+ @ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
+ public MyService myService() {
+ return new MyServiceImpl();
+ }
+
+ // 方式2：@Component扫描
+ @Component
+ public class ComponentService {
+ // ...
+ }
+
+ // 方式3：@Import导入
+ @Import({ImportedConfig.class, ImportSelector.class})
+ public class ImportDemo {
+ // ...
+ }
+
+ // 方式4：实现ImportSelector
+ public class CustomImportSelector implements ImportSelector {
+ @Override
+ public String[] selectImports(AnnotationMetadata importingClassMetadata) {
+ return new String[]{"com.example.ImportedService"};
+ }
+ }
+}
+```
+
+### 2. Bean实例化过程
+
+```java
+// Bean实例化的详细过程
+public class BeanInstantiationProcess {
+
+ // 1. 实例化前处理
+ @Override
+ public Object postProcessBeforeInstantiation(Class beanClass, String beanName) {
+ System.out.println("实例化前处理: " + beanName);
+ return null; // 返回null继续正常实例化
+ }
+
+ // 2. 实例化后处理
+ @Override
+ public boolean postProcessAfterInstantiation(Object bean, String beanName) {
+ System.out.println("实例化后处理: " + beanName);
+ return true; // 返回true继续属性填充
+ }
+
+ // 3. 属性填充前处理
+ @Override
+ public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
+ System.out.println("属性填充处理: " + beanName);
+ return pvs;
+ }
+
+ // 4. 初始化前处理
+ @Override
+ public Object postProcessBeforeInitialization(Object bean, String beanName) {
+ System.out.println("初始化前处理: " + beanName);
+ return bean;
+ }
+
+ // 5. 初始化后处理
+ @Override
+ public Object postProcessAfterInitialization(Object bean, String beanName) {
+ System.out.println("初始化后处理: " + beanName);
+ return bean;
+ }
+}
+```
+
+## 📋 配置加载顺序
+
+### 1. 配置文件加载优先级
+
+Spring Boot按以下顺序加载配置（优先级从高到低）：
+
+```java
+// 配置加载顺序示例
+public class ConfigurationLoadingOrder {
+
+ /*
+ * 1. 命令行参数
+ * java -jar app.jar --server.port=8081
+ */
+
+ /*
+ * 2. SPRING_APPLICATION_JSON中的属性
+ * SPRING_APPLICATION_JSON='{"server.port":8082}' java -jar app.jar
+ */
+
+ /*
+ * 3. ServletConfig初始化参数
+ * web.xml中的
+ */
+
+ /*
+ * 4. ServletContext初始化参数
+ * web.xml中的
+ */
+
+ /*
+ * 5. JNDI属性
+ * java:comp/env
+ */
+
+ /*
+ * 6. Java系统属性
+ * System.getProperties()
+ */
+
+ /*
+ * 7. 操作系统环境变量
+ * System.getenv()
+ */
+
+ /*
+ * 8. RandomValuePropertySource
+ * random.*属性
+ */
+
+ /*
+ * 9. jar包外的application-{profile}.properties/yml
+ * 10. jar包内的application-{profile}.properties/yml
+ * 11. jar包外的application.properties/yml
+ * 12. jar包内的application.properties/yml
+ */
+
+ /*
+ * 13. @PropertySource注解指定的配置文件
+ */
+
+ /*
+ * 14. 默认属性
+ * SpringApplication.setDefaultProperties()
+ */
+}
+```
+
+### 2. 配置文件位置优先级
+
+```java
+// 配置文件搜索位置（优先级从高到低）
+public class ConfigurationLocations {
+
+ /*
+ * 1. file:./config/ (项目根目录下的config文件夹)
+ * 2. file:./ (项目根目录)
+ * 3. classpath:/config/ (classpath下的config文件夹)
+ * 4. classpath:/ (classpath根目录)
+ */
+
+ // 自定义配置文件位置
+ @SpringBootApplication
+ public class Application {
+ public static void main(String[] args) {
+ System.setProperty("spring.config.location",
+ "classpath:/custom/,file:./config/");
+ SpringApplication.run(Application.class, args);
+ }
+ }
+}
+```
+
+### 3. Profile配置
+
+```java
+// Profile配置示例
+@Configuration
+@Profile("dev") // 开发环境配置
+public class DevConfig {
+
+ @Bean
+ public DataSource dataSource() {
+ return new HikariDataSource();
+ }
+}
+
+@Configuration
+@Profile("prod") // 生产环境配置
+public class ProdConfig {
+
+ @Bean
+ public DataSource dataSource() {
+ return new DruidDataSource();
+ }
+}
+
+// 激活Profile的方式
+public class ProfileActivation {
+
+ /*
+ * 1. 配置文件中指定
+ * spring.profiles.active=dev,test
+ *
+ * 2. 命令行参数
+ * java -jar app.jar --spring.profiles.active=prod
+ *
+ * 3. 环境变量
+ * export SPRING_PROFILES_ACTIVE=prod
+ *
+ * 4. 程序中指定
+ * SpringApplication app = new SpringApplication(Application.class);
+ * app.setAdditionalProfiles("dev");
+ */
+}
+```
+
+## 🏷️ 核心注解解析
+
+### 1. 配置相关注解
+
+```java
+// @ConfigurationProperties - 配置属性绑定
+@ConfigurationProperties(prefix = "app.user")
+@Data
+public class UserProperties {
+ private String name;
+ private Integer age;
+ private List hobbies;
+ private Map settings;
+
+ // 嵌套配置
+ private Database database = new Database();
+
+ @Data
+ public static class Database {
+ private String url;
+ private String username;
+ private String password;
+ }
+}
+
+// 使用配置属性
+@RestController
+@EnableConfigurationProperties(UserProperties.class)
+public class UserController {
+
+ private final UserProperties userProperties;
+
+ public UserController(UserProperties userProperties) {
+ this.userProperties = userProperties;
+ }
+
+ @GetMapping("/user/config")
+ public UserProperties getUserConfig() {
+ return userProperties;
+ }
+}
+```
+
+### 2. 条件注解详解
+
+```java
+// 条件注解示例
+@Configuration
+public class ConditionalConfig {
+
+ // 基于类存在的条件
+ @Bean
+ @ConditionalOnClass(RedisTemplate.class)
+ public RedisService redisService() {
+ return new RedisService();
+ }
+
+ // 基于Bean存在的条件
+ @Bean
+ @ConditionalOnBean(DataSource.class)
+ public JdbcTemplate jdbcTemplate(DataSource dataSource) {
+ return new JdbcTemplate(dataSource);
+ }
+
+ // 基于Bean不存在的条件
+ @Bean
+ @ConditionalOnMissingBean(RestTemplate.class)
+ public RestTemplate restTemplate() {
+ return new RestTemplate();
+ }
+
+ // 基于属性的条件
+ @Bean
+ @ConditionalOnProperty(
+ name = "app.feature.enabled",
+ havingValue = "true",
+ matchIfMissing = false
+ )
+ public FeatureService featureService() {
+ return new FeatureService();
+ }
+
+ // 基于表达式的条件
+ @Bean
+ @ConditionalOnExpression("${app.cache.enabled:false} and ${app.cache.type:redis} == 'redis'")
+ public CacheManager cacheManager() {
+ return new RedisCacheManager();
+ }
+
+ // 基于Web应用类型的条件
+ @Bean
+ @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
+ public ServletWebServerFactory servletWebServerFactory() {
+ return new TomcatServletWebServerFactory();
+ }
+}
+```
+
+### 3. 自定义条件注解
+
+```java
+// 自定义条件注解
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Conditional(OnDatabaseCondition.class)
+public @interface ConditionalOnDatabase {
+ DatabaseType value();
+}
+
+// 条件实现类
+public class OnDatabaseCondition implements Condition {
+
+ @Override
+ public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+ Map attributes = metadata.getAnnotationAttributes(
+ ConditionalOnDatabase.class.getName());
+
+ DatabaseType required = (DatabaseType) attributes.get("value");
+ String databaseUrl = context.getEnvironment().getProperty("spring.datasource.url");
+
+ if (databaseUrl == null) {
+ return false;
+ }
+
+ return switch (required) {
+ case MYSQL -> databaseUrl.contains("mysql");
+ case POSTGRESQL -> databaseUrl.contains("postgresql");
+ case ORACLE -> databaseUrl.contains("oracle");
+ default -> false;
+ };
+ }
+}
+
+// 使用自定义条件注解
+@Configuration
+public class DatabaseConfig {
+
+ @Bean
+ @ConditionalOnDatabase(DatabaseType.MYSQL)
+ public MySQLDialect mysqlDialect() {
+ return new MySQLDialect();
+ }
+
+ @Bean
+ @ConditionalOnDatabase(DatabaseType.POSTGRESQL)
+ public PostgreSQLDialect postgresqlDialect() {
+ return new PostgreSQLDialect();
+ }
+}
+```
+
+## ❓ 面试常见问题
+
+### Q1: Spring Boot的启动流程是什么？
+
+**答案：**
+1. **创建SpringApplication实例**：解析主配置类，确定应用类型
+2. **准备环境**：加载配置文件，设置Profile
+3. **创建ApplicationContext**：根据应用类型创建对应的上下文
+4. **准备上下文**：设置环境，加载配置，注册Bean定义
+5. **刷新上下文**：实例化Bean，处理依赖注入
+6. **完成启动**：发布启动完成事件，调用Runner
+
+### Q2: Spring Boot自动配置的原理是什么？
+
+**答案：**
+```java
+// 自动配置原理
+public class AutoConfigurationPrinciple {
+
+ /*
+ * 1. @EnableAutoConfiguration注解
+ * - 通过@Import导入AutoConfigurationImportSelector
+ *
+ * 2. AutoConfigurationImportSelector
+ * - 读取META-INF/spring.factories文件
+ * - 获取所有自动配置类的全限定名
+ *
+ * 3. 条件注解过滤
+ * - @ConditionalOnClass：类路径存在指定类
+ * - @ConditionalOnBean：容器中存在指定Bean
+ * - @ConditionalOnProperty：配置文件中存在指定属性
+ *
+ * 4. 配置类生效
+ * - 满足条件的配置类被加载
+ * - 创建相应的Bean实例
+ */
+}
+```
+
+### Q3: Spring Boot中Bean的加载顺序如何控制？
+
+**答案：**
+```java
+// Bean加载顺序控制
+@Configuration
+public class BeanOrderConfig {
+
+ // 1. 使用@Order注解
+ @Bean
+ @Order(1)
+ public FirstService firstService() {
+ return new FirstService();
+ }
+
+ @Bean
+ @Order(2)
+ public SecondService secondService() {
+ return new SecondService();
+ }
+
+ // 2. 使用@DependsOn注解
+ @Bean
+ @DependsOn("firstService")
+ public DependentService dependentService() {
+ return new DependentService();
+ }
+
+ // 3. 通过构造函数依赖
+ @Bean
+ public ServiceWithDependency serviceWithDependency(FirstService firstService) {
+ return new ServiceWithDependency(firstService);
+ }
+}
+```
+
+### Q4: Spring Boot如何实现零配置？
+
+**答案：**
+```java
+// 零配置实现原理
+public class ZeroConfigurationPrinciple {
+
+ /*
+ * 1. 约定优于配置
+ * - 默认配置文件位置：application.properties/yml
+ * - 默认静态资源位置：/static, /public, /resources, /META-INF/resources
+ * - 默认模板位置：/templates
+ *
+ * 2. 自动配置
+ * - 根据classpath中的jar包自动配置相应功能
+ * - 提供默认配置，用户可以覆盖
+ *
+ * 3. 嵌入式服务器
+ * - 内置Tomcat、Jetty、Undertow
+ * - 无需外部服务器部署
+ *
+ * 4. Starter依赖
+ * - 预定义依赖组合
+ * - 简化依赖管理
+ */
+
+ // 示例：Web应用零配置启动
+ @SpringBootApplication
+ public class ZeroConfigApp {
+ public static void main(String[] args) {
+ SpringApplication.run(ZeroConfigApp.class, args);
+ // 仅需这一行代码即可启动Web应用
+ }
+ }
+}
+```
+
+### Q5: Spring Boot Starter的工作原理？
+
+**答案：**
+```java
+// 自定义Starter示例
+// 1. 创建自动配置类
+@Configuration
+@ConditionalOnClass(MyService.class)
+@EnableConfigurationProperties(MyServiceProperties.class)
+public class MyServiceAutoConfiguration {
+
+ @Bean
+ @ConditionalOnMissingBean
+ public MyService myService(MyServiceProperties properties) {
+ return new MyService(properties);
+ }
+}
+
+// 2. 配置属性类
+@ConfigurationProperties(prefix = "myservice")
+@Data
+public class MyServiceProperties {
+ private String name = "default";
+ private boolean enabled = true;
+ private Duration timeout = Duration.ofSeconds(30);
+}
+
+// 3. 在META-INF/spring.factories中注册
+/*
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+com.example.MyServiceAutoConfiguration
+*/
+
+// 4. 创建starter模块的pom.xml
+/*
+
+
+ org.springframework.boot
+ spring-boot-autoconfigure
+
+
+ org.springframework.boot
+ spring-boot-configuration-processor
+ true
+
+
+*/
+```
+
+### Q6: Spring Boot中如何处理循环依赖？
+
+**答案：**
+```java
+// 循环依赖处理
+@Service
+public class ServiceA {
+
+ // 1. 构造函数循环依赖（Spring无法解决）
+ // private final ServiceB serviceB;
+ // public ServiceA(ServiceB serviceB) { this.serviceB = serviceB; }
+
+ // 2. 字段注入循环依赖（Spring可以解决）
+ @Autowired
+ private ServiceB serviceB;
+
+ // 3. 使用@Lazy注解延迟初始化
+ @Autowired
+ @Lazy
+ private ServiceB lazyServiceB;
+
+ // 4. 使用ApplicationContext获取Bean
+ @Autowired
+ private ApplicationContext applicationContext;
+
+ public void useServiceB() {
+ ServiceB serviceB = applicationContext.getBean(ServiceB.class);
+ serviceB.doSomething();
+ }
+
+ // 5. 使用@PostConstruct
+ @PostConstruct
+ public void init() {
+ // 在初始化完成后处理依赖
+ }
+}
+
+// 解决循环依赖的最佳实践
+@Configuration
+public class CircularDependencyConfig {
+
+ // 重新设计，避免循环依赖
+ @Bean
+ public CommonService commonService() {
+ return new CommonService();
+ }
+
+ @Bean
+ public ServiceA serviceA(CommonService commonService) {
+ return new ServiceA(commonService);
+ }
+
+ @Bean
+ public ServiceB serviceB(CommonService commonService) {
+ return new ServiceB(commonService);
+ }
+}
+```
+
+### Q7: Spring Boot的监控和健康检查如何实现？
+
+**答案：**
+```java
+// Actuator监控配置
+@Configuration
+public class ActuatorConfig {
+
+ // 1. 自定义健康检查
+ @Component
+ public class CustomHealthIndicator implements HealthIndicator {
+
+ @Override
+ public Health health() {
+ // 检查外部服务状态
+ boolean externalServiceUp = checkExternalService();
+
+ if (externalServiceUp) {
+ return Health.up()
+ .withDetail("external-service", "Available")
+ .withDetail("check-time", System.currentTimeMillis())
+ .build();
+ } else {
+ return Health.down()
+ .withDetail("external-service", "Unavailable")
+ .withDetail("error", "Connection timeout")
+ .build();
+ }
+ }
+
+ private boolean checkExternalService() {
+ // 实际的健康检查逻辑
+ return true;
+ }
+ }
+
+ // 2. 自定义指标
+ @Component
+ public class CustomMetrics {
+
+ private final Counter requestCounter;
+ private final Timer requestTimer;
+
+ public CustomMetrics(MeterRegistry meterRegistry) {
+ this.requestCounter = Counter.builder("custom.requests.total")
+ .description("Total number of requests")
+ .register(meterRegistry);
+
+ this.requestTimer = Timer.builder("custom.requests.duration")
+ .description("Request duration")
+ .register(meterRegistry);
+ }
+
+ public void recordRequest() {
+ requestCounter.increment();
+ }
+
+ public Timer.Sample startTimer() {
+ return Timer.start();
+ }
+ }
+
+ // 3. 自定义端点
+ @Component
+ @Endpoint(id = "custom")
+ public class CustomEndpoint {
+
+ @ReadOperation
+ public Map customInfo() {
+ Map info = new HashMap<>();
+ info.put("status", "running");
+ info.put("version", "1.0.0");
+ info.put("uptime", ManagementFactory.getRuntimeMXBean().getUptime());
+ return info;
+ }
+
+ @WriteOperation
+ public void updateConfig(@Selector String key, String value) {
+ // 更新配置的逻辑
+ System.setProperty(key, value);
+ }
+ }
+}
+
+// application.yml配置
+/*
+management:
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,custom
+ endpoint:
+ health:
+ show-details: always
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+*/
+```
+
+## 🛠️ 实战应用场景
+
+### 1. 多数据源配置
+
+```java
+@Configuration
+public class MultiDataSourceConfig {
+
+ @Primary
+ @Bean(name = "primaryDataSource")
+ @ConfigurationProperties(prefix = "spring.datasource.primary")
+ public DataSource primaryDataSource() {
+ return DataSourceBuilder.create().build();
+ }
+
+ @Bean(name = "secondaryDataSource")
+ @ConfigurationProperties(prefix = "spring.datasource.secondary")
+ public DataSource secondaryDataSource() {
+ return DataSourceBuilder.create().build();
+ }
+
+ @Primary
+ @Bean(name = "primaryJdbcTemplate")
+ public JdbcTemplate primaryJdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
+ return new JdbcTemplate(dataSource);
+ }
+
+ @Bean(name = "secondaryJdbcTemplate")
+ public JdbcTemplate secondaryJdbcTemplate(@Qualifier("secondaryDataSource") DataSource dataSource) {
+ return new JdbcTemplate(dataSource);
+ }
+}
+```
+
+### 2. 异步处理配置
+
+```java
+@Configuration
+@EnableAsync
+public class AsyncConfig implements AsyncConfigurer {
+
+ @Override
+ @Bean(name = "taskExecutor")
+ public Executor getAsyncExecutor() {
+ ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+ executor.setCorePoolSize(5);
+ executor.setMaxPoolSize(10);
+ executor.setQueueCapacity(100);
+ executor.setThreadNamePrefix("async-");
+ executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+ executor.initialize();
+ return executor;
+ }
+
+ @Override
+ public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
+ return (ex, method, params) -> {
+ System.err.println("异步方法执行异常: " + method.getName());
+ ex.printStackTrace();
+ };
+ }
+}
+
+// 使用异步方法
+@Service
+public class AsyncService {
+
+ @Async("taskExecutor")
+ public CompletableFuture processAsync(String data) {
+ // 异步处理逻辑
+ try {
+ Thread.sleep(2000);
+ return CompletableFuture.completedFuture("处理完成: " + data);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ return CompletableFuture.failedFuture(e);
+ }
+ }
+}
+```
+
+### 3. 缓存配置
+
+```java
+@Configuration
+@EnableCaching
+public class CacheConfig {
+
+ @Bean
+ public CacheManager cacheManager() {
+ RedisCacheManager.Builder builder = RedisCacheManager
+ .RedisCacheManagerBuilder
+ .fromConnectionFactory(redisConnectionFactory())
+ .cacheDefaults(cacheConfiguration());
+
+ return builder.build();
+ }
+
+ private RedisCacheConfiguration cacheConfiguration() {
+ return RedisCacheConfiguration.defaultCacheConfig()
+ .entryTtl(Duration.ofMinutes(30))
+ .serializeKeysWith(RedisSerializationContext.SerializationPair
+ .fromSerializer(new StringRedisSerializer()))
+ .serializeValuesWith(RedisSerializationContext.SerializationPair
+ .fromSerializer(new GenericJackson2JsonRedisSerializer()));
+ }
+}
+
+// 使用缓存
+@Service
+public class UserService {
+
+ @Cacheable(value = "users", key = "#id")
+ public User findById(Long id) {
+ // 查询数据库
+ return userRepository.findById(id);
+ }
+
+ @CacheEvict(value = "users", key = "#user.id")
+ public void updateUser(User user) {
+ userRepository.save(user);
+ }
+
+ @CacheEvict(value = "users", allEntries = true)
+ public void clearAllCache() {
+ // 清除所有缓存
+ }
+}
+```
+
+## 📊 性能优化建议
+
+### 1. 启动性能优化
+
+```java
+@SpringBootApplication
+public class OptimizedApplication {
+
+ public static void main(String[] args) {
+ // 1. 设置系统属性优化启动
+ System.setProperty("spring.backgroundpreinitializer.ignore", "true");
+ System.setProperty("spring.jmx.enabled", "false");
+
+ SpringApplication app = new SpringApplication(OptimizedApplication.class);
+
+ // 2. 禁用不需要的自动配置
+ app.setWebApplicationType(WebApplicationType.SERVLET);
+
+ // 3. 设置懒加载
+ app.setLazyInitialization(true);
+
+ app.run(args);
+ }
+}
+
+// application.yml优化配置
+/*
+spring:
+ main:
+ lazy-initialization: true
+ jmx:
+ enabled: false
+ autoconfigure:
+ exclude:
+ - org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration
+ - org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
+*/
+```
+
+### 2. 内存优化
+
+```java
+@Configuration
+public class MemoryOptimizationConfig {
+
+ // 1. 使用对象池
+ @Bean
+ public GenericObjectPool expensiveObjectPool() {
+ GenericObjectPoolConfig config = new GenericObjectPoolConfig<>();
+ config.setMaxTotal(10);
+ config.setMaxIdle(5);
+ config.setMinIdle(2);
+
+ return new GenericObjectPool<>(new ExpensiveObjectFactory(), config);
+ }
+
+ // 2. 配置连接池
+ @Bean
+ @ConfigurationProperties(prefix = "spring.datasource.hikari")
+ public HikariDataSource dataSource() {
+ HikariDataSource dataSource = new HikariDataSource();
+ dataSource.setMaximumPoolSize(20);
+ dataSource.setMinimumIdle(5);
+ dataSource.setConnectionTimeout(30000);
+ dataSource.setIdleTimeout(600000);
+ dataSource.setMaxLifetime(1800000);
+ return dataSource;
+ }
+}
+```
+
+---
+
+*这份Spring Boot 2完整学习指南涵盖了从基础概念到高级应用的所有关键知识点，是学习框架和面试准备的完整资料。*
diff --git "a/PHP\347\211\210\346\234\254\346\233\264\346\226\260\346\200\273\347\273\223/PHP-8.1-\346\226\260\347\211\271\346\200\247.md" "b/PHP\347\211\210\346\234\254\346\233\264\346\226\260\346\200\273\347\273\223/PHP-8.1-\346\226\260\347\211\271\346\200\247.md"
new file mode 100644
index 0000000..5def176
--- /dev/null
+++ "b/PHP\347\211\210\346\234\254\346\233\264\346\226\260\346\200\273\347\273\223/PHP-8.1-\346\226\260\347\211\271\346\200\247.md"
@@ -0,0 +1,294 @@
+# PHP 8.1 新特性详解
+
+PHP 8.1 于2021年11月25日发布，是PHP语言的一个重大更新，引入了许多令人兴奋的新特性。
+
+## 🎯 核心新特性
+
+### 1. 枚举 (Enums)
+
+PHP 8.1引入了原生枚举支持，提供了类型安全的常量集合。
+
+```php
+// 纯枚举
+enum Status
+{
+ case PENDING;
+ case RUNNING;
+ case COMPLETED;
+}
+
+// 支持值的枚举
+enum StatusCode: int
+{
+ case PENDING = 1;
+ case RUNNING = 2;
+ case COMPLETED = 3;
+
+ public function label(): string
+ {
+ return match($this) {
+ self::PENDING => '待处理',
+ self::RUNNING => '运行中',
+ self::COMPLETED => '已完成',
+ };
+ }
+}
+
+// 使用示例
+function processTask(Status $status): void
+{
+ match($status) {
+ Status::PENDING => echo "任务待处理",
+ Status::RUNNING => echo "任务运行中",
+ Status::COMPLETED => echo "任务已完成",
+ };
+}
+```
+
+### 2. 纤程 (Fibers)
+
+纤程提供了轻量级的协程支持，允许在任意点暂停和恢复执行。
+
+```php
+$fiber = new Fiber(function (): void {
+ $value = Fiber::suspend('fiber');
+ echo "Value used to resume fiber: ", $value, PHP_EOL;
+});
+
+$value = $fiber->start();
+echo "Value from fiber suspending: ", $value, PHP_EOL;
+
+$fiber->resume('test');
+
+// 实际应用示例
+function fetchData($url) {
+ $fiber = new Fiber(function() use ($url) {
+ $data = Fiber::suspend($url);
+ return processData($data);
+ });
+
+ $suspendedUrl = $fiber->start();
+ $response = httpRequest($suspendedUrl);
+ return $fiber->resume($response);
+}
+```
+
+### 3. 只读属性 (Readonly Properties)
+
+只读属性只能在声明时或构造函数中初始化一次。
+
+```php
+class User
+{
+ public readonly string $id;
+ public readonly string $name;
+
+ public function __construct(string $id, string $name)
+ {
+ $this->id = $id;
+ $this->name = $name;
+ }
+}
+
+$user = new User('123', 'John');
+echo $user->name; // 可以读取
+// $user->name = 'Jane'; // 错误：不能修改只读属性
+```
+
+### 4. 一等可调用语法 (First-class Callable Syntax)
+
+新的语法使得创建可调用对象更加简洁。
+
+```php
+// 旧语法
+$fn = 'strlen';
+$fn = Closure::fromCallable('strlen');
+
+// 新语法
+$fn = strlen(...);
+$fn = $obj->method(...);
+$fn = $obj::staticMethod(...);
+
+// 使用示例
+$numbers = [1, 2, 3, 4, 5];
+$strings = array_map(strval(...), $numbers);
+
+class Calculator
+{
+ public function add($a, $b) { return $a + $b; }
+}
+
+$calc = new Calculator();
+$addFunction = $calc->add(...);
+echo $addFunction(5, 3); // 输出: 8
+```
+
+### 5. 交集类型 (Intersection Types)
+
+允许指定一个值必须同时满足多个类型约束。
+
+```php
+interface Loggable
+{
+ public function log(): void;
+}
+
+interface Cacheable
+{
+ public function cache(): void;
+}
+
+class Service implements Loggable, Cacheable
+{
+ public function log(): void { /* ... */ }
+ public function cache(): void { /* ... */ }
+}
+
+// 交集类型
+function process(Loggable&Cacheable $service): void
+{
+ $service->log();
+ $service->cache();
+}
+
+process(new Service()); // 正确
+```
+
+### 6. never 返回类型
+
+表示函数永远不会正常返回。
+
+```php
+function redirect(string $url): never
+{
+ header('Location: ' . $url);
+ exit();
+}
+
+function throwException(): never
+{
+ throw new Exception('Something went wrong');
+}
+```
+
+## 🔧 其他重要改进
+
+### 新的数组函数
+
+```php
+// array_is_list() - 检查数组是否为列表
+$list = [1, 2, 3];
+$map = ['a' => 1, 'b' => 2];
+
+var_dump(array_is_list($list)); // true
+var_dump(array_is_list($map)); // false
+```
+
+### 新的字符串函数
+
+```php
+// str_contains() 的补充函数
+str_starts_with('Hello World', 'Hello'); // true
+str_ends_with('Hello World', 'World'); // true
+```
+
+### 新的文件系统函数
+
+```php
+// fsync() 和 fdatasync()
+$file = fopen('data.txt', 'w');
+fwrite($file, 'Hello World');
+fsync($file); // 强制写入磁盘
+fclose($file);
+```
+
+## 📈 性能改进
+
+- **JIT编译器优化**: 改进了即时编译器的性能
+- **继承缓存**: 减少了类继承的开销
+- **更快的类解析**: 优化了类和函数的解析速度
+- **内存使用优化**: 减少了内存占用
+
+## ⚠️ 向后不兼容的变更
+
+### 1. 资源到对象的迁移
+
+许多资源类型已转换为对象：
+
+```php
+// PHP 8.0 及之前
+$stream = fopen('file.txt', 'r');
+var_dump(is_resource($stream)); // true
+
+// PHP 8.1
+$stream = fopen('file.txt', 'r');
+var_dump($stream instanceof \GdImage); // 对于GD资源
+```
+
+### 2. 默认错误报告级别变更
+
+```php
+// PHP 8.1 默认包含 E_ALL
+error_reporting(E_ALL); // 新的默认值
+```
+
+## 🚀 升级建议
+
+1. **测试枚举兼容性**: 确保现有代码不与新的enum关键字冲突
+2. **检查只读属性**: 评估在现有类中使用只读属性的机会
+3. **性能测试**: 利用新的性能改进进行基准测试
+4. **代码审查**: 使用新的语法特性改进代码质量
+
+## 📚 实际应用示例
+
+### 状态机实现
+
+```php
+enum OrderStatus: string
+{
+ case PENDING = 'pending';
+ case CONFIRMED = 'confirmed';
+ case SHIPPED = 'shipped';
+ case DELIVERED = 'delivered';
+ case CANCELLED = 'cancelled';
+
+ public function canTransitionTo(self $status): bool
+ {
+ return match([$this, $status]) {
+ [self::PENDING, self::CONFIRMED] => true,
+ [self::PENDING, self::CANCELLED] => true,
+ [self::CONFIRMED, self::SHIPPED] => true,
+ [self::SHIPPED, self::DELIVERED] => true,
+ default => false,
+ };
+ }
+}
+```
+
+### 不可变数据对象
+
+```php
+class Point
+{
+ public readonly float $x;
+ public readonly float $y;
+
+ public function __construct(float $x, float $y)
+ {
+ $this->x = $x;
+ $this->y = $y;
+ }
+
+ public function distance(Point $other): float
+ {
+ return sqrt(
+ pow($this->x - $other->x, 2) +
+ pow($this->y - $other->y, 2)
+ );
+ }
+}
+```
+
+---
+
+*PHP 8.1 为现代PHP开发带来了强大的新工具，特别是枚举和纤程为构建更安全、更高效的应用程序提供了基础。*
diff --git "a/PHP\347\211\210\346\234\254\346\233\264\346\226\260\346\200\273\347\273\223/README.md" "b/PHP\347\211\210\346\234\254\346\233\264\346\226\260\346\200\273\347\273\223/README.md"
new file mode 100644
index 0000000..573284e
--- /dev/null
+++ "b/PHP\347\211\210\346\234\254\346\233\264\346\226\260\346\200\273\347\273\223/README.md"
@@ -0,0 +1,71 @@
+# PHP 8.1-8.4 版本更新总结
+
+本目录整理了PHP 8.1到8.4版本的主要更新内容，包括新特性、改进和重要变更。
+
+## 目录结构
+
+- [PHP 8.1 新特性](./PHP-8.1-新特性.md) - 枚举、纤程、只读属性等
+- [PHP 8.2 新特性](./PHP-8.2-新特性.md) - 只读类、DNF类型等
+- [PHP 8.3 新特性](./PHP-8.3-新特性.md) - 类型化类常量、json_validate等
+- [PHP 8.4 新特性](./PHP-8.4-新特性.md) - 属性钩子、非对称可见性等
+- [版本对比总结](./版本对比总结.md) - 各版本特性对比表
+
+## 版本发布时间线
+
+| 版本 | 发布日期 | 支持状态 |
+|------|----------|----------|
+| PHP 8.1 | 2021-11-25 | 安全修复支持至2024-11-25 |
+| PHP 8.2 | 2022-12-08 | 安全修复支持至2025-12-08 |
+| PHP 8.3 | 2023-11-23 | 活跃支持至2025-11-23 |
+| PHP 8.4 | 2024-11-21 | 活跃支持至2026-11-21 |
+
+## 主要特性概览
+
+### PHP 8.1 核心特性
+- **枚举 (Enums)** - 原生枚举类型支持
+- **纤程 (Fibers)** - 轻量级协程支持
+- **只读属性 (Readonly Properties)** - 不可变属性
+- **一等可调用语法** - 简化回调函数语法
+- **交集类型** - 多类型约束
+
+### PHP 8.2 核心特性
+- **只读类 (Readonly Classes)** - 整个类不可变
+- **DNF类型** - 析取范式类型
+- **敏感参数标记** - 隐藏敏感信息
+- **新的随机数扩展** - 更好的随机数生成
+
+### PHP 8.3 核心特性
+- **类型化类常量** - 类常量类型声明
+- **json_validate()函数** - JSON验证函数
+- **深度克隆只读属性** - 只读属性的深度复制
+- **#[Override]属性** - 方法重写标记
+
+### PHP 8.4 核心特性
+- **属性钩子 (Property Hooks)** - 属性访问器
+- **非对称可见性** - 不同的读写权限
+- **懒加载对象** - 延迟初始化对象
+- **#[Deprecated]属性** - 弃用标记
+
+## 升级建议
+
+1. **从PHP 8.1升级到8.2**: 主要关注只读类和DNF类型的使用
+2. **从PHP 8.2升级到8.3**: 注意类型化类常量的语法变化
+3. **从PHP 8.3升级到8.4**: 重点关注属性钩子和非对称可见性
+
+## 性能改进
+
+每个版本都包含了显著的性能改进：
+- **PHP 8.1**: JIT编译器优化，性能提升5-10%
+- **PHP 8.2**: 内存使用优化，启动时间减少
+- **PHP 8.3**: 类加载优化，运行时性能提升
+- **PHP 8.4**: 属性访问优化，整体性能提升8-15%
+
+## 兼容性注意事项
+
+- 每个新版本都可能包含向后不兼容的变更
+- 建议在升级前进行充分测试
+- 查看各版本的迁移指南了解具体变更
+
+---
+
+*最后更新: 2025-01-25*
diff --git "a/image/\345\205\254\344\274\227\345\217\267\344\272\214\347\273\264\347\240\201\345\233\276\347\211\207.png" "b/image/\345\205\254\344\274\227\345\217\267\344\272\214\347\273\264\347\240\201\345\233\276\347\211\207.png"
deleted file mode 100644
index 9a37ae7..0000000
Binary files "a/image/\345\205\254\344\274\227\345\217\267\344\272\214\347\273\264\347\240\201\345\233\276\347\211\207.png" and /dev/null differ
diff --git "a/image/\345\244\217\345\244\251\347\232\204\351\243\216.jpg" "b/image/\345\244\217\345\244\251\347\232\204\351\243\216.jpg"
deleted file mode 100644
index dcb4c3c..0000000
Binary files "a/image/\345\244\217\345\244\251\347\232\204\351\243\216.jpg" and /dev/null differ
diff --git "a/image/\350\265\236\350\265\217\347\240\201.jpg" "b/image/\350\265\236\350\265\217\347\240\201.jpg"
deleted file mode 100644
index 4599217..0000000
Binary files "a/image/\350\265\236\350\265\217\347\240\201.jpg" and /dev/null differ
diff --git "a/\344\270\255\351\227\264\344\273\266/k8s_share.md" "b/\344\270\255\351\227\264\344\273\266/k8s_share.md"
new file mode 100644
index 0000000..2b2dc29
--- /dev/null
+++ "b/\344\270\255\351\227\264\344\273\266/k8s_share.md"
@@ -0,0 +1,391 @@
+# 📘 Kubernetes（K8s）基础分享
+
+> 面向公司内部开发 / 测试 / 运维同学的入门分享，时长建议 45–60 分钟。
+> 目标：听完之后，每个人都能“说清楚概念 + 看懂 YAML + 自己把一个服务部署到 K8s 上”。
+
+---
+
+## 一、分享目标 & 适用人群
+
+**分享目标**
+- 理解为什么需要 K8s，以及它大概解决什么问题。
+- 掌握 K8s 的核心概念与常用资源类型。
+- 能从 0 写出一个简单的 Deployment + Service 并在集群运行。
+- 知道基本的排错思路和公司内部推荐实践。
+
+**适用人群**
+- 日常编写服务端 / 后端应用的开发同学。
+- 需要在 K8s 环境验证功能的测试同学。
+- 负责环境维护、发布上线的运维 / SRE 同学。
+
+---
+
+## 二、为什么会出现 Kubernetes？
+
+**1. 传统部署方式的痛点**
+- 应用直接部署在物理机 / 虚拟机上：
+ - 环境不一致：依赖库版本、系统配置难以统一。
+ - 资源利用率低：一台机器上只敢跑少量服务，浪费 CPU / 内存。
+ - 部署和回滚麻烦：靠脚本或人工操作，容易出错。
+
+**2. 容器带来的变化**
+- 打包：应用 + 运行时 + 依赖一起打包成镜像，做到“构建一次，到处运行”。
+- 隔离：不同应用之间通过容器隔离，减少相互影响。
+- 启动快：容器秒级拉起，适合弹性扩缩容。
+
+**3. 有了容器还不够：为什么需要 K8s？**
+- 单纯有 Docker 以后，还会遇到：
+ - 有很多容器要管理：放在哪台机器？怎么分配资源？
+ - 容器挂掉怎么办：谁来拉起来、怎么保证副本数？
+ - 外部怎么访问容器：IP 不固定、端口多且混乱。
+ - 多环境、多团队：如何隔离、如何统一配置？
+- Kubernetes 的核心价值：
+ 通过**声明式配置**和一系列控制器，自动地帮我们做**调度、扩缩容、自愈、服务发现和配置管理**。
+
+---
+
+## 三、Kubernetes 整体架构概览
+
+可以把 K8s 理解成一个“集群操作系统”：
+
+```text
+┌─────────────────────────┐
+│ 控制面 Control Plane │（负责“大脑”和控制）
+│ - API Server │
+│ - Scheduler │
+│ - Controller Manager │
+│ - etcd │
+└─────────────┬───────────┘
+ │
+ （通过 API 管理）
+ │
+┌─────────────┴───────────┐
+│ 工作节点 Node │（真正跑容器的“机器”）
+│ - kubelet │
+│ - kube-proxy │
+│ - Container Runtime │
+└─────────────────────────┘
+```
+
+**关键点理解：**
+- `Control Plane`：整个平台的“大脑”和“控制中心”，负责接收我们的配置、做调度和状态维护。
+- `Node`：实际承载 Pod / 容器运行的工作节点，可以是虚机、物理机或云主机。
+- `etcd`：分布式键值存储，保存 K8s 集群的所有状态（配置和元数据）。
+
+---
+
+## 四、核心概念快速扫盲
+
+可以用“一句话”把这些概念串起来：
+
+> 在一个 **Cluster** 中，我们按 **Namespace** 做隔离，在多个 **Node** 上运行 **Pod**。
+> 我们用 **Deployment** 等控制器管理 Pod 的副本和升级，用 **Service / Ingress** 提供稳定访问入口，
+> 用 **ConfigMap / Secret / Volume / PV / PVC** 管理配置和存储，用 **Label / Selector** 把所有资源“串起来”。
+
+### 1. Cluster / Namespace / Node
+
+- **Cluster（集群）**
+ - 一组运行着 K8s 组件的机器的集合，是整个系统的边界。
+ - 一般我们会按环境划分：测试集群、预发集群、生产集群等。
+
+- **Namespace（命名空间）**
+ - 集群内的逻辑隔离单元，类似一个“虚拟子集群”。
+ - 常见用途：按环境（`dev/test/prod`）、按团队或按业务线划分。
+
+- **Node（节点）**
+ - 运行 Pod 的工作机器，可以理解为“宿主机”。
+ - 每个节点上运行 `kubelet`（负责和控制面通信）和 `kube-proxy`（负责网络）。
+
+### 2. Pod：最小调度单位
+
+- 一个 Pod 是一组一同运行在同一 Node 上的容器集合：
+ - 共享同一个 IP 地址和端口空间。
+ - 共享存储卷（Volume）。
+- 常见模式：
+ - 一个 Pod 一个主容器（最常见）。
+ - Sidecar 模式：主容器 + 辅助容器（如日志收集、代理等）。
+- 注意：**Pod 是易失的**，不直接手工管理单个 Pod，而是通过更高层的控制器来管理。
+
+### 3. 控制器：Deployment / StatefulSet / DaemonSet / Job
+
+- **Deployment**
+ - 最常用的无状态应用控制器。
+ - 功能：管理 Pod 副本数、滚动升级、回滚。
+ - 典型场景：Web 服务、API 服务。
+
+- **StatefulSet**
+ - 面向有状态应用（通常需要稳定网络标识 & 持久存储）。
+ - Pod 有固定的序号和稳定名称，如 `xxx-0`、`xxx-1`。
+ - 典型场景：数据库、某些中间件组件。
+
+- **DaemonSet**
+ - 确保每个（或部分）节点上都有一个 Pod 运行。
+ - 典型场景：日志采集 Agent、监控 Agent。
+
+- **Job / CronJob**
+ - Job：一次性任务，执行完成后退出。
+ - CronJob：周期性任务，类似 Linux 的 crontab。
+
+### 4. Service：服务发现与负载均衡
+
+- Pod 的 IP 会变化，不能直接依赖 Pod IP。
+- Service 通过 **Label Selector** 找到一组 Pod，给这组 Pod 提供：
+ - 稳定的虚拟 IP（ClusterIP）。
+ - 在这些 Pod 之间做负载均衡。
+
+常见类型：
+- `ClusterIP`：默认类型，用于集群内部访问。
+- `NodePort`：在每个节点打开一个固定端口，对集群外暴露。
+- `LoadBalancer`：在云环境中创建云厂商的负载均衡器。
+
+### 5. Ingress：统一的 HTTP/HTTPS 入口
+
+- Ingress 提供了 HTTP/HTTPS 层的路由能力：
+ - 按域名路由：`api.xxx.com`、`web.xxx.com`。
+ - 按路径路由：`/api` 转发到服务 A，`/web` 转发到服务 B。
+ - 可以做 TLS/HTTPS 终止。
+- Ingress 本身只是一组规则，需要对应的 **Ingress Controller**（如 Nginx Ingress、Traefik 等）实现。
+
+### 6. 配置与密钥：ConfigMap / Secret
+
+- **ConfigMap**
+ - 保存非敏感配置信息，如应用配置、开关、环境变量等。
+ - 可通过环境变量或挂载文件方式注入到 Pod。
+
+- **Secret**
+ - 保存敏感数据，如密码、Token、证书等。
+ - 只在需要的 Pod 中挂载 / 注入，并配合权限控制。
+
+### 7. 存储：Volume / PV / PVC
+
+- Volume（卷）
+ - 定义在 Pod 内部，生命周期随 Pod。
+ - 用于容器间共享数据或临时数据。
+
+- PersistentVolume（PV）/ PersistentVolumeClaim（PVC）
+ - PV：集群级别的存储资源，通常由运维提供（NFS、云硬盘等）。
+ - PVC：应用侧对存储的“申请”，描述需要多大、什么访问模式。
+ - Pod 通过 PVC 绑定到具体的 PV，做到“存储与 Pod 解耦”。
+
+### 8. Label / Selector / Annotation
+
+- Label：附加在资源上的键值对，如：
+ - `app=order-service`、`env=prod`、`team=payment`
+- Selector：基于 Label 的筛选条件：
+ - Service / Deployment / HPA 等都会通过 Selector 找到相关资源。
+- Annotation：非结构化备注信息，一般给工具或运维使用，不参与筛选。
+
+---
+
+## 五、从 0 到 1：部署一个最简单的 Web 应用
+
+目标：在 K8s 集群里跑一个 Nginx 服务，并通过 Service 访问。
+
+### 1. 前置条件
+- 已有可访问的 K8s 集群（本地 kind / minikube，或公司内部集群）。
+- `kubectl` 已配置好上下文，可以正常执行 `kubectl get nodes`。
+
+### 2. 编写 Deployment + Service（示例）
+
+创建一个文件 `nginx-demo.yaml`：
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: nginx-demo
+ labels:
+ app: nginx-demo
+spec:
+ replicas: 2
+ selector:
+ matchLabels:
+ app: nginx-demo
+ template:
+ metadata:
+ labels:
+ app: nginx-demo
+ spec:
+ containers:
+ - name: nginx
+ image: nginx:1.25
+ ports:
+ - containerPort: 80
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: nginx-demo-svc
+spec:
+ type: NodePort
+ selector:
+ app: nginx-demo
+ ports:
+ - port: 80
+ targetPort: 80
+ nodePort: 30080
+```
+
+### 3. 部署与验证
+
+```bash
+# 部署
+kubectl apply -f nginx-demo.yaml
+
+# 查看 Deployment / Pod / Service
+kubectl get deploy,pod,svc
+
+# 查看某个 Pod 的详细信息
+kubectl describe pod
+
+# 访问（NodePort）
+curl http://<任意节点IP>:30080
+```
+
+通过这个 Demo，可以直观地理解：
+- Deployment 如何管理多副本 Pod。
+- Service 如何给一组 Pod 提供稳定访问入口。
+- YAML 的核心结构和字段。
+
+---
+
+## 六、常用 `kubectl` 命令速查
+
+> 建议在 PPT 中单独放一页，供开发 / 排错时参考。
+
+- 集群与资源查看
+ - `kubectl get nodes`
+ - `kubectl get ns`
+ - `kubectl get pod -A`（查看所有命名空间 Pod）
+ - `kubectl get deploy,svc,ingress`
+
+- 详情与事件
+ - `kubectl describe pod `
+ - `kubectl get events --sort-by=.lastTimestamp`
+
+- 日志与进入容器
+ - `kubectl logs `
+ - `kubectl logs -f -c `
+ - `kubectl exec -it -- /bin/sh`
+
+- 部署与回滚
+ - `kubectl apply -f xxx.yaml`
+ - `kubectl delete -f xxx.yaml`
+ - `kubectl rollout status deployment `
+ - `kubectl rollout undo deployment `
+
+- 资源管理
+ - `kubectl scale deployment --replicas=4`
+ - `kubectl top pod`（需要 metrics-server）
+
+---
+
+## 七、常见问题与排错思路
+
+适合作为分享中互动部分，可以结合实际故障案例讲解。
+
+### 1. Pod 一直是 Pending
+
+常见原因：
+- 集群资源不足：CPU / 内存不够。
+- 节点选择约束太严格：节点亲和 / 污点容忍配置导致排不进去。
+- PVC 未绑定：有持久化存储需求但 PVC 无法绑定 PV。
+
+排查步骤：
+- `kubectl describe pod ` 看调度事件和报错信息。
+- `kubectl get node` 看资源是否充足。
+- 如涉及 PVC：`kubectl get pvc,pv`。
+
+### 2. Pod CrashLoopBackOff / Error
+
+常见原因：
+- 应用自身异常退出，如配置错误、依赖无法连接。
+- 健康检查配置不合理导致频繁重启。
+
+排查步骤：
+- `kubectl logs ` 看容器日志。
+- 查看 liveness / readiness 配置，放宽阈值验证。
+- 在本地/测试环境用相同镜像跑一遍复现问题。
+
+### 3. ImagePullBackOff / ErrImagePull
+
+常见原因：
+- 镜像地址写错、Tag 不存在。
+- 私有仓库认证失败，没有配置 `imagePullSecrets`。
+
+排查步骤：
+- `kubectl describe pod ` 看拉取镜像的报错信息。
+- 确认镜像仓库地址、项目名、Tag 等是否正确。
+- 如是私有仓库，检查 Secret 是否存在并已配置到 Pod。
+
+### 4. Service 访问不通
+
+常见原因：
+- Service 的 selector 与 Pod 的 label 不匹配，导致找不到后端 Pod。
+- 容器内部真实监听端口与 Service 配置的 `targetPort` 不一致。
+- 跨命名空间访问时，使用的 DNS 名称不正确。
+
+排查步骤：
+- `kubectl get endpoints ` 看后端是否有 Pod。
+- 进入 Pod 内使用 `curl localhost:` 验证应用自身是否可用。
+- 在同命名空间 Pod 中访问 `http://:` 进行排查。
+
+### 5. Ingress 不生效
+
+常见原因：
+- 集群未正确安装 Ingress Controller。
+- Ingress 资源中的域名未正确解析到入口 IP。
+- Ingress 规则配置与 Service 名称 / 端口不匹配。
+
+排查步骤：
+- `kubectl get pod -n ` 检查 Ingress Controller 状态。
+- `kubectl describe ingress ` 查看事件与路由规则。
+- 使用 `curl -H "Host: xxx.com" http:///path` 进行验证。
+
+---
+
+## 八、公司内部推荐实践（可根据实际情况调整）
+
+> 这一部分适合结合公司现有平台 / 规范进行二次补充。
+
+- 命名与分组
+ - 按环境：`dev` / `test` / `staging` / `prod` 使用独立 Namespace 或独立集群。
+ - 统一 Label 规范：`app`、`env`、`team`、`owner` 等，方便运维和观测。
+
+- 配置管理
+ - 所有可变配置放到 ConfigMap / Secret 中，不写死在镜像内。
+ - 为不同环境准备不同的配置文件，避免手工改 YAML。
+
+- 资源与伸缩
+ - 为 Pod 设置合理的 `resources.requests` 和 `resources.limits`，避免“谁都抢不到资源”或“有人把机器吃满”。
+ - 核心服务启用 HPA，根据 CPU / QPS / 自定义指标自动扩缩容。
+ - 对核心业务增加 PodDisruptionBudget，保证升级 / 维护时可用实例数。
+
+- 安全与权限
+ - 尽量不要在容器中使用 root 用户运行应用。
+ - Secret 按最小权限原则使用，不在无关 Pod 中挂载。
+ - 配合 RBAC 控制不同角色对集群的访问权限。
+
+- 发布与回滚
+ - 统一通过 CI/CD 平台部署应用，禁止直接手动改线上 Deployment。
+ - 重要变更采用灰度发布：先在部分实例 / 流量上验证，再全量发布。
+ - 使用 Deployment 的滚动升级与回滚能力，快速恢复到上一版本。
+
+---
+
+## 九、参考资料（推荐会后深入阅读）
+
+- 官方文档
+ - Kubernetes 官网主页：
+ - Kubernetes 官方文档（英文）：
+ - Kubernetes 中文文档（社区翻译）：
+
+- 容器基础
+ - Docker 入门指南：
+
+- 进阶书籍（可作为读书会素材）
+ - 《Kubernetes in Action》
+ - 《Kubernetes 权威指南》
+ - 《云原生应用架构实践》
+
+> 建议：分享结束后将本 Markdown 与 Demo YAML 示例一并放到内部代码仓库，后续新同学可以直接跟着文档练习与复现。
diff --git "a/\345\216\237\345\210\233\350\257\227\351\233\206/\345\244\217\345\244\251\347\232\204\351\243\216\346\210\221\346\260\270\350\277\234\350\256\260\345\276\227.md" "b/\345\216\237\345\210\233\350\257\227\351\233\206/\345\244\217\345\244\251\347\232\204\351\243\216\346\210\221\346\260\270\350\277\234\350\256\260\345\276\227.md"
deleted file mode 100644
index 500af79..0000000
--- "a/\345\216\237\345\210\233\350\257\227\351\233\206/\345\244\217\345\244\251\347\232\204\351\243\216\346\210\221\346\260\270\350\277\234\350\256\260\345\276\227.md"
+++ /dev/null
@@ -1,49 +0,0 @@
-夜深了，宁静了。
-朝南的窗，
-我轻轻地打开了。
-夏夜的风，
-温柔且粘人，
-穿过头发，
-吻着耳朵，
-感觉特别舒服。
-
-想起了小时候，
-老家屋子热得发烫~
-我牵着母亲的大手，
-抱着小枕头，
-裹着小凉席，
-一步两步三步，
-走向楼顶，睡觉。
-
-那时候，
-漫天的繁星活泼且迷人，
-对着我不停眨着眼，
-像大眼睛的小女孩子，
-害羞地浅笑。
-月亮也圆圆大大的，
-像个暖心的大姐姐，
-马上要抱着我入眠。
-
-那时候，
-萤火虫似一盏盏小油灯，
-照亮的我小脸蛋。
-知了在吵闹过后，
-也安静了下来，
-周围像人过港空的街道。
-飞机划过苍穹，
-留下隆隆的声音，
-给这个夜，留下美好的快照。
-
-母亲在我耳旁喃喃细语，
-赶紧睡觉吧，
-明天跟我去田里，
-收割水稻。
-
-一听，我心就乐了。
-想到田里有活泼的稻花鱼，
-有早出晚归的小田螺，
-还有喜欢偷吃稻谷的小麻雀。
-慢慢地，进入了梦乡，
-带着对母亲的思念~
-
-最后，提前祝天底下所有的母亲，母亲节快乐~
\ No newline at end of file
diff --git "a/\347\274\223\345\255\230Redis\346\200\273\347\273\223/\347\274\223\345\255\230\344\270\200\350\207\264\346\200\247\346\226\271\346\241\210\345\222\214\347\255\226\347\225\245.md" "b/\347\274\223\345\255\230Redis\346\200\273\347\273\223/\347\274\223\345\255\230\344\270\200\350\207\264\346\200\247\346\226\271\346\241\210\345\222\214\347\255\226\347\225\245.md"
new file mode 100644
index 0000000..77ddf8c
--- /dev/null
+++ "b/\347\274\223\345\255\230Redis\346\200\273\347\273\223/\347\274\223\345\255\230\344\270\200\350\207\264\346\200\247\346\226\271\346\241\210\345\222\214\347\255\226\347\225\245.md"
@@ -0,0 +1,809 @@
+# 缓存一致性方案和策略 - 面试必备
+
+## 📋 目录
+- [缓存一致性问题概述](#缓存一致性问题概述)
+- [常见的缓存一致性方案](#常见的缓存一致性方案)
+- [缓存更新策略](#缓存更新策略)
+- [分布式缓存一致性](#分布式缓存一致性)
+- [实际应用场景](#实际应用场景)
+- [面试常见问题](#面试常见问题)
+
+## 🎯 缓存一致性问题概述
+
+### 什么是缓存一致性问题？
+
+缓存一致性问题是指缓存中的数据与数据库中的数据不一致的情况，主要表现为：
+
+1. **数据不一致**：缓存和数据库中的数据值不同
+2. **时效性问题**：缓存中的数据已过期但仍被使用
+3. **并发问题**：多个请求同时操作导致的数据不一致
+
+### 产生原因
+
+```java
+// 典型的缓存不一致场景
+public class UserService {
+
+ // 场景1：先更新数据库，再删除缓存
+ public void updateUser(User user) {
+ // 1. 更新数据库
+ userDao.update(user);
+
+ // 2. 删除缓存 - 如果这步失败，就会出现不一致
+ redisTemplate.delete("user:" + user.getId());
+ }
+
+ // 场景2：并发读写导致的不一致
+ public User getUser(Long userId) {
+ String key = "user:" + userId;
+ User user = redisTemplate.get(key);
+
+ if (user == null) {
+ // 从数据库查询
+ user = userDao.findById(userId);
+ if (user != null) {
+ // 写入缓存 - 并发情况下可能写入旧数据
+ redisTemplate.set(key, user, 3600);
+ }
+ }
+ return user;
+ }
+}
+```
+
+## 🔧 常见的缓存一致性方案
+
+### 1. Cache Aside Pattern（旁路缓存）
+
+**读操作流程：**
+```java
+public User getUserById(Long userId) {
+ String key = "user:" + userId;
+
+ // 1. 先查缓存
+ User user = redisTemplate.opsForValue().get(key);
+ if (user != null) {
+ return user;
+ }
+
+ // 2. 缓存未命中，查数据库
+ user = userDao.findById(userId);
+ if (user != null) {
+ // 3. 写入缓存
+ redisTemplate.opsForValue().set(key, user, Duration.ofHours(1));
+ }
+
+ return user;
+}
+```
+
+**写操作流程：**
+```java
+public void updateUser(User user) {
+ // 方案1：先更新数据库，再删除缓存（推荐）
+ userDao.update(user);
+ redisTemplate.delete("user:" + user.getId());
+
+ // 方案2：先删除缓存，再更新数据库
+ // redisTemplate.delete("user:" + user.getId());
+ // userDao.update(user);
+}
+```
+
+### 2. Write Through Pattern（写穿透）
+
+```java
+@Service
+public class CacheWriteThroughService {
+
+ public void updateUser(User user) {
+ // 同时更新缓存和数据库
+ CompletableFuture dbUpdate = CompletableFuture.runAsync(() -> {
+ userDao.update(user);
+ });
+
+ CompletableFuture cacheUpdate = CompletableFuture.runAsync(() -> {
+ redisTemplate.opsForValue().set("user:" + user.getId(), user);
+ });
+
+ // 等待两个操作都完成
+ CompletableFuture.allOf(dbUpdate, cacheUpdate).join();
+ }
+}
+```
+
+### 3. Write Behind Pattern（写回）
+
+```java
+@Component
+public class WriteBehindCache {
+
+ private final Map writeBuffer = new ConcurrentHashMap<>();
+
+ @Scheduled(fixedDelay = 5000) // 每5秒执行一次
+ public void flushToDatabase() {
+ if (!writeBuffer.isEmpty()) {
+ Map toFlush = new HashMap<>(writeBuffer);
+ writeBuffer.clear();
+
+ // 批量写入数据库
+ batchUpdateDatabase(toFlush);
+ }
+ }
+
+ public void updateUser(User user) {
+ // 立即更新缓存
+ String key = "user:" + user.getId();
+ redisTemplate.opsForValue().set(key, user);
+
+ // 加入写缓冲区，延迟写入数据库
+ writeBuffer.put(key, user);
+ }
+}
+```
+
+## 🔄 缓存更新策略
+
+### 1. 延迟双删策略
+
+```java
+public void updateUserWithDelayedDoubleDelete(User user) {
+ // 第一次删除缓存
+ redisTemplate.delete("user:" + user.getId());
+
+ // 更新数据库
+ userDao.update(user);
+
+ // 延迟删除缓存
+ CompletableFuture.runAsync(() -> {
+ try {
+ Thread.sleep(1000); // 延迟1秒
+ redisTemplate.delete("user:" + user.getId());
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ });
+}
+```
+
+### 2. 基于消息队列的异步更新
+
+```java
+@Service
+public class AsyncCacheUpdateService {
+
+ @Autowired
+ private RabbitTemplate rabbitTemplate;
+
+ public void updateUser(User user) {
+ // 更新数据库
+ userDao.update(user);
+
+ // 发送缓存更新消息
+ CacheUpdateMessage message = new CacheUpdateMessage();
+ message.setKey("user:" + user.getId());
+ message.setOperation("DELETE");
+
+ rabbitTemplate.convertAndSend("cache.update.exchange",
+ "cache.update.routing.key",
+ message);
+ }
+
+ @RabbitListener(queues = "cache.update.queue")
+ public void handleCacheUpdate(CacheUpdateMessage message) {
+ if ("DELETE".equals(message.getOperation())) {
+ redisTemplate.delete(message.getKey());
+ }
+ }
+}
+```
+
+### 3. 基于版本号的乐观锁
+
+```java
+@Entity
+public class User {
+ @Id
+ private Long id;
+ private String name;
+ private String email;
+
+ @Version
+ private Long version; // 版本号
+
+ // getters and setters
+}
+
+@Service
+public class OptimisticLockCacheService {
+
+ public void updateUser(User user) {
+ String key = "user:" + user.getId();
+
+ try {
+ // 更新数据库（乐观锁）
+ int updated = userDao.updateWithVersion(user);
+
+ if (updated > 0) {
+ // 更新成功，删除缓存
+ redisTemplate.delete(key);
+ } else {
+ // 更新失败，版本冲突
+ throw new OptimisticLockException("数据已被其他用户修改");
+ }
+ } catch (OptimisticLockException e) {
+ // 处理版本冲突
+ redisTemplate.delete(key); // 删除可能过期的缓存
+ throw e;
+ }
+ }
+}
+```
+
+## 🌐 分布式缓存一致性
+
+### 1. 基于Redis的分布式锁
+
+```java
+@Component
+public class DistributedCacheConsistency {
+
+ @Autowired
+ private RedisTemplate redisTemplate;
+
+ public void updateUserWithDistributedLock(User user) {
+ String lockKey = "lock:user:" + user.getId();
+ String lockValue = UUID.randomUUID().toString();
+
+ try {
+ // 获取分布式锁
+ Boolean acquired = redisTemplate.opsForValue()
+ .setIfAbsent(lockKey, lockValue, Duration.ofSeconds(30));
+
+ if (acquired) {
+ // 更新数据库
+ userDao.update(user);
+
+ // 删除缓存
+ redisTemplate.delete("user:" + user.getId());
+ } else {
+ throw new RuntimeException("获取锁失败，请稍后重试");
+ }
+ } finally {
+ // 释放锁
+ releaseLock(lockKey, lockValue);
+ }
+ }
+
+ private void releaseLock(String lockKey, String lockValue) {
+ String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
+ "return redis.call('del', KEYS[1]) else return 0 end";
+
+ redisTemplate.execute(new DefaultRedisScript<>(script, Long.class),
+ Collections.singletonList(lockKey), lockValue);
+ }
+}
+```
+
+### 2. 基于Canal的数据同步
+
+```java
+@Component
+public class CanalCacheSync {
+
+ @EventListener
+ public void handleDatabaseChange(CanalEntry.Entry entry) {
+ if (entry.getEntryType() == CanalEntry.EntryType.ROWDATA) {
+ CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
+
+ for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
+ if (rowChange.getEventType() == CanalEntry.EventType.UPDATE ||
+ rowChange.getEventType() == CanalEntry.EventType.DELETE) {
+
+ // 解析主键
+ String primaryKey = extractPrimaryKey(rowData);
+
+ // 删除对应的缓存
+ String cacheKey = "user:" + primaryKey;
+ redisTemplate.delete(cacheKey);
+
+ log.info("缓存已删除: {}", cacheKey);
+ }
+ }
+ }
+ }
+}
+```
+
+## 💡 实际应用场景
+
+### 场景1：电商商品信息缓存
+
+```java
+@Service
+public class ProductCacheService {
+
+ // 商品信息查询
+ public Product getProduct(Long productId) {
+ String key = "product:" + productId;
+
+ // 1. 查询缓存
+ Product product = redisTemplate.opsForValue().get(key);
+ if (product != null) {
+ return product;
+ }
+
+ // 2. 查询数据库
+ product = productDao.findById(productId);
+ if (product != null) {
+ // 3. 写入缓存，设置随机过期时间避免缓存雪崩
+ int expireTime = 3600 + new Random().nextInt(600); // 1-1.1小时
+ redisTemplate.opsForValue().set(key, product, Duration.ofSeconds(expireTime));
+ }
+
+ return product;
+ }
+
+ // 商品信息更新
+ @Transactional
+ public void updateProduct(Product product) {
+ // 1. 更新数据库
+ productDao.update(product);
+
+ // 2. 删除相关缓存
+ String productKey = "product:" + product.getId();
+ String categoryKey = "category:products:" + product.getCategoryId();
+
+ redisTemplate.delete(productKey);
+ redisTemplate.delete(categoryKey);
+
+ // 3. 发送缓存更新事件
+ applicationEventPublisher.publishEvent(new ProductUpdatedEvent(product.getId()));
+ }
+}
+```
+
+### 场景2：用户会话缓存
+
+```java
+@Service
+public class UserSessionCacheService {
+
+ public void updateUserSession(String sessionId, UserSession session) {
+ String key = "session:" + sessionId;
+
+ // 使用Redis事务确保一致性
+ redisTemplate.execute(new SessionCallback