一、SpringMVC简介
1、什么是MVC
MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M：Model，模型层，指工程中的JavaBean，作用是处理数据
JavaBean分为两类：
- 一类称为实体类Bean：专门存储业务数据的，如Student、User等
- 一类称为业务处理Bean：指Service或Dao对象，专门用于处理业务逻辑和数据访问
V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器
MVC的工作流程：
用户通过视图层发送请求到浏览器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller在根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器
笔记中案例：https://github.com/DFshmily/Java/upload/main/SpringMVC
2、什么是SpringMVC
SpringMVC是Spring的一个后续产品，是Spring的一个子项目
SpringMVC是Spring为表述层开发提供的一整套完备的解决方案，在表述层框架经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为Java EE项目表述层开发的首选方案
注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层、表述层表示前台页面和后台servlet
3、SpringMVC的特点
- Spring家族原生产品，与IOC容器等基础设施无缝对接
- 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理
- 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
- 代码清新简洁，大幅度提升开发效率
- 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
- 性能卓著，尤其适合现代大型、超大型互连网项目要求
二、搭建环境
1、开发环境
IDE：IDEA：2022.1.4
构建工具：maven 3.8.6
服务器：tomcat 9
Spring版本
2、创建maven工程
（1）添加web模块
（2）打包方式：war
（3）引入依赖
<?xml version="1.0" encoding="UTF-8"?>
<!--Maven作用：1.用来做项目构建 2.项目jar包管理-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>springMVC_demo1</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<!-- SpringMVC-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.23</version>
</dependency>
<!-- 日志-->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.4.3</version>
<scope>test</scope>
</dependency>
<!-- ServletAPI-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<!-- 依赖范围：provided，代表服务器已经提供-->
<scope>provided</scope>
</dependency>
<!-- thymeleaf和spring5整合包-->
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf-spring5</artifactId>
<version>3.1.0.M3</version>
</dependency>
</dependencies>
</project>
3、配置web.xml
注册SpringMVC的前端控制器DispatcherServlet
（1）默认配置方式
此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>-servlet.xml,例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名springMVC-servlet.xml
web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!-- 配置SpringMVC的前端控制器，对浏览器发生的请求进行统一处理-->
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<!--
设置springMVC的核心控制器所能处理的请求的请求路径
'/'所匹配的请求可以是/login或.html或.js或.css方式的请求路径
但是'/'不能匹配.jsp请求路径的请求
-->
<url-pattern></url-pattern>
</servlet-mapping>
</web-app>
（2）扩展配置方式
可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间
<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置SpringMVC配置文件的位置和名称-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 将前端控制器DispatcherServlet的初始化时间提前到服务器启动时-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
4、创建请求控制器
由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器
请求控制器中每一个处理请求的方法成为控制器方法
因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Srping的IOC容器管理，此时SpringMVC才能够识别控制器的存在
@Controller //控制层组件
public class HelloController {
}
5、创建springMVC的配置文件
springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 扫描组件-->
<context:component-scan base-package="com.mvc"></context:component-scan>
<!-- 配置Thymeleaf视图解析器-->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
<property name="order" value="1"/>
<property name="characterEncoding" value="UTF-8"/>
<property name="templateEngine">
<bean class="org.thymeleaf.spring5.SpringTemplateEngine">
<property name="templateResolver">
<bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
<!-- 视图前缀-->
<property name="prefix" value="/WEB-INF/templates/"/>
<!-- 视图后缀-->
<property name="suffix" value=".html"/>
<property name="templateMode" value="HTML5"/>
<property name="characterEncoding" value="UTF-8"/>
</bean>
</property>
</bean>
</property>
</bean>
<!-- 处理静态资源，例如html、js、css、jpg
若只设置该标签，则只能访问静态资源，其他请求则无法访问
此时必须设置<mvc:annotation-driven/>解决问题
-->
<!--一般不需要后面的-->
<mvc:default-servlet-handler/>
<!-- 开启mvc注解驱动-->
<mvc:annotation-driven>
<mvc:message-converters>
<!-- 处理响应中文内容乱码-->
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="defaultCharset" value="UTF-8"/>
<property name="supportedMediaTypes">
<list>
<value>text/html</value>
<value>application/json</value>
</list>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
</beans>
6、测试
（1）实现对首页的访问
在请求控制器中创建处理请求的方法
HelloController.java
package com.mvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @author DFshmily
*/
@Controller //控制层组件
public class HelloController {
// "/"--->/WEB-INF/templates/index.html
//@RequestMapping注解：处理请求和控制器方法之间的映射关系
//@RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径
//localhost：8080/springMVC/
@RequestMapping("/")
public String index(){
//设置视图名称
return "index";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
</body>
</html>
（2）通过超连接跳转到指定页面
在主页index.html中设置超链接
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/target}">访问目标页面target.html</a>
</body>
</html>
HelloController.java
package com.mvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @author DFshmily
*/
@Controller //控制层组件
public class HelloController {
// "/"--->/WEB-INF/templates/index.html
//@RequestMapping注解：处理请求和控制器方法之间的映射关系
//@RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径
//localhost：8080/springMVC/
@RequestMapping("/")
public String index(){
//设置视图名称
return "index";
}
@RequestMapping("/target")
public String toTarget(){
return "target";
}
}
target.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
Hello DFshmily!
</body>
</html>
7、总结
浏览器发送请求，若请求地址符号前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理，
前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法，
处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymelea对视图进行渲染，最终转发到视图对应页面
三、@RequestMapping注解
1、@RequestMapping注解的功能
从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系
SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求
2、@RequestMapping注解的位置
⚫@RequestMapping标识一个类：设置映射请求的请求路径的初始信息
⚫@RequestMapping标识一个方法：设置映射请求请求路径的具体信息
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/hello")
public class RequestMappingController {
//此时请求映射所映射的请求路径为：/hello/testRequestMapping
@RequestMapping("/testRequestMapping")
public String testRequestMapping(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/hello/testRequestMapping}">测试RequestMapping注解的位置</a>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>RequestMapping注解位置</h2>
</body>
</html>
3、@RequestMapping注解的value属性
⚫@RequestMapping注解的value属性通过请求的请求地址匹配请求映射
⚫@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址对应的请求
⚫@RequestMapping注解的value属必须设置，至少通过请求地址匹配请求映射
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class RequestMappingController {
//RequestMapping注解的value属性
//可以访问value中的任意一个路径
@RequestMapping(
value = {"/testRequestMapping","/hello"}
)
public String testRequestMapping(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/hello}">测试RequestMapping注解的位置-->/hello</a><br>
<a th:href="@{/testRequestMapping}">测试RequestMapping注解的位置-->/testRequestMapping</a><br>
<!--不能访问-->
<a th:href="@{/hello/testRequestMapping}">测试RequestMapping注解的位置-->/hello/testRequestMapping</a>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>RequestMapping注解位置</h2>
</body>
</html>
4、@RequestMapping注解的method属性
⚫@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
⚫@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求
若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，
则浏览器报错405 Request method ‘POST’ not supported
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
//RequestMapping注解的value属性
//可以访问value中的任意一个路径
@RequestMapping(
value = {"/testRequestMapping","/hello"},
method = {RequestMethod.GET,RequestMethod.POST}//RequestMethod.GET不支持POST的请求,要加RequestMethod.POST
)
public String testRequestMapping(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/hello}">测试RequestMapping注解的位置-->/hello</a><br>
<a th:href="@{/testRequestMapping}">测试RequestMapping注解的位置-->/testRequestMapping</a><br>
<!--不能访问-->
<a th:href="@{/hello/testRequestMapping}">测试RequestMapping注解的位置-->/hello/testRequestMapping</a>
<form th:action="@{/hello}" method="post">
<input type="submit" value="测试RequestMapping注解的method属性--->POST">
</form>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>RequestMapping注解位置</h2>
</body>
</html>
注：
（1）对于处理指定请求的控制器方法，SpringMVC中提供了@RequestMapping的派生注解
| 处理get请求的映射 | @GetMapping |
|---|---|
| 处理post请求的映射 | @PostMapping |
| 处理put请求的映射 | @PutMapping |
| 处理delete请求的映射 | @DeleteMapping |
（2）常用的请求方式有get、post、put、delete
但是目前浏览器只支持get和post，若在from表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理
若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter
@GetMapping和@PostMapping的例子：
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
public String testRequestMapping(){
return "success";
}
@GetMapping("/testGetMapping")
public String testGetMapping(){
return "success";
}
@PostMapping("/testPostMapping")
public String testPostMapping(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/testGetMapping}">测试GetMapping注解</a><br>
<form th:action="@{/testPostMapping}" method="post">
<input type="submit" value="测试PostMapping注解">
</form>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>RequestMapping注解位置</h2>
</body>
</html>
@PutMapping的例子：
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
@RequestMapping(value = "/testPut",method = RequestMethod.PUT)
public String testPut(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<!--form表单中的method方法默认按get方法，不能用put-->
<form th:action="@{/testPut}" method="put">
<input type="submit" value="测试from表单是否能够发送put或delete请求方式">
</form>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>RequestMapping注解位置</h2>
</body>
</html>
测试结果：
5、@RequestMapping注解的params属性（了解）
⚫@RequestMapping注解的params属性通过请求的请求参数匹配请求映射
⚫@RequestMapping注解的params属性是一个字符串类型的数组，可以通过四中表达式设置请求参数和请求映射的匹配关系
⭐”params”：要求请求映射所匹配的请求必须携带params请求参数
⭐”!params”：要求请求映射所匹配的请求必须不能携带params请求参数
⭐”params=value“：要求请求映射所匹配的请求必须携带params请求参数且params=value
⭐”params!=value“：要求请求映射所匹配的请求必须携带params请求参数但是params!=value
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
@RequestMapping(
value = {"/testParamsAndHeaders"},
params = {"username"}
)
public String testParamsAndHeaders(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{testParamsAndHeaders(username='admin',password=123)}">RequestMapping注解的Params属性--->testParamsAndHeaders</a>
</body>
</html>
6、@RequestMapping注解的headers属性（了解）
⚫@RequestMapping注解的headers属性通过的请求头信息匹配请求映射
⚫@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系
⭐”header”：要求请求映射所匹配的请求必须携带header请求参数
⭐”!header”：要求请求映射所匹配的请求必须不能携带header请求参数
⭐”header=value“：要求请求映射所匹配的请求必须携带header请求参数且header=value
⭐”header!=value“：要求请求映射所匹配的请求必须携带header请求参数但是header!=value
若当前请求满足@RequestMapping注解的headers和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到
7、SpringMVC支持ant风格的路径
？：表示任意的单个字符
*：表示任意的0个或多个字符
**：表示任意的一层或多层目前
注意：在使用**时，只能使用/**/xxx的方式
以？为例：
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
@RequestMapping("/a?a/testAnt")
public String testAnt(){
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<!--都可以成功a?a,中的？可以为任意单个字符-->
<a th:href="@{/a1a/testAnt}">测试@RequestMapping可以匹配的Ant路径-->使用？</a><br>
<a th:href="@{/a2a/testAnt}">测试@RequestMapping可以匹配的Ant路径-->使用？</a><br>
<a th:href="@{/a3a/testAnt}">测试@RequestMapping可以匹配的Ant路径-->使用？</a>
</body>
</html>
8、SpringMVC支持路径中的占位符（重点）
原始方式：/deleteUser?id=1
rest方式：/deleteUser/1
SpringMVC路径中的占位符常用与rest风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参
RequestMappingController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
//@RequestMapping("/hello")
public class RequestMappingController {
@RequestMapping("/testPath/{id}/{username}")
public String testPath(@PathVariable("id")Integer id,@PathVariable("username") String username){
System.out.println("id:"+id+",username"+username);
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/testPath/1/admin}">测试路径中的占位符————>testPath</a>
</body>
</html>
四、SpringMVC获取请求参数
1、通过servletAPI获取
将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象
ParamController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
@Controller
public class ParamController {
@RequestMapping("/testServletAPI")
//形参位置的request
public String testServletAPI(HttpServletRequest request){
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username:"+username+"pawssword:"+password);
return "success";
}
}
TestController.java
package com.springmvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class TestController {
@RequestMapping("/")
public String index(){
return "index";
}
@RequestMapping("/parma")
public String param(){
return "test_parma";
}
}
test_parma.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>测试请求参数</title>
</head>
<body>
<h1>测试请求参数</h1>
<a th:href="@{/testServletAPI(username='admin',password=123456)}">测试使用ServletAPI获取请求参数</a>
</body>
</html>
2、通过控制器方法的形参获取请求参数
在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参
ParamController.java
@PostMapping("/testParam")
//@RequestParam中的required为false，不是必须的,不传参数的话就是defaultValue中设置的默认值
public String testParma(@RequestParam(value = "user_name",required = false,defaultValue = "默认值") String username, String password, String[] hobby){
//若请求参数中出现多个同名的请求参数，可以再控制器方法的形参位置设置字符串类型或字符串数组接收此数据
//若使用字符串类型的形参，最终结果为请求参数的每一个值之间使用逗号进行拼接
System.out.println("username:"+username+",password:"+password+",hobby:"+ Arrays.toString(hobby));
return "success";
}
test_parma.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>测试请求参数</title>
</head>
<body>
<h1>测试请求参数</h1>
<a th:href="@{/testServletAPI(username='admin',password=123456)}">测试使用ServletAPI获取请求参数</a><br>
<a th:href="@{/testParam(username='admin',password=123456)}">测试通过控制器方法的形参获取请求参数</a>
<form th:action="@{/testParam}" method="post">
姓名：<input type="text" name="user_name"><br>
密码：<input type="password" name="password"><br>
爱好：<input type="checkbox" name="hobby" value="a">a
<input type="checkbox" name="hobby" value="b">b
<input type="checkbox" name="hobby" value="c">c<br>
<input type="submit" value="测试通过控制器方法的形参获取请求参数">
</form>
</body>
</html>
注：
若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参接收此请求参数
若使用字符串数组类型的形参，此参数的数组中包含了每一个数据
若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果
3、@RequestParam
@RequestParam是将请求参数和控制器方法的形参创建映射关系
@RequestParam注解一共有三个属性：
value：指定为形参赋值的请求参数的参数名
required：设置是否必须传输此请求参数，默认值为true
若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；
若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null
4、@RequestHeader
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@Requestparam
@PostMapping("/testParam")
public String testParma(
@RequestHeader("Host") String host){
System.out.println("host:"+host);
}
运行结果：
host:localhost：8080
@PostMapping("/testParam")
public String testParma(
@RequestHeader(value = "DF",required = true,defaultValue = "shmily") String host){
System.out.println("host:"+host);
}
运行结果：
host:shmily
5、@CookieValue
@CookieValue是将Cookie数据和控制器方法的形参创建映射关系
@CookieValue注解一共三个属性：value、required、defaultValue，用法同@RequestParam
@PostMapping("/testParam")
public String testParma(
//@CookieValue( "Idea-1cb5354") String JSESSIONID
@CookieValue(value = "Cookie",required = true,defaultValue = "cookie") String cookie)
{
System.out.println("Cookie:"+cookie);
}
运行结果：
//JSESSIONID:2c3874e6-94af-4d67-a05b-7d86ffd68398
Cookie:cookie
6、通过POJO获取请求参数
可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值
test_parma.html
<form th:action="@{/testPOJO}" method="post">
用户名：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
性别：<input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女<br>
年龄：<input type="text" name="age"><br>
邮箱：<input type="text" name="email"><br>
<input type="submit" value="使用实体类来接收请求参数">
</form>
User.java
package com.springmvc.bean;
public class User {
private Integer id;
private String username;
private String password;
private String sex;
private String email;
//反射默认无参构造，在生成有参构造的同时要加上无参构造
public User() {
}
public User(Integer id, String username, String password, String sex, String email) {
this.id = id;
this.username = username;
this.password = password;
this.sex = sex;
this.email = email;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", sex='" + sex + '\'' +
", email='" + email + '\'' +
'}';
}
}
ParamController.java
@RequestMapping("/testPOJO")
public String testBean(User user){
System.out.println(user);
return "success";
}
运行结果：
User{id=null, username='11', password='11', sex='??��', email='test@qq.com'}
7、解决获取请求参数乱码的问题
解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册
①在tomcat的config文件中的service.xml中加入URIEncoding=”UTF-8″
<Connector port="8080" URIEncoding="UTF-8" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
②
<!-- 配置springMVC的编码过滤器-->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
注：SpringMVC中处理编码的过滤器一定要求配置到其他过滤器之前，否则无效
③tomcat：在VM options中加入-Dfile.encoding=UTF-8
五、域对象共享数据
1、使用servletAPI向request域对象共享数据
ScopeController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
@Controller
public class ScopeController {
//使用servletAPI向request域对象共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request){
request.setAttribute("testRequestScope","hello,servletAPI");
return "success";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/testRequestByServletAPI}">通过servletAPI向request域对象共享数据</a>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>success</title>
</head>
<body>
<h1>success</h1>
<p th:text="${testRequestScope}"></p>
</body>
</html>
2、使用ModelAndView向request域对象共享数据
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
ModelAndView modelAndView = new ModelAndView();
//处理模型数据，即向请求域request共享数据
modelAndView.addObject("testRequestScope","hello,ModelAndView");
//设置视图名称
modelAndView.setViewName("success");
return modelAndView;
}
3、使用Model向request域对象共享数据
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testRequestScope","hello,Model");
return "success";
}
4、使用map向request域对象共享数据
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
map.put("testRequestScope","hello,Map");
return "success";
}
5、使用ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testMpdelMap(ModelMap modelMap){
modelMap.addAttribute("testRequestScope","hello.ModelMap");
return "success";
}
6、Model、ModelMap、Map的关系
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testRequestScope","hello,Model");
System.out.println(model.getClass().getName());
return "success";
}
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
map.put("testRequestScope","hello,Map");
System.out.println(map.getClass().getName());
return "success";
}
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
modelMap.addAttribute("testRequestScope","hello.ModelMap");
System.out.println(modelMap.getClass().getName());
return "success";
}
运行结果：
org.springframework.validation.support.BindingAwareModelMap
org.springframework.validation.support.BindingAwareModelMap
org.springframework.validation.support.BindingAwareModelMap
Model、ModelMap、Map类型的参数其实本质上都是BindingAwareModelMap类型的
public interface Model()
public class ModelMap extends LinkedHashMap<String,Object>{}
public class EctendModelMap extends ModelMap inplements Model{}
public class BindingAwareModelMap extends ExtendedModelMap{}
7、向session域对象共享数据
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope","hello,session");
return "success";
}
8、向application域对象共享数据
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
ServletContext application = session.getServletContext();
application.setAttribute("testApplicationScope","hello,application");
return "success";
}
所用文件：
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/testRequestByServletAPI}">通过servletAPI向request域对象共享数据</a><br>
<a th:href="@{/testModelAndView}">通过ModelAndView向request域对象共享数据</a><br>
<a th:href="@{/testModel}">通过Model向request域对象共享数据</a><br>
<a th:href="@{/testMap}">通过Map集合向request域对象共享数据</a><br>
<a th:href="@{/testModelMap}">通过ModelMap集合向request域对象共享数据</a><br>
<a th:href="@{/testSession}">通过servletAPI向session域对象共享数据</a><br>
<a th:href="@{/testApplication}">通过servletAPI向application域对象共享数据</a><br>
</body>
</html>
ScopeController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Map;
@Controller
public class ScopeController {
//使用servletAPI向request域对象共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request){
request.setAttribute("testRequestScope","hello,servletAPI");
return "success";
}
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
ModelAndView modelAndView = new ModelAndView();
//处理模型数据，即向请求域request共享数据
modelAndView.addObject("testRequestScope","hello,ModelAndView");
//设置视图名称
modelAndView.setViewName("success");
return modelAndView;
}
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testRequestScope","hello,Model");
System.out.println(model.getClass().getName());
return "success";
}
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
map.put("testRequestScope","hello,Map");
System.out.println(map.getClass().getName());
return "success";
}
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
modelMap.addAttribute("testRequestScope","hello.ModelMap");
System.out.println(modelMap.getClass().getName());
return "success";
}
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope","hello,session");
return "success";
}
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
ServletContext application = session.getServletContext();
application.setAttribute("testApplicationScope","hello,application");
return "success";
}
}
success.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>success</title>
</head>
<body>
<h1>success</h1>
<p th:text="${testRequestScope}"></p>
<p th:text="${testSessionScope}"></p>
<p th:text="${testApplicationScope}"></p>
</body>
</html>
六、SpringMVC的视图
SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户
SpringMVC视图的种类很多，默认有转发视图InternalResourceView和重定向视图RedirectView
当工程引入jstl的依赖，转发视图会自动转换为jstlView
若使用的视图技术为ThymeleafView，在SpringMVC的配置文件中配置了ThymeleafView的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView
1、ThymeleafView
当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转
@RequestMapping("/testThymeleafView")
public String testThymeleafView(){
return "success";
}
}
2、转发视图
SpringMVC中默认的转发视图是InternalResourceView
SpringMVC中创建转发视图的情况：
当控制器方法中所设置的视图名称以”forward:”为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward:”去掉，剩余部分作为最终路径通过转发的方式实现跳转
例如”forward:/”，”forward:/testThymeleafView”
@RequestMapping("/testForward")
public String testForward(){
return "forward:/testThymeleafView";
}
3、重定向视图
SpringMVC中默认的重定向视图是RedirectView
当控制器方法中设置的视图名称以”edirect:”为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”redirect:”去掉，剩余部分作为最终路径通过重定向的方式实现跳转
例如”redirect:/”，”redirect:/testThymeleafView”
@RequestMapping("/testRedirect")
public String testRedirect(){
return "redirect:/testThymeleafView";
}
注：
重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径
4、视图控制器view-controller
当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示
<!-- 配置静态资源的处理,不开启MVC的注解驱动会请求都失效
path：设置处理的请求地址
view-name:设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<!-- 开启MVC的注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
注：
当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：
<!-- 开启MVC的注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
所有文件：
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/testRequestByServletAPI}">通过servletAPI向request域对象共享数据</a><br>
<a th:href="@{/testModelAndView}">通过ModelAndView向request域对象共享数据</a><br>
<a th:href="@{/testModel}">通过Model向request域对象共享数据</a><br>
<a th:href="@{/testMap}">通过Map集合向request域对象共享数据</a><br>
<a th:href="@{/testModelMap}">通过ModelMap集合向request域对象共享数据</a><br>
<a th:href="@{/testSession}">通过servletAPI向session域对象共享数据</a><br>
<a th:href="@{/testApplication}">通过servletAPI向application域对象共享数据</a><br>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>success</title>
</head>
<body>
<h1>success</h1>
<p th:text="${testRequestScope}"></p>
<p th:text="${testSessionScope}"></p>
<p th:text="${testApplicationScope}"></p>
</body>
</html>
test_view.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<a th:href="@{/testThymeleafView}">测试ThymeleafView</a><br>
<a th:href="@{/testForward}">测试InternalResourceView</a><br>
<a th:href="@{/testRedirect}">测试RedirectView</a><br>
</body>
</html>
TestController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//实现页面跳转
@Controller
public class TestController {
@RequestMapping("/")
public String index(){
return "index";
}
@RequestMapping("/test_view")
public String testView(){
return "test_view";
}
}
ScopeController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Map;
@Controller
public class ScopeController {
//使用servletAPI向request域对象共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request){
request.setAttribute("testRequestScope","hello,servletAPI");
return "success";
}
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
ModelAndView modelAndView = new ModelAndView();
//处理模型数据，即向请求域request共享数据
modelAndView.addObject("testRequestScope","hello,ModelAndView");
//设置视图名称
modelAndView.setViewName("success");
return modelAndView;
}
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testRequestScope","hello,Model");
System.out.println(model.getClass().getName());
return "success";
}
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
map.put("testRequestScope","hello,Map");
System.out.println(map.getClass().getName());
return "success";
}
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
modelMap.addAttribute("testRequestScope","hello.ModelMap");
System.out.println(modelMap.getClass().getName());
return "success";
}
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope","hello,session");
return "success";
}
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
ServletContext application = session.getServletContext();
application.setAttribute("testApplicationScope","hello,application");
return "success";
}
}
ViewController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ViewController {
@RequestMapping("/testThymeleafView")
public String testThymeleafView(){
return "success";
}
@RequestMapping("/testForward")
public String testForward(){
return "forward:/testThymeleafView";
}
@RequestMapping("/testRedirect")
public String testRedirect(){
return "redirect:/testThymeleafView";
}
}
springMVC.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 扫描组件-->
<context:component-scan base-package="com"></context:component-scan>
<!-- 配置Thymeleaf视图解析器-->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
<property name="order" value="1"/>
<property name="characterEncoding" value="UTF-8"/>
<property name="templateEngine">
<bean class="org.thymeleaf.spring5.SpringTemplateEngine">
<property name="templateResolver">
<bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
<!-- 视图前缀-->
<property name="prefix" value="/WEB-INF/templates/"/>
<!-- 视图后缀-->
<property name="suffix" value=".html"/>
<property name="templateMode" value="HTML5"/>
<property name="characterEncoding" value="UTF-8"/>
</bean>
</property>
</bean>
</property>
</bean>
<!-- 配置静态资源的处理,不开启MVC的注解驱动会请求都失效
path：设置处理的请求地址
view-name:设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<!-- 开启MVC的注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
</beans>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!-- 配置springMVC的编码过滤器-->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置Servlet前端控制器-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置SpringMVC配置文件的位置和名称-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springMVC.xml</param-value>
</init-param>
<!-- 将前端控制器DispatcherServlet的初始化时间提前到服务器启动-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
七、RESTful
1、RESTful简介
REST：Representational State Transfer，表现层资源状态转移
（1）资源
资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成，每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词，一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址，对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。
（2）资源的表述
资源的表述是一段对于资源在某个特定时刻的状态的描述，可以在客户端—服务器端之间转移（交换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格式可以通过协商机制来确定，请求—响应方向的表述通常使用不同的格式。
（3）状态转移
状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述，通过转移和操作资源的表述，来间接实现操作资源的目的。
2、RESTful的实现
具体说，就是HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE，
它们分别对应四种基本操作：GET用来获取资源，POST用来新建资源，PUT用来更新资源，DELETE用来删除资源
REST风格提倡URL地址使用统一的风格设计，从前到各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为URL地址的一部分，以保证整体风格的一致性。
| 操作 | 传统方式 | REST风格 |
|---|---|---|
| 查询操作 | getUserById?=1 | user/1–>get请求方式 |
| 保存操作 | saveUser | user–>post请求方式 |
| 更新操作 | updateUser | user/1–>put请求方式 |
| 删除操作 | deleteUser?Id=1 | user/1–>delete请求方式 |
3、HiddenHttpMethodFilter
由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC提供了HiddenHttpMethodFilter帮助我们将POST请求转换为DELETE或PUT请求
HiddenHttpMethodFilter处理put和delete请求的条件：
①当前请求的请求方式必须为post
②当前请求必须传输请求参数_method
所用文件：
test_rest.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<a th:href="@{/user}">查询所有用户信息</a><br>
<a th:href="@{/user/1}">根据id查询用户信息</a><br>
<form th:action="@{/user}" th:method="post">
用户名：<input type="text" name="username" ><br>
密码：<input type="text" name="password" ><br>
<input type="submit" value="添加用户">
</form>
<form th:action="@{/user}" th:method="post">
<input type="hidden" name="_method" value="PUT">
用户名：<input type="text" name="username" ><br>
密码：<input type="password" name="password" ><br>
<input type="submit" value="修改用户">
</form>
</body>
</html>
success.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns="http://www.w3.org/1999/html">
<head>
<meta charset="UTF-8">
<title>success</title>
</head>
<body>
<h1>success</h1>
<p th:text="${testRequestScope}"></p>
<p th:text="${testSessionScope}"></p>
<p th:text="${testApplicationScope}"></p>
</body>
</html>
TestController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//实现页面跳转
@Controller
public class TestController {
@RequestMapping("/")
public String index(){
return "index";
}
@RequestMapping("/test_view")
public String testView(){
return "test_view";
}
@RequestMapping("/test_rest")
public String testRest(){
return "test_rest";
}
}
UserController.java
package com.springmvc.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class UserController {
/**
* 使用RESTFul模拟用户资源的增删改查
* /users GET 查询所有用户信息
* /user/1 GET 根据用户id查询用户信息
* /user POST 添加用户信息
* /user PUT 修改用户信息
* /user/1 DELETE 删除用户信息
*/
@RequestMapping(value="/user",method=RequestMethod.GET)
public String getAllUser(){
System.out.println("查询所有用户信息");
return "success";
}
@RequestMapping(value="/user/{id}",method=RequestMethod.GET)
public String getUserById(){
System.out.println("根据用户id查询用户信息");
return "success";
}
@RequestMapping(value="/user",method=RequestMethod.POST)
public String insertUser(String username,String password){
System.out.println("添加用户信息:"+username+" "+password);
return "success";
}
@RequestMapping(value="/user",method=RequestMethod.PUT)
public String updateUser(String username,String password){
System.out.println("修改用户信息:"+username+" "+password);
return "success";
}
}
springMVC.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 扫描组件-->
<context:component-scan base-package="com"></context:component-scan>
<!-- 配置Thymeleaf视图解析器-->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
<property name="order" value="1"/>
<property name="characterEncoding" value="UTF-8"/>
<property name="templateEngine">
<bean class="org.thymeleaf.spring5.SpringTemplateEngine">
<property name="templateResolver">
<bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
<!-- 视图前缀-->
<property name="prefix" value="/WEB-INF/templates/"/>
<!-- 视图后缀-->
<property name="suffix" value=".html"/>
<property name="templateMode" value="HTML5"/>
<property name="characterEncoding" value="UTF-8"/>
</bean>
</property>
</bean>
</property>
</bean>
<!-- 配置静态资源的处理,不开启MVC的注解驱动会请求都失效
path：设置处理的请求地址
view-name:设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<mvc:view-controller path="/" view-name="test_view"></mvc:view-controller>
<mvc:view-controller path="/" view-name="test_rest"></mvc:view-controller>
<!-- 开启MVC的注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
</beans>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!-- 配置springMVC的编码过滤器,编码的必须放最前面-->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置HiddenHttpMethodFilter过滤器-->
<filter>
<filter-name>HiddenHttpMethodFilter</filter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置Servlet前端控制器-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置SpringMVC配置文件的位置和名称-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springMVC.xml</param-value>
</init-param>
<!-- 将前端控制器DispatcherServlet的初始化时间提前到服务器启动-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
八、RESTful案例
1、准备工作
和传统CRUD一样，实现对员工信息的增删改查
- 搭建环境
- 准备实现类
Employee.java
package com.springmvc.rest.bean;
public class Employee {
private Integer id;
private String lastName;
private String email;
private Integer sex;
public Employee() {
}
public Employee(Integer id, String lastName, String email, Integer sex) {
this.id = id;
this.lastName = lastName;
this.email = email;
this.sex = sex;
}
public Employee(int id, String aa, String email, int i) {
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", lastName='" + lastName + '\'' +
", email='" + email + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
EmployeeController.java
package com.springmvc.rest.controller;
import com.springmvc.rest.Dao.EmployeeDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class EmployeeController {
@Autowired
private EmployeeDao employeeDao;
}
EmployeeDao.java
package com.springmvc.rest.Dao;
import com.springmvc.rest.bean.Employee;
import org.springframework.stereotype.Repository;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
@Repository
public class EmployeeDao {
//模拟数据库中的数据
public static Map<Integer, Employee> employees= null;
//员工有所属的部门
static {
employees = new HashMap<Integer, Employee>();
employees.put(1001, new Employee(1001, "E-AA", "aa@163.com",1));
employees.put(1002, new Employee(1002, "E-BB", "bb@163.com",0));
employees.put(1003, new Employee(1003, "E-CC", "CC@163.com",1));
employees.put(1004, new Employee(1004, "E-DD", "DD@163.com",1));
employees.put(1005, new Employee(1005, "E-EE", "EE@163.com",1));
}
//主键自增
private static Integer initId = 1006;
//增加与修改员工
public void save(Employee employee){
if(employee.getId() == null){
employee.setId(initId++);
}
employees.put(employee.getId(), employee);
}
//查询全部员工信息
public Collection<Employee> getAll(){
return employees.values();
}
//通过id查询员工
public Employee get(Integer id){
return employees.get(id);
}
//通过id删除员工
public void delete(Integer id){
employees.remove(id);
}
}
2、功能清单
| 功能 | URL地址 | 请求方式 |
|---|---|---|
| 访问首页 | / | GET |
| 查询全部数据 | /employee | GET |
| 删除 | /employee/2 | DELETE |
| 跳转到添加数据页面 | /toAdd | DET |
| 执行保存 | /employee | POST |
| 跳转到更新数据页面 | /employee/2 | GET |
| 执行更新 | /employww | PUT |
3、具体功能：访问首页
（1）配置view-controller
（2）创建页面
4、具体功能：查询所有员工数据
（1）控制器方法
（2）创建employee_list.html
5、具体功能：删除
（1）创建处理delete请求方式的表单
（2）删除超链接绑定点击事件
（3）控制器方法
6、具体功能：跳转到添加数据页面
（1）配置view-controller
原文地址：https://www.cnblogs.com/DFshmily/p/16755669.html
1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！
2. 分享目的仅供大家学习和交流，请务用于商业用途!
3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！
4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！
5. 如有链接无法下载、失效或广告，请联系管理员处理！
6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！
7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！
8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载
声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性
