1829 lines
59 KiB
Markdown
1829 lines
59 KiB
Markdown
# `Spring`笔记
|
||
|
||
- 公共AI网站：https://chatgptplus.cn/
|
||
- vue3官网：https://cn.vuejs.org/
|
||
- SpringBoot官网：https://docs.spring.io/spring-boot/index.html
|
||
|
||
## Ant风格访问
|
||
|
||
Spring MVC 支持 **Ant 风格**（Ant-style path matching）主要体现在 URL 路径匹配模式上。这种模式是 Spring Web 框架用来进行 URL 模式匹配的一种方式，借用了 Apache Ant（一个流行的 Java 构建工具）中的路径匹配规则。Ant 风格的路径匹配使得 URL 路径映射更加灵活和方便。
|
||
|
||
- `*` 匹配单一路径层级中的任意字符。
|
||
- `**` 匹配任意多个路径层级。
|
||
- `?` 匹配单个字符。
|
||
|
||
### 1. **Ant 风格路径匹配规则**
|
||
|
||
Ant 风格的路径匹配规则中有几个特殊字符，分别是 `*`、`**` 和 `?`，它们具有不同的匹配意义：
|
||
|
||
#### (1) `*`（匹配零个或多个字符）
|
||
|
||
- `*` 可以匹配路径中的任何部分，但只能匹配单一层级中的路径。
|
||
- 举个例子，`/foo/*` 可以匹配 `/foo/bar` 或 `/foo/abc`，但不能匹配 `/foo/bar/baz`。
|
||
- 示例：
|
||
- `/foo/*` 匹配 `/foo/bar`。
|
||
- `/foo/*/bar` 匹配 `/foo/abc/bar`。
|
||
|
||
#### (2) `**`（匹配零个或多个目录）
|
||
|
||
- `**` 可以匹配多个目录层级，它比 `*` 更加强大，能够跨越多个层级。
|
||
- 示例：
|
||
- `/foo/**/bar` 匹配 `/foo/bar`、`/foo/abc/bar`、`/foo/abc/def/bar` 等。
|
||
- `/foo/**/bar/**/baz` 匹配 `/foo/abc/bar/xyz/baz`。
|
||
|
||
#### (3) `?`（匹配单个字符）
|
||
|
||
- `?` 用于匹配单个字符，不是零个或多个字符。它通常用于精确匹配某些路径中的单个字符。
|
||
- 示例：
|
||
- `/foo/a?c` 可以匹配 `/foo/abc`，但不能匹配 `/foo/abcc`。
|
||
|
||
### 2. **Ant 风格的路径匹配应用**
|
||
|
||
Spring MVC 采用了这种路径匹配方式，使得映射 URL 路径时更加灵活。例如，使用 `@RequestMapping` 注解来定义控制器方法时，可以利用 Ant 风格的路径匹配规则。
|
||
|
||
#### 示例 1：`@RequestMapping` 使用 Ant 风格
|
||
|
||
```java
|
||
@Controller
|
||
public class MyController {
|
||
|
||
@RequestMapping("/foo/*") // 匹配路径 /foo/bar 或 /foo/abc
|
||
public String handleFoo() {
|
||
return "foo";
|
||
}
|
||
|
||
@RequestMapping("/foo/**") // 匹配路径 /foo/bar 或 /foo/abc/xyz
|
||
public String handleFooRecursive() {
|
||
return "fooRecursive";
|
||
}
|
||
|
||
@RequestMapping("/foo/a?c") // 匹配路径 /foo/abc，但不匹配 /foo/abcc
|
||
public String handleSpecificPattern() {
|
||
return "specificPattern";
|
||
}
|
||
}
|
||
```
|
||
|
||
在这个例子中：
|
||
|
||
- `/foo/*` 只会匹配 `/foo/bar` 或 `/foo/abc` 等简单路径。
|
||
- `/foo/**` 会匹配 `/foo/bar`、`/foo/abc/xyz` 等多层次路径。
|
||
- `/foo/a?c` 会匹配 `/foo/abc`，但不会匹配 `/foo/abcc`。
|
||
|
||
#### 示例 2：`@RequestMapping` 配合请求方法
|
||
|
||
Spring MVC 还支持在映射中结合请求方法（如 `GET`、`POST`）来实现更细粒度的路径匹配：
|
||
|
||
```java
|
||
@Controller
|
||
@RequestMapping("/foo")
|
||
public class FooController {
|
||
|
||
@RequestMapping(value = "/bar/*", method = RequestMethod.GET) // GET 请求
|
||
public String handleBar() {
|
||
return "barGET";
|
||
}
|
||
|
||
@RequestMapping(value = "/bar/**", method = RequestMethod.POST) // POST 请求
|
||
public String handleBarPost() {
|
||
return "barPOST";
|
||
}
|
||
}
|
||
```
|
||
|
||
在这个例子中：
|
||
|
||
- `/foo/bar/*` 仅在处理 `GET` 请求时匹配。
|
||
- `/foo/bar/**` 仅在处理 `POST` 请求时匹配。
|
||
|
||
### 3. **Ant 风格路径与通配符的结合使用**
|
||
|
||
在实际开发中，Spring MVC 支持 Ant 风格路径的同时，还可以与路径变量、正则表达式等功能结合使用。
|
||
|
||
#### 示例 1：路径变量 + Ant 风格
|
||
|
||
```java
|
||
@RequestMapping("/user/{id}/**") // 匹配多层路径，id 为路径变量
|
||
public String handleUser(@PathVariable("id") String userId) {
|
||
return "User ID: " + userId;
|
||
}
|
||
```
|
||
|
||
- 这个路径匹配 `/user/123/abc/xyz`，其中 `id` 会捕获为 `123`。
|
||
|
||
#### 示例 2：正则表达式 + Ant 风格
|
||
|
||
```java
|
||
@RequestMapping("/product/{id:\\d+}/**") // 正则匹配数字 id
|
||
public String handleProduct(@PathVariable("id") String productId) {
|
||
return "Product ID: " + productId;
|
||
}
|
||
```
|
||
|
||
- 这里的路径 `/product/{id:\\d+}/**` 只会匹配数字形式的 `id`，比如 `/product/123/abc/xyz`。
|
||
|
||
### 4. **优先级和匹配规则**
|
||
|
||
在使用 Ant 风格路径匹配时，路径匹配的优先级有一定的规则。具体来说，`/**` 会匹配任何路径，所以它的优先级通常较低，避免与其他精确匹配的路径冲突。
|
||
|
||
#### 示例：优先级比较
|
||
|
||
```java
|
||
@Controller
|
||
@RequestMapping("/foo")
|
||
public class FooController {
|
||
|
||
@RequestMapping("/foo/{id}") // 精确匹配路径 /foo/{id}
|
||
public String handleFoo(@PathVariable String id) {
|
||
return "foo:" + id;
|
||
}
|
||
|
||
@RequestMapping("/foo/**") // 匹配所有以 /foo/ 开头的路径
|
||
public String handleFooCatchAll() {
|
||
return "catchAll";
|
||
}
|
||
}
|
||
```
|
||
|
||
在这个例子中，如果访问 `/foo/bar`，它会首先匹配 `/foo/{id}`，因为它更精确。
|
||
|
||
## 编写Spring应用
|
||
|
||
### `@SpringBootApplication` 注解
|
||
|
||
1. **`@EnableAutoConfiguration`**：
|
||
- 这个注解让 Spring Boot 根据项目中的依赖，自动配置 Spring 应用程序。Spring Boot 提供了大量的自动配置支持，帮助我们省去手动配置许多常见的功能。
|
||
- 例如，如果你的项目中加入了 `spring-boot-starter-web` 依赖，Spring Boot 会自动配置一个嵌入式的 Tomcat 服务器和一些常见的 Web 功能。
|
||
2. **`@ComponentScan`**：
|
||
- 这个注解启用 Spring 的组件扫描机制。它会扫描当前类所在的包及其子包，自动发现并注册 `@Component`、`@Service`、`@Repository`、`@Controller` 等注解标注的类。
|
||
- 通过 `@ComponentScan`，你不需要手动指定要扫描的包，Spring Boot 会自动扫描当前包及其子包下的所有组件。
|
||
3. **`@Configuration`**：
|
||
- 这个注解表示该类是一个 Spring 配置类，类似于 XML 配置文件，用于定义 Spring 应用的 Bean 配置。
|
||
- 该类可以包含 `@Bean` 注解的方法，返回要管理的 Bean。
|
||
|
||
### `@SpringBootTest` 注解
|
||
|
||
`@SpringBootTest` 注解是用于测试 Spring Boot 应用的一个重要注解，它提供了一种方便的方式来启动 Spring Boot 应用上下文，并对整个 Spring Boot 应用进行集成测试。这个注解本身也包含了多个注解，它使得我们能够在测试类中创建一个完整的 Spring 容器来进行集成测试。
|
||
|
||
具体来说，`@SpringBootTest` 是一个组合注解，它整合了以下几个主要的注解：
|
||
|
||
1. **`@ContextConfiguration`**：
|
||
- `@ContextConfiguration` 注解用于加载 Spring 配置文件或者配置类，在测试时会初始化 Spring 容器。`@SpringBootTest` 默认会加载 Spring Boot 应用的主配置类（即包含 `@SpringBootApplication` 注解的类），作为 Spring 容器的上下文。
|
||
- 它的作用是让测试类能够加载到 Spring 配置并创建一个完整的应用上下文。
|
||
2. **`@TestExecutionListeners`**：
|
||
- 该注解指定了测试执行时的监听器。在 Spring 测试框架中，`@TestExecutionListeners` 会提供某些扩展功能，如事务管理、环境配置等，但它的实际作用在大多数测试中不太明显，通常由 Spring Boot 自动配置。
|
||
3. **`@DirtiesContext`**：
|
||
- 这个注解会告诉 Spring 在测试执行之后清除（或重置）应用上下文，通常用于测试中的应用上下文需要被清理或重置，以避免测试间的相互影响。`@SpringBootTest` 会根据需要处理上下文的清理工作。
|
||
4. **`@BootstrapWith`**：
|
||
- 这个注解是用于引导测试的，它会指定 `SpringBootTestContextBootstrapper` 来启动 Spring Boot 测试上下文。这是一个 Spring Boot 测试框架中的内部机制，用于初始化应用上下文并准备测试。
|
||
|
||
### 测试页面
|
||
|
||
编写控制界面，返回`index.html`
|
||
|
||
```java
|
||
@RequestMapping
|
||
@Controller
|
||
public class HomeController {
|
||
|
||
@Operation(summary = "主页内容")
|
||
@GetMapping("index")
|
||
public String index() {
|
||
return "index";
|
||
}
|
||
}
|
||
```
|
||
|
||
测试页面返回结果
|
||
|
||
```java
|
||
@WebMvcTest(HomeController.class)
|
||
class HomeControllerTest {
|
||
|
||
@Autowired
|
||
private MockMvc mockMvc;
|
||
|
||
@Test
|
||
void index() throws Exception {
|
||
mockMvc.perform(MockMvcRequestBuilders.get("/"))// 访问路径
|
||
.andExpect(MockMvcResultMatchers.status().isOk())// 判断状态是否成功
|
||
.andExpect(MockMvcResultMatchers.view().name("index"))// 判断视图名称是否是index
|
||
// 是否包含字段
|
||
.andExpect(MockMvcResultMatchers.content().string(Matchers.containsString("欢迎。。。")));
|
||
}
|
||
}
|
||
```
|
||
|
||
访问index的页面
|
||
|
||
```html
|
||
<!DOCTYPE html>
|
||
<html lang="en">
|
||
<head>
|
||
<meta charset="UTF-8">
|
||
<title>Index 测试页面</title>
|
||
</head>
|
||
<body>
|
||
<h1>欢迎。。。</h1>
|
||
<img alt="" th:src="@{/images/icon_3.png}">
|
||
<img alt="通常MVC项目静态资源放在 static/images 下" src="images/index/diannao.png">
|
||
</body>
|
||
</html>
|
||
```
|
||
|
||
> 静态资源问题，如果用户是访问静态资源，如果直接写在`template`方式引入资源会找不到，因为默认资源都放在`static`目录下载的。
|
||
|
||
#### 什么时候该用这种测试
|
||
|
||
##### 1. **验证控制器的业务逻辑**
|
||
|
||
- `@WebMvcTest` 本质上是用来验证 **控制器层的行为**，而不是渲染出来的页面。它帮助你测试控制器是否能正确处理 HTTP 请求、是否返回正确的视图名称或正确的响应状态码等。
|
||
- 比如，你可以测试一个 `GET /home` 请求是否返回了预期的视图名称 `"index"`，或者返回的状态码是否是 `200 OK`，而这些正是你在控制器中希望验证的部分。**这与页面渲染无关**，所以它不会显示页面内容，也不会出现渲染时的误差。
|
||
|
||
##### 2. **关注点分离**
|
||
|
||
- 使用 `@WebMvcTest` 进行单元测试能够将 **Web 层** 与 **业务逻辑层**（Service、Repository）进行解耦。通过这种方式，你可以专注于测试控制器层的 HTTP 请求和响应，而不需要担心 Service 层的逻辑是否正确，或者数据库的连接是否正常。
|
||
- 控制器层和页面渲染是两个不同的关注点。**控制器层的目标是处理请求、确定视图名称、返回模型数据**等，而页面渲染本身通常由前端技术或模板引擎处理，更多是浏览器中的前端渲染过程。
|
||
|
||
##### 3. **通过 Mock 数据模拟请求和响应**
|
||
|
||
- 在 `@WebMvcTest` 中，`MockMvc` 会模拟请求并验证响应，它不会执行实际的页面渲染或显示，只会检查你定义的 **控制器输出** 是否符合预期。因此，它能有效避免浏览器渲染过程中的误差。
|
||
- 比如，`MockMvc` 可以验证你的控制器是否正确返回了某个 HTML 页面的视图名称，而不用关注 HTML 的具体内容。如果你的目标是确保控制器的逻辑没有错误，这种方式是非常高效的。
|
||
|
||
##### 4. **测试时更快速且更简洁**
|
||
|
||
- 通过 `@WebMvcTest` 测试时，你只加载 Web 层的相关组件，不需要启动整个应用的上下文，因此测试速度通常更快。
|
||
- 它让你能够快速定位问题。例如，如果测试失败，你可以很清楚地知道是控制器中的视图名称、请求参数的处理，还是其他的 HTTP 相关操作出了问题。反而如果进行实际的浏览器渲染测试，可能涉及到浏览器兼容性、前端细节等问题，会增加复杂度。
|
||
|
||
##### 5. **避免不必要的页面渲染**
|
||
|
||
- 事实上，控制器的核心功能并不依赖于页面渲染。控制器应该保证的是：
|
||
- 正确处理请求
|
||
- 返回适当的视图名称和模型数据
|
||
- 设置正确的响应状态码和其他 HTTP 相关的参数
|
||
- 页面渲染通常是通过模板引擎（如 Thymeleaf、JSP）完成的，而 `@WebMvcTest` 仅仅验证的是 **控制器的行为**，例如它返回的是正确的视图名称（而不是真的生成 HTML 页面）。
|
||
|
||
##### 6. **不同类型的测试互为补充**
|
||
|
||
- 你可以把
|
||
|
||
```
|
||
@WebMvcTest
|
||
```
|
||
|
||
和 端到端测试（如集成测试或 UI 测试）结合起来使用：
|
||
|
||
- **`@WebMvcTest`** 用于测试控制器的行为、请求路径、视图名称等。
|
||
- **端到端测试** 可以通过实际浏览器或工具（如 Selenium）来模拟用户操作，查看页面是否正确渲染，验证 HTML 是否按预期显示。
|
||
|
||
## 访问控制
|
||
|
||
请求地址时返回对应的网页文件
|
||
|
||
- `@RestController`用于返回对象格式的内容，在后面会使用`ModelAndView`可以返回网页文件
|
||
- `@Controller`用于返回网页文件
|
||
|
||
### 环境要求
|
||
|
||
```xml
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-web</artifactId>
|
||
</dependency>
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-test</artifactId>
|
||
<scope>test</scope>
|
||
</dependency>
|
||
<!-- thymeleaf -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-thymeleaf</artifactId>
|
||
</dependency>
|
||
<!-- devtools -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-devtools</artifactId>
|
||
<scope>runtime</scope>
|
||
<optional>true</optional>
|
||
</dependency>
|
||
<!-- lombok -->
|
||
<dependency>
|
||
<groupId>org.projectlombok</groupId>
|
||
<artifactId>lombok</artifactId>
|
||
<version>1.18.36</version>
|
||
</dependency>
|
||
```
|
||
|
||
### 错误页面设置
|
||
|
||
在这个路径下可以配置错误码要访问的页面，也就是可以自定义页面内容
|
||
|
||
|
||
|
||
### 使用`@Controller`
|
||
|
||
返回需要访问的HTML内容页面，最后返回的字符串就是页面，这个页面位于`templates`目录下
|
||
|
||
```java
|
||
@RequestMapping("/use")
|
||
@Controller
|
||
public class UseController {
|
||
|
||
// 带参数访问
|
||
@RequestMapping(value = "hello", method = RequestMethod.GET, params = {"name"})
|
||
public String hello() {
|
||
return "hello";
|
||
}
|
||
|
||
@GetMapping("jumpPage")
|
||
public String jumpPage() {
|
||
return "jumpPage";
|
||
}
|
||
|
||
@GetMapping("index")
|
||
public String quick() {
|
||
return "user";
|
||
}
|
||
|
||
// 跳转的页面
|
||
@GetMapping("toJump")
|
||
public String toJump() {
|
||
return "redirect:jumpPage";
|
||
}
|
||
}
|
||
```
|
||
|
||
如果在使用`@Controller`需要返回JSON内容，需要在控制器方法上加上`@ResponseBody`
|
||
|
||
```java
|
||
@GetMapping("getJson")
|
||
@ResponseBody
|
||
public List<String> getJson() {
|
||
ArrayList<String> list = new ArrayList<>();
|
||
list.add("a");
|
||
list.add("b");
|
||
list.add("c");
|
||
|
||
return list;
|
||
}
|
||
```
|
||
|
||
#### 将视图和模型拆开
|
||
|
||
```java
|
||
// 将视图和模型拆开
|
||
@GetMapping("page/test3")
|
||
public String test3(Model model) {
|
||
model.addAttribute("test3", "测试3");
|
||
return "page/test3";
|
||
}
|
||
```
|
||
|
||
### 使用`@RestController`
|
||
|
||
#### 使用方式1
|
||
|
||
如果使用`@RestController`那么返回的就是JSON对象，但是这时候要想返回网页文件，需要使用`ModelAndView`
|
||
|
||
```java
|
||
@RequestMapping("userRest")
|
||
@RestController
|
||
public class UseRestController {
|
||
|
||
@GetMapping("page/test")
|
||
public ModelAndView test() {
|
||
ModelAndView modelAndView = new ModelAndView();
|
||
modelAndView.setViewName("page/test");
|
||
modelAndView.addObject("message", "这是消息内容");
|
||
return modelAndView;
|
||
}
|
||
}
|
||
```
|
||
|
||
我们引入了`thymeleaf`所以有以下内容`<h4 th:text="'消息：'+ ${message}"></h4>`
|
||
|
||
```html
|
||
<!DOCTYPE html>
|
||
<html lang="en">
|
||
<head>
|
||
<meta charset="UTF-8">
|
||
<title>使用RestController返回页面信息</title>
|
||
</head>
|
||
<body>
|
||
<h3>使用RestController返回页面信息</h3>
|
||
<h4 th:text="'消息：'+ ${message}"></h4>
|
||
</body>
|
||
</html>
|
||
```
|
||
|
||
> 其中`modelAndView.addObject("message", "这是消息内容");`是可选的
|
||
|
||
#### 使用方式2
|
||
|
||
在控制器方法上使用`ModelAndView`
|
||
|
||
```java
|
||
@GetMapping("page/test2")
|
||
public ModelAndView test2(ModelAndView modelAndView) {
|
||
modelAndView.addObject("hello", "你好");
|
||
modelAndView.setViewName("page/test2");
|
||
return modelAndView;
|
||
}
|
||
```
|
||
|
||
## 向session共享数据
|
||
|
||
在 Spring MVC 中，**Session** 是用于存储用户会话期间的数据的一种机制。每个用户访问的应用程序都将拥有一个唯一的会话。通过 `HttpSession`，可以在用户的会话中存储一些数据，直到用户关闭浏览器或会话过期。
|
||
|
||
Spring MVC 提供了多种方式来与 `HttpSession` 进行交互，下面详细介绍如何通过 `HttpSession` 向 Session 共享数据。
|
||
|
||
### 1. **通过 `HttpSession` 操作 Session 数据**
|
||
|
||
在 Spring MVC 控制器中，您可以通过 `HttpSession` 对象来存储和读取会话数据。
|
||
|
||
#### 示例：将数据添加到 Session
|
||
|
||
```java
|
||
@Controller
|
||
public class SessionController {
|
||
|
||
@RequestMapping("/setSessionData")
|
||
public String setSessionData(HttpSession session) {
|
||
// 将数据存储到 Session 中
|
||
session.setAttribute("username", "JohnDoe");
|
||
session.setAttribute("age", 30);
|
||
return "sessionSet"; // 返回视图名
|
||
}
|
||
|
||
@RequestMapping("/getSessionData")
|
||
public String getSessionData(HttpSession session, Model model) {
|
||
// 从 Session 中获取数据
|
||
String username = (String) session.getAttribute("username");
|
||
Integer age = (Integer) session.getAttribute("age");
|
||
model.addAttribute("username", username);
|
||
model.addAttribute("age", age);
|
||
return "sessionData"; // 返回视图名
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /setSessionData` 会将数据 `"username": "JohnDoe"` 和 `"age": 30` 存储到 Session 中。
|
||
- `GET /getSessionData` 会从 Session 中获取并显示存储的值。
|
||
|
||
### 2. **使用 `@SessionAttributes` 注解**
|
||
|
||
`@SessionAttributes` 注解用于将控制器中的某些模型属性放入 Session 中。这种方式比直接操作 `HttpSession` 更为方便和简洁，特别是当需要共享多个模型属性时。
|
||
|
||
#### 示例：使用 `@SessionAttributes`
|
||
|
||
```java
|
||
@Controller
|
||
@SessionAttributes("user")
|
||
public class UserController {
|
||
|
||
// 在模型中添加用户对象
|
||
@RequestMapping("/setUser")
|
||
public String setUser(Model model) {
|
||
User user = new User("John", 30);
|
||
model.addAttribute("user", user);
|
||
return "userSet";
|
||
}
|
||
|
||
// 从 Session 中获取用户对象
|
||
@RequestMapping("/getUser")
|
||
public String getUser(@ModelAttribute("user") User user, Model model) {
|
||
model.addAttribute("user", user);
|
||
return "userDetails";
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /setUser` 会将 `user` 对象放入 Session 中。
|
||
- `GET /getUser` 会从 Session 中获取 `user` 对象。
|
||
|
||
`@SessionAttributes` 注解不仅可以放入 Session 中，还可以与 `@ModelAttribute` 注解结合使用，确保模型数据保持在 Session 中。
|
||
|
||
### 3. **使用 `@ModelAttribute` 注解**
|
||
|
||
`@ModelAttribute` 注解允许将数据放入模型中，并且在方法调用前通过 `Model` 传递给视图。如果和 `@SessionAttributes` 一起使用，它可以将属性直接添加到 `HttpSession`。
|
||
|
||
#### 示例：使用 `@ModelAttribute` 和 `@SessionAttributes`
|
||
|
||
```java
|
||
@Controller
|
||
@SessionAttributes("cart")
|
||
public class CartController {
|
||
|
||
// 在模型中创建并存储购物车
|
||
@ModelAttribute("cart")
|
||
public Cart createCart() {
|
||
return new Cart(); // 创建一个空的购物车对象
|
||
}
|
||
|
||
// 添加商品到购物车
|
||
@RequestMapping("/addToCart")
|
||
public String addToCart(@ModelAttribute("cart") Cart cart, @RequestParam("item") String item) {
|
||
cart.addItem(item); // 将商品添加到购物车
|
||
return "cartUpdated";
|
||
}
|
||
|
||
// 显示购物车内容
|
||
@RequestMapping("/viewCart")
|
||
public String viewCart(@ModelAttribute("cart") Cart cart, Model model) {
|
||
model.addAttribute("cart", cart);
|
||
return "viewCart";
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /addToCart?item=Apple` 会将 `Apple` 添加到 `cart` 中。
|
||
- `GET /viewCart` 会显示购物车中的内容。
|
||
|
||
### 4. **通过 `@RequestParam` 或 `@PathVariable` 获取 Session 数据**
|
||
|
||
如果在请求中需要通过路径变量或请求参数传递数据并存储到 Session 中，可以结合 `@RequestParam` 或 `@PathVariable` 来实现。
|
||
|
||
#### 示例：使用 `@RequestParam` 存储 Session 数据
|
||
|
||
```java
|
||
@Controller
|
||
public class SessionController {
|
||
|
||
@RequestMapping("/setSession/{username}")
|
||
public String setSessionData(@PathVariable("username") String username, HttpSession session) {
|
||
session.setAttribute("username", username);
|
||
return "sessionSet";
|
||
}
|
||
|
||
@RequestMapping("/getSession")
|
||
public String getSessionData(HttpSession session, Model model) {
|
||
String username = (String) session.getAttribute("username");
|
||
model.addAttribute("username", username);
|
||
return "sessionData";
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /setSession/JohnDoe` 会将 `"username": "JohnDoe"` 存储到 Session 中。
|
||
- `GET /getSession` 会从 Session 中获取并显示 `username`。
|
||
|
||
### 5. **删除 Session 数据**
|
||
|
||
如果希望在某个操作后清除 Session 中的某些数据，可以使用 `HttpSession` 提供的 `removeAttribute` 方法。
|
||
|
||
#### 示例：删除 Session 数据
|
||
|
||
```java
|
||
@Controller
|
||
public class SessionController {
|
||
|
||
@RequestMapping("/removeSessionData")
|
||
public String removeSessionData(HttpSession session) {
|
||
session.removeAttribute("username"); // 删除指定的属性
|
||
return "sessionRemoved";
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /removeSessionData` 会从 Session 中删除 `"username"` 属性。
|
||
|
||
### 6. **Session 过期与清理**
|
||
|
||
默认情况下，Spring MVC 的 `HttpSession` 会话会在用户关闭浏览器后过期，或者会话超时（默认30分钟）。可以在 `web.xml` 或应用的配置类中设置会话超时：
|
||
|
||
#### 示例：设置 Session 超时
|
||
|
||
```xml
|
||
<session-config>
|
||
<session-timeout>30</session-timeout> <!-- 设置会话超时为30分钟 -->
|
||
</session-config>
|
||
```
|
||
|
||
### 7. **通过 Spring 配置 Session**
|
||
|
||
通过 Spring 配置文件或 Java 配置类，还可以控制 Session 的相关行为（如会话过期时间、session 的持久化等）。
|
||
|
||
#### 示例：Java 配置类
|
||
|
||
```java
|
||
@Configuration
|
||
@EnableWebMvc
|
||
public class WebConfig implements WebMvcConfigurer {
|
||
|
||
@Override
|
||
public void addInterceptors(InterceptorRegistry registry) {
|
||
registry.addInterceptor(new SessionInterceptor()).addPathPatterns("/**");
|
||
}
|
||
}
|
||
```
|
||
|
||
`SessionInterceptor` 可以用于监控和管理 Session 数据。
|
||
|
||
> 在 Spring MVC 中，向 Session 共享数据主要有以下几种方式：
|
||
>
|
||
> - **`HttpSession`**：通过 `HttpSession` 对象存储和读取 Session 数据。
|
||
> - **`@SessionAttributes`**：通过 `@SessionAttributes` 注解将模型属性添加到 Session 中。
|
||
> - **`@ModelAttribute`**：结合 `@SessionAttributes` 使用，将模型数据持久化到 Session 中。
|
||
> - **`@RequestParam` 和 `@PathVariable`**：将请求参数或路径变量存储到 Session 中。
|
||
> - **Session 过期与清理**：可以通过配置控制会话超时，或手动清除 Session 数据。
|
||
|
||
## 向application域共享数据
|
||
|
||
在 Spring MVC 中，`Application` 域（也称为 **ServletContext**）是一个全局范围，用于在整个应用程序中共享数据。不同于 **Session** 域和 **Request** 域，`Application` 域中的数据对整个 Web 应用的所有用户都是可见的，因此适合存储全局共享的配置信息、常量、初始化数据等。
|
||
|
||
在 Spring MVC 中，我们可以通过 `ServletContext` 来向 **Application** 域共享数据，通常使用 `setAttribute` 和 `getAttribute` 方法来进行操作。
|
||
|
||
### 1. **通过 `ServletContext` 共享数据**
|
||
|
||
`ServletContext` 是与整个 Web 应用程序相关联的对象，它允许你在多个请求和多个会话之间共享数据。在 Spring MVC 中，可以通过以下两种方式来访问 `ServletContext`：
|
||
|
||
- 直接使用 `HttpServletRequest.getSession().getServletContext()` 获取 `ServletContext`。
|
||
- 使用 `@Autowired` 注解注入 `ServletContext` 对象。
|
||
|
||
#### 示例 1：通过 `ServletContext` 共享数据
|
||
|
||
##### 1.1 通过 `HttpServletRequest` 获取 `ServletContext`
|
||
|
||
```java
|
||
@Controller
|
||
public class ApplicationController {
|
||
|
||
@RequestMapping("/setApplicationData")
|
||
public String setApplicationData(HttpServletRequest request) {
|
||
// 获取 ServletContext
|
||
ServletContext servletContext = request.getServletContext();
|
||
// 向 Application 域存储数据
|
||
servletContext.setAttribute("appName", "SpringMVCApp");
|
||
servletContext.setAttribute("version", "1.0.0");
|
||
return "applicationDataSet";
|
||
}
|
||
|
||
@RequestMapping("/getApplicationData")
|
||
public String getApplicationData(HttpServletRequest request, Model model) {
|
||
// 获取 ServletContext
|
||
ServletContext servletContext = request.getServletContext();
|
||
// 从 Application 域获取数据
|
||
String appName = (String) servletContext.getAttribute("appName");
|
||
String version = (String) servletContext.getAttribute("version");
|
||
|
||
model.addAttribute("appName", appName);
|
||
model.addAttribute("version", version);
|
||
return "applicationData";
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /setApplicationData` 会向 `Application` 域中存储 `"appName": "SpringMVCApp"` 和 `"version": "1.0.0"`。
|
||
- `GET /getApplicationData` 会从 `Application` 域中读取数据，并返回给视图。
|
||
|
||
##### 1.2 通过 `@Autowired` 注入 `ServletContext`
|
||
|
||
```java
|
||
@Controller
|
||
public class ApplicationController {
|
||
|
||
@Autowired
|
||
private ServletContext servletContext;
|
||
|
||
@RequestMapping("/setApplicationData")
|
||
public String setApplicationData() {
|
||
// 向 Application 域存储数据
|
||
servletContext.setAttribute("appName", "SpringMVCApp");
|
||
servletContext.setAttribute("version", "1.0.0");
|
||
return "applicationDataSet";
|
||
}
|
||
|
||
@RequestMapping("/getApplicationData")
|
||
public String getApplicationData(Model model) {
|
||
// 从 Application 域获取数据
|
||
String appName = (String) servletContext.getAttribute("appName");
|
||
String version = (String) servletContext.getAttribute("version");
|
||
|
||
model.addAttribute("appName", appName);
|
||
model.addAttribute("version", version);
|
||
return "applicationData";
|
||
}
|
||
}
|
||
```
|
||
|
||
在这个例子中，`@Autowired` 注解会自动将 `ServletContext` 注入到控制器中。
|
||
|
||
### 2. **应用场景**
|
||
|
||
将数据放到 `Application` 域中通常用于存储以下类型的数据：
|
||
|
||
- **应用级别的数据**：例如应用名称、版本号、初始化配置等，这些数据是全局共享的。
|
||
- **常量和初始化信息**：如果有一些需要在多个请求中共享的常量或初始化信息，可以将它们放到 `Application` 域中。
|
||
- **数据库连接池或常用资源**：对于一些全局共享的资源（如数据库连接池），可以在 `Application` 域中进行配置并在不同的请求中共享。
|
||
|
||
### 3. **注意事项**
|
||
|
||
- **全局共享**：与 `Session` 和 `Request` 域不同，`Application` 域中的数据对所有用户和请求都可见。因此，要特别小心在 `Application` 域中存储敏感数据，避免泄漏用户个人信息等。
|
||
- **生命周期**：`Application` 域中的数据在整个应用程序生命周期内有效，直到应用服务器重新启动。因此，放入 `Application` 域的数据一般是全局的、不会频繁变化的。
|
||
- **线程安全**：`Application` 域的数据是共享的，因此在并发访问时要考虑线程安全问题。如果有多个线程访问同一数据，可能需要进行同步。
|
||
|
||
### 4. **清理 Application 域中的数据**
|
||
|
||
如果不再需要某个共享数据，可以使用 `removeAttribute` 方法从 `Application` 域中移除该数据。
|
||
|
||
#### 示例：删除 `Application` 域中的数据
|
||
|
||
```java
|
||
@Controller
|
||
public class ApplicationController {
|
||
|
||
@RequestMapping("/removeApplicationData")
|
||
public String removeApplicationData(HttpServletRequest request) {
|
||
// 获取 ServletContext
|
||
ServletContext servletContext = request.getServletContext();
|
||
// 从 Application 域移除数据
|
||
servletContext.removeAttribute("appName");
|
||
servletContext.removeAttribute("version");
|
||
return "applicationDataRemoved";
|
||
}
|
||
}
|
||
```
|
||
|
||
**URL 请求：**
|
||
|
||
- `GET /removeApplicationData` 会从 `Application` 域中移除 `appName` 和 `version` 属性。
|
||
|
||
### 5. **使用 `@ApplicationScope`（Spring 方式）**
|
||
|
||
如果使用 Spring 框架进行开发，也可以使用 Spring 提供的 **`@ApplicationScope`** 注解来定义在整个应用范围内共享的 Bean。这种方法通常用于 Spring 组件，而不是直接操作 `ServletContext`。
|
||
|
||
#### 示例：使用 `@ApplicationScope`
|
||
|
||
```java
|
||
@Component
|
||
@Scope("application")
|
||
public class AppConfig {
|
||
private String appName = "SpringMVCApp";
|
||
|
||
public String getAppName() {
|
||
return appName;
|
||
}
|
||
}
|
||
```
|
||
|
||
在这种情况下，Spring 管理的 Bean 会在应用级别共享，类似于 `ServletContext` 中存储的数据。
|
||
|
||
> - `Application` 域（即 `ServletContext`）用于在整个应用程序范围内共享数据，适合存储全局共享的信息、配置和常量。
|
||
> - 通过 `HttpServletRequest.getServletContext()` 或 `@Autowired` 注解可以访问 `ServletContext` 并向 `Application` 域中共享数据。
|
||
> - 数据存储在 `Application` 域中可以在整个应用程序生命周期内有效，适用于共享全局性的、无需频繁更新的数据。
|
||
> - 应谨慎存储敏感数据，并注意线程安全和数据的生命周期。
|
||
>
|
||
|
||
## 重定向和转发使用
|
||
|
||
在 Spring MVC 中，**重定向（Redirect）**和**转发（Forward）**是两种常见的请求处理方式，它们分别用于不同的场景。Spring 提供了灵活的 API 来实现这两种请求方式。
|
||
|
||
### 1. **转发（Forward）**
|
||
|
||
**转发**是指服务器将请求转发到另一个资源（如 JSP 页面或另一个控制器方法），并且请求和响应都不会发生改变。即，URL 不会发生变化，客户端仍然看到原始的 URL。
|
||
|
||
#### 转发的实现
|
||
|
||
在 Spring MVC 中，可以通过以下两种方式实现转发：
|
||
|
||
- 使用 `RequestDispatcher.forward()` 方法。
|
||
- 使用 `ModelAndView` 中的 `"forward:"` 前缀来指定转发的路径。
|
||
|
||
##### 示例 1：使用 `RequestDispatcher` 转发
|
||
|
||
```java
|
||
@Controller
|
||
public class ForwardController {
|
||
|
||
@RequestMapping("/forwardExample")
|
||
public void forward(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
|
||
// 使用 Servlet 的 RequestDispatcher 进行转发
|
||
request.getRequestDispatcher("/forwardedPage").forward(request, response);
|
||
}
|
||
|
||
@RequestMapping("/forwardedPage")
|
||
public String forwardedPage() {
|
||
return "forwardedPage"; // 返回视图
|
||
}
|
||
}
|
||
```
|
||
|
||
##### 示例 2：使用 `ModelAndView` 转发
|
||
|
||
```java
|
||
@Controller
|
||
public class ForwardController {
|
||
|
||
@RequestMapping("/forwardExample")
|
||
public ModelAndView forwardExample() {
|
||
// 使用 ModelAndView 进行转发
|
||
return new ModelAndView("forward:/forwardedPage");
|
||
}
|
||
|
||
@RequestMapping("/forwardedPage")
|
||
public String forwardedPage() {
|
||
return "forwardedPage"; // 返回视图
|
||
}
|
||
}
|
||
```
|
||
|
||
**解释：**
|
||
|
||
- `forward:/forwardedPage` 表示将请求转发到 `/forwardedPage`，且客户端的 URL 不会发生变化。
|
||
- 在转发的过程中，控制器方法返回的视图会直接被渲染。
|
||
|
||
#### 转发的特点
|
||
|
||
- **URL 不改变**：用户的浏览器地址栏不会发生变化，仍然显示原始的请求路径。
|
||
- **共享同一个请求**：请求数据（如请求参数）会被转发到目标资源，可以通过 `request` 对象共享。
|
||
- **适用于内部请求**：转发是服务端内部的操作，适用于控制器之间的跳转或者从控制器到视图的跳转。
|
||
|
||
### 2. **重定向（Redirect）**
|
||
|
||
**重定向**是指服务器告诉客户端（浏览器）重新发起一个新的请求。重定向会导致浏览器地址栏的 URL 更新为新的地址，因此会导致一次新的 HTTP 请求。
|
||
|
||
#### 重定向的实现
|
||
|
||
在 Spring MVC 中，重定向可以通过以下几种方式实现：
|
||
|
||
- 使用 `redirect:` 前缀返回视图。
|
||
- 使用 `HttpServletResponse.sendRedirect()` 方法。
|
||
|
||
##### 示例 1：使用 `redirect:` 前缀
|
||
|
||
```java
|
||
@Controller
|
||
public class RedirectController {
|
||
|
||
@RequestMapping("/redirectExample")
|
||
public String redirectExample() {
|
||
// 使用 redirect: 前缀进行重定向
|
||
return "redirect:/redirectedPage";
|
||
}
|
||
|
||
@RequestMapping("/redirectedPage")
|
||
public String redirectedPage() {
|
||
return "redirectedPage"; // 返回视图
|
||
}
|
||
}
|
||
```
|
||
|
||
##### 示例 2：使用 `HttpServletResponse.sendRedirect()`
|
||
|
||
```java
|
||
@Controller
|
||
public class RedirectController {
|
||
|
||
@RequestMapping("/redirectExample")
|
||
public void redirectExample(HttpServletResponse response) throws IOException {
|
||
// 使用 HttpServletResponse.sendRedirect() 进行重定向
|
||
response.sendRedirect("/redirectedPage");
|
||
}
|
||
|
||
@RequestMapping("/redirectedPage")
|
||
public String redirectedPage() {
|
||
return "redirectedPage"; // 返回视图
|
||
}
|
||
}
|
||
```
|
||
|
||
**解释：**
|
||
|
||
- `redirect:/redirectedPage` 会发出一个 HTTP 302 重定向响应，浏览器会发起一次新的请求到 `/redirectedPage`，并更新地址栏的 URL。
|
||
- 使用 `HttpServletResponse.sendRedirect()` 方法也会发送重定向响应，同样会导致浏览器重新发起新的请求。
|
||
|
||
#### 重定向的特点
|
||
|
||
- **URL 改变**：浏览器的地址栏会更新为重定向的目标 URL。
|
||
- **不同的请求**：重定向会产生一次新的 HTTP 请求，原请求的参数不会自动携带到新请求中，除非在重定向 URL 中显式传递。
|
||
- **适用于跨请求跳转**：重定向适合用于不同请求之间的跳转，特别是当需要在多个请求中传递数据时。
|
||
|
||
### 3. **重定向与转发的区别**
|
||
|
||
| 特性 | 重定向（Redirect） | 转发（Forward） |
|
||
| ------------ | ----------------------------------------------------------- | ---------------------------------------------- |
|
||
| **URL 变化** | 浏览器地址栏会更新为新的 URL | 浏览器地址栏不会改变，仍然是原始请求 URL |
|
||
| **请求次数** | 会产生两次请求：第一次请求重定向，第二次是新的目标请求 | 只会产生一次请求（内部请求） |
|
||
| **数据传递** | 重定向后，数据不能自动传递到新请求中，除非通过 URL 参数传递 | 可以直接传递请求数据，如请求参数和请求属性 |
|
||
| **适用场景** | 当需要跨请求或跨控制器传递数据时，或者需要跳转到外部 URL | 当请求处理完成后，内部跳转到另一个视图或资源时 |
|
||
| **性能** | 因为需要进行两次请求，所以相比转发略有性能开销 | 因为只需要一次请求，性能开销较小 |
|
||
|
||
### 4. **常见使用场景**
|
||
|
||
#### (1) **重定向的使用场景**
|
||
|
||
- **表单提交后的重定向**：表单数据提交后，为了防止表单重复提交（用户刷新页面时），常常会使用重定向到另一个页面，这种方法叫做 **Post/Redirect/Get (PRG)** 模式。
|
||
|
||
例如，用户提交了一个订单数据后，页面显示 "订单已提交"，并重定向到订单查看页面。
|
||
|
||
```java
|
||
@RequestMapping("/submitOrder")
|
||
public String submitOrder(Order order) {
|
||
orderService.save(order);
|
||
// 提交订单后重定向到订单详情页
|
||
return "redirect:/orderDetails?orderId=" + order.getId();
|
||
}
|
||
```
|
||
|
||
- **外部 URL 重定向**：在用户登录后重定向到外部系统或第三方网站。
|
||
|
||
```java
|
||
@RequestMapping("/redirectToExternalSite")
|
||
public String redirectToExternal() {
|
||
// 重定向到外部 URL
|
||
return "redirect:http://www.example.com";
|
||
}
|
||
```
|
||
|
||
#### (2) **转发的使用场景**
|
||
|
||
- **内部资源的转发**：当需要在同一应用程序内部跳转时（如从控制器到视图），或者从一个控制器跳转到另一个控制器时，可以使用转发。
|
||
|
||
例如，在处理用户请求后，将其转发到 JSP 页面进行显示：
|
||
|
||
```java
|
||
@RequestMapping("/showUser")
|
||
public String showUserDetails(Model model) {
|
||
User user = userService.getUser();
|
||
model.addAttribute("user", user);
|
||
return "forward:/userDetails.jsp"; // 内部转发到 userDetails.jsp 页面
|
||
}
|
||
```
|
||
|
||
- **从一个控制器跳转到另一个控制器**：在处理完业务逻辑后，可能需要跳转到另一个控制器来处理某些逻辑。
|
||
|
||
```java
|
||
@RequestMapping("/processOrder")
|
||
public String processOrder(Order order) {
|
||
orderService.process(order);
|
||
return "forward:/orderConfirmation"; // 内部跳转到订单确认页面
|
||
}
|
||
```
|
||
|
||
- **重定向（Redirect）**：客户端浏览器会发起一次新的请求，地址栏 URL 会发生变化，适用于需要跨请求跳转或外部跳转的场景。
|
||
- **转发（Forward）**：请求在服务器内部被转发，地址栏 URL 不变，适用于同一请求的内部跳转。
|
||
|
||
## Spring 表单验证
|
||
|
||
在 Spring MVC 中，表单验证是通过一系列的注解来完成的。
|
||
|
||
### **`@NotNull`**
|
||
|
||
- **作用**：确保字段值不为空。
|
||
|
||
- **用法**：用于字段、方法参数或返回值上，表示该字段不能为空。如果字段为空，将验证失败并返回相应的错误信息。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@NotNull(message = "用户名不能为空")
|
||
private String username;
|
||
```
|
||
|
||
### **`@NotEmpty`**
|
||
|
||
- **作用**：确保字段不为空，并且不为一个空字符串。
|
||
|
||
- **用法**：用于字符串、集合等类型，验证字段不仅不能为空，而且不能为空字符串。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@NotEmpty(message = "密码不能为空")
|
||
private String password;
|
||
```
|
||
|
||
### **`@NotBlank`**
|
||
|
||
- **作用**：确保字段不为空，并且不为一个空白字符串（即非空白字符）。
|
||
|
||
- **用法**：类似于 `@NotEmpty`，但除了不为空，还要求去除空白字符后不能为零长度。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@NotBlank(message = "电子邮件不能为空")
|
||
private String email;
|
||
```
|
||
|
||
### **`@Size(min, max)`**
|
||
|
||
- **作用**：验证字段的大小，适用于字符串、集合、数组等类型。
|
||
|
||
- **用法**：可以设置最小值和最大值来限制字段的长度或集合的大小。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Size(min = 6, max = 20, message = "密码长度必须在6到20之间")
|
||
private String password;
|
||
```
|
||
|
||
### **`@Email`**
|
||
|
||
- **作用**：验证字段是否符合有效的电子邮件格式。
|
||
|
||
- **用法**：用于验证字符串字段是否为有效的电子邮件地址格式。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Email(message = "请输入有效的电子邮件地址")
|
||
private String email;
|
||
```
|
||
|
||
### **`@Pattern(regexp)`**
|
||
|
||
- **作用**：根据正则表达式验证字段值。
|
||
|
||
- **用法**：可以根据自定义的正则表达式来验证字段的内容。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Pattern(regexp = "^\\d{10}$", message = "请输入有效的手机号码")
|
||
private String phoneNumber;
|
||
```
|
||
|
||
### **`@Min(value)` 和 `@Max(value)`**
|
||
|
||
- **作用**：确保数字类型字段的值在指定范围内。
|
||
|
||
- **用法**：`@Min` 用于验证值是否大于等于指定的最小值，`@Max` 用于验证值是否小于等于指定的最大值。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Min(value = 18, message = "年龄不能小于18岁")
|
||
@Max(value = 100, message = "年龄不能大于100岁")
|
||
private int age;
|
||
```
|
||
|
||
### **`@DecimalMin(value)` 和 `@DecimalMax(value)`**
|
||
|
||
- **作用**：用于验证浮动值是否在指定范围内，类似于 `@Min` 和 `@Max`，但适用于 `BigDecimal` 或 `Double` 类型的数值。
|
||
|
||
- **用法**：`@DecimalMin` 验证值是否大于等于指定的最小值，`@DecimalMax` 验证值是否小于等于指定的最大值。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@DecimalMin(value = "0.0", inclusive = true, message = "价格不能小于0")
|
||
private BigDecimal price;
|
||
```
|
||
|
||
### **`@Future`**
|
||
|
||
- **作用**：验证日期字段的值是否为将来日期。
|
||
|
||
- **用法**：用于 `java.util.Date`、`java.time.LocalDate` 或 `java.time.LocalDateTime` 等日期类型的字段。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Future(message = "日期必须是未来的时间")
|
||
private LocalDate eventDate;
|
||
```
|
||
|
||
### **`@Past`**
|
||
|
||
- **作用**：验证日期字段的值是否为过去的日期。
|
||
|
||
- **用法**：类似于 `@Future`，但是验证日期必须是过去的时间。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Past(message = "出生日期必须是过去的时间")
|
||
private LocalDate birthDate;
|
||
```
|
||
|
||
### **`@AssertTrue`**
|
||
|
||
- **作用**：验证字段值是否为 `true`。
|
||
|
||
- **用法**：适用于布尔类型字段，如果值不是 `true`，则验证失败。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@AssertTrue(message = "必须接受条款和条件")
|
||
private boolean acceptedTerms;
|
||
```
|
||
|
||
### **`@AssertFalse`**
|
||
|
||
- **作用**：验证字段值是否为 `false`。
|
||
|
||
- **用法**：适用于布尔类型字段，如果值不是 `false`，则验证失败。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@AssertFalse(message = "不能接受条款")
|
||
private boolean declinedTerms;
|
||
```
|
||
|
||
### **`@Valid` 和 `@Validated`**
|
||
|
||
- **作用**：触发嵌套对象的验证。
|
||
|
||
- **用法**：当你有嵌套对象（如表单中的对象属性是另一个对象），使用 `@Valid` 或 `@Validated` 注解来递归验证该对象。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Valid
|
||
private Address address;
|
||
```
|
||
|
||
### **`@Digits(integer, fraction)`**
|
||
|
||
- **作用**：验证数字字段的有效性，确保字段值是一个有效的数字，并且整数部分和小数部分的位数符合指定要求。
|
||
|
||
- **用法**：`integer` 参数用于指定数字的整数部分的最大位数，`fraction` 参数用于指定小数部分的最大位数。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Digits(integer = 5, fraction = 2, message = "金额应为最大5位整数和2位小数")
|
||
private BigDecimal amount;
|
||
```
|
||
|
||
- 这个例子验证金额字段的最大值为 `99999.99`（即最多5位整数和2位小数）。
|
||
|
||
### **`@CreditCardNumber`**
|
||
|
||
- **作用**：验证信用卡号的有效性，确保其符合信用卡的常见格式，通常包括 Luhn 算法的验证。
|
||
|
||
- **用法**：该注解用于验证信用卡号的格式是否有效。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@CreditCardNumber(message = "请输入有效的信用卡号")
|
||
private String creditCardNumber;
|
||
```
|
||
|
||
- 该注解会根据常见的信用卡规则（如 VISA、MasterCard 等）验证输入的信用卡号是否合法。
|
||
|
||
### **`@Range(min, max)`**（不是 Spring 内置的，但通常来自 Hibernate Validator）
|
||
|
||
- **作用**：验证字段值是否在指定的范围内。常用于 `Integer`、`Long`、`Double` 等数值类型的字段。
|
||
|
||
- **用法**：指定字段的有效范围，当值不在范围内时会验证失败。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Range(min = 1, max = 100, message = "数字必须在1到100之间")
|
||
private int quantity;
|
||
```
|
||
|
||
- 该注解会验证 `quantity` 字段的值是否在 `1` 到 `100` 之间。
|
||
|
||
### **`@URL`**
|
||
|
||
- **作用**：验证字段是否为有效的 URL 格式。
|
||
|
||
- **用法**：用于字符串类型的字段，验证其是否符合有效的 URL 格式。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@URL(message = "请输入有效的网址")
|
||
private String website;
|
||
```
|
||
|
||
### **`@Valid` 与 `@Validated`**
|
||
|
||
- **作用**：用于嵌套对象的验证，确保嵌套对象的字段也进行验证。
|
||
|
||
- **用法**：这两个注解会触发嵌套对象的验证，通常用于嵌套的复杂表单数据结构。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Valid
|
||
private Address address;
|
||
```
|
||
|
||
- 如果 `Address` 类中有字段使用了验证注解，`@Valid` 会递归地验证 `Address` 对象的所有字段。
|
||
|
||
### **`@FutureOrPresent`**
|
||
|
||
- **作用**：验证日期或时间字段的值是否是当前日期（包括今天）或未来的日期。
|
||
|
||
- **用法**：该注解用于日期和时间字段，确保其为今天或将来的日期。
|
||
|
||
- 示例
|
||
|
||
：
|
||
|
||
```java
|
||
@FutureOrPresent(message = "事件日期必须是今天或将来")
|
||
private LocalDate eventDate;
|
||
```
|
||
|
||
### **`@PastOrPresent`**
|
||
|
||
- **作用**：验证日期或时间字段的值是否是当前日期（包括今天）或过去的日期。
|
||
|
||
- **用法**：与 `@FutureOrPresent` 相反，确保字段是过去或今天的日期。
|
||
|
||
- 示
|
||
|
||
```java
|
||
@PastOrPresent(message = "出生日期必须是过去的时间或今天")
|
||
private LocalDate birthDate;
|
||
```
|
||
|
||
### **`@Null`**
|
||
|
||
- **作用**：验证字段是否为 `null`。如果字段不为空，则验证失败。
|
||
|
||
- **用法**：该注解可以用于字段或方法参数上，确保字段值必须为 `null`。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@Null(message = "该字段必须为null")
|
||
private String nickname;
|
||
```
|
||
|
||
### **`@ScriptAssert(lang, script)`**
|
||
|
||
- **作用**：通过自定义脚本验证字段值。
|
||
|
||
- **用法**：允许使用自定义脚本（如 JavaScript）来执行复杂的验证逻辑。需要指定脚本语言和脚本内容。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@ScriptAssert(lang = "javascript", script = "_this.password == _this.confirmPassword", message = "密码和确认密码必须一致")
|
||
private String password;
|
||
private String confirmPassword;
|
||
```
|
||
|
||
- 这个注解可以用于检查两个字段值是否一致。
|
||
|
||
### **`@UniqueElements`**（Hibernate Validator 扩展）
|
||
|
||
- **作用**：确保集合中的元素是唯一的，常用于 List 或 Set 类型字段。
|
||
|
||
- **用法**：适用于集合类型字段，确保集合中的元素不重复。
|
||
|
||
- 示例
|
||
|
||
```java
|
||
@UniqueElements(message = "列表中的元素必须唯一")
|
||
private List<String> tags;
|
||
```
|
||
|
||
## Thymeleaf快速入门
|
||
|
||
Thymeleaf 是一种现代化的 Java 模板引擎，广泛用于生成 HTML、XML、JavaScript 等内容。它有许多内置的指令和功能，用于渲染动态内容、条件渲染、循环、处理表达式等。以下是 Thymeleaf 中常见的指令和属性的详细介绍：
|
||
|
||
### 1. **`th:text`**
|
||
|
||
用于替换元素的文本内容。
|
||
|
||
```html
|
||
<span th:text="${message}"></span>
|
||
```
|
||
|
||
- `${message}` 的值会替换 `span` 元素的文本。
|
||
|
||
> 如果需要格式化日期，需要注意，使用`temporals`进行操作
|
||
>
|
||
> ```html
|
||
> <td class="text-success" th:text="${#temporals.format(bill.transactionDate,'yyyy-MM-dd HH:mm:ss')}"></td>
|
||
> ```
|
||
|
||
### 2. **`th:utext`**
|
||
|
||
用于替换元素的文本内容，并允许处理 HTML 标签（不会转义 HTML）。
|
||
|
||
```html
|
||
<span th:utext="${htmlContent}"></span>
|
||
```
|
||
|
||
- `${htmlContent}` 的内容直接插入，并解析其中的 HTML。
|
||
|
||
### 3. **`th:value`**
|
||
|
||
设置表单元素的 `value` 属性，通常用于输入框或选择框。
|
||
|
||
```html
|
||
<input type="text" th:value="${user.name}" />
|
||
```
|
||
|
||
- 将 `${user.name}` 的值赋给该输入框的 `value` 属性。
|
||
|
||
### 4. **`th:each`**
|
||
|
||
用于循环遍历集合或数组。
|
||
|
||
```html
|
||
<ul>
|
||
<li th:each="person : ${people}">
|
||
<span th:text="${person.name}"></span>
|
||
</li>
|
||
</ul>
|
||
```
|
||
|
||
- 遍历 `people` 集合，输出每个 `person.name`。
|
||
|
||
### 5. **`th:if`**
|
||
|
||
用于条件渲染，只有满足条件时才渲染元素。
|
||
|
||
```html
|
||
<div th:if="${user.isAdmin}">
|
||
<p>Welcome, admin!</p>
|
||
</div>
|
||
```
|
||
|
||
- 如果 `user.isAdmin` 为 `true`，渲染该 `div`。
|
||
|
||
### 6. **`th:unless`**
|
||
|
||
与 `th:if` 相反，只有条件为 `false` 时才渲染元素。
|
||
|
||
```html
|
||
<div th:unless="${user.isAdmin}">
|
||
<p>You are not an admin!</p>
|
||
</div>
|
||
```
|
||
|
||
- 如果 `user.isAdmin` 为 `false`，渲染该 `div`。
|
||
|
||
### 7. **`th:attr`**
|
||
|
||
用于设置元素的多个属性。
|
||
|
||
```html
|
||
<img th:attr="src=${imageUrl}" th:attr="alt=${imageDescription}" />
|
||
```
|
||
|
||
- 设置 `img` 元素的 `src` 和 `alt` 属性。
|
||
|
||
### 8. **`th:src` / `th:href`**
|
||
|
||
用于动态设置 `src` 或 `href` 属性。
|
||
|
||
```html
|
||
<img th:src="@{${imageUrl}}" alt="Image">
|
||
<a th:href="@{${linkUrl}}">Click Here</a>
|
||
```
|
||
|
||
- `th:src` 用于设置图片的 `src` 属性，`th:href` 用于设置链接的 `href` 属性。
|
||
|
||
### 9. **`th:class`**
|
||
|
||
动态设置 `class` 属性，支持条件表达式。
|
||
|
||
```html
|
||
<div th:class="${isActive} ? 'active' : 'inactive'">...</div>
|
||
```
|
||
|
||
- 如果 `isActive` 为 `true`，设置 `class="active"`，否则为 `inactive`。
|
||
|
||
### 10. **`th:classappend` / `th:classprepend`**
|
||
|
||
分别在现有的 `class` 属性上追加或前置新类。
|
||
|
||
```html
|
||
<div th:classappend="'newClass'">...</div>
|
||
<div th:classprepend="'prefixClass'">...</div>
|
||
```
|
||
|
||
- `th:classappend` 会将新的类追加到现有类的后面。
|
||
- `th:classprepend` 会将新的类添加到现有类的前面。
|
||
|
||
### 11. **`th:id`**
|
||
|
||
设置元素的 `id` 属性。
|
||
|
||
```html
|
||
<input type="text" th:id="${elementId}" />
|
||
```
|
||
|
||
- 设置 `input` 元素的 `id` 为 `${elementId}` 的值。
|
||
|
||
### 12. **`th:action`**
|
||
|
||
设置表单的 `action` 属性。
|
||
|
||
```html
|
||
<form th:action="@{/submitForm}" method="post">
|
||
<!-- form fields -->
|
||
</form>
|
||
```
|
||
|
||
- 设置表单的 `action` 为 `/submitForm`。
|
||
|
||
### 13. **`th:style`**
|
||
|
||
设置元素的 `style` 属性。
|
||
|
||
```html
|
||
<div th:style="'color: ' + ${color}"></div>
|
||
```
|
||
|
||
- 动态设置 `style` 属性，`${color}` 的值会成为 `color` 样式的值。
|
||
|
||
### 14. **`th:fragment`**
|
||
|
||
定义一个可重用的片段，通常在模板中调用。
|
||
|
||
```html
|
||
<div th:fragment="userFragment">
|
||
<p>Welcome, <span th:text="${user.name}"></span></p>
|
||
</div>
|
||
```
|
||
|
||
- 定义一个 `userFragment` 片段，可以在其他模板中引用。
|
||
|
||
### 15. **`th:replace`**
|
||
|
||
替换当前元素，并将一个片段或其他模板插入其中。
|
||
|
||
```html
|
||
<div th:replace="~{userFragment}"></div>
|
||
```
|
||
|
||
- `th:replace` 会将 `userFragment` 片段的内容插入到当前 `div` 中。
|
||
|
||
### 16. **`th:include`**
|
||
|
||
将另一个模板的内容插入当前模板中，但不会替换当前元素。
|
||
|
||
```html
|
||
<div th:include="~{userFragment}"></div>
|
||
```
|
||
|
||
- 插入 `userFragment` 的内容，但保留当前 `div` 元素。
|
||
|
||
### 17. **`th:with`**
|
||
|
||
局部变量声明，用于在模板中定义临时变量。
|
||
|
||
```html
|
||
<div th:with="total=${cart.totalPrice}">
|
||
<p th:text="'Total price: ' + ${total}"></p>
|
||
</div>
|
||
```
|
||
|
||
- `th:with` 用于在当前元素的上下文中定义变量，类似于局部变量。
|
||
|
||
### 18. **`th:block`**
|
||
|
||
在模板中定义一个不会渲染任何 HTML 标签的块元素。用于组合多个元素。
|
||
|
||
```html
|
||
<th:block th:each="person : ${people}">
|
||
<p th:text="${person.name}"></p>
|
||
</th:block>
|
||
```
|
||
|
||
- `th:block` 不会渲染任何标签，但可以用来包装多个元素进行条件判断或循环。
|
||
|
||
### 19. **`th:switch` / `th:case`**
|
||
|
||
类似于 Java 中的 `switch` 语句，用于条件选择。
|
||
|
||
```html
|
||
<div th:switch="${status}">
|
||
<span th:case="'active'">Active</span>
|
||
<span th:case="'inactive'">Inactive</span>
|
||
<span th:case="*">Unknown</span>
|
||
</div>
|
||
```
|
||
|
||
- 根据 `${status}` 的值，渲染对应的 `span` 元素。
|
||
|
||
### 20. **`th:object`**
|
||
|
||
用来为表单元素绑定一个对象。
|
||
|
||
```html
|
||
<form th:action="@{/submit}" th:object="${user}">
|
||
<input type="text" th:field="*{name}" />
|
||
<input type="text" th:field="*{email}" />
|
||
<button type="submit">Submit</button>
|
||
</form>
|
||
```
|
||
|
||
- `th:object` 绑定整个表单到 `user` 对象。
|
||
- `th:field` 用于绑定每个表单字段到对象的属性。
|
||
|
||
### 21. **`th:href` / `th:src`**
|
||
|
||
用于动态设置 URL 值。
|
||
|
||
```html
|
||
<a th:href="@{/users/{id}(id=${user.id})}">Profile</a>
|
||
<img th:src="@{/images/{imageName}(imageName=${image.name})}" />
|
||
```
|
||
|
||
- 动态生成 URL，支持路径变量的替换。
|
||
|
||
### 22. **`th:placeholder`**
|
||
|
||
设置表单输入框的 `placeholder` 属性。
|
||
|
||
```html
|
||
<input type="text" th:placeholder="${placeholderText}" />
|
||
```
|
||
|
||
- 设置 `input` 的 `placeholder` 为 `${placeholderText}` 的值。
|
||
|
||
### 23. **`th:errors`**
|
||
|
||
显示与 `username` 属性相关的错误信息。如果 `username` 为空或者不符合验证规则，这里就会显示出相应的错误消息。
|
||
|
||
```html
|
||
<div th:errors="*{email}"></div> <!-- 错误信息展示 -->
|
||
```
|
||
|
||
你还可以通过 `th:errors` 对错误消息进行自定义格式化。例如，使用 `*{field}` 可以获取字段的错误信息。
|
||
|
||
```html
|
||
<div th:errors="*{username}">Error</div>
|
||
```
|
||
|
||
如果验证失败，错误消息将显示在 `<div>` 中。如果没有错误，它会显示默认的 "Error" 文本。
|
||
|
||
## SpringSecurity
|
||
|
||
### 密码转换器（Password Encoder）
|
||
|
||
Spring Security 提供了多种密码转换器（Password Encoder），这些转换器用于对用户密码进行加密和验证。常见的密码转换器包括：
|
||
|
||
1. **BCryptPasswordEncoder**：
|
||
|
||
- 使用 **BCrypt** 算法对密码进行加密。
|
||
|
||
- 是最常用的密码加密方案，具有强大的加密性，并且支持自动加盐（salt），防止暴力破解攻击。
|
||
|
||
- 示例：
|
||
|
||
```java
|
||
@Bean
|
||
public PasswordEncoder passwordEncoder() {
|
||
return new BCryptPasswordEncoder();
|
||
}
|
||
```
|
||
|
||
2. **NoOpPasswordEncoder**：
|
||
|
||
- 不对密码进行加密，直接返回明文密码。
|
||
|
||
- 主要用于开发和测试环境，**不推荐在生产环境中使用**。
|
||
|
||
- 示例：
|
||
|
||
```java
|
||
@Bean
|
||
public PasswordEncoder passwordEncoder() {
|
||
return NoOpPasswordEncoder.getInstance();
|
||
}
|
||
```
|
||
|
||
3. **Pbkdf2PasswordEncoder**：
|
||
|
||
- 使用 **PBKDF2** 算法进行密码加密。
|
||
|
||
- 提供较强的安全性，并且支持对密码进行哈希。
|
||
|
||
- 示例：
|
||
|
||
```java
|
||
@Bean
|
||
public PasswordEncoder passwordEncoder() {
|
||
return new Pbkdf2PasswordEncoder();
|
||
}
|
||
```
|
||
|
||
4. **Argon2PasswordEncoder**：
|
||
|
||
- 使用 **Argon2** 算法对密码进行加密。
|
||
|
||
- Argon2 是目前被认为最强的密码哈希算法，支持内存密集型计算，从而防止硬件加速破解。
|
||
|
||
- 示例：
|
||
|
||
```java
|
||
@Bean
|
||
public PasswordEncoder passwordEncoder() {
|
||
return new Argon2PasswordEncoder();
|
||
}
|
||
```
|
||
|
||
5. **SCryptPasswordEncoder**：
|
||
|
||
- 使用 **SCrypt** 算法进行密码加密。
|
||
|
||
- SCrypt 是另一种内存密集型的密码加密算法，与 Argon2 类似，旨在防止硬件加速破解。
|
||
|
||
- 示例：
|
||
|
||
```java
|
||
@Bean
|
||
public PasswordEncoder passwordEncoder() {
|
||
return new SCryptPasswordEncoder();
|
||
}
|
||
```
|
||
|
||
6. **MessageDigestPasswordEncoder** (已废弃)：
|
||
|
||
- 基于 **MessageDigest** 算法进行加密（如 SHA-1、SHA-256 等）。
|
||
- 由于缺乏盐和密钥加密机制，已被其他更强的加密方式所替代。
|
||
|
||
> 选择密码转换器的建议：
|
||
>
|
||
> - 在现代应用中，推荐使用 **BCryptPasswordEncoder** 或 **Argon2PasswordEncoder**，这两种算法提供了强大的加密性。
|
||
> - **Pbkdf2PasswordEncoder** 和 **SCryptPasswordEncoder** 也可以作为备选方案，尤其是当你希望加密算法能够承受更多资源密集型攻击时。
|
||
> - **NoOpPasswordEncoder** 仅限于开发和测试环境。
|
||
|
||
### 访问主页
|
||
|
||
需要使用`http://localhost:8080/index`来访问主页，可以在配置中配置，访问根路径直接跳转
|
||
|
||
```java
|
||
@RequestMapping
|
||
@Controller
|
||
public class HomeController {
|
||
|
||
@Operation(summary = "主页内容")
|
||
@GetMapping("index")
|
||
public String index() {
|
||
return "index";
|
||
}
|
||
|
||
@Operation(summary = "订单内容")
|
||
@GetMapping("order")
|
||
public String order() {
|
||
return "order";
|
||
}
|
||
|
||
@Operation(summary = "login")
|
||
@GetMapping("login")
|
||
public String login() {
|
||
return "login";
|
||
}
|
||
}
|
||
```
|
||
|
||
在配置中
|
||
|
||
```java
|
||
import org.springframework.context.annotation.Configuration;
|
||
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
|
||
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
|
||
|
||
@Configuration
|
||
public class WebConfiguration implements WebMvcConfigurer {
|
||
|
||
@Override
|
||
public void addViewControllers(ViewControllerRegistry registry) {
|
||
registry.addViewController("/")
|
||
// .setViewName("forward:/index") //两种方式写法
|
||
.setViewName("index");
|
||
registry.addViewController("/login");
|
||
}
|
||
}
|
||
```
|
||
|
||
### 自定义登录
|
||
|
||
```java
|
||
package cn.bunny.springdemo.configuration;
|
||
|
||
import cn.bunny.springdemo.dao.entity.AdminUser;
|
||
import org.springframework.context.annotation.Bean;
|
||
import org.springframework.context.annotation.Configuration;
|
||
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
|
||
import org.springframework.security.core.userdetails.UserDetails;
|
||
import org.springframework.security.core.userdetails.UserDetailsService;
|
||
import org.springframework.security.crypto.password.PasswordEncoder;
|
||
import org.springframework.security.crypto.scrypt.SCryptPasswordEncoder;
|
||
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
|
||
import org.springframework.security.web.SecurityFilterChain;
|
||
|
||
import java.util.ArrayList;
|
||
|
||
@Configuration
|
||
public class SecurityConfiguration {
|
||
|
||
@Bean
|
||
public PasswordEncoder passwordEncoder() {
|
||
return new SCryptPasswordEncoder(4, 8, 1, 8, 32);
|
||
}
|
||
|
||
/**
|
||
* 使用内存方式
|
||
*
|
||
* @param encoder 密码加密器
|
||
* @return 基于内存的用户
|
||
*/
|
||
@Bean
|
||
public UserDetailsService userDetailsService(PasswordEncoder encoder) {
|
||
ArrayList<UserDetails> userDetails = new ArrayList<>();
|
||
userDetails.add(new AdminUser("admin", encoder.encode("admin"), true));
|
||
userDetails.add(new AdminUser("bunny", encoder.encode("password"), true));
|
||
|
||
return new InMemoryUserDetailsManager(userDetails);
|
||
}
|
||
|
||
// /**
|
||
// * 使用数据库方式
|
||
// *
|
||
// * @param userService 获取用户数据（如数据库）
|
||
// * @return 基于数据库的用户
|
||
// */
|
||
// @Bean
|
||
// public UserDetailsService userDetailsService(UserService userService) {
|
||
// return username -> {
|
||
// AdminUser adminUser = userService.getOne(Wrappers.<AdminUser>lambdaQuery().eq(AdminUser::getUsername, userService));
|
||
// if (adminUser != null) {
|
||
// return adminUser;
|
||
// }
|
||
// throw new UsernameNotFoundException("未找到 AdminUser");
|
||
// };
|
||
// }
|
||
|
||
@Bean
|
||
public SecurityFilterChain filterChain(HttpSecurity security) throws Exception {
|
||
return security
|
||
.authorizeHttpRequests(authorizationManagerRequestMatcherRegistry ->
|
||
authorizationManagerRequestMatcherRegistry
|
||
.requestMatchers("/order").hasRole("USER")// 请求需要含有USER角色
|
||
.requestMatchers("/", "/index", "/login", "/images/**").permitAll()
|
||
)
|
||
/* 自定义登录页面 */
|
||
// .formLogin(AbstractAuthenticationFilterConfigurer::permitAll)// 默认的登录页会自动启用，无需额外配置
|
||
.formLogin(formLoginConfigurer -> formLoginConfigurer
|
||
.loginPage("/login")
|
||
// .loginProcessingUrl("/authenticate")
|
||
.usernameParameter("username")// 自定义用户名名称
|
||
.usernameParameter("password")// 自定义密码名称
|
||
.defaultSuccessUrl("/index")// 登录成功后默认跳转页面
|
||
// .defaultSuccessUrl("/index", true)// 登录成功后默认跳转页面，如果用户之前访问页面也需要强制跳转到 /index 可以传递第二个参数
|
||
)
|
||
.build();
|
||
}
|
||
}
|
||
```
|
||
|
||
### CSRF 伪造
|
||
|
||
通常在自定义登录页面中加入
|
||
|
||
```html
|
||
<label>
|
||
<input name="_csrf" placeholder="_csrf" th:value="${_csrf.token}" type="hidden"/>
|
||
</label>
|
||
```
|
||
|
||
如果需要禁用
|
||
|
||
```java
|
||
.csrf(AbstractHttpConfigurer::disable)// 前后端分离可以禁用
|
||
```
|
||
|
||
### 开发授权服务器
|
||
|
||
```xml
|
||
<!--资源服务器-->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-oauth2-resource server</artifactId>
|
||
</dependency>
|
||
<!-- 客户应用 -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-oauth2-client</artifactId>
|
||
</dependency>
|
||
<!-- 授权服务器 -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-oauth2-authorization-server</artifactId>
|
||
</dependency>
|
||
```
|
||
|