一、SpringMVC简介
1. 介绍
Spring Web MVC 是基于Servlet API构建的原始Web框架，从一开始就包含在Spring Framework 中。在控制层框架经历Srust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC 作为Java EE项目表述层开发的首选方案。之所以能做到这一点，是因为SpringMVC 具备以下优势：
- Spring 家族原生产品，与IOC容器等基础设施无缝对接
- 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
- 代码清新简洁，大幅度提升开发效率
- 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
- 性能卓著，尤其适合现代大型、超大型互联网项目要求
2. 主要作用
SSM框架构建起单体项目的技术栈需求，其中的SpringMVC负责表述层（控制层）实例简化
SpringMVC的作用主要覆盖的是表述层，例如：请求映射、数据输入、视图界面、请求分发、表单、回显、会话控制、过滤拦截、异步交互、文件上传、文件下载、数据校验、类型转换等等
最终总结：
- 简化前端参数接收（形参列表）
- 简化后端数据响应（返回值）
3. 核心组件和调用流程理解
SpringMVC 与许多其他Web框架一样，是围绕前端控制器模拟设计的，其中中央Servlet DispatcherServlet 做整体请求处理调度，除了DispatcherServlet SpringMVC其他特殊组件协作完成请求处理和响应呈现。
SpringMVC涉及组件理解：
- DispatcherServlet：SpringMVC提供，我们需要使用web.xml 配置时其生效，它是整个流程处理的核心，所有请求都经过它的处理和分发！（CEO）
- HandlerMapping：SpringMVC提供，我们需要进行 IoC配置使其加入 IoC容器方可生效，它内部缓存 handler（Controller方法）和 handler访问路径数据，被DispathcherServlet调用，用于查找路径对应的 handler。（秘书）
- HandlerAdapter：SpringMVC提供，我们需要进行IoC配置使其加入IoC容器方可生效，它可以处理请求参数和处理响应数据，每次DispatcherServlet都是通过handlerAdapeter间接调用handler，他是handler和DisopatcherServlet之间的适配器。（经理）
- Handler：handler又称处理器，他是Controller类内部的方法简称，是由我们自己定义，用来接收参数，向后调用业务，最终返回响应结果。（打工人）
- ViewResolver：SpringMVC提供，我们需要进行 IoC 配置使其加入 IoC 容器方可生效，视图解析器主要作用简化模板视图页面查找的，但是需要注意，前后端分离项目，后端只返回JSON 数据，不返回页面，那就不需要视图解析器，所以，视图解析器相对其他的组件不是必须的。（财务）
二、SpringMVC接收数据
1. 访问路径设置
@RequestMapping 注解的作用就是将请求的 URL 地址和处理请求的方式（handler 方法）关联起来，建立映射关系。SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的方法来处理这个请求。
1.1 精准路径匹配
在 @RequestMapping 注解指定 URL 地址时，不使用任何通配符，按照请求地址进行精准匹配。
@Controller
public class UserController {
/**
* 精准设置访问地址 /user/login
*/
@RequestMapping(value = {"/user/login"})
@ResponseBody
public String login(){
System.out.println("UserController.login");
return "login success!!";
}
/**
* 精准设置访问地址 /user/register
*/
@RequestMapping(value = {"/user/register"})
@ResponseBody
public String register(){
System.out.println("UserController.register");
return "register success!!";
}
}1.2 模糊路径匹配
在 @RequestMapping 注解指定 URL 地址时，通过使用通配符，匹配多个类似的地址。
@Controller
public class ProductController {
/**
* 路径设置为 /product/*
* /* 为单层任意字符串 /product/a /product/aaa 可以访问此handler
* /product/a/a 不可以
* 路径设置为 /product/**
* /** 为任意层任意字符串 /product/a /product/aaa 可以访问此handler
* /product/a/a 也可以访问
*/
@RequestMapping("/product/*")
@ResponseBody
public String show(){
System.out.println("ProductController.show");
return "product show!";
}
}
单层匹配和多层匹配：
/*：只能匹配URL地址中的一层，如果想准确匹配两层，那么就写“/*/*”以此类推。
/**：可以匹配URL地址中的多层。
其中所谓的一层或多层是指一个URL地址字符串被“/”划分出来的各个层次
这个知识点虽然对于@RequestMapping注解来说实用性不大，但是将来配置拦截器的时候也遵循这个规则。1.3 类和方法级别区别
@RequestMapping 注解可以用于类级别和方法级别，它们之间的区别：
- 设置到类级别：@RequestMapping 注解可以设置在控制器类上，用于映射整个控制器的通用请求路径。这样，如果控制器中的多个方法都需要映射同一请求路径，就不需要在每个方法上添加映射路径。
- 设置到方法级别：@RequestMapping 注解也可以单独设置在控制器方法上，用于更细粒度地映射请求路径和处理方法。当多个方法处理同一个路径的不同操作时，可以使用方法级别的 @RequestMapping 注解进行更精细的映射。
//1.标记到handler方法
@RequestMapping("/user/login")
@RequestMapping("/user/register")
@RequestMapping("/user/logout")
//2.优化标记类+handler方法
//类上
@RequestMapping("/user")
//handler方法上
@RequestMapping("/login")
@RequestMapping("/register")
@RequestMapping("/logout")1.4 附带请求方式限制
HTTP 协仪定义了八种请求方式，在SpringMVC 中封装了下面这个枚举类：
public enum RequestMethod {
GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
}默认情况下：@RequestMapping("/logout") 任何请求方式都可以访问。
如果需要特定指定：
@Controller
public class UserController {
/**
* 精准设置访问地址 /user/login
* method = RequestMethod.POST 可以指定单个或者多个请求方式!
* 注意:违背请求方式会出现405异常!
*/
@RequestMapping(value = {"/user/login"} , method = RequestMethod.POST)
@ResponseBody
public String login(){
System.out.println("UserController.login");
return "login success!!";
}
/**
* 精准设置访问地址 /user/register
*/
@RequestMapping(value = {"/user/register"},method = {RequestMethod.POST,RequestMethod.GET})
@ResponseBody
public String register(){
System.out.println("UserController.register");
return "register success!!";
}
}注意：违背请求方式，会出现405异常。
1.5 进阶注解
还有 @RequestMapping 的 HTTP 方法特定快捷方式变体：
@GetMapping 、@PostMapping 、@PutMapping 、@DeleteMapping 、@PatchMapping
@RequestMapping(value="/login",method=RequestMethod.GET)
||
@GetMapping(value="/login")注意：进阶注解只能添加到 handler 方法上，无法添加到类上。
1.6 常见配置问题
出现原因：多个handler 方法映射了同一个地址，导致 SpringMVC 在接收到这个地址的请求时该找哪个 handler 方法处理。
There is already 'demo03MappingMethodHandler' bean method com.atguigu.mvc.handler.Demo03MappingMethodHandler#empGet() mapped.
2. 接收参数（重点）
2.1 param 和 json参数比较
在HTTP 请求中，我们可以选择不同的参数类型，如 param类型和JSON 类型。两种参数的区别和对比：
- 参数编码：param 类型的参数会被编码为 ASCII 码。而JSON 类型的参数会被编码为 UTF-8。
- 参数顺序：param 类型的参数没有顺序限制。JSON类型的参数是有序的。JSON采用键值对的形式进行传递，其中键值对是有序排列的。
- 数据类型：param 类型的参数仅支持字符串类型、数值类型和布尔类型等简单数据类型。而JSON类型的参数则支持更复杂的数据类型，如数组、对象等。
- 嵌套性：param 类型的参数不支持嵌套。JSON类型的参数支持嵌套，可以传递更复杂的数据结构。
- 可读性：param 类型的参数格式比JSON类型的参数更加简单、易读。JSON格式在传递嵌套数据结构时更加清晰易懂。
总的来说，param 类型的参数适用于单一的数据传递，而JSON 类型的参数则更适用于更复杂的数据结构传递。根据具体的业务需求，需要选择合适的参数类型。在实际开发中，常见的做法是：在GET 请求中采用 param 类型的参数，而在 POST 请求中采用 JSON 类型的参数传递。
2.2 param参数接收
1）直接接值
客户端请求
handler接收参数只要形参名和类型与传递参数相同，即可自动接收。
@Controller
@RequestMapping("param")
public class ParamController {
/**
* 前端请求: http://localhost:8080/param/value?name=xx&age=18
*
* 可以利用形参列表,直接接收前端传递的param参数!
* 要求: 参数名 = 形参名
* 类型相同
* 出现乱码正常，json接收具体解决！！
* @return 返回前端数据
*/
@GetMapping(value="/value")
@ResponseBody
public String setupForm(String name,int age){
System.out.println("name = " + name + ", age = " + age);
return name + age;
}
}2）@RequestParam注解
可以使用 @RequestParam 注解将 Servlet 请求参数（即查询参数或表单数据）绑定到控制器中的方法参数。
@RequestParam使用场景：
- 指定绑定的请求参数名
- 要求请求参数必须传递
- 为请求参数提供默认值
/**
* 前端请求: http://localhost:8080/param/data?name=xx&stuAge=18
*
* 使用@RequestParam注解标记handler方法的形参
* 指定形参对应的请求参数@RequestParam(请求参数名称)
*/
@GetMapping(value="/data")
@ResponseBody
public Object paramForm(@RequestParam("name") String name,
@RequestParam("stuAge") int age){
System.out.println("name = " + name + ", age = " + age);
return name+age;
}默认情况下，使用此批注方法参数是必需的，但你可以通过将 @RequestParam 批注的 required 属性设置为 false。如果没有设置非必须，也没有传递参数会出现 400 状态码。
将参数设置非必须，并且设置默认值：
@GetMapping(value="/data")
@ResponseBody
public Object paramForm(@RequestParam("name") String name,
@RequestParam(value = "stuAge",required = false,defaultValue = "18") int age){
System.out.println("name = " + name + ", age = " + age);
return name+age;
}3）特殊场景接值
① 一名多值
多选框，提交的数据的时候一个key对应多个值，我们可以使用集合进行接收。
/**
* 前端请求: http://localhost:8080/param/mul?hbs=吃&hbs=喝
*
* 一名多值,可以使用集合接收即可!但是需要使用@RequestParam注解指定
*/
@GetMapping(value="/mul")
@ResponseBody
public Object mulForm(@RequestParam List<String> hbs){
System.out.println("hbs = " + hbs);
return hbs;
}② 实体接收
Spring MVC 是Spring 框架提供的 Web 框架，它允许开发者使用实体对象来接收 HTTP 请求中的参数。通过这种方式，可以在方法内部直接使用对象的属性来访问请求参数，而不需要每个参数都写一遍。
public class User {
private String name;
private int age = 18;
// getter 和 setter 略
}
@Controller
@RequestMapping("param")
public class ParamController {
@RequestMapping(value = "/user", method = RequestMethod.POST)
@ResponseBody
public String addUser(User user) {
// 在这里可以使用 user 对象的属性来接收请求参数
System.out.println("user = " + user);
return "success";
}
}上述代码中，将请求参数 name 和 age 映射到实体类属性上，要求属性名必须等于参数名，否则无法映射。
使用postman传递参数测试：
2.3 路径参数接收
路径传递参数是一种在 URL 路径中传递参数的方式，在RESTFUL的 Web 应用程序中，经常使用路径传递参数来表资源的唯一标识符或更复杂的标识方式。而Spring MVC 框架提供了 @PathVariable 注解来处理路径传递参数。
@PathVariable 注解允许将 URL 中的占位符映射到控制器方法中的参数。
/**
* 动态路径设计: /user/{动态部分}/{动态部分} 动态部分使用{}包含即可! {}内部动态标识!
* 形参列表取值: @PathVariable Long id 如果形参名 = {动态标识} 自动赋值!
* @PathVariable("动态标识") Long id 如果形参名 != {动态标识} 可以通过指定动态标识赋值!
*
* 访问测试: /param/user/1/root -> id = 1 uname = root
*/
@GetMapping("/user/{id}/{name}")
@ResponseBody
public String getUser(@PathVariable Long id,
@PathVariable("name") String uname) {
System.out.println("id = " + id + ", uname = " + uname);
return "user_detail";
}2.4 json参数
前端传递 JSON 数据时，Spring MVC 框架可以使用 @RequestBody 注解来将 JSON 数据转换为 java 对象。@RequestBody 注解表示当前方法参数的值应该从请求体中获取，并且需要指定 value 属性来指示请求体应该映射到哪个参数上。
1）前端发送 JSON 数据的示例：（使用postman 测试）
{
"name": "张三",
"age": 18,
"gender": "男"
}2）定义一个用于接收 JSON 数据的 java类。
public class Person {
private String name;
private int age;
private String gender;
// getter 和 setter 略
}3）在控制器中，使用 @RequestBody 注解来接收 JSON 数据，并将其转换为 Java对象。
@PostMapping("/person")
@ResponseBody
public String addPerson(@RequestBody Person person) {
// 在这里可以使用 person 对象来操作 JSON 数据中包含的属性
return "success";
}在上述代码中，@RequestBody 注解将请求体中的 JSON 数据映射到 Person 类型的 person参数并将其作为一个对象来传递给 addPerson() 方法处理。
注意：<mvc:annotation是一个整合配置标签，一个标签将springmvc必备组件都加入到ioc容器中！其中包含handlerMapping和handlerAdapter以及json转化器等等！
<!--
注意: 导入mvc命名空间!
mvc:annotation-driven 是一个整合标签
他会导入handlerMapping和handlerAdapter
他会导入json数据格式转化器等等!
-->
<mvc:annotation-driven />3. 接收Cookie 数据
可以使用 @CookieValue 注释将 HTTP Cookie 的值绑定到控制器中的方法参数。
考虑使用以下 cookie 的请求：
JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84@Controller
@RequestMapping("/ck")
public class CookieController {
@GetMapping("/cookie")
@ResponseBody
public String getSessionId(@CookieValue("JSESSIONID") String sessionId ){
System.out.println("sessionId = " + sessionId);
return "sessionId"+sessionId;
}
}4. 接收请求头数据
可以使用 @RequestHeader 批注将请求标头绑定到控制器中的方法参数。
考虑以下带有标头的请求：
Host localhost:8080
Accept text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding gzip,deflate
Accept-Charset ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive 300实例获取 Accept 标头的值：
@Controller
@RequestMapping("/header")
public class HeaderController {
@GetMapping("/accept")
@ResponseBody
public String getAccept(@RequestHeader("Accept") String accept){
System.out.println("accept = " + accept);
return accept;
}
}5. 原生Api对象操作
下表描述了支持的控制器方法参数：
| Controller method argument 控制器方法参数 | Description |
|---|---|
jakarta.servlet.ServletRequest, jakarta.servlet.ServletResponse | 请求/响应对象 |
jakarta.servlet.http.HttpSession | 强制存在会话。因此，这样的参数永远不会为 null 。 |
java.io.InputStream, java.io.Reader | 用于访问由 Servlet API 公开的原始请求正文。 |
java.io.OutputStream, java.io.Writer | 用于访问由 Servlet API 公开的原始响应正文。 |
@PathVariable | 接收路径参数注解 |
@RequestParam | 用于访问 Servlet 请求参数，包括多部分文件。参数值将转换为声明的方法参数类型。 |
@RequestHeader | 用于访问请求标头。标头值将转换为声明的方法参数类型。 |
@CookieValue | 用于访问Cookie。Cookie 值将转换为声明的方法参数类型。 |
@RequestBody | 用于访问 HTTP 请求正文。正文内容通过使用 HttpMessageConverter 实现转换为声明的方法参数类型。 |
java.util.Map, org.springframework.ui.Model, org.springframework.ui.ModelMap | 共享域对象，并在视图呈现过程中向模板公开。 |
Errors, BindingResult | 验证和数据绑定中的错误信息获取对象！ |
获取原生对象示例：
/**
* 如果想要获取请求或者响应对象,或者会话等,可以直接在形参列表传入,并且不分先后顺序!
* 注意: 接收原生对象,并不影响参数接收!
*/
@GetMapping("api")
@ResponseBody
public String api(HttpSession session , HttpServletRequest request,
HttpServletResponse response){
String method = request.getMethod();
System.out.println("method = " + method);
return "api";
}6. 共享域对象操作
6.1 属性（共享）域作用回顾
在JavaWeb中，共享域指的是在 Servlet 中存储数据，以便在同一 Web 应用程序的多个组件中进行共享和访问。常见的共享域有四种：ServletContext、HttpSession、HttpServletRequest、PageContext.
- ServletContext 共享域：ServletContext 对象可以在整个Web 应用程序中共享数据，是最大的共享域。一般可以用于保存整个Web 应用程序的全局配置信息，以及所有用户都共享的数据。在 ServletContext 中保存的数据是线程安全的。
- HttpSession 共享域：HttpSession 对象可以在同一用户发出的多个请求之间共享数据，但只能在同一个会话中使用。比如，可以将用户登录状态保存在 HttpSession中，让用户在多个页面间保持登录状态。
- HttpServletRequest 共享域：HttpServletRequest 对象可以在同一个请求的多个处理方法之间共享数据。比如，可以将请求的参数和属性存储在HttpServletRequest 中，让处理器方法之间可以访问这些数据。
- PageContext 共享域：PageContext 对象是在JSP 页面Servlet 创建时自动创建的。它可以在JSP 的各个作用域中共享数据，包括pageScope 、requestScope、sessionScope、applicationScope 等作用域。
共享域的作用是提供了方便实用的方法在同一 Web 应用程序的多个组件之间传递数据，并且可以将数据保存在不同的共享域中，根据需要进行选择和使用。
6.2 Request 级别属性（共享）域
6.3 Session 级别属性（共享）域
6.4 Application 级别属性（共享）域
三、SpringMVC 响应数据
1. handler 方法分析
理解handler 方法的作用和组成：
/**
* TODO: 一个controller的方法是控制层的一个处理器,我们称为handler
* TODO: handler需要使用@RequestMapping/@GetMapping系列,声明路径,在HandlerMapping中注册,供DS查找!
* TODO: handler作用总结:
* 1.接收请求参数(param,json,pathVariable,共享域等)
* 2.调用业务逻辑
* 3.响应前端数据(页面（不讲解模版页面跳转）,json,转发和重定向等)
* TODO: handler如何处理呢
* 1.接收参数: handler(形参列表: 主要的作用就是用来接收参数)
* 2.调用业务: { 方法体 可以向后调用业务方法 service.xx() }
* 3.响应数据: return 返回结果,可以快速响应前端数据
*/
@GetMapping
public Object handler(简化请求参数接收){
调用业务方法
return 简化响应前端数据;
}总结：请求数据接收我们都是通过handler 的形参列表
前端数据响应，我们都是通过handler 的 return 关键字快速处理。
SpringMVC 简化了参数接收和响应。
2. 页面跳转控制
2.1 快速返回 jsp 视图
1）开发模式回顾
在Web 开发中，有两种主要的开发模式：前后端分离和混合开发。
2）jsp技术了解
JSP（javaServer Pages）是一种动态网页开发技术，它是由sun 公司提出的一种基于 java 技术的 Web 页面制作技术，可以在HTML 文件种嵌入 java 代码，使得生成动态内容的编写更简单。
3）准备 jsp 页面和依赖
pom.xml 依赖
<!-- jsp需要依赖! jstl-->
<dependency>
<groupId>jakarta.servlet.jsp.jstl</groupId>
<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
<version>3.0.0</version>
</dependency>jsp页面创建
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<!-- 可以获取共享域的数据,动态展示! jsp== 后台vue -->
${msg}
</body>
</html>4）快速响应模板页面
① 配置jsp 视图解析器
spring-mvc.xml
<!-- 配置动态页面语言jsp的视图解析器,快速查找jsp-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="/WEB-INF/views/"/>
<property name="suffix" value=".jsp"/>
</bean>② handler 返回视图
/**
* 跳转到提交文件页面 /save/jump
*
* 如果要返回jsp页面!
* 1.方法返回值改成字符串类型
* 2.返回逻辑视图名即可
* <property name="prefix" value="/WEB-INF/views/"/>
* + 逻辑视图名 +
* <property name="suffix" value=".jsp"/>
*/
@GetMapping("jump")
public String jumpJsp(Model model){
System.out.println("FileController.jumpJsp");
model.addAttribute("msg","request data!!");
return "home";
}2.2 转发和重定向
在 SpringMVC 中，Handler 方法返回值来实现快速转发，可以使用 redirect 或者 forward 关键字来实现重定向。
@RequestMapping("/redirect-demo")
public String redirectDemo() {
// 重定向到 /demo 路径
return "redirect:/demo";
}
@RequestMapping("/forward-demo")
public String forwardDemo() {
// 转发到 /demo 路径
return "forward:/demo";
}
//注意： 转发和重定向到项目下资源路径都是相同，都不需要添加项目根路径！填写项目下路径即可！总结：
- 将方法的返回值，设置String 类型
- 转发使用 forward 关键字，重定向使用 redirect 关键字
- 关键 :/ 路径
- 注意：如果是项目下的资源，转发和重定向都是一样都是项目下的路径，都不需要添加项目根路径。
3. 返回JSON 数据（重点）
3.1 前置准备
导入 jackson 依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.0</version>
</dependency>添加数据转化器
<!--
注意: 导入mvc命名空间!
mvc:annotation-driven 是一个整合标签
他会导入handlerMapping和handlerAdapter
他会导入json数据格式转化器等等!
-->
<mvc:annotation-driven />3.2 @ResponseBody
1）方法上使用 @ResponseBody
可以在方法上使用 @ResponseBody 注解，用于将方法返回的对象序列化为 JSON 或 XML 格式的数据，并发送给客户。在前后端分离的项目中使用。
测试方法：
@GetMapping("/accounts/{id}")
@ResponseBody
public Object handle() {
// ...
return obj;
}具体来说，@ResponseBody 注解可以用来标识方法或者方法返回值，表示方法的返回值是要直接返回给客户端的数据，而不是由视图解析器来解析并渲染生成响应体（viewResolver 没用）。
测试方法：
@RequestMapping(value = "/user/detail", method = RequestMethod.POST)
@ResponseBody
public User getUser(@RequestBody User userParam) {
System.out.println("userParam = " + userParam);
User user = new User();
user.setAge(18);
user.setName("John");
//返回的对象,会使用jackson的序列化工具,转成json返回给前端!
return user;
}返回结果：
2. 类上使用 @ResponseBody，如果类中每个方法上都标记了 @ResponseBody 注解，那么这些注解就可以提取到类上。
@ResponseBody //responseBody可以添加到类上,代表默认类中的所有方法都生效!
@Controller
@RequestMapping("param")
public class ParamController {
}3.3 @RestController
类上的 @ResponseBody 注解可以和 @Controller 注解合并为 @RestController 注解。所以使用了 @RestController 注解就相当于给类中的每个方法都加了 @ResponseBody注解。
4. 返回静态资源处理
四、RESTFul 风格设计
1. RESTFul 风格概述
1.1 RESTFul 风格简介
RESTFul （Representational State Transfer）是一种软件架构风格，用于设计网络应用程序和服务之间的通信。它是一种基于标准 HTTP 方法的简单和轻量级的通信协议，广泛应用于现代的 Web 服务开发。
通过遵循 RESTFul 架构的设计原则，可以建设出易于理解、可扩展、松耦合和可重用的 Web 服务。RESTFul API 的特点是简单、清晰，并且易于使用和理解，它们使用标准的 HTTP 方法和状态码进行通信，不需要额外的协议和中间件。
RESTFul 架构通常用于构建 Web API，提供数据的传输和操作。它可以用于各种应用场景，包括客户端应用、页面应用（SPA）、移动应用程序和微服务架构等。
总之，RESTFul是一种基于 HTTP 和标准化的设计原则的软件架构风格，用于设计和实现可靠、可扩展和易于集成的 Web 服务和应用程序。
1.2 RESTFul 风格特点
- 每一个URI 代表 1 种资源
- 客户端使用 GET、POST、PUT、DELETE 4个表示操作方式的动词对服务端资源进行操作：GET 用来获取资源，POST用来新建资源（也可以用于更新资源），PUT永安里更新资源，DELETE用来删除资源。
- 资源的表现形式是 XML 或者 JSON。
- 客户端与服务端之间的交互在请求之间是无状态的，从客户端到服务端的每个请求都必须包含理解请求所必需的信息。
1.3 RESTFul 风格设计规范
1）HTTP 协议请求方式要求
REST 风格主张在项目设计、开发过程中，具体的操作符合HTTP 协议定义的请求方式的语义
| 操作 | 请求方式 |
|---|---|
| 查询操作 | GET |
| 保存操作 | POST |
| 删除操作 | DELETE |
| 更新操作 | PUT |
2）URL 路径风格要求
REST风格下每个资源都应该有一个唯一的标识符，例如一个URI （统一资源标识符）或者一个 URL（统一资源定位符）。资源的标识符应该能明确地说明该资源的信息，同时也应该是可被理解和解释的！
使用 URL + 请求方式确定具体的动作，他也是一种标准的 HTTP 协议请求
| 操作 | 传统风格 | REST 风格 |
|---|---|---|
| 保存 | /CRUD/saveEmp | URL 地址：/CRUD/emp 请求方式：POST |
| 删除 | /CRUD/removeEmp?empId=2 | URL 地址：/CRUD/emp/2 请求方式：DELETE |
| 更新 | /CRUD/updateEmp | URL 地址：/CRUD/emp 请求方式：PUT |
| 查询 | /CRUD/editEmp?empId=2 | URL 地址：/CRUD/emp/2 请求方式：GET |
- 总结
根据接口的具体动作，选择具体的 HTTP 协议请求方式
路径设计从原来携带动标识，改成名词，对应资源的唯一标识即可。
1.4 RESTFul 风格好处
- 含蓄安全：
使用问号键值对的方式给服务器传递数据太明显，容易被人利用来对系统进行破坏。使用 REST 风格携带数据不再明显的暴露数据的名称。
- 风格统一
URL 地址整体格式统一，从前到后始终都使用斜杠划分各个单词，用简单一致的格式表达语义。
- 无状态
在调用一个接口（访问、操作资源）的时候，可以不用考虑上下文，不用考虑当前状态，极大的降低了系统设计的复杂度。
- 严谨、规范
严格按照 HTTP1.1 协议中定义的请求方式本身的语义进行操作
- 简介、优雅
过去做增删改查操作需要设计4个不同的URL，现在一个就够了。
2. RESTFul 风格实战
2.1 需求分析
- 数据结构：User{id 唯一标识，name 用户名，age 用户年龄}
- 功能分析
- 用户数据分页展示功能（条件：page 页数 默认1，size 每页数量 默认 10）
- 保存用户功能
- 根据用户 id 查询用户详情功能
- 根据用户 id 更新用户数据功能
- 根据用户 id 删除用户数据功能
- 多条件模糊查询用户功能（条件：keyword 模板关键字，page 页数 默认1，size 每页数量 默认 10）
2.2 RESTFul 风格接口设计
1）接口设计
| 功能 | 接口和请求方式 | 请求参数 | 返回值 |
|---|---|---|---|
| 分页查询 | GET /user | page=1&size=10 param | { 响应数据 } |
| 用户添加 | POST /user | { user 数据 } | {响应数据} |
| 用户详情 | GET /user/1 | 路径参数 | {响应数据} |
| 用户更新 | PUT /user | { user 更新数据} | {响应数据} |
| 用户删除 | DELETE /user/1 | 路径参数 | {响应数据} |
| 条件模糊 | GET /user/search | page=1&size=10&keywork=关键字 | {响应数据} |
2）问题讨论
为什么查询用户详情，就使用路径传递参数，多条件模糊查询，就可以请求参数传递？
误区：RESTFul 风格下，不是所有请求参数都是路径传递，可以使用其他方式传递。
在RUSTFul API 的设计中，路径、请求参数、请求体都是用来向服务器传递信息的方式。
- 对于查询用户详情，使用路径传递参数是因为这是一个单一资源的查询，即查询一条用户记录。使用路径参数可以明确指定所请求的资源，便于服务器定位并返回对应的资源，也符合 RESTFul 风格的要求。
- 而对于多条模糊查询，使用请求参数传递是因为这是一个资源集合的查询，即查询多条用户记录。使用请求参数可以通过组合不同参数来限制查询结果，路径参数的组合和排列可能会很多，不如使用请求参数更加灵活和简洁。
2.3 后台接口实现
准备用户实体类：
/**
* projectName: com.atguigu.pojo
* 用户实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Integer id;
private String name;
private Integer age;
}准备Controller：
/**
* projectName: com.atguigu.controller
*
* description: 用户模块的控制器
*/
@RequestMapping("user")
@RestController
public class UserController {
/**
* 模拟分页查询业务接口
*/
@GetMapping
public Object queryPage(@RequestParam(name = "page",required = false,defaultValue = "1")int page,
@RequestParam(name = "size",required = false,defaultValue = "10")int size){
System.out.println("page = " + page + ", size = " + size);
System.out.println("分页查询业务!");
return "{'status':'ok'}";
}
/**
* 模拟用户保存业务接口
*/
@PostMapping
public Object saveUser(@RequestBody User user){
System.out.println("user = " + user);
System.out.println("用户保存业务!");
return "{'status':'ok'}";
}
/**
* 模拟用户详情业务接口
*/
@PostMapping("/{id}")
public Object detailUser(@PathVariable Integer id){
System.out.println("id = " + id);
System.out.println("用户详情业务!");
return "{'status':'ok'}";
}
/**
* 模拟用户更新业务接口
*/
@PutMapping
public Object updateUser(@RequestBody User user){
System.out.println("user = " + user);
System.out.println("用户更新业务!");
return "{'status':'ok'}";
}
/**
* 模拟条件分页查询业务接口
*/
@GetMapping("search")
public Object queryPage(@RequestParam(name = "page",required = false,defaultValue = "1")int page,
@RequestParam(name = "size",required = false,defaultValue = "10")int size,
@RequestParam(name = "keyword",required= false)String keyword){
System.out.println("page = " + page + ", size = " + size + ", keyword = " + keyword);
System.out.println("条件分页查询业务!");
return "{'status':'ok'}";
}
}
