什么是MVC
MVC是一种架构思想,将软件按照模型、视图、控制器来划分。
什么是SpringMVC
SpringMVC是Spring的一个后续产品,是Spring为表述层开发提供的一整套完备的解决方案。
SpringMVC的特点
3. 修改打包方式和引入依赖
<packaging>warpackaging>
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.3.2version>
dependency>
<dependency>
<groupId>ch.qos.logbackgroupId>
<artifactId>logback-classicartifactId>
<version>1.2.3version>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>3.1.0version>
<scope>providedscope>
dependency>
<dependency>
<groupId>org.thymeleafgroupId>
<artifactId>thymeleaf-spring5artifactId>
<version>3.0.15.RELEASEversion>
dependency>
dependencies>
4. 配置web.xml
默认的配置方式:在此配置下,SpringMVC的配置文件默认位于WEB-INF下,默认名称为
,例如,以下的配置所对应的SpringMVC的配置文件位于WEB-INF下,文件名为springMVC-servlet.xml。但以后我们的配置文件一般是放在resource目录下的,所以不建议使用这种方式。
<servlet>
<servlet-name>springMVCservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>springMVCservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
扩展配置:可通过init-param标签设置SpringMVC配置文件的位置和名称,通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间。
<servlet>
<servlet-name>springMVCservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springMVC.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>springMVCservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
注:为什么要配置web.xml?因为浏览器发送的请求要交给前端控制器进行统一的处理,前端控制器是一个servlet,我们要想通过servlet处理请求,就必须在web.xml进行注册,然后在web.xml配置相关的参数。
5. 创建请求控制器
由于前端控制器对浏览器发送的请求进行了统一的处理,但是具体的请求有不同的处理过程,因此需要创建处理具体请求的类,即请求控制器。
@Controller
public class HelloWorld {
}
6. 配置springMVC配置文件
我们创建了请求控制器,还需要配置扫描组件,扫描到指定的包。配置Thymeleaf视图解析器,解析页面。
<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"
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">
<context:component-scan base-package="com.hxp.mvc.controller">context:component-scan>
<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>
beans>
7. 访问首页
配置tomcat,上下文路径为:/springMVC
编写页面:
// "/" --> /WEB-INF/templates/index.html
@RequestMapping("/")
public String index() {
//返回视图名称
return "index";
}
解决浏览器解析的绝对路径:
因为tomcat配置了上下文路径,但上下文路径是可能变化的,不能写死,所以需要使用Thymeleaf解析绝对路径。
@RequestMapping("/target")
public String toTarget() {
return "target";
}
点击超链接,会经过控制器,跳转到target.html页面
总结:浏览器发送请求,若请求地址符合前端控制器的url-pattern,该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件,通过扫描组件找到控制器,将请求地址和控制器中@RequestMapping注解的value属性值进行匹配,若匹配成功,该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称,该视图名称会被视图解析器解析,加上前缀和后缀组成视图的路径,通过Thymeleaf对视图进行渲染,最终转发到视图所对应页面。
(1)@RequestMapping注解的功能
从注解名称上我们可以看到,@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来,建立映射关系。
SpringMVC 接收到指定的请求,就会来找到在映射关系中对应的控制器方法来处理这个请求。
注意:RequestMapping中的value,不能重复,不然启动直接报错。
(2)@RequestMapping注解的位置
查看源码发现,它可以放在类上,也可以放在方法上
@RequestMapping标识一个类:设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法:设置映射请求的请求路径的具体信息
(3)@RequestMapping注解的value属性
查看源码发现,value属性是一个字符串数组
@RequestMapping注解的value属性是一个字符串类型的数组,表示该请求映射能够匹配多个请求地址所对应的请求。
@RequestMapping注解的value属性必须设置,至少通过请求地址匹配请求映射。
(4)@RequestMapping注解的method属性
method属性通过请求的请求方式匹配请求映射,该属性类型是RequestMethod数组,表示能匹配多种请求方式的请求。满足设置的其中一个就行。
若请求方式不满足method属性,则报错405:Request method ‘POST’ not supported。
不写method属性,表示不指定提交方式,任何方式都能匹配请求。
对于处理指定请求方式的控制器方法,SpringMVC中提供了@RequestMapping的派生注解:@GetMapping、@PostMapping、@PutMapping、@DeleteMapping。
常用的请求方式有get、post、put、delete,但是目前浏览器只支持get和post,若在form表单提交时,为method设置了其他请求方式的字符串,则按照默认的请求方式get处理。
(5)@RequestMapping注解的params属性
@RequestMapping注解的params属性通过请求的请求参数匹配请求映射。
@RequestMapping注解的params属性是一个字符串类型的数组,可以通过四种表达式设置请求参数和请求映射的匹配关系。
如果param写了多个,必须同时满足条件。
<a th:href="@{/testParams(username='admin',password=123456)}">测试paramsa>
@RequestMapping(value = "/testParams", params = {"username","password=123456"})
public String testParams() {
return "target";
}
这里password输入的“123”,与上面params不符,所以报错了。
(6)@RequestMapping注解的headers属性
@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射。
@RequestMapping注解的headers属性是一个字符串类型的数组,可以通过四种表达式设置请求头信息和请求映射的匹配关系。
如果header写了多个,必须同时满足条件。
若当前请求满足@RequestMapping注解的value和method属性,但不满足headers属性,此时页面显示404错误,即资源未找到。
(7)SpringMVC支持ant风格的路径
?
:表示任意的单个字符
*
:表示任意的0个或多个字符
**
:表示任意的一层或多层目录
注意:在使用**
时,只能使用/**/xxx
的方式
// @RequestMapping("/a?a/testAnt")
// @RequestMapping("/a*a/testAnt")
@RequestMapping("/**/testAnt")
public String testAnt() {
return "target";
}
(8)SpringMVC支持路径中的占位符
原始方式:/deleteUser?id=1
rest方式:/deleteUser/1
SpringMVC路径中的占位符常用于restful风格中,当请求路径中将某些数据通过路径的方式传输到服务器中,就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据,在通过@PathVariable注解,将占位符所表示的数据赋值给控制器方法的形参。
@RequestMapping("/testPath/{id}")
public String testPath(@PathVariable("id") Integer id) {
System.out.println("id: " + id);
return "target";
}
(1)通过ServletAPI获取
将HttpServletRequest作为控制器方法的形参,此时HttpServletRequest类型的参数表示封装了当前请求的请求报文对象。
@RequestMapping("/testParam")
public String testParam(HttpServletRequest request) {
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username:" + username + ", password:" + password);
return "success";
}
(2)通过控制器方法的形参获取请求参数
在控制器方法形参位置,设置和请求参数同名的形参,当浏览器发送请求,匹配到请求映射时,在DispatcherServlet中就会将请求参数赋值给相应的形参。
若请求所传输的请求参数中有多个同名的请求参数,此时可以在控制器方法的形参中设置字符串类型或字符串数组的形参接收此请求参数。
<form th:action="@{/testParam2}" method="get">
用户名:<input type="text" name="username"><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">
<input type="submit">
form>
@RequestMapping("/testParam2")
public String testParam2(String username, String password, String[] hobby) {
System.out.println("username:" + username + ", password" + password + ", hobby:" + Arrays.toString(hobby));
return "target";
}
(3)@RequestParam
@RequestParam是将请求参数和控制器方法的形参创建映射关系。
三个属性:
@RequestMapping("/testParam3")
public String testParam3(
@RequestParam(value = "user_name", required = false, defaultValue = "hehe") String username) {
System.out.println("username:" + username);
return "target";
}
(4)@RequestHeader
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性:value、required、defaultValue
@RequestMapping("/testParam3")
public String testParam3(
@RequestParam(value = "user_name", required = false, defaultValue = "hehe") String username,
@RequestHeader(value = "Host", required = false, defaultValue = "hehe") String host) {
System.out.println("username:" + username);
System.out.println("Host:" + host);
return "target";
}
(5)@CookieValue
@CookieValue是将cookie数据和控制器方法的形参创建映射关系
@RequestMapping("/testParam3")
public String testParam3(
@RequestParam(value = "user_name", required = false, defaultValue = "hehe") String username,
@RequestHeader(value = "Host", required = false, defaultValue = "hehe") String host,
@CookieValue("JSESSIONID") String JSESSIONID) {
System.out.println("JSESSIONID:" + JSESSIONID);
return "target";
}
(6)通过实体类获取请求参数
可以在控制器方法的形参位置设置一个实体类类型的形参,此时若浏览器传输的请求参数的参数名和实体类中的属性名一致,那么请求参数就会为此属性赋值。
<form th:action="@{/testBean}" method="post">
用户名:<input type="text" name="username"><br>
密码:<input type="password" name="password"><br>
性别:<input type="radio" name="sex" value="male">男<input type="radio" name="sex" value="female">女
年龄:<input type="text" name="age">
邮箱:<input type="text" name="email">
<input type="submit" value="使用实体类接收请求参数">
form>
@RequestMapping("/testBean")
public String testBean(User user) {
System.out.println(user);
return "target";
}
(7)解决获取请求参数的乱码问题
解决获取请求参数的乱码问题,可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter,必须在web.xml中进行注册。
在web.xml中添加如下配置,设置请求编码格式和响应编码格式。
<filter>
<filter-name>CharacterEncodingFilterfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>UTF-8param-value>
init-param>
<init-param>
<param-name>forceResponseEncodingparam-name>
<param-value>trueparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>CharacterEncodingFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
看到后面发现视频中多了这段配置,看起来像解决中文乱码问题的,记录在这(配置在springMVC.xml中)。
<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/htmlvalue>
<value>application/jsonvalue>
list>
property>
bean>
mvc:message-converters>
mvc:annotation-driven>
选择域对象,要选择一个能实现功能,并行范围最小的域对象。
(1)使用servletAPI向request域对象共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request) {
request.setAttribute("testRequestScope", "hello, servletAPI");
return "success";
}
(2)使用ModelAndView向request域对象共享数据
ModelAndView有Model和View的功能,Model主要用于向请求域共享数据,View主要用于设置视图,实现页面跳转。
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView() {
ModelAndView mav = new ModelAndView();
//处理模型数据,即向请求域request共享数据
mav.addObject("testRequestScope", "hello, ModelAndView");
//设置视图名称
mav.setViewName("success");
return mav;
}
(3)使用Model向request域对象共享数据
@RequestMapping("/testModel")
public String testModel(Model model) {
model.addAttribute("testRequestScope", "hello, Model");
System.out.println(model.getClass().getName());
return "success";
}
(4)使用map向request域对象共享数据
形参具有向域对象共享数据的功能。
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) {
map.put("testRequestScope", "hello, map");
System.out.println(map.getClass().getName());
return "success";
}
(5)使用ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap) {
modelMap.addAttribute("testRequestScope", "hello, ModelMap");
System.out.println(modelMap.getClass().getName());
return "success";
}
(6)Model、ModelMap、Map之间的关系
Model、ModelMap、Map类型的参数本质上都是BindingAwareModelMap类型的,分别请求上面写的三个方法可以验证:
查看源码可以发现:
说明ModelMap实现了Map接口
ctrl+h,查看类的继承结构
查看BindingAwareModelMap,发现它继承ExtendedModelMap
查看ExtendedModelMap,发现它继承ModelMap并且实现了Model接口。
总结:BindingAwareModelMap间接实现了它们三者
public interface Model {}
public class ModelMap extends LinkedHashMap {}
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}
(7)SpringMVC观察源码,控制器方法执行之后,返回统一的ModelAndView对象
进入控制器之前,先执行了DispatcherServlet中的方法。
最终返回的就是这个mv
(8)使用ServletAPI向session域对象共享数据
@RequestMapping("/testSession")
public String testSession(HttpSession session) {
session.setAttribute("testSessionScope", "hello, session");
return "success";
}
<p th:text="${session.testSessionScope}">p>
(9)使用ServletAPI向application域对象共享数据
@RequestMapping("/testApplication")
public String testApplication(HttpSession session) {
ServletContext application = session.getServletContext();
application.setAttribute("testApplicationScope", "hello, application");
return "success";
}
<p th:text="${application.testApplicationScope}">p>
SpringMVC中的视图是View接口,视图的作用是渲染数据,将模型Model中的数据展示给用户。
SpringMVC视图的种类很多,默认有转发视图和重定向视图。
若使用的视图技术为Thymeleaf,在SpringMVC的配置文件中配置了Thymeleaf的视图解析器,由此视图解析器解析之后所得到的是ThymeleafView。
(1)ThymeleafView
当控制器方法中所设置的视图名称没有任何前缀时,此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析,视图名称拼接视图前缀和视图后缀所得到的最终路径,会通过转发的方式实现跳转。
进入这个方法
进入render()方法
可以看出是Thymeleaf视图解析
(2)转发视图
SpringMVC中默认的转发视图是InternalResourceView。
当控制器方法中所设置的视图名称以“forward:”为前缀时,创建InternalResourceView视图,此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析,而是会将前缀“forward:”去掉,剩余部分作为最终路径通过转发的方式实现跳转。
(3)重定向视图
SpringMVC中默认的重定向视图是RedirectView
当控制器方法中所设置的视图名称以“redirect:”为前缀时,创建RedirectView视图,此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析,而是会将前缀“redirect:”去掉,剩余部分作为最终路径通过重定向的方式实现跳转。
@RequestMapping("/testRedirect")
public String testRedirect() {
return "redirect:/testThymeleafView";
}
转发和重定向的区别:
(4)视图控制器view-controller
当控制器方法中,仅仅用来实现页面跳转,没有其他任何请求处理的过程,即只需要设置视图名称时,可以将处理器方法使用view-controller标签进行表示。
<mvc:view-controller path="/" view-name="index">mvc:view-controller>
注意:我们在配置文件配置了view-controller之后,那么控制器映射的请求路径将全部失效。
此时需要加上另一个配置。
<mvc:annotation-driven/>
HttpMessageConverter,报文信息转换器,将请求报文转换为Java对象,或将Java对象转换为响应报文。
HttpMessageConverter提供了两个注解和两个类型:@RequestBody、@ResponseBody、RequestEntity、ResponseEntity。
(1)@RequestBody获取请求题信息
@RequestBody可以获取请求体,需要在控制器方法设置一个形参,使用@RequestBody进行标识,当前请求的请求体就会为当前注解所标识的形参赋值。
<form th:action="@{/testRequestBody}" method="post">
<input type="text" name="username">
<input type="text" name="password">
<input type="submit" value="测试@RequestBody">
form>
@RequestMapping(value = "/testRequestBody", method = RequestMethod.POST)
public String testRequestBody(@RequestBody String request) {
System.out.println("requestBody:" + request);
return "target";
}
(2)RequestEntity
RequestEntity封装请求报文的一种类型,需要在控制器方法的形参中设置该类型的形参,当前请求的请求报文就会赋值给该形参,可以通过getHeaders()获取请求头信息,通过getBody()获取请求体信息。
@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity) {
//当前requestEntity表示整个请求报文的信息
System.out.println("请求头:" + requestEntity.getHeaders());
System.out.println("请求体:" + requestEntity.getBody());
return "target";
}
(3)@ResponseBody
原始方式响应浏览器数据
@RequestMapping("/testResponse")
public void testResponse(HttpServletResponse response) throws IOException {
response.getWriter().print("hello, response");
}
注解方式 响应浏览器数据
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody() {
return "hello, response";
}
(4)@ResponseBody处理json
@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser() {
return new User(1, "user1", "123",18, "male", "[email protected]");
}
因为浏览器不认识我们的Java对象,需要把java对象转换成json字符串响应回去。
添加这个依赖,返回时能将java对象自动转换为json格式的字符串。
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.12.6version>
dependency>
同时也要加上注解驱动。
<mvc:annotation-driven/>
注:json有两种类型,一种是json对象,一种是json数组。不同的类型,我们获取里面的数据就需要使用不同的方式。
(5)SpringMVC处理ajax
请求超链接
<div id="app">
<a @click="testAxios" th:href="@{/testAxios}">SpringMVC处理ajaxa>
div>
通过vue和axios处理点击事件
<script type="text/javascript" th:src="@{/static/js/vue.js}">script>
<script type="text/javascript" th:src="@{/static/js/axios.min.js}">script>
<script type="text/javascript">
new Vue({
el: "#app",
methods:{
testAxios:function (event) {
axios({
method:"post",
url:event.target.href,
params:{
username:"admin",
password:"123456"
}
}).then(function (response) {
alert(response.data);
});
event.preventDefault();
}
}
})
script>
@RequestMapping("/testAxios")
@ResponseBody
public String testAxios(String username, String password) {
System.out.println(username + "," + password);
return "hello,axios";
}
(6)@RestController注解
@RestController注解时springMVC提供的一个复合注解,标识在控制器的类上,就相当于为类添加了@Controller注解,并且为其中的每个方法添加了@ResponseBody注解。
(7)ResponseEntity
ResponseEntity用于控制器方法的返回值类型,该控制器方法的返回值就是响应到浏览器的响应报文。
(1)文件下载
使用ResponseEntity实现下载文件的功能。
@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
//获取ServletContext对象
ServletContext servletContext = session.getServletContext();
//获取服务器中文件的真实路径
String realPath = servletContext.getRealPath("/static/img/1.jpg");
//创建输入流
InputStream is = new FileInputStream(realPath);
//创建字节数据
byte[] bytes = new byte[is.available()];
//将流读到字节数组中
is.read(bytes);
//创建HttpHeaders对象设置响应头信息
MultiValueMap<String, String> headers = new HttpHeaders();
//设置要下载方式以及下载文件的名字
headers.add("Content-Disposition", "attachment;filename=1.jpg");
//设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
//创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes,headers,statusCode);
//关闭输入流
is.close();
return responseEntity;
}
(2)文件上传
文件上传要求form表单的请求方式必须为post,并且添加属性enctype=“multipart/form-data”。
SpringMVC中将上传的文件封装到MultipartFile对象中,通过此对象可以获取文件相关信息。
上传步骤:
<dependency>
<groupId>commons-fileuploadgroupId>
<artifactId>commons-fileuploadartifactId>
<version>1.3.1version>
dependency>
配置文件上传解析器,将上传的文件封装为MultipartFile。注意,这里必须指定id,而且id必须等于multipartResolver,不然spring找不到bean,类也就没装载进去。
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">bean>
<form th:action="@{/testUp}" method="post" enctype="multipart/form-data">
头像:<input type="file" name="photo"><br>
<input type="submit" value="上传">
form>
注意:形参的名称要和上面标签的name属性的值要相同,不然获取不到。
@RequestMapping("/testUp")
public String testUp(MultipartFile photo) {
System.out.println(photo.getName()); //表单中name属性的值
System.out.println(photo.getOriginalFilename()); //文件名
String filename = photo.getOriginalFilename();
//通过ServletContext获取服务器中photo目录的路径
ServletContext servletContext = session.getServletContext();
String photoPath = servletContext.getRealPath("photo");
File file = new File(photoPath);
//判断phonePath所对应路径是否存在
if (!file.exists()) {
//若不存在,则创建目录
file.mkdir();
}
String finalPath = photoPath + File.separator + filename;
photo.transferTo(new File(finalPath)); //上传(先读再写)
return "success";
}
(3)解决文件重名的问题
如果此时再上传一张图片,与刚才的文件同名,刚才的文件会被新上传的文件覆盖掉。
(1)拦截器是用来拦截控制器方法的。
拦截器中的三个抽象方法:preHandle、postHandle、afterCompletion,一个在控制器方法执行之前,一个在控制器方法执行之后,一个执行在渲染视图完毕之后。
<mvc:interceptors>
<bean class="com.hxp.mvc.interceptors.FirstInterceptor">bean>
mvc:interceptors>
SpringMVC中的拦截器需要 实现HandlerInterceptor或者继承HandlerInterceptorAdapter类。
public class FirstInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("FirstInterceptor --> preHandle");
return false; //false表示拦截
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("FirstInterceptor --> postHandle");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("FirstInterceptor --> afterCompletion");
}
}
所以preHandle为false,直接return,也就不会执行下面的代码了。
第二种方式配置拦截器
@Component
public class FirstInterceptor implements HandlerInterceptor {
<mvc:interceptors>
<ref bean="firstInterceptor">ref>
mvc:interceptors>
注意:以上两种方式进行配置,会对DispatcherServlet所处理的所有请求进行拦截。
设置要拦截的请求,path="/*"
表示拦截一层请求路径,如:/test。多层请求路径,如:/a/test 拦截不了。path="/**"
能拦截多层请求路径。
设置需要排除的请求,表示 / 这个请求路径不拦截。
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/*" />
<mvc:exclude-mapping path="/" />
<ref bean="firstInterceptor">ref>
mvc:interceptor>
mvc:interceptors>
(2)拦截器的执行顺序
这里再写一个拦截器
<mvc:interceptors>
<ref bean="firstInterceptor">ref>
<ref bean="secondInterceptor">ref>
mvc:interceptors>
@Component
public class SecondInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("SecondInterceptor --> preHandle");
return true; //false表示拦截
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("SecondInterceptor --> postHandle");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("SecondInterceptor --> afterCompletion");
}
}
观察源码:
interceptorIndex:返回false的拦截器之前的拦截器的索引。
(1)基于配置的异常处理
properties的键表示处理器方法执行过程中出现的异常。
properties的值表示若出现指定异常,设置一个新的视图名称,跳转到指定页面。
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<prop key="java.lang.ArithmeticException">errorprop>
props>
property>
<property name="exceptionAttribute" value="ex">property>
bean>
error.html
出现错误
<p th:text="${ex}">p>
@RequestMapping("testException")
public String testException() {
System.out.println(1/0);
return "success";
}
(2)基于注解的异常处理
@ControllerAdvice将当前类标识为异常处理的组件。
@ExceptionHandler用于设置所标识方法处理的异常。
ex表示当前请求处理中出现的异常对象。
@ControllerAdvice
public class ExceptionController {
@ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
public String testExceptionHandler(Exception ex, Model model) {
model.addAttribute("ex", ex);
return "error";
}
}
REST:Representational State Transfer,表现层资源状态转移。
资源的表述:资源的表述是一段对于资源在某个特定时刻的状态的描述。资源的表述可以有多种格式,例如HTML/XML/JSON/纯文本/图片/视频/音频等待。
状态转移:客户端和服务端之间转移资源状态的表述。通过转移和操作资源的表述,来间接实现操作资源的目的。
具体说,就是HTTP协议里面,四个表示操作方式的动词:GET、POST、PUT、DELETE。
它们分别对应四种基本操作:GET用来获取资源,POST用来新建资源,PUT用来更新资源,DELETE用来删除资源。
REST风格提倡URL地址使用统一的风格设计,从前到后各个单词使用斜杆分开,不使用问号键值对方式携带请求参数,而是将要发送给服务器的数据作为URL地址的一部分,以保证整体风格的一致性。
浏览器只支持发送get和post请求,那么如何发送delete和put方式的请求呢?
SpringMVC提供了HiddenHttpMethodFilter帮助我们将POST请求转换为Delete或PUT请求。
HiddenHttpMethodFilter处理put和delete请求的条件:
当前请求的请求方式必须为post;
当前请求必须传输请求参数 _method。
<filter>
<filter-name>HiddenHttpMethodFilterfilter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<form th:action="@{/user}" 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="修改"><br>
form>
@RequestMapping(value = "/user", method = RequestMethod.PUT)
public String updateUser() {
}
注意:上面编写的配置,不要写在“编码过滤器”的前面,如果它写在前面,那么HiddenHttpMethodFilter会先执行,然后获取了请求参数,没有进行编码过滤器,从而导致乱码。所以,要先配置编码的过滤器。
(1)环境搭建
public class Employee {
private Integer id;
private String lastName;
private String email;
private Integer gender;
...
@Repository
public class EmployeeDao {
private static Map<Integer, Employee> employees = null;
static {
employees = new HashMap<>();
employees.put(1001, new Employee(1001, "E-AA", "[email protected]", 1));
employees.put(1002, new Employee(1002, "E-BB", "[email protected]", 1));
employees.put(1003, new Employee(1003, "E-CC", "[email protected]", 1));
employees.put(1004, new Employee(1004, "E-DD", "[email protected]", 1));
employees.put(1005, new Employee(1005, "E-EE", "[email protected]", 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();
}
public Employee get(Integer id) {
return employees.get(id);
}
public void delete(Integer id) {
employees.remove(id);
}
}
@Controller
public class EmployeeController {
@Autowired
private EmployeeDao employeeDao;
}
(2)查看员工列表
@RequestMapping(value = "/employee", method = RequestMethod.GET)
public String getAllEmployee(Model model) {
Collection<Employee> employeeList = employeeDao.getAll();
model.addAttribute("employeeList", employeeList);
return "employee_list";
}
<a th:href="@{/employee}">查看员工信息a>
<table id="dataTable" border="1" cellpadding="0" cellspacing="0" style="text-align: center;">
<tr>
<th colspan="5">Employee Infoth>
tr>
<tr>
<th>idth>
<th>lastNameth>
<th>emailth>
<th>genderth>
<th>optionsth>
tr>
<tr th:each="employee : ${employeeList}">
<td th:text="${employee.id}">td>
<td th:text="${employee.lastName}">td>
<td th:text="${employee.email}">td>
<td th:text="${employee.gender}">td>
<td>
<a href="">deletea>
<a href="">updatea>
td>
tr>
table>
(2)删除功能
想通过DELETE的方式提交数据,需要用表单进行提交,表单中method要等于post,隐藏域的name要为"_method",value为真正的提交方式"delete",这里使用vue来提交表单。
<form id="deleteForm" method="post">
<input type="hidden" name="_method" value="delete">
form>
<script type="text/javascript" th:src="@{/static/js/vue.js}">script>
<script type="text/javascript">
var vue = new Vue({
el:"#dataTable",
methods:{
deleteEmployee:function (event) {
//根据id获取表单元素
var deleteForm = document.getElementById("deleteForm");
//将触发点击事件的超链接的href属性赋值给表单
deleteForm.action = event.target.href;
//提交表单
deleteForm.submit();
//取消超链接的默认行为
event.preventDefault();
}
}
});
script>
删除成功,跟原来的请求就没关系了,所以用重定向跳转页面。
@RequestMapping(value = "/employee/{id}", method = RequestMethod.DELETE)
public String deleteEmployee(@PathVariable("id") Integer id) {
employeeDao.delete(id);
return "redirect:/employee";
}
在springMVC.xml中添加配置,因为要加载静态资源,可能找不到。先由SpringMVC处理请求映射,如果找不到再交给默认的Servlet处理,如果默认的Servlet也处理不了,那么将会报错404。
<mvc:default-servlet-handler/>
<mvc:view-controller path="/toAdd" view-name="employee_add">mvc:view-controller>
添加数据的页面 employee_add.html:
<form th:action="@{/employee}" method="post">
lastName: <input type="text" name="lastName"><br>
email: <input type="text" name="email"><br>
gender: <input type="radio" name="gender" value="1">male
<input type="radio" name="gender" value="1">female <br>
<input type="submit" value="add"> <br>
form>
@RequestMapping(value = "/employee", method = RequestMethod.POST)
public String addEmployee(Employee employee) {
employeeDao.save(employee);
return "redirect:/employee";
}
@RequestMapping(value = "/employee/{id}", method = RequestMethod.GET)
public String getEmployeeById(@PathVariable("id") Integer id, Model model) {
Employee employee = employeeDao.get(id);
model.addAttribute("employee", employee);
return "employee_update";
}
修改数据的页面 employee_update.html
<form th:action="@{/employee}" method="post">
<input type="hidden" name="_method" value="put">
<input type="hidden" name="id" th:value="${employee.id}">
lastName: <input type="text" name="lastName" th:value="${employee.lastName}"><br>
email: <input type="text" name="email" th:value="${employee.email}"><br>
gender: <input type="radio" name="gender" value="1" th:field="${employee.gender}">male
<input type="radio" name="gender" value="0" th:field="${employee.gender}">female <br>
<input type="submit" value="update"> <br>
form>
@RequestMapping(value = "/employee", method = RequestMethod.PUT)
public String updateEmployee(Employee employee) {
employeeDao.save(employee);
return "redirect:/employee";
}
DispatcherServlet本质上是一个Servlet,所以天然的遵循Servlet的生命周期。所以宏观上是Servlet生命周期来进行调度。
DispatcherServlet初始化策略,初始化DispatcherServlet的各个组件。
重写父类的service方法
重写HttpServlet的service方法
doService()执行服务,处理请求和响应。
找到它的子类,里面有个doDispatcher()方法
mappedHandler:调用链
包含handler、interceptorList、interceptorIndex。
由处理器适配器调用具体的控制器方法,最终获得ModelAndView对象
用户向服务器发送请求,请求被SpringMVC前端控制器DispatcherServlet捕获。
DispatcherServlet对请求URL进行解析,得到请求资源标识符(URI),判断请求URI对应的映射:
使用配置类和注解代替web.xml和SpringMVC配置文件的功能。
(1)创建初始化类,代替web.xml
在Servlet3.0环境中,容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类,如果找到的话就用它来配置Servlet容器。
Spring提供了这个接口的实现,名为SpringServletContainerInitializer,这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.0引入了一个便利的WebApplicationInitializer基础实现,名为AbstractAnnotationConfigDispatcherServletInitializer,当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候,容器会自动发现它,并用它来配置Servlet上下文。
//web工程的初始化类,用来代替web.xml
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
/**
* 指定spring的配置类
* @return
*/
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class}; //编写好spring的配置类
}
/**
* 指定SpringMVC的配置类
* @return
*/
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class}; //编写好SpringMVC的配置类
}
/**
* 指定DispatcherServlet的映射规则,即url-pattern
* @return
*/
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
/**
* 注册过滤器
* @return
*/
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceResponseEncoding(true);
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
}
}
(2)WebConfig:配置视图解析器
/**
* 代替SpringMVC的配置文件:
* 1.扫描组件 2.视图解析器 3.view-controller 4.default-servlet-handler
* 5.mvc注解驱动 6.文件上传解析器 7. 异常处理 8.拦截器
*/
@Configuration //将当前类标识为一个配置类
@ComponentScan("com.hxp.annotation.controller") //1.扫描组件
@EnableWebMvc //5.mvc注解驱动
public class WebConfig {
//配置模板解析器
@Bean
public ITemplateResolver templateResolver() {
WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
webApplicationContext.getServletContext()
);
templateResolver.setPrefix("/WEB-INF/templates/");
templateResolver.setSuffix(".html");
templateResolver.setCharacterEncoding("UTF-8");
templateResolver.setTemplateMode(TemplateMode.HTML);
return templateResolver;
}
//生成模板引擎并为模板引擎注入模板解析器
@Bean
public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
SpringTemplateEngine templateEngine = new SpringTemplateEngine();
templateEngine.setTemplateResolver(templateResolver);
return templateEngine;
}
//生成视图解析器并为解析器注入模板引擎
@Bean
public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
viewResolver.setCharacterEncoding("UTF-8");
viewResolver.setTemplateEngine(templateEngine);
return viewResolver;
}
}
(3)在WebConfig中配置默认servlet、拦截器、view-controller
拦截器:
让WebConfig实现WebMvcConfigurer
@Configuration //将当前类标识为一个配置类
@ComponentScan("com.hxp.annotation.controller") //1.扫描组件
@EnableWebMvc //5.mvc注解驱动
public class WebConfig implements WebMvcConfigurer {
// 4.default-servlet-handler
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
// 8.拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
TestInterceptor testInterceptor = new TestInterceptor();
registry.addInterceptor(testInterceptor).addPathPatterns("/**");
}
// 3.view-controller
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("hello").setViewName("hello");
}
}
(4)配置文件上传解析器、异常处理器
// 6.文件上传解析器
@Bean
public MultipartResolver multipartResolver() {
CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
return commonsMultipartResolver;
}
// 7.异常处理
@Override
public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
Properties prop = new Properties();
prop.setProperty("java.lang.ArithmeticException", "error");
exceptionResolver.setExceptionMappings(prop);
exceptionResolver.setExceptionAttribute("exception"); //获取异常的键
resolvers.add(exceptionResolver);
}