📄个人主页:胖虎不秃头
✨个人简介:Java领域新星创作者,随时准备跑路的大二学生
🔥精品专栏:有这一个就够了
🌈个人名言:知道的越多,不知道的越多
💥刷题神器:推荐一款算法刷题网站Nowcoder👉点击跳转刷题网站进行注册学习
文章目录
- 第1章 SpringMVC概述
- 第2章 SpringMVC注解式开发
- 第3章 拦截器与异常处理器
- 第4章RESTful
- 第5章 注解配置SpringMVC及执行流程
第1章 SpringMVC概述
1.1 SpringMVC简介
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视图,渲染数据后最终响应给浏览器
SpringMVC是Spring的一个后续产品,是Spring的一个子项目
SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、
WebWork、Strust2 等诸多产品的历代更迭之后,目前业界普遍选择了 SpringMVC 作为 Java EE 项目
表述层开发的首选方案。
注:三层架构分为表述层(或表示层)、业务逻辑层、数据访问层,表述层表示前台页面和后台
servlet
1.2 SpringMVC的优点
1.2.1 基于MVC架构
基于 MVC 架构,功能分工明确。解耦合。
1.2.2 容易理解,上手快,使用简单
就可以开发一个注解的 SpringMVC 项目,SpringMVC 也是轻量级的,jar 很小。不依赖的特定的接口和类。
1.2.3作为Spring框架一部分,能够使用Spring的IOC和AOP
方便整合Strtus,MyBatis,Hiberate,JPA 等其他框架。
1.2.4 SpringMVC 强化注解的使用
在Controller, Service, Dao 都可以使用注解。方便灵活。使用@Controller 创建处理器对象,@Service 创建业务对象,@Autowired 或者@Resource 在控制器类中注入 Service,在Service 类中注入 Dao。
1.3SpringMVC优化的方向
1.4 SpringMVC执行的流程
执行流程说明:
- 向服务器发送HTTP请求,请求被前端控制器 DispatcherServlet 捕获。
- DispatcherServlet 根据中的配置对请求的URL进行解析,得到请求资源标识符(URI)。然后根据该URI,调用 HandlerMapping 获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以 HandlerExecutionChain 对象的形式返回。
- DispatcherServlet 根据获得的Handler,选择一个合适的 HandlerAdapter。
- 提取Request中的模型数据,填充Handler入参,开始执行Handler(Controller)。在填充Handler的入参过程中,根据你的配置,Spring将帮你做一些额外的工作:HttpMessageConveter:将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息。
- 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等。
- 数据格式化:对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等。
- 数据验证:验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中。
- Handler(Controller)执行完成后,向 DispatcherServlet 返回一个 ModelAndView 对象。
- 根据返回的ModelAndView,选择一个适合的 ViewResolver(必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet。
- ViewResolver 结合Model和View,来渲染视图。
- 视图负责将渲染结果返回给客户端
1.5基于注解的SpringMVC程序
所谓 SpringMVC 的注解式开发是指:
在代码中通过对类与方法的注解,便可完成处理器在 springmvc 容器的注册。注解式开发是重点。
项目案例功能:用户提交一个请求,服务端处理器在接收到这个请求后,给出一条欢迎信息,在响应页面中显示该信息。
创建步骤:
- 新建maven_web项目
- 添加依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
- 删除web.xml文件重新添加,因为自动生成的web.xml文件版本太低了。
- 在web.xml文件中注册SpringMvc框架。
因为web的请求都是由Servlet来进行处理的,而SpringMVC的核心处理器就是一个DispatcherServlet,它负责接收客户端的请求,并根据请求的路径分派给对应的action(控制器)进行处理,处理结束后依然由核心处理器DispatcherServlet进行响应返回。
中央调度器的全限定性类名在导入的 Jar 文件 spring-webmvc-5.2.5.RELEASE.jar 的第一个包org.springframework.web.servlet下可找到。
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!--初始化参数,init-param的配置,由于springmvc的核心配置包扫描和视图解析器的默认配置路径在webinfo下,但是项目一般会把配置文件放在resource下,所以要进行初识配置找到springmvc的核心配置-->
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
<!--可以这样写<url-pattern>/</url-pattern>表示处理所有请求,
但是不要写/*,这样会处理.jsp结尾的请求,而.jsp的请求有jspServlet处理-->
<!--设置springMVC的核心控制器所能处理的请求的请求路径
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径
但是/不能匹配.jsp请求路径的请求 -->
classpath:springmvc.xml
表示从类路径下加载SpringMVC的配置文件。
指定拦截以.action结尾的请求,交给核心处理器DispatcherServlet处理。
-
删除index.jsp页面,重新建index.jsp页面,因为自动生成的页面缺失指令设置。
-
开发页面,发出请求。
<a href="${pageContext.request.contextPath}/zar/hello.action">访问action</a>
- 其中:
- /zar 是类上的注解路径
- /hello 是方法上的注解路径
-
在webapp目录上新添目录/admin。
-
在/admin目录下新建main.jsp页面。用来进行服务器处理完毕后数据的回显。
-
开发HelloSpringMvc.java–>控制器(相当于以前的servlet)。这是一个普通的类,不用继承和实现接口。类中的每个方法就是一个具体的action控制器。
- 类中的方法定义有规范:
- A. 访问权限是public。
- B. 方法名自定义。
- C. 方法的参数可以有多个,任意类型,用来接收客户端提交上来的数据。
- D. 方法的返回值任意。以返回String居多。
@Controller
@RequestMapping("/zar")
public class HelloSpringMvc {
@RequestMapping("/hello")
public String one(){
return "main";
}
}
@Controller:表示当前类为处理器,交给Spring容器去创建对象。
@RequestMapping:表示路径映射。该注解可以加在类上相当于包名,还可以加在方法上相当于action的名称,都是来指定映射路径的。
- 完成springmvc.xml文件的配置。在工程的类路径即resources目录下创建 SpringMVC 的配置文件 springmvc.xml。该文件名可以任意命名。推荐使用springmvc.xml.
<context:component-scan base-package="com.bjpowernode.controller"></context:component-scan> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
SpringMVC框架为了避免对于请求资源路径与扩展名上的冗余,在视图解析器
InternalResouceViewResolver 中引入了请求的前辍与后辍。而action中只需给出要跳转页面的文件名即可,对于具体的文件路径与文件扩展名,视图解析器会自动完成拼接。
context:component-scan:用来进行包扫描,这里用于指定@Controller注解所在的包路径。
1.6总结
浏览器发送请求,若请求地址符合前端控制器的url-pattern,该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件,通过扫描组件找到控制器,将请求地址和控制器中@RequestMapping注解的value属性值进行匹配,若匹配成功,该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称,该视图名称会被视图解析器解析,加上前缀和后缀组成视图的路径,通过Thymeleaf对视图进行渲染,最终转发到视图所对应页面
第2章 SpringMVC注解式开发
2.1@RequestMapping定义请求规则
2.1.1 指定模块名称
-
通过@RequestMapping 注解可以定义处理器对于请求的映射规则。
-
该注解可以注解在方法上,也可以注解在类上,但意义是不同的。
-
value 属性值常以“/”开始。
-
@RequestMapping 的 value 属性用于定义所匹配请求的 URI。
-
一个@Controller 所注解的类中,可以定义多个处理器方法。
-
不同的处理器方法所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的value 属性中。但若这些请求具有相同的 URI 部分,则这些相同的 URI部分可以被抽取到注解在类之上的@RequestMapping 的 value 属性中。此时的这个 URI 表示模块(相当于包)的名称。URI 的请求是相对于 Web 的根目录。
-
换个角度说,要访问处理器的指定方法,必须要在方法指定 URI 之前加上处理器类前定义的模块名称。
示例:
提取后
@Controller
@RequestMapping("/zar")
public class HelloSpringMvc {
//相当于一个控制器处理的方法
@RequestMapping("/hello")
public String one() {
return "main";
}
@RequestMapping("/two")
public String two() {
return "main";
}
//客户端的请求:
// <form action="${pageContext.request.contextPath}/zar/hello.action">
// <form action="${pageContext.request.contextPath}/zar/two.action"> }
2.1.2对请求提交方式的定义
- 对于@RequestMapping,其有一个属性 method,用于对被注解方法所处理请求的提交方式进行限制,即只有满足该 method 属性指定的提交方式的请求,才会执行该被注解方法。
- Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与 RequestMethod.POST,分别表示提交方式的匹配规则为 GET 与 POST 提交。
@RequestMapping(value = "/hello", method = RequestMethod.POST)
public String one() {
return "main";
}
以上处理器方法只能处理 POST 方式提交的请求。
客户端浏览器常用的请求方式,及其提交方式有以下几种:
也就是说,只要指定了处理器方法匹配的请求提交方式为 POST,则相当于指定了请求发送的方式:要么使用表单请求,要么使用 AJAX 请求。其它请求方式被禁用。
当然,若不指定 method 属性,则无论是 GET 还是 POST 提交方式,均可匹配。即对于请求的提交方式无要求。
(1)post提交方式
(2)get提交方式
对于处理指定请求方式的控制器方法,SpringMVC中提供了@RequestMapping的派生注解
- 处理get请求的映射–>@GetMapping
- 处理post请求的映射–>@PostMapping
- 处理put请求的映射–>@PutMapping
- 处理delete请求的映射–>@DeleteMapping
2.1.3@RequestMapping注解的params属性(了解)
@RequestMapping注解的params属性通过请求的请求参数匹配请求映射
@RequestMapping注解的params属性是一个字符串类型的数组,可以通过四种表达式设置请求参数
和请求映射的匹配关系
-
“param”:要求请求映射所匹配的请求必须携带param请求参数
<a th:href="@{/test(username='admin',password=123456)">测试@RequestMapping的 params属性-->/test</a><br>
@RequestMapping( value = {"/testRequestMapping", "/test"} ,method = {RequestMethod.GET, RequestMethod.POST} ,params = {"username","password!=123456"} ) public String testRequestMapping(){ return "success"; }
-
“param=value”:要求请求映射所匹配的请求必须携带param请求参数且param=value
-
“param!=value”:要求请求映射所匹配的请求必须携带param请求参数但是param!=value
注:
若当前请求满足@RequestMapping注解的value和method属性,但是不满足params属性,此时页面回报错400:Parameter conditions “username, password!=123456” not met for actual
request parameters: username={admin}, password={123456}
2.1.4@RequestMapping注解的headers属性(了解)
@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射,来源页面
@RequestMapping注解的headers属性是一个字符串类型的数组,可以通过四种表达式设置请求头信
息和请求映射的匹配关系
- “header”:要求请求映射所匹配的请求必须携带header请求头信息
- “!header”:要求请求映射所匹配的请求必须不能携带header请求头信息
- “header=value”:要求请求映射所匹配的请求必须携带header请求头信息且header=value
- “header!=value”:要求请求映射所匹配的请求必须携带header请求头信息且header!=value
若当前请求满足@RequestMapping注解的value和method属性,但是不满足headers属性,此时页面
显示404错误,即资源未找到
2.2 五种数据提交的方式
前四种数据注入的方式,会自动进行类型转换。但无法自动转换日期类型。
(1)单个数据注入
在方法中声明一个和表单提交的参数名称相同的参数,由框架按照名称直接注入。
(2)对象封装注入
在方法中声明一个自定义的实体类参数,框架调用实体类中相应的setter方法注入属性值,只要保证实体类中成员变量的名称与提交请求的name属性值一致即可。
(3)动态占位符提交(仅用于超链接)
使用框架提供的一个注解@PathVariable,将请求url中的值作为参数进行提取,只能是超链接。restful风格下的数据提取方式。restful是一种软件架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。
(4)请求参数名称与形参名称不一致
请求与形参中的名字不对应,可以使用
@RequestParam(value="name1",required=true)String namea
来进行参数名称绑定。
(5)使用HttpServletRequest对象提取
在方法参数中声明一个request对象,使用request的getParameter()获取表单提交的数据,这样得到的数据还要手工进行数据类型的转换。
public String five(HttpServletRequest request){
int age=new Integer(request.getParameter("stuage"));
String name=request.getParameter("stuname");
System.out.println(age+"*********"+name);
return "main";
}
(6)获取请求头信息@RequestHeader
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性:value、required、defaultValue,用法同@RequestParam
(7)获取Cookie值@CookieValue
@CookieValue是将cookie数据和控制器方法的形参创建映射关系
@CookieValue注解一共有三个属性:value、required、defaultValue,用法同@RequestParam
2.3请求参数中文乱码解决
对于前面所接收的请求参数,若含有中文,则会出现中文乱码问题。Spring 对于请求参数中的中文乱码问题,给出了专门的字符集过滤器: spring-web-5.2.5.RELEASE.jar 的org.springframework.web.filter 包下的 CharacterEncodingFilter 类。
(1)解决方案
- 在 web.xml 中注册字符集过滤器,即可解决 Spring 的请求参数的中文乱码问题。
- 不过,最好将该过滤器注册在其它过滤器之前。因为过滤器的执行是按照其注册顺序进行的。
(2)源码分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I2YGXSv6-1659882586542)(…/…/…/…/Pictures/Spring/wps15.jpg)]
2.4处理器方法的返回值(处理AJAX请求)
使用@Controller 注解的处理器的方法,其返回值常用的有四种类型:
-
第一种:ModelAndView
-
第二种:String
-
第三种:无返回值void
-
第四种:返回对象类型
2.4.1返回 ModelAndView
- 若处理器方法处理完后,需要跳转到其它资源,且又要在跳转的资源间传递数据,此时处理器方法返回 ModelAndView 比较好。
- 当然,若要返回 ModelAndView,则处理器方法中需要定义 ModelAndView 对象。
- 在使用时,若该处理器方法只是进行跳转而不传递数据,或只是传递数据而并不向任何资源跳转(如对页面的 Ajax 异步响应),此时若返回 ModelAndView,则将总是有一部分多余:要么 Model 多余,要么 View 多余。即此时返回 ModelAndView 将不合适。较少使用。
2.4.2返回 String
处理器方法返回的字符串可以指定逻辑视图名,通过视图解析器解析可以将其转换为物理视图地址。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1gMsHVb-1659882586543)(…/…/…/…/Pictures/Spring/wps16.jpg)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ojn4atP-1659882586543)(…/…/…/…/Pictures/Spring/wps17.jpg)](https://img-blog.csdnimg.cn/15a94715b6594994994f09713df9ff6f.jpeg)
当然,也可以直接返回资源的物理视图名。不过,此时就不需要再在视图解析器中再配置前辍与后辍了。
2.4.1无返回值void
对于处理器方法返回 void 的应用场景,应用在AJAX 响应处理。若处理器对请求处理后,无需跳转到其它任何资源,此时可以让处理器方法返回 void。我们SSM整合案例中的分页使用的就是无返回值。
2.4.2返回对象Object
- 处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer,自定义对象,Map,List 等。
- 但返回的对象不是作为逻辑视图出现的,而是作为直接在页面显示的数据出现的。
- 返回对象,需要使用@ResponseBody 注解,将转换后的 JSON 数据放入到响应体中。
- Ajax请求多用于Object返回值类型。
- 由于转换器底层使用了Jackson 转换方式将对象转换为JSON 数据,所以需要添加Jackson的相关依赖。
项目案例:使用ajax请求返回一个JSON结构的学生.
实现步骤:
A.在pom.xml文件中添加依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>
B.添加jQuery的函数库,在webapp目录下,新建js目录,拷贝jquery-3.3.1.js到目录下
C.在页面添加jQuery的函数库的引用
<script src="js/jquery-3.3.1.js"></script>
D.发送ajax请求
function show() {
$.ajax({
url:"${pageContext.request.contextPath}/ajax.action",
type:"post",
dataType:"json",
success:function (stu) {
$("#oneStu").html(stu.name+"------"+stu.age);
}
});
}
E.开发action
@Controller
public class AjaxDemo {
@RequestMapping("/ajax")
@ResponseBody //此注解用来解析ajax请求
public Object ajax(){
Student stu = new Student("张三",22);
return stu;
}
}
F.在springmvc.xml文件中添加注解驱动
<mvc:annotation-driven></mvc:annotation-driven>
G.index.jsp页面
<a href="javascript:show()">ajax访问服务器,返回一个学生</a>
<br>
2.5SpringMVC的四种跳转方式
2.5.1 转发与重定向
- 默认的跳转是请求转发,直接跳转到jsp页面展示
- 使用框架提供的关键字redirect:,进行一个重定向操作,包括重定向页面和重定向action,
- 使用框架提供的关键字forward:,进行服务器内部转发操作,包括转发页面和转发action。
- 当使用redirect:和forward:关键字时,视图解析器中前缀后缀的拼接就无效了。
页面部分:
<!--ctrl+d:复制当前行-->
<a href="${pageContext.request.contextPath}one.action">请求转发页面(默认)</a><br>
<a href="${pageContext.request.contextPath}two.action">请求转发action</a><br>
<a href="${pageContext.request.contextPath}three.action">重定向页面</a><br>
<a href="${pageContext.request.contextPath}four.action">重定向action</a><br>
Controller部分:
@Controller
public class JumpAction {
@RequestMapping("/one")
public String one(){
System.out.println("请求转发页面(默认)");
//以前的访问方式 //request.getRequestDispatcher("/admin/main.jsp").forward(request,response);
//观察地址栏的变化: http://localhost:8080/one.action
//return "main"; //默认的访问方式是自动拼接前缀和后缀进行跳转
return "forward:/fore/user.jsp";//只要使用了forward:就可以屏蔽前缀和后缀的拼接,自己手工构建返回的全部路径+.jsp
}
@RequestMapping("/two")
public String two(){
System.out.println("请求转发action");
//观察地址栏的变化: http://localhost:8080/two.action
return "forward:/other.action";
//不使用forward:,就会是这样的路径 /admin/other.action/.jsp
}
@RequestMapping("/three")
public String three(){
System.out.println("重定向页面");
//观察地址栏的变化 http://localhost:8080/admin/main.jsp
return "redirect:/admin/main.jsp";
//只要使用了redirect:就可以屏蔽前缀和后缀的拼接
}
@RequestMapping("/four")
public String four(){
System.out.println("重定向action");
//观察地址栏的变化 http://localhost:8080/other.action
return "redirect:/other.action";
//只要使用了redirect:就可以屏蔽前缀和后缀的拼接
}
}
2.5.2 视图控制器view-controller
当控制器方法中,仅仅用来实现页面跳转,即只需要设置视图名称时,可以将处理器方法使用view
controller标签进行表示
<!--path:设置处理的请求地址 view-name:设置请求地址所对应的视图名称 -->
<mvc:view-controller path="/testView" view-name="success"></mvc:view-controller>
注:
当SpringMVC中设置任何一个view-controller时,其他控制器中的请求映射将全部失效,此时需
要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签:
<mvc:annotation-driven />
2.6SpringMVC支持的默认参数类型
JSP中内置对象
- pagecontext JSP页面的范围
- HttpServletRequest 一次请求的范围
- HttpSession 一次会话的范围
- ServletContext(application) 整个应用的范围
这些类型只要写在方法参数中就可以使用了。
1)HttpServletRequest 对象
2)HttpServletResponse 对象
3)HttpSession 对象
4)Model/ModelMap 对象
5)Map<String,Object>对象
示例:
@Controller
public class ParamAction {
@RequestMapping("/param")
public String param(HttpServletRequest request,
HttpServletResponse response,
HttpSession session,
Model model,
ModelMap modelMap,
Map map){
//Map ,Model,ModelMap,request都使用请求作用域进行传值,
//所以必须使用请求转发的方式进行跳转,否则丢失数据
Student stu = new Student("张三",22);
request.setAttribute("requestStu",stu);
session.setAttribute("sessionStu",stu);
modelMap.addAttribute("modelMapStu",stu);
model.addAttribute("modelStu",stu);
map.put("mapStu",stu);
return "main"; //切记请求转发跳转
// return "redirect:/admin/main.jsp";//会丢失数据
}
}
注意Model,Map,ModelMap都使用的是request请求作用域,意味着只能是请求转发后,页面才可以得到值。
2.6.1 使用ServletAPI向request域对象共享数据
@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
request.setAttribute("testScope", "hello,servletAPI");
return "success";
}
2.6.2 使用ModelAndView向request域对象共享数据
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
/**
* ModelAndView有Model和View的功能
* Model主要用于向请求域共享数据
* View主要用于设置视图,实现页面跳转
*/
ModelAndView mav = new ModelAndView();
//向请求域共享数据
mav.addObject("testScope", "hello,ModelAndView");
//设置视图,实现页面跳转
mav.setViewName("success");
return mav;
}
2.6.3 使用Model向request域对象共享数据
@RequestMapping("/testModel")
public String testModel(Model model){
model.addAttribute("testScope", "hello,Model");
return "success";
}
2.6.4 使用map向request域对象共享数据
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map){
map.put("testScope", "hello,Map");
return "success";
}
2.6.5 使用ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
modelMap.addAttribute("testScope", "hello,ModelMap");
return "success";
}
2.5.6 Model、ModelMap、Map的关系
Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的
public interface Model{}
public class ModelMap extends LinkedHashMap<String, Object> {}
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}
2.5.7、向session域共享数据
@RequestMapping("/testSession")
public String testSession(HttpSession session){
session.setAttribute("testSessionScope", "hello,session");
return "success";
}
2.5.8、向application域共享数据
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
ServletContext application = session.getServletContext();
application.setAttribute("testApplicationScope", "hello,application");
return "success";
}
2.7日期处理
2.7.1 日期注入
日期类型不能自动注入到方法的参数中。需要单独做转换处理。
使用@DateTimeFormat注解,需要在springmvc.xml文件中添加 <mvc:annotation-driven />标签。
(1)在方法的参数上使用@DateTimeFormat注解
@RequestMapping("/submitone")
public String submitdateone(
@DateTimeFormat(pattern="yyyy-MM-dd")
Date mydate){
System.out.println(mydate);
return "dateShow";
}
(2)在类的成员setXXX()方法上使用@DateTimeFormat注解
@DateTimeFormat(pattern="yyyy-MM-dd")
public void setDate(Date date) {
this.date = date;
}
但这种解决方案要在每个使用日期类型的地方都去添加使用@DateTimeFormat注解,比较麻烦,我们可以使用@InitBinder注解来进行类中统一日期类型的处理。
(3)@InitBinder注解解决类中日期问题
@InitBinder
public void initBinder(WebDataBinder dataBinder) {
SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(sf, true));
}
这样在类中出现的所有日期都可以进行转换了。
2.7.2 日期显示
(1)JSON中的日期显示
需要在类中的成员变量的getXXX方法上加注解.
@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
public Date getDate() {
return date;
}
(2)JSP页面的日期显示
需要使用国际化标签,先添加依赖
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
导入国际化的标签库
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
再使用标签显示日期
<c:forEach items="${list}" var="stu"> ${stu.name}-------${stu.age}-------
<fmt:formatDate value="${stu.date}" pattern="yyyy-MM-dd">
2.8 <mvc:annotation-driven />标签的使用
- <mvc:annotation-driven />会自动注册两个bean,分别为**DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter。**是springmvc为@controller分发请求所必须的。
- 除了注册了这两个bean,还提供了很多支持。
1)支持使用ConversionService 实例对表单参数进行类型转换;
2)支持使用 @NumberFormat 、@DateTimeFormat;
3)注解完成数据类型的格式化;
4)支持使用 @RequestBody 和 @ResponseBody 注解;
5)静态资源的分流也使用这个标签;
2.9资源在WEB-INF目录下
- 很多企业会将动态资源放在WEB-INF目录下,这样可以保证资源的安全性。
- 在WEB-INF目录下的动态资源不可以直接访问,必须要通过请求转发的方式进行访问。
- 这样避免了通过地址栏直接对资源的访问。重定向也无法访问动态资源。
项目案例:
页面结构图:
action:
@Controller
public class ShowAction {
@RequestMapping("/showIndex")
public String showIndex(){
System.out.println("index.............");
return "index";
}
@RequestMapping("/showMain")
public String showMain(){
System.out.println("main.............");
return "main";
}
@RequestMapping("/showLogin")
public String showLogin(){
System.out.println("login.............");
return "login";
}
@RequestMapping("/login")
public String login(String name, String pwd, HttpServletRequest request){
if("admin".equals(name) && "123".equals(pwd)){
return "main";
}
request.setAttribute("msg","用户名或密码不正确!");
return "login";
}
}
运行结果:
2.10SpringMVC支持ant风格的路径
- ?:表示任意的单个字符(不包括**?**)
- :表示任意的0个或多个字符(不包括*?**和 / )
- **:表示任意层数的任意目录
注意:在使用 ** 时,只能使用/**/xxx的方式, * *前后不能有任何字符,只能有//
2.11@RestController注解
@RestController注解是springMVC提供的一个复合注解,标识在控制器的类上,就相当于为类添加了@Controller注解,并且为其中的每个方法添加了@ResponseBody注解
第3章 拦截器与异常处理器
- SpringMVC 中的 Interceptor 拦截器,它的主要作用是拦截指定的用户请求,并进行相应的预处理与后处理。
- 其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类,并且也找到了要执行该处理器类的处理器适配器,在处理器适配器执行处理器之前”。
- 当然,在处理器映射器映射出所要执行的处理器类时,已经将拦截器与处理器组合为了一个处理器执行链,并返回给了中央调度器。
3.1 拦截器介绍
3.1.1拦截器的应用场景
1、日志记录:记录请求信息的日志
2、权限检查,如登录检查
3、性能检测:检测方法的执行时间
3.1.2 拦截器的执行原理
3.1.3拦截器执行的时机
1)preHandle():在请求被处理之前进行操作
2)postHandle():在请求被处理之后,但结果还没有渲染前进行操作,可以改变响应结果
3)afterCompletion:所有的请求响应结束后(渲染视图完毕)执行善后工作,清理对象,关闭资源
3.1.4 拦截器实现的两种方式
1)继承HandlerInterceptorAdapter的父类
2)实现HandlerInterceptor接口,实现的接口,推荐使用实现接口的方式
3.2 HandlerInterceptor接口分析
自定义拦截器,需要实现 HandlerInterceptor 接口。而该接口中含有三个方法:
(1) preHandle
该方法在处理器方法执行之前执行。其返回值为 boolean,若为 true,则紧接着会执行处理器方法,且会将 afterCompletion()方法放入到一个专门的方法栈中等待执行。
(2) postHandle
该方法在处理器方法执行之后执行。处理器方法若最终未被执行,则该方法不会执行。由于该方法是在处理器方法执行完后执行,且该方法参数中包含 ModelAndView,所以该方法可以修改处理器方法的处理结果数据,且可以修改跳转方向。
(3)afterCompletion
当preHandle()方法返回 true 时,会将该方法放到专门的方法栈中,等到对请求进行响应的所有工作完成之后才执行该方法。即该方法是在中央调度器渲染(数据填充)了响应页面之后执行的,此时对 ModelAndView 再操作也对响应无济于事。afterCompletion 最后执行的方法,清除资源,例如在 Controller 方法中加入数据等。
3.3 自定义拦截器实现权限验证
实现一个权限验证拦截器。
- 修改web.xml文件中请求路径
- 将所有的页面放入WEB-INF目录下
- 开发登录action
- 开发拦截器
- 配置springmvc.xml文件
<!--注册拦截器-->
<mvc:interceptors>
<mvc:interceptor>
<!--配置拦截的路径(哪些请求被拦截)-->
<!--"/*"是一层路径-->
<!--"/**"是多层路径-->
<mvc:mapping path="/**"/>
<!--设置放行的请求-->
<mvc:exclude-mapping path="/login"></mvc:exclude-mapping>
<mvc:exclude-mapping path="/showLogin"></mvc:exclude-mapping>
<!--设置进行功能处理的拦截器类-->
<bean class="com.bjpowernode.interceptor.LoginInterceptor"></bean>
<!--单独的bean或者ref也可以进行配置-->
</mvc:interceptor>
</mvc:interceptors>
3.4 过滤器和拦截器的区别
1、实现原理不同
过滤器和拦截器 底层实现方式大不相同,过滤器 是基于函数回调的,拦截器 则是基于Java的反射机制(动态代理)实现的。
2、使用范围不同
- 过滤器 实现的是 javax.servlet.Filter 接口,而这个接口是在Servlet规范中定义的,也就是说过滤器Filter 的使用要依赖于Tomcat等容器,导致它只能在web程序中使用。
- 拦截器(Interceptor) 它是一个Spring组件,并由Spring容器管理,并不依赖Tomcat等容器,是可以单独使用的。不仅能应用在web程序中,也可以用于Application、Swing等程序中。
3、触发时机不同
- 过滤器Filter是在请求进入容器后,但在进入servlet之前进行预处理,请求结束是在servlet处理完以后。
- 拦截器 Interceptor 是在请求进入servlet后,在进入Controller之前进行预处理的,Controller 中渲染了对应的视图之后请求结束。
4、拦截的请求范围不同
Filter 处理中
Interceptor 前置
Interceptor 处理中
Interceptor 后置
Filter 处理中
- 过滤器Filter执行了两次,拦截器Interceptor只执行了一次。
- 这是因为过滤器几乎可以对所有进入容器的请求起作用,
- 而拦截器只会对Controller中请求或访问static目录下的资源请求起作用。
5、拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。
- ①拦截器是基于java的反射机制的,而过滤器是基于函数回调。
- ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。
- ③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用。
- ④拦截器可以访问action上下文、值栈里的对象,而过滤器不能访问。
- ⑤在action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次。
- ⑥拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。
3.5 多个拦截器的执行顺序
①若每个拦截器的preHandle()都返回true
此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关:
preHandle()会按照配置的顺序执行,而postHandle()和afterCompletion()会按照配置的反序执行
②若某个拦截器的preHandle()返回了false
preHandle()返回false和它之前的拦截器的preHandle()都会执行,postHandle()都不执行,返回false
的拦截器之前的拦截器的afterCompletion()会执行
3.6 异常处理器
3.6.1 基于配置的异常处理
SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口:HandlerExceptionResolver
HandlerExceptionResolver接口的实现类有:DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver
SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver,使用方式:
<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>
3.6.2 基于注解的异常处理
//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
//@ExceptionHandler用于设置所标识方法处理的异常
@ExceptionHandler(ArithmeticException.class)
//ex表示当前请求处理中出现的异常对象
public String handleArithmeticException(Exception ex, Model model){
model.addAttribute("ex", ex);
return "error";
}
}
第4章RESTful
4.1RESTful简介
REST:Representational State Transfer,表现层资源状态转移。
①资源
- 资源是一种看待服务器的方式,即,将服务器看作是由很多离散的资源组成。
- 每个资源是服务器上一个 可命名的抽象概念。
- 因为资源是一个抽象的概念,所以它不仅仅能代表服务器文件系统中的一个文件、 数据库中的一张表等等具体的东西,可以将资源设计的要多抽象有多抽象,只要想象力允许而且客户端 应用开发者能够理解。
- 与面向对象设计类似,资源是以名词为核心来组织的,首先关注的是名词。
- 一个 资源可以由一个或多个URI来标识。
- URI既是资源的名称,也是资源在Web上的地址。对某个资源感兴 趣的客户端应用,可以通过资源的URI与其进行交互。
②资源的表述
- 资源的表述是一段对于资源在某个特定时刻的状态的描述。
- 可以在客户端-服务器端之间转移(交换)。
- 资源的表述可以有多种格式,例如HTML/XML/JSON/纯文本/图片/视频/音频等等。
- 资源的表述格式可以通过协商机制来确定。
- 请求-响应方向的表述通常使用不同的格式。
③状态转移
- 状态转移说的是:在客户端和服务器端之间转移(transfer)代表资源状态的表述。
- 通过转移和操作资 源的表述,来间接实现操作资源的目的。
4.2RESTful的实现
具体说,就是 HTTP 协议里面,四个表示操作方式的动词:GET、POST、PUT、DELETE。
它们分别对应四种基本操作:GET 用来获取资源,POST 用来新建资源,PUT 用来更新资源,DELETE 用来删除资源。
REST 风格提倡 URL 地址使用统一的风格设计,从前到后各个单词使用斜杠分开,不使用问号键值对方式携带请求参数,而是将要发送给服务器的数据作为 URL 地址的一部分,以保证整体风格的一致性。
操作 | 传统方式 | REST风格 |
---|---|---|
查询操作 | getUserById?id=1 | user/1–>get请求方式 |
保存操作 | saveUser | user–>post请求方式 |
删除操作 | deleteUser?id=1 | user/1–>delete请求方式 |
更新操作 | updateUser | user–>put请求方式 |
4.3HiddenHttpMethodFilter
- 由于浏览器只支持发送get和post方式的请求,那么该如何发送put和delete请求呢?
- SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求
- HiddenHttpMethodFilter 处理put和delete请求的条件:
- a>当前请求的请求方式必须为post
- b>当前请求必须传输请求参数_method
- 满足以上条件,HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数
_ method的值,因此请求参数 _ method的值才是最终的请求方式
在web.xml中注册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中提供了两个过滤器:CharacterEncodingFilter和
HiddenHttpMethodFilter
在web.xml中注册时,必须先注册CharacterEncodingFilter,再注册HiddenHttpMethodFilter 原因:
在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的
request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作:
String paramValue = request.getParameter(this.methodParam);
第5章 注解配置SpringMVC及执行流程
使用配置类和注解代替web.xml和SpringMVC配置文件的功能
5.1创建初始化类,代替web.xml
- 在Servlet3.0环境中,容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类, 如果找到的话就用它来配置Servlet容器。
- Spring提供了这个接口的实现,名为SpringServletContainerInitializer,这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。
- Spring3.2引入了一个便利的WebApplicationInitializer基础实现,名为AbstractAnnotationConfigDispatcherServletInitializer,当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候,容器会自 动发现它,并用它来配置Servlet上下文。
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
/**
*指定spring的配置类
*@return
*/ @Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
/**
*指定SpringMVC的配置类
*@return
*/ @Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class};
}
/**
*指定DispatcherServlet的映射规则,即url-pattern
*@return
*/ @Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
/**
*添加过滤器
*@return
*/
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
encodingFilter.setEncoding("UTF-8"); encodingFilter.setForceRequestEncoding(true);
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
}
}
5.2 创建SpringConfig配置类,代替spring的配置文件
@Configuration
public class SpringConfig {
//ssm整合之后,spring的配置信息写在此类中
}
5.3 创建WebConfig配置类,代替SpringMVC的配置文件
@Configuration
//扫描组件@ComponentScan("com.atguigu.mvc.controller")
//开启MVC注解驱动@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
//使用默认的servlet处理静态资源@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer){
configurer.enable();
}
//配置文件上传解析器@Bean
public CommonsMultipartResolver multipartResolver(){
return new CommonsMultipartResolver();
}
//配置拦截器@Override
public void addInterceptors(InterceptorRegistry registry) {
FirstInterceptor firstInterceptor = new FirstInterceptor();
registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
}
//配置视图控制
/*@Override
public void addViewControllers(ViewControllerRegistry registry) { registry.addViewController("/").setViewName("index");
}*/
//配置异常映射
/*@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;
}
}
5.4测试功能
@RequestMapping("/")
public String index(){
return "index";
}
5.5 SpringMVC常用组件
-
DispatcherServlet:前端控制器,不需要工程师开发,由框架提供
作用:统一处理请求和响应,整个流程控制的中心,由它调用其它组件处理用户的请求
-
HandlerMapping:处理器映射器,不需要工程师开发,由框架提供
作用:根据请求的url、method等信息查找Handler,即控制器方法
-
Handler:处理器,需要工程师开发
作用:在DispatcherServlet的控制下Handler对具体的用户请求进行处理
-
HandlerAdapter:处理器适配器,不需要工程师开发,由框架提供
作用:通过HandlerAdapter对处理器(控制器方法)进行执行
-
ViewResolver:视图解析器,不需要工程师开发,由框架提供
作用:进行视图解析,得到相应的视图,例如:ThymeleafView、InternalResourceView、RedirectView
-
View:视图
作用:将模型数据通过页面展示给用户
5.6 SpringMVC的执行流程
-
用户向服务器发送请求,请求被SpringMVC 前端控制器 DispatcherServlet捕获。
-
DispatcherServlet对请求URL进行解析,得到请求资源标识符(URI),判断请求URI对应的映射:
a) 不存在
i. 再判断是否配置了mvc:default-servlet-handler
ii. 如果没配置,则控制台报映射查找不到,客户端展示404错误
iii. 如果有配置,则访问目标资源(一般为静态资源,如:JS,CSS,HTML),找不到客户端也会展示404 错误
b) 存在则执行下面的流程
-
根据该URI,调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以HandlerExecutionChain执行链对象的形式返回。
-
DispatcherServlet 根据获得的Handler,选择一个合适的HandlerAdapter。
-
如果成功获得HandlerAdapter,此时将开始执行拦截器的preHandler(…)方法【正向】
-
提取Request中的模型数据,填充Handler入参,开始执行Handler(Controller)方法,处理请求。 在填充Handler的入参过程中,根据你的配置,Spring将帮你做一些额外的工作:
- HttpMessageConveter:将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息
- 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等
- 数据格式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
- 数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中
-
Handler执行完成后,向DispatcherServlet 返回一个ModelAndView对象。
-
此时将开始执行拦截器的postHandle(…)方法【逆向】。
-
根据返回的ModelAndView(此时会判断是否存在异常:如果存在异常,则执行HandlerExceptionResolver进行异常处理)选择一个适合的ViewResolver进行视图解析,根据Model和View,来渲染视图。
-
渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。
-
将渲染结果返回给客户端。