feat:增加字体

2025-11-27 14:44:19 +08:00
parent c064dfc417
commit daab0c4495
21 changed files with 1045 additions and 125 deletions
--- a/docs/SpringBoot/SpringBoot3-GraalVM.md
+++ b/docs/SpringBoot/SpringBoot3-GraalVM.md
@@ -0,0 +1,72 @@
+# 一、原生镜像
+&emsp;&emsp;传统 Java 应用基于 JVM 运行，需要加载完整的类库和 JVM 运行时环境，导致启动时间长、内存占用高。而**原生镜像技术通过提前编译（AOT）将 Java 应用直接编译为本地机器码，无需 JVM 即可运行**，具有以下核心优势：
+
+1. 启动速度极快：毫秒级启动，相比传统 JVM 应用提升 10-100 倍、
+2. 内存占用低：仅包含应用运行所需的最小资源集合
+3. 部署体积小：通常为传统 JAR 包的 1/10 左右
+4. 适合云原生场景：尤其适合 Kubernetes 等容器化环境
+
+# 二、安装使用
+## 2.1 基础软件
+1. GraalVM（类似于JAVA JDK）下载：[官网](https://www.graalvm.org/downloads/)，下载完成后需要配置环境变量
+2. native-image安装：cmd运行：gu install native-image
+3. Visual Studio Community2022 选择：使用C++的桌面开发
+
+## 2.2 结合Springboot3 项目
+1. IDEA创建Springboot3项目
+2. Project Structure选择GraalVM JDK
+3. 配置pom打包
+```xml
+<plugins>
+  <!-- 将项目打包成可执行的 JAR/WAR 文件 -->
+  <!-- repackage目标会替换 Maven 默认的打包行为 -->
+  <!-- 使 JAR/WAR 文件包含所有依赖项，成为一个独立运行的应用 -->
+  <plugin>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-maven-plugin</artifactId>
+      <executions>
+          <execution>
+              <goals>
+                  <goal>repackage</goal>
+                  <!-- 执行 AOT 编译 -->
+                  <goal>process-aot</goal>
+              </goals>
+          </execution>
+      </executions>
+  </plugin>
+
+  <!-- GraalVM Native Maven 插件 -->
+  <plugin>
+      <groupId>org.graalvm.buildtools</groupId>
+      <artifactId>native-maven-plugin</artifactId>
+      <version>0.10.2</version>
+      <configuration>
+          <buildArgs combine.children="append">
+              <!-- 支持 http 协议 -->
+              <buildArg>--enable-url-protocols=http</buildArg>
+              <!-- 用于解决数据库中文乱码问题 -->
+              <buildArg>-H:+AddAllCharsets</buildArg>
+          </buildArgs>
+      </configuration>
+      <executions>
+          <execution>
+              <id>build-native</id>
+              <goals>
+                  <goal>compile-no-fork</goal>
+              </goals>
+          </execution>
+      </executions>
+  </plugin>
+</plugins>
+```
+4. 选择Maven->Lifecycle->clean和package，或者输入命令：mvn -Pnative native:compile
+5. 在target目录下可以看到生成的.exe文件，打开运行即可。
+
+## 三、注意事项
+&emsp;&emsp;实际体验下来发现主要存在以下几个问题
+1. 编译打包的速度非常慢
+2. 目前有些第三方库并不支持（Mybatis已支持，Mybatis Plus暂不支持）
+
+# 四、参考资料
+1. [使用 Spring Boot 和 GraalVM 构建原生镜像](https://springdoc.cn/spring-native-intro/)
+2. [GraalVM 原生镜像支持](https://docs.springframework.org.cn/spring-boot/reference/native-image/introducing-graalvm-native-images.html)
--- a/docs/SpringBoot/SpringBootBean.md
+++ b/docs/SpringBoot/SpringBootBean.md
@@ -0,0 +1,60 @@
+## 一、Bean概念
+### 1.1 定义
+&emsp;&emsp;Spring bean是Spring框架在运行时管理的对象，Bean是一个由Spring IoC容器实例化、组装和管理的对象。  
+&emsp;&emsp;一个 Bean 可以是任何普通的 Java 对象，例如 POJO、Service、Respository、Controller 等等。将一个类声明为 Bean 的方式可以是在类级别上使用 `@Component` 注解或其派生注解（`@Service`、`@Repository`、`@Controller`等），也可以是通过配置文件进行显式的声明。
+
+### 1.2 实例化
+&emsp;&emsp;Spring 容器负责实例化 Bean。当应用程序启动时，Spring 容器会根据配置信息或注解扫描的结果，找到并实例化所有被标记为 Bean 的类，并将它们加入容器中。实例化的过程由 Spring 的 IoC 容器负责。
+
+### 1.3 管理
+&emsp;&emsp;一旦 Bean 被实例化，Spring 容器将负责管理 Bean 的生命周期和依赖关系。它会根据配置文件或注解的信息，自动解决 Bean 之间的依赖关系，确保在需要的时候正确的注入依赖。Spring 容器还会负责销毁不再需要的 Bean。
+
+### 1.4 依赖注入
+&emsp;&emsp;依赖注入是 Spring 框架的一个重要特性，它允许通过自动或显式配置的方式将 Bean 的依赖项注入到其它 Bean 中。依赖注入可以通过构造函数注入、Setter 方法注入或字段注入的方式实现，其中最常见的是使用 `@Autowired`注解进行注入。
+
+### 1.5 作用域
+&emsp;&emsp;Spring 框架提供了多种作用域（scope）来管理 Bean 的生命周期。常见的作用域包括单例（Singleton）、原型（Prototype）、会话（Session）、请求（Request）等。默认情况下，Bean 是单例的，即每个容器中只存在一个实例。但可以根据需要配置其它作用域。
+
+### 1.6 自动装配
+&emsp;&emsp;Spring Boot 支持自动装配（Auto - wiring），它能够根据类型或名称自动解析和注入依赖关系。通过在需要注入的字段、构造函数或 Setter 方法上使用 `@Autowired` 注解，Spring 容器会自动查找并注入对应的 Bean。
+
+## 二、Bean生命周期
+![暂无图片](https://cxx0822.iepose.cn/rustfs/blog/b30628a6b1fa3cfd250cc5efff612a68.jpg 'Bean生命周期.jpg')
+
+### 2.1 实例化
+&emsp;&emsp;指创建对象的过程，也就是说，当 Spring 容器启动时，它会扫描所有的配置文件，读取 Bean 定义，然后根据定义创建 Bean 对象的实例。这个过程中，Spring 容器会使用反射机制来调用 Bean 的构造函数来实例化对象。
+
+### 2.2 属性赋值
+&emsp;&emsp;对 Bean 的实例化对象进行属性填充；
+
+### 2.3 初始化
+&emsp;&emsp;指 Bean 对象被创建后，Spring 容器会根据配置文件中的定义来对其进行一系列的属性设置、依赖注入等操作，使其可以正常运行。这个过程中，Spring 容器会调用 Bean 的一些特定方法，如 set 方法、init-method 方法等来完成对象的初始化。
+
+### 2.4 销毁
+&emsp;&emsp;执行一些预定义的销毁方法；
+
+## 三、Bean注解——@Component 
+### 基本概念
+&emsp;&emsp;@Component 是 Spring 框架中的一个注解，用于将类标记为 Spring 管理的组件。当一个类被 @Component 注解修饰时，Spring 会在启动时自动扫描并将该类实例化为 Bean，放入应用程序的上下文（ApplicationContext）中，以便在其他地方可以通过依赖注入使用。
+
+### 主要作用
+1. 组件扫描：Spring 通过组件扫描机制自动发现并注册被 @Component 注解的类。
+2. Bean 定义：被注解的类会被视为 Spring Bean，由 Spring 容器管理其生命周期。
+3. 依赖注入：其他组件可以通过注解（如 @Autowired）注入这些 Bean。
+
+### 其他衍生注解
+| **注解**         | **所属层**         | **继承关系**      | **适用场景**                                                                 |
+|------------------|--------------------|-------------------|----------------------------------------------------------------------------|
+| **@Component**   | 通用组件           | 基础注解          | 不适合特定层的组件（如工具类、配置类）                                       |
+| **@Repository**  | 数据访问层 (DAO)   | 继承 @Component   | 数据库操作类、ORM 映射类（如 JPA Repository）                                |
+| **@Service**     | 服务层 (Service)   | 继承 @Component   | 业务逻辑处理（如订单处理、用户认证）                                         |
+| **@Controller**  | 控制层 (MVC/Web)   | 继承 @Component   | 处理 HTTP 请求的控制器（如 REST API、Web 页面控制器）                         |
+| **@RestController** | 控制层 (REST API) | 继承 @Controller  | RESTful API 接口开发                                                         |
+
+| **注解**         | **功能描述**                                                                 | **Spring 自动处理特性**                                                                       |
+|------------------|-----------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|
+| **@Component**   | 标记类为 Spring Bean，通过组件扫描自动注册。<br>无特定语义，是其他组件注解的基础。                 | - Bean 生命周期管理<br>- 依赖注入支持                                                                 |
+| **@Repository**  | 标记数据访问组件（如数据库操作类），<br>自动处理数据访问异常。 | - 异常转换<br>- DAO 组件扫描                                                        |
+| **@Service**     | 标记业务逻辑组件，负责处理业务流程、事务管理等。<br>提供语义化，明确该类在架构中的角色。                  | - 与 @Transactional 注解默认集成<br>- IDE 识别为服务层组件                                                     |
+| **@Controller**  | 标记 Web 控制器，处理 HTTP 请求。<br>与 Spring MVC 框架紧密集成。                              | - 请求映射自动注册<br>- 支持 @RequestMapping、@GetMapping 等注解<br>- 视图解析（返回视图名称或 JSON）               |
+| **@RestController** | @Controller + @ResponseBody 的组合，专门用于 RESTful API，直接返回 JSON/XML 等数据。                  | - 所有方法默认返回 JSON/XML（无需每个方法添加 @ResponseBody）                                                                 |
--- a/docs/SpringBoot/SpringBootStarter.md
+++ b/docs/SpringBoot/SpringBootStarter.md
@@ -0,0 +1,105 @@
+# 一、简介
+&emsp;&emsp;Spring Boot Starter是一组预定义的依赖项集合，旨在简化Maven或Gradle等构建工具中的依赖管理。每个Starter都包含了实现特定功能所需的库和组件，以及相应的配置文件。开发者只需在项目中引入相应的Starter依赖，即可快速搭建起具备该功能的项目骨架。  
+&emsp;&emsp;Starter=依赖+自动配置+配置文件
+
+# 二、实现原理
+## 2.1 传统实现
+&emsp;&emsp;例如引入Spring中的jpa，则需要以下步骤：
+1. 在Maven中引入数据库依赖
+2. 在Maven中引入jpa依赖
+3. 在配置文件中配置属性
+4. 调试程序
+
+&emsp;&emsp;每次新建项目都需要重复此流程，操作繁琐。
+
+## 2.2 自定义Starter实现
+1. 新建Maven项目，在pom.xml文件中定义需要的依赖项。
+2. 创建自动配置类 AutoConfigurationTest，添加@configuration注解，使其能够被SpringBoot自动扫描到。
+3. 添加自动装配机制，在src/main/resources/META-INF文件夹下创建spring.factories文件，添加以下配置：
+
+```bash
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+com.example.springbootstartercustom.AutoConfigurationTest
+```
+
+&emsp;&emsp;注：这里文件夹和文件名一定要正确，因此SpringFactoriesLoader中就是这么定义的。
+
+4. 在配置文件中自定义属性（可选）。
+5. 安装打包到maven仓库中。
+6. 其他项目通过pom.xml文件引入该starter。
+
+## 2.3 Starter实现原理
+&emsp;&emsp;加载依赖->扫描自动配置类->加载配置文件
+
+# 三、高级特性
+## 3.1 可插拔Starter
+&emsp;&emsp;所谓可插拔就是可以自行决定是否需要加载该starter的功能。例如可以通过注解的方式决定是否加载。
+
+1. 定义注解
+
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface EnableAutoConfigTest {
+    
+}
+```
+
+2. 在自动配置类 AutoConfiguration中增加条件注解
+
+```java
+@Configuration
+@ConditionalOnBean(annotation = EnableAutoConfigTest.class)
+public class AutoConfigurationTest {
+}
+```
+
+3. 在相应位置添加@EnableAutoConfigTest注解该stater才会生效。
+
+## 3.2 自定义配置文件
+&emsp;&emsp;所谓自定义配置文件，就是可以在引入stater后，可以通过修改配置文件覆盖原来的配置属性，从而灵活配置stater功能。
+
+1. 引用spring-boot-configuration-processor
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-configuration-processor</artifactId>
+  <optional>true</optional>
+</dependency>
+```
+
+2. 定义Properties配置类
+
+```java
+@ConfigurationProperties(prefix = "test")
+public class TestProperties {
+    private String name = "test";
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+```
+
+3. 在自动配置类 AutoConfigurationTest中引用
+
+```java
+@Configuration(proxyBeanMethods = false)
+@Import({TestProperties.class})
+public class AutoConfigurationTest {
+    @Resource
+    private TestProperties testProperties;
+}
+```
+
+4. 在引入的stater工程中，修改配置文件：
+
+```yaml
+test:
+  name: test1
+```
--- a/docs/SpringBoot/SpringMVC.md
+++ b/docs/SpringBoot/SpringMVC.md
@@ -0,0 +1,89 @@
+# 一、基础概念
+&emsp;&emsp;Spring MVC（Spring Model-View-Controller）是 Spring Framework 中的一部分，它是一个基于 **<font style="color:#DF2A3F;">请求驱动</font>** 的 Web 框架，主要用于构建 Web 应用程序，并且遵循 MVC（模型-视图-控制器） 设计模式。它将 Web 应用的业务逻辑、用户界面和请求处理分离，使得代码更加模块化和可维护。
+
+# 二、具体流程
+![暂无图片](https://cxx0822.iepose.cn/rustfs/blog/04fb16a3e32f247bbf0bb7e176de8444.png '具体流程.png')
+
+1. **客户端发起HTTP请求**  
+
+&emsp;&emsp;客户端（浏览器、API 客户端等）向服务器发送 HTTP 请求。请求包含了目标 URL、HTTP 方法（GET、POST 等）以及可能的请求参数。
+前端通过发送 HTTP 请求（通常是 AJAX 请求）到后端的 API 端点，并期望获得响应（通常是 JSON 数据）。
+
+2. **请求到达 DispatcherServlet**  
+
+&emsp;&emsp;所有 HTTP 请求都会先到达 Spring MVC 的核心组件：**<font style="color:#DF2A3F;">DispatcherServlet</font>**。它是前端控制器，负责将请求分发给正确的处理器。DispatcherServlet 是所有请求的入口，Spring Boot 会自动配置它。  
+&emsp;&emsp;DispatcherServlet 接受所有的 HTTP 请求，根据请求 URL 和 HTTP 方法，定位匹配的控制器方法，将请求交给相应的 Handler Mapping 来匹配控制器。在请求处理前后，执行 拦截器（可选）。最终通过 View Resolver 返回一个合适的视图（对于 RESTful API，通常返回 JSON 格式的数据）。
+
+3. **查找处理器（Handler Mapping）**
+
+&emsp;&emsp;DispatcherServlet 根据请求的 URL 和 HTTP 方法，查找与之匹配的处理器方法（通常是一个控制器中的方法）。这是由 HandlerMapping 完成的。Spring MVC 提供了多种方式来映射 URL 到控制器方法，例如 @RequestMapping、@GetMapping 等注解。  
+&emsp;&emsp;@RestController：该注解标记的类会返回 JSON 数据。  
+&emsp;&emsp;@RequestMapping：用于映射 URL 路径和 HTTP 方法。  
+&emsp;&emsp;@GetMapping、@PostMapping 等：简化版本的 @RequestMapping。  
+
+4. **执行拦截器（Interceptor）**
+
+&emsp;&emsp;在请求到达控制器之前，DispatcherServlet 会依次执行配置的拦截器。拦截器主要用于日志记录、安全检查、请求参数的预处理等。  
+&emsp;&emsp;preHandle：请求进入控制器方法之前。  
+&emsp;&emsp;postHandle：请求完成后，视图渲染之前。  
+&emsp;&emsp;afterCompletion：视图渲染完成后。  
+&emsp;&emsp;**<font style="color:#DF2A3F;">如果拦截器的 preHandle 方法返回 false，请求会被拦截，后续的处理不会继续进行。</font>**
+
+5. **控制器方法处理请求（Handler Execution）**
+
+&emsp;&emsp;DispatcherServlet 调用合适的控制器方法来处理请求。控制器方法负责处理请求的业务逻辑，并返回一个 Java 对象，这个对象会被自动转换成 JSON 格式返回给客户端。  
+&emsp;&emsp;Spring 通过 @ResponseBody 注解（或 @RestController）实现将 Java 对象自动转换为 JSON 格式。默认情况下，Spring 使用 Jackson 来将 Java 对象序列化成 JSON 数据。  
+&emsp;&emsp;@RestController：将控制器标记为返回 JSON 数据的 RESTful 控制器。  
+&emsp;&emsp;@ResponseBody：标记方法返回的数据需要直接作为响应体返回，而不是解析为视图。  
+&emsp;&emsp;@RequestParam：用于获取单个请求参数。  
+&emsp;&emsp;@PathVariable：用于从 URL 中提取变量（如 /users/{id} 中的 {id}）。  
+
+6. **响应返回客户端**
+
+&emsp;&emsp;DispatcherServlet 将处理完的结果（JSON 数据）返回给客户端。响应数据通常会包含：  
+&emsp;&emsp;**状态码**：如 200 OK（成功）、201 Created（资源创建成功）、404 Not Found（资源未找到）、500 Internal Server Error（服务器错误）等。  
+&emsp;&emsp;**响应头**：通常包括 Content-Type: application/json，表示响应体是 JSON 格式。  
+&emsp;&emsp;**响应体**：包含返回的数据，通常是一个 JSON 格式的对象或数组。  
+
+注：以上只适用于基于RESTful API 前后端分离的架构。
+
+# 三、完整流程
+![暂无图片](https://cxx0822.iepose.cn/rustfs/blog/cad3b69253771b02b07d94f7d01c0e4f.png '完整流程.png')
+&emsp;&emsp;在SpringMVC前面还有Tomcat容器层。客户端发起请求后，先经过Tomcat容器，根据请求的 URL 确定该请求是否是静态资源请求（如 .html、.css、.js）。如果是静态资源请求，Tomcat 会直接返回文件，而不经过 Spring MVC 的请求处理链。对于动态请求（如请求 /user 等），Tomcat 会将这些请求交给 DispatcherServlet 进行处理。  
+&emsp;&emsp;在进入DispatcherServlet前可以增加过滤器进行处理。过滤器不属于Spring部分。  
+&emsp;&emsp;Tomcat 是一个轻量级的 Web 服务器和 Servlet 容器，支持 Java Servlet 和 JSP 规范，能够处理 HTTP 请求并生成动态 Web 内容。  
+&emsp;&emsp;Servlet 是 Java 编写的服务器端程序，能够接收 HTTP 请求并生成响应，它是动态 Web 内容生成的核心技术。  
+&emsp;&emsp;Tomcat 管理 Servlet 的生命周期，并负责处理客户端的请求和返回响应。  
+
+# 四、重要知识点
+## 4.1 拦截器和过滤器区别
+1. 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
+2. 拦截器只能对action请求(DispatcherServlet 映射的请求)起作用，而过滤器则可以对几乎所有的请求起作用。
+3. 拦截器可以访问容器中的Bean(DI)，而过滤器不能访问（基于spring注册的过滤器也可以访问容器中的bean）。
+4. 执行顺序：过滤器->拦截器
+
+## 4.2 拦截器执行顺序
+&emsp;&emsp;HandlerInterceptor 拦截器执行顺序：
+1. preHandle()：请求处理前 按注册顺序依次执行。
+2. Controller：请求处理 请求到达Controller并被处理。
+3. postHandle()：请求处理后，视图渲染前 按注册顺序逆序执行。
+4. afterCompletion()：视图渲染后 按注册顺序逆序执行。
+
+## 4.3 请求和响应体拦截器
+&emsp;&emsp;RequestBodyAdvice, ResponseBodyAdvice主要发生在Controller执行前后：
+1. preHandle()：请求处理前
+2. beforeBodyRead：请求体反序列化前
+3. @RequestBody：Controller方法参数绑定
+4.  Controller：请求处理
+5. beforeBodyWrite()：响应体序列化之前
+6. postHandle()：请求处理后
+7. 视图渲染
+8. afterCompletion()：请求结束
+
+## 4.4  @Controller 和 @RestController区别
+&emsp;&emsp;@Controller：用于定义一个 Spring MVC 控制器类。它通常用于返回视图（如 JSP 或 Thymeleaf）。  
+&emsp;&emsp;@RestController：是 @Controller 和 @ResponseBody 的组合，用于开发 RESTful API。它将方法的返回值直接写入 HTTP 响应体中，通常返回 JSON 或 XML 格式的数据。  
+
+## 4.5 异常处理
+&emsp;&emsp;@ExceptionHandler：用于控制器类或方法中处理特定异常。它会捕获指定的异常并返回相应的响应（如错误页面、错误消息等）。  
+&emsp;&emsp;@ControllerAdvice：是一个全局异常处理器，用于捕获应用中所有控制器抛出的异常。
--- a/docs/SpringBoot/index.md
+++ b/docs/SpringBoot/index.md
@@ -7,3 +7,7 @@ title: SpringBoot

 - [Spring IOC简介](/SpringBoot/SpringIOC)
 - [SpringBoot启动流程](/SpringBoot/SpringBoot-Start-Process)
+- [Spring MVC简介](/SpringBoot/SpringMVC)
+- [SpringBoot Starter原理](/SpringBoot/SpringBootStarter)
+- [SpringBoot Bean简介](/SpringBoot/SpringBootBean)
+- [SpringBoot3原生镜像](/SpringBoot/SpringBoot3-GraalVM)