文章目录
SpringMVC
SpringMVC简介
什么是MVC
MVC是一种软件架构的思想,将软件按照模型,视图,控制器来划分
M
Model,模型层,工程中的javaBean,作用是处理数据
V
View,视图层,指工程中的html或jsp等页面,作用是与用户进行交互,展示数据
C
Controller,控制层,指工程中的servlet,作用是接收请求和响应浏览器
MVC的工作流程
什么是SpringMVC
1)Java轻量级web开发框架
2)是Spring的一个子项目,业界作为java EE项目表述层开发的首选方案
三层架构:表述层,业务逻辑层,数据访问层
表述层表示前台界面和后台servlet
SpringMVC特点
- Spring家族原生产品,与IOC容器等基础设施无缝对接
- 基于原生Servlet,通过前端控制器DispatcherServlet,对请求和响应进行统一处理
- 表述层各细分领域需要解决的问题全方位覆盖,提供全面解决方案
- 代码清新简洁,大幅度提升开发效率
- 内部组件化程度高,可插拔式组件即插即用,想要什么功能配置相应组件即可
- 性能卓著,尤其适合现代大型、超大型互联网项目要求
HelloWorld!
开发环境
jdk8+spring5+tomcat9 (tomcat10不可以)+maven3.8
开发步骤
创建maven工程
1)添加web模块
2)pom.xml中打包方式改为war
3)pom.xml中引入依赖
<dependencies>
<!-- SpringMVC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.1</version>
</dependency>
<!-- 日志 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
<!-- ServletAPI -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- Spring5和Thymeleaf整合包 -->
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf-spring5</artifactId>
<version>3.0.12.RELEASE</version>
</dependency>
</dependencies>
注:由于 Maven 的传递性,我们不必将所有需要的包全部配置依赖,而是配置最顶端的依赖,其他靠传递性导入。
配置web.xml
注册SpringMVC的前端控制器DispatcherServlet
<!-- 配置SpringMVC的前端控制器,对浏览器发送的请求统一进行处理 -->
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
<init-param>
<!-- contextConfigLocation为固定值 -->
<param-name>contextConfigLocation</param-name>
<!-- 使用classpath:表示从类路径查找配置文件,例如maven工程中的src/main/resources -->
<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>
<!--
设置springMVC的核心控制器所能处理的请求的请求路径
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径
但是/不能匹配.jsp请求路径的请求
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
注:
标签中使用/和/*的区别:
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径,但是/不能匹配.jsp请求路径的请求
因此就可以避免在访问jsp页面时,该请求被DispatcherServlet处理,从而找不到相应的页面
/*则能够匹配所有请求,例如在使用过滤器时,若需要对所有请求进行过滤,就需要使用/*的写法
创建请求控制器
创建控制类,上面添加@Controller注解将其标识为一个控制层组件,交给Spring的IOC容器管理,此时SpringMVC才能识别到控制器的存在
@Controller
public class HelloController {
}
创建SpringMVC的配置文件
<!-- 自动扫描包 -->
<context:component-scan base-package="com.atguigu.mvc.controller"/>
<!-- 配置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>
测试helloworld
实现对首页的访问
请求控制器处理请求的方法
// @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">//这个部分一定要有,idea可以通过设置使得每次新建你html文件自带这部分
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/hello}">HelloWorld</a><br/>
</body>
</html>
在请求控制器中创建处理请求的方法
@RequestMapping("/hello")
public String HelloWorld() {
return "target";
}
项目结构
@RequestMapping注解
@RequestMapping注解介绍
@RequestMapping注解的功能
讲请求和处理请求的控制器方法关联起来,建立映射关系
浏览器发送请求,SpringMVC 接收到指定的请求,就会来找到在映射关系中对应的控制器方法来处理这个请求。
@RequestMapping注解的位置
@RequestMapping标识一个类:设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法:设置映射请求请求路径的具体信息
@Controller
@RequestMapping("/test")
public class RequestMappingController {
//此时请求映射所映射的请求的请求路径为:/test/testRequestMapping
@RequestMapping("/testRequestMapping")
public String testRequestMapping(){
return "success";
}
}
@RequestMapping注解属性
@RequestMapping注解的value属性
1)通过请求的请求地址匹配请求映射
2)是一个字符串类型的数组,表示该请求映射能够匹配多个请求地址所对应的请求
3)必须设置,至少通过请求地址匹配请求映射
@RequestMapping注解的method属性
1)通过请求的请求方式(get或post)匹配请求映射
2)method属性是一个RequestMethod类型的数组,表示该请求映射能够匹配多种请求方式的请求
3)若当前请求的请求地址满足请求映射的value属性,但是请求方式不满足method属性,则浏览器报错405:Request method ‘POST’ not supported
4)如果不设置这个属性,默认任何请求方式都可以
注:
1、对于处理指定请求方式的控制器方法,SpringMVC中提供了@RequestMapping的派生注解
处理get请求的映射–>@GetMapping
处理post请求的映射–>@PostMapping
处理put请求的映射–>@PutMapping
处理delete请求的映射–>@DeleteMapping
2、常用的请求方式有get,post,put,delete
但是目前浏览器只支持get和post,若在form表单提交时,为method设置了其他请求方式的字符串(put或delete),则按照默认的请求方式get处理
若要发送put和delete请求,则需要通过spring提供的过滤器HiddenHttpMethodFilter,在RESTful部分会讲到
@RequestMapping注解的params属性(了解)
1)value与method里面的参数都是满足一个即可,params和Headers属性里面的参数必须同时满足
2)通过请求的请求参数匹配映射
3)是一个字符串类型的数组,可以通过四种表达式设置请求参数和请求映射的匹配关系
四种参数表达式:
“param”:要求请求映射所匹配的请求必须携带param请求参数
“!param”:要求请求映射所匹配的请求必须不能携带param请求参数
“param=value”:要求必须携带param请求参数且param=value
“param!=value”:要求必须携带param请求参数但是param!=value
@RequestMapping注解的Headers属性(了解)
1)通过请求的请求头匹配映射
2)是一个字符串类型的数组,可以通过四种表达式设置请求参数和请求映射的匹配关系
四种参数表达式:
“header”:要求请求映射所匹配的请求必须携带header请求头信息
“!header”:要求请求映射所匹配的请求必须不能携带header请求头信息
“header=value”:要求请求映射所匹配的请求必须携带header请求头信息且header=value
“header!=value”:要求请求映射所匹配的请求必须携带header请求头信息且header!=value
SpringMVC支持ant风格的路径
实现模糊匹配,在@RequestMapping的value属性值中使用ant风格的路径
?:表示任意的单个字符,(处了\和?)
*:表示任意的0个或多个字符,(除了\和?)
:表示任意的一层或多层目录,这样代表的部分就可以用多个/啦
注意:在使用时,只能使用//xxx的形式
如果这样写:/aa/xxx就会把解析为两个*
SpringMVC支持路径中的占位符(重点)
原始传参方式:/deleteUser?id=1
restful风格传参方式:/deleteUser/1
SpringMVC通过占位符实现这种传参方式,在RESTful风格中,当请求路径中将某些数据通过路径的方式传输到服务器,可以在RequestMapping注解的value属性中通过占位符*{xxx}表示传输的数据,再通过@PathVariable*注解,将占位符表示的数据赋值给控制器的形参
index代码
<a th:href="@{/testRest/1/admin}">测试占位符</a>
控制器代码
@RequestMapping("/testRest/{id}/{username}")
//@PathVariable注解将占位符中的内容赋值给形参
public String testRest(@PathVariable("id") Integer id,@PathVariable("username") String username){
System.out.println("id:"+id + ",username:" + username);
return "sucess";
}
//最终输出的内容为-->id:1,username:admin
SpringMVC获取请求参数
通过ServletAPI获取
@RequestMapping("/testParam")
//将HttpServletRequest作为控制器方法的形参,此时形参request代表当前请求
public String testParam(HttpServletRequest request){
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username:"+username+",password:"+password);
return "success";
}
通过控制器方法的形参获取
在控制器方法的形参位置,设置和请求参数同名的形参,当浏览器发送请求,匹配到请求映射时,在DispatcherServlet中就会将请求参数赋值给相应的形参
@RequestMapping("/testParam")
public String testParam(String username,String password,String hobby){
System.out.println("username:" + username + "password:" + password + hobby);
return "sucess";
}
注意
如果有多个同名的请求参数,可以用字符串或者字符数组接收,如果用字符串接收,返回结果为每个数据之间用逗号拼接的结果
@RequestParam
介绍
是将请求参数和控制器方法的形参创建映射关系,放在控制器方法的形参之前
属性
1)value:指定为形参赋值的请求参数的参数名
2)required:设置是否必须传输此请求参数,默认值为true,若设为true,没有传输请求参数且没有设置defaultValue属性,则报错,若设为false,则形参值为null
3)defaultValue:不管required属性值为true或false,当value所指定的请求参数没有传输或传输的值为""时,则使用默认值为形参赋值
@RequestHeader
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
属性,属性的用法同@RequestParam
@CookieValue
@CookieValue是将cookie数据和控制器方法的形参创建映射关系
属性,属性的用法同@RequestParam
通过POJO(实体类)获取请求参数
pojo:简单的实体类
在控制器方法的形参位置设置一个实体类类型的形参,若浏览器传输的请求参数的参数名和实体类中的属性名一致,那么请求参数就会为此属性赋值
解决获取请求参数的乱码问题
1)get请求乱码:是tomcat造成的,之前已经解决过了,直接在tomcat文件里改就行
2)post请求乱码:每次请求先经过过滤器再经过DispatcherServlet,因此使用过滤器来解决
3)解决请求参数乱码问题(post请求乱码),可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter,需要在web.xml中进行注册
!--配置springMVC的编码过滤器-->
//可以看CharacterEncodingFilter的源码
<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中处理编码的过滤器一定要配置到其他过滤器之前,否则无效
域对象共享数据
向request对象中共享数据
使用ServletAPI
@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
request.setAttribute("testScope", "hello,servletAPI");
return "success";
}
使用ModelAndView
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
/**
* ModelAndView有Model和View的功能
* Model主要用于向请求域共享数据
* View主要用于设置视图,实现页面跳转
*/
ModelAndView mav = new ModelAndView();
//向请求域中共享数据
mav.addObject("testScope", "hello,ModelAndView");
//设置视图,实现页面跳转
mav.setViewName("success");
return mav;
}
使用Model
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testScope", "hello,Model");
return "success";
}
使用map
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map){
map.put("testScope", "hello,Map");
return "success";
}
使用ModelMap
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
modelMap.addAttribute("testScope", "hello,ModelMap");
return "success";
}
Model,ModelMap,map的关系
向session域共享数据
控制器方法
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope", "hello,session");
return "success";
}
解析时,
<p th:text="${session.testSessionScope}"></p>
向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的视图
SpringMVC中的视图是View接口,视图的作用是渲染数据,将模型Model中的数据展示给用户
ThymeleafView
1)如果使用的视图技术为Thymeleaf,在SpringMVC配置文件中配置了Thymeleaf的视图解析器,由此视图解析器解析之后所得到的是ThymeleafView
2)控制器方法中所设置的视图名称没有任何前缀时,创建ThymeleafView视图
@RequestMapping("/testThymeleafView")
public String testHello(){
return "success";
}
转发视图
控制器中所设置的视图名称以"forward:"为前缀时,创建InternalResourceView视图
@RequestMapping("/testForward")
public String testForward(){
//转发到testThymeleafView请求
return "forward:/testThymeleafView";
}
重定向视图
控制器方法中所设置的视图名称以"redirect:"为前缀时,创建RedirectView视图
@RequestMapping("/testRedirect")
public String testRedirect(){
//重定向到testThymeleafView请求,WEB-INF下面内容不能被重定向访问
return "redirect:/testThymeleafView";
}
视图控制器view-controller
在SpringMVC配置文件中添加
<!--代替控制器中那部分代码,但是如果只加这个,控制器中的所有请求映射会全部失效-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
//path:设置处理的请求地址
//view-name:设置请求地址所对应的视图名称
可以代替控制器中这部分代码
@RequestMapping("/")
public String index(){
return "index";
}
但是当SpringMVC中设置任何一个view-controller时,其他控制器中的请求映射将全部失效,此时需要在SpringMVC核心配置文件中设置开启mvc注解驱动
<!-- 开启MVC注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
RESTful
什么是REST
即Resource Representational State Transfer
Resource(资源)Representational (资源的表述)State Transfer(状态转移)
RESTful风格规则
前提引入:在传统的项目开发中,我们通常都会将操作资源的动词写进 URL 中,而这些动词通常都是我们自行定义的,并没有一个统一的规范。莎士比亚说:一千个人眼中就有一个千个哈姆雷特,这句话应用在这里,再合适不过了。哪怕是对同一资源的相同操作,不同的人所定义的 URL 也是各不相同的。
RESTFul 提倡我们使用统一的风格来设计URL,其规则如下。
1) URL 只用来标识和定位资源,不得包含任何与操作相关的动词
2)当请求中需要携带参数时,将参数通过斜杠(/)拼接到URL中,将其作为URL的一部分发送到服务器中,而不再像以前一样使用问号(?)拼接键值对的方式来携带参数
RESTful的实现
资源操作 | 传统方式 URL | RESTFul URL | HTTP 请求方式 |
---|---|---|---|
查询操作(SELECT) | http://localhost:8080/biancheng/getUserById?id=1 | http://localhost:8080/biancheng/user/1 | GET |
保存或新增资源(INSERT) | http://localhost:8080/biancheng/saveUser | http://localhost:8080/biancheng/user | POST |
修改操作(UPDATE) | http://localhost:8080/biancheng/updateUser | http://localhost:8080/biancheng/user | PUT |
删除操作(DELETE) | http://localhost:8080/biancheng/deleteUser?id=1 | http://localhost:8080/biancheng/user/1 | DELETE |
HiddenHttpMethodFilter
问题引入
由于浏览器只支持发送get和post方式的请求,那么改如何发送put和delete请求呢?
SpringMVC提供了HiddenHttpMethodFilter帮助我们将post请求转换为delete或put请求
转化条件
1)当前请求的请求方式必须为post
2)当前请求必须传输请求参数_method
满足以上条件,HiddenHttpMethodFilter过滤器就会将当前请求的请求方式转化为请求参数_method的值,因此请求参数_mthod的值才是最终的请求方式
转化步骤
1)在web.xml中注册HiddenHttpMethodFilter
<!--配置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>
注意:目前为止,SpringMVC中提供了两个过滤器,HiddenHttpMethodFilter和CharacterEncodingFilter,注册时,必须先注册CharacterEncodingFilter再注册HiddenHttpMethodFilter,否则CharacterEncodingFilter会失效,原因是在设置编码的过滤器(CharacterEncodingFilter)之前不能设置任何的请求参数,而HiddenHttpMethodFilter中刚好设置了。
2)视图页面代码
<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>
3)控制器方法
@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String xg(String username,String password) {
System.out.println("修改用户信息:" + username + " " + password);
return "success";
}
补充
<!-- 开放对静态资源的访问 首先由DispachServlet处理,如果请求DispachServlet处理不了,当前的请求就会被DeafaultServlet来处理-->
<mvc:default-servlet-handler/>
<!-- 但是只加上面这个就会都是DefaultServlet处理,只有同时加上下面的注解驱动后,才能实现先DispachServlet再DeafaultServlet的顺序-->
<!-- 开启MVC注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
小插曲,maven打包报错:
Cannot access defaults field of Properties
解决方案:pom.xml中添加
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.3.1</version>
</plugin>
</plugins>
</build>
HttpMessageConverter
什么是HttpMessageConverter
1)报文信息转换器,将请求报文转换为Java对象,或将java对象转换为响应报文
即请求报文->java对象->响应报文
2)提供了两个注解和两个类型:@RequestBody,@ResponseBody,RequestEntity,ResponseEntity
@RequestBody
可以获取请求体,需要在控制器方法设置一个形参,使用@RequestBody进行标识,当前请求体就会赋值给当前注解所标识的形参
@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody){
System.out.println("requestBody:"+requestBody);
return "success";
}
//requestBody存放的内容即为请求体
RequestEntity
封装请求报文的一种类型,在控制器方法中设置该类型的形参,请求的请求报文就会赋值给该形参,通过*getHeaders()获取请求头信息,通过getBody()*获取请求体信息
@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){
System.out.println("requestHeader:"+requestEntity.getHeaders());
System.out.println("requestBody:"+requestEntity.getBody());
return "success";
}
@ResponseBody
使用ServletAPI方法将响应报文响应到浏览器
@RequestMapping("/testResponse")
public void testResponse(HttpServletResponse response) throws IOException {
response.getWriter().print("hello,Response");//将打印的内容直接作为响应报文的响应体响应到浏览器
}
浏览器界面显示hello,Response
使用@ResponseBody注解将响应报文响应到浏览器
用于标识一个控制器方法,可以将该方法的返回值直接作为响应报文的响应体响应到浏览器
//返回值不再是视图名称而是响应到浏览器的响应体
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
return "hello,ResponseBody";
}
浏览器界面显示hello,ResponseBody
@ResponseBody处理json
导入jackson依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.1</version>
</dependency>
在SpringMVC核心配置文件中开启mvc注解驱动
<mvc:annotation-driven />
控制器方法编写
将java对象作为控制器方法的返回值返回,就会自动转换为json格式的字符串
@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
return new User(1001,"admin","123456",23,"男");
}
浏览器页面中展示的是json格式的数据
@ResponseBody处理ajax
前端内容下次一定学~
@RestController
是一个复合注解,标识在控制器的类上面,相当于为类添加了@Controller注解,并且为其中的每个方法添加了@ResponseBody注解
ResponseEntity
用于控制器方法的返回值类型,该控制器方法的返回值就是响应到浏览器的响应报文
文件下载和上传
(这一部分其实听的有点懵懵的)
文件下载
使用ResponseEntity实现下载文件功能
@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
//获取ServletContext对象
ServletContext servletContext = session.getServletContext();
//获取服务器中文件的真实路径
String realPath = servletContext.getRealPath("/static/img/1.png");
//创建输入流
InputStream is = new FileInputStream(realPath);
//创建字节数组
byte[] bytes = new byte[is.available()];//获取当前文件对应的输入流所对应的字节数
//将流读到字节数组中
is.read(bytes);
//创建HttpHeaders对象设置响应头信息
MultiValueMap<String, String> headers = new HttpHeaders();
//设置要下载方式以及下载文件的名字,attachment以附件的形式下载,filename设置下载文件的默认名字,这一行不管在什么地方什么方式下载基本格式都是一样的
headers.add("Content-Disposition", "attachment;filename=niuzi.png");
//设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
//创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
//关闭输入流
is.close();
return responseEntity;
}
文件上传
相关细节
1)文件上传要求form表单的请求方式必须为post,并且添加属性enctype=“multipart/form-data”
2)SpringMVC中将上传的文件封装到MultipartFile对象中,通过此对象可以获取文件相关信息
上传步骤
1)pom.xml中添加依赖
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
2)在SpringMVC配置文件中添加配置
<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
3)控制器方法
@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
//获取上传的文件的文件名
String fileName = photo.getOriginalFilename();
//处理文件重名问题
String hzName = fileName.substring(fileName.lastIndexOf("."));//.最后一次出现的索引
//将UUTD作为文件名
fileName = UUID.randomUUID().toString() + hzName;
//获取服务器中photo目录的路径
ServletContext servletContext = session.getServletContext();
String photoPath = servletContext.getRealPath("photo");
File file = new File(photoPath);
//如果不存在就创建
if(!file.exists()){
file.mkdir();
}
String finalPath = photoPath + File.separator + fileName;
//实现上传功能
photo.transferTo(new File(finalPath));
return "success";
}
拦截器
拦截器的配置
SpringMVC中的拦截器用于拦截控制器方法的执行
SpringMVC中的拦截器需要实现HandlerInterceptor接口
必须在SpringMVC配置文件中进行配置
<!-- 配置拦截器-->
<mvc:interceptors>
<!-- 方式一 <bean class="com.zhe.com.zhe.interceptors.FirstInterceptor"></bean>-->
<!-- 方式二,需要在firstInterceptor上面加组件注解,方式一二都默认对所有请求进行拦截 <ref bean="firstInterceptor"></ref>-->
<!-- 方式三可以指定拦截路径,自定义拦截规则-->
<mvc:interceptor>
<!-- 设置拦截路径 拦截所有路径-->
<mvc:mapping path="/**"/>
<!-- 排除哪一个路径不用拦截-->
<mvc:exclude-mapping path="/"/>
<!-- 指定拦截器-->
<ref bean="firstInterceptor"></ref>
</mvc:interceptor>
</mvc:interceptors>
拦截器的三个抽象方法
@Component
public class FirstInterceptor implements HandlerInterceptor {
//idea快捷键ctrl+o:重写方法
//控制器方法之前执行
//preHandle()
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("FirstInterceptor-->preHandle");
return true;//返回true表示放行,即调用控制器方法,返回false表示拦截,即不调用控制器方法
}
//控制器方法之后执行
//postHandle()
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("FirstInterceptor-->postHandle");
}
//视图渲染之后执行
//afterCompletion()
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("FirstInterceptor-->afterCompletion");
}
}
多个拦截器的执行顺序
每个拦截器的preHandle都返回true
执行顺序与拦截器在SpringMVC的配置文件的配置顺序有关
preHandle()会按照配置顺序执行,postHandle()和afterComplation()会按照配置的相反顺序执行
配置顺序
<ref bean="firstInterceptor"></ref>
<ref bean="secondInterceptor"></ref>
执行顺序
某一个拦截器的preHandle()返回了false
preHandle()返回false的拦截器和它之前的拦截器的preHandle()都会执行,postHandle()都不执行,返回false的拦截器之前的拦截器的afterComplation()会执行
下面是将secondInterceptor拦截器的preHandle返回值设为了false
异常处理器
基于配置的异常处理器
1)SpringMVC提供了一个处理控制器方法执行过程中所出现异常的接口:HandlerExceptionResolver
2)HandlerExceptionResolver的实现类:DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver
3)SpringMVC提供自定义的异常处理器SimpleMappingExceptionResolver,使用方式,在SpringMVC配置文件中配置
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<!--
properties的键表示处理器方法执行过程中出现的异常
properties的值表示若出现指定异常时,设置一个新的视图名称,跳转到指定页面
-->
<prop key="java.lang.ArithmeticException">error</prop>
</props>
</property>
<!--
exceptionAttribute属性设置一个属性名,将出现的异常信息在请求域中进行共享
-->
<property name="exceptionAttribute" value="ex"></property>
</bean>
基于注解的异常处理器
//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
//@ExceptionHandler用于设置所标识方法处理的异常
//出现当前异常,就会将当前方法作为新的控制器方法
@ExceptionHandler(ArithmeticException.class)
//ex表示当前请求处理中出现的异常对象
public String handleArithmeticException(Exception ex, Model model){
model.addAttribute("ex", ex);//放到请求域中
return "error";
}
}
注解配置SpringMVC
使用配置类和注解代替web.xml和SpringMVC配置文件(SpringMVC.xml)
初始化类代替web.xml
//web工程的初始化类,用来代替web.xml
//需要继承AACDSI这个类
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
//ctrl+o重写方法
//指定spring的配置类
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{springConfig.class};
}
//指定springMVC的配置类
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{webConfig.class};
}
//指定DispatcherServlet的映射规则,即url-pattern
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
//注册过滤器
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceResponseEncoding(true);
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};
}
}
SpringConfig配置类代替Spring配置文件
@Configuration
public class SpringConfig {
//ssm整合之后,spring的配置信息写在此类中
}
WebConfig配置类代替SpringMVC的配置文件
@Configuration
//代替springMVC的配置文件
//1.扫描组件
//2.视图解析器
//3.view-controller
//4.default-servlet-handler
//5.mvc注解驱动
//6.文件上传解析器
//7.异常处理器
//8.拦截器
//扫描组件
@ComponentScan("com.zhe")
//开启mvc注解驱动
@EnableWebMvc
public class webConfig implements WebMvcConfigurer {
//view-controller
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/hello").setViewName("hello");
}
//default-servlet-handler
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
//拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
testInterceptor testInterceptor = new testInterceptor();
registry.addInterceptor(testInterceptor).addPathPatterns("/**");
}
//文件上传解析器
@Bean
public MultipartResolver multipartResolver(){
CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
return commonsMultipartResolver;
}
//异常处理器
@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("ex");
resolvers.add(exceptionResolver);
}
//下面就是视图解析器的配置了,不用详细看
//配置生成模板解析器
@Bean
public ITemplateResolver templateResolver() {
WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
// ServletContextTemplateResolver需要一个ServletContext作为构造参数,可通过WebApplicationContext 的方法获得
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;
}
}
SpringMVC执行流程
SpringMVC常用组件
DispatcherServlet:前端控制器,由框架提供
作用:统一处理请求和响应,整个流程控制的中心,由它调用其他组件处理用户的请求
HandlerMapping:处理器映射器,由框架提供
作用:根据请求的url,method等信息查找Handler(控制器方法)
Handler:处理器(控制器方法),需要工程师开发
作用:在DispatcherServlet的控制下Handler对具体的用户请求进行处理
HandlerAdapter:处理器适配器,由框架提供
作用:通过HandlerAdapter对处理器(控制器方法)
进行执行
ViewResolver:视图解析器,由框架提供
作用:进行视图解析,得到相应的视图
View:视图
作用:将模型数据通过页面展示给用户
SpringMVC执行流程
一图胜千言