一 SpringMVC 概述
1、SpringMVC 概述
- Spring 为展现层提供的基于 MVC 设计理念的优秀的 Web 框架，是目前最主流的 MVC 框架之一。
- Spring3.0 后全面超越 Struts2，成为最优秀的 MVC 框架。
- Spring MVC 通过一套 MVC 注解，让 POJO 成为处理请求的控制器，而无须实现任何接口。
- 支持 REST 风格的 URL 请求。
- 采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性。
2、是什么
- 一种轻量级的、基于MVC的Web层应用框架。偏前端而不是基于业务逻辑层。
- 是Spring框架的一个后续产品。
- Spring框架结构图(新版本)：
- Spring框架结构图(老版本)：
3、能干什么
- 天生与Spring框架集成，如：(IOC,AOP)
- 支持Restful风格
- 进行更简洁的Web层开发
- 支持灵活的URL到页面控制器的映射
- 非常容易与其他视图技术集成，如:Velocity、FreeMarker等等。
- 因为模型数据不存放在特定的API里，而是放在一个Model里(Map数据结构实现，因此很容易被其他框架使用)
- 非常灵活的数据验证、格式化和数据绑定机制、能使用任何对象进行数据绑定，不必实现特定框架的API
- 更加简单、强大的异常处理
- 对静态资源的支持
- 支持灵活的本地化、主题等解析
4、去哪下
- 基于Spring框架，多了个web的jar包
5、怎么玩
- 将Web层进行了职责解耦，也就和struts2一样，基于请求-响应模型
- 常用主要组件
- DispatcherServlet：前端控制器
- Controller：处理器/页面控制器，做的是MVC中的C的事情，但控制逻辑转移到前端控制器了，用于对请求进行处理
- HandlerMapping ：请求映射到处理器，找谁来处理，如果映射成功返回一个HandlerExecutiongChain对象（包含一个Handler处理器(页面控制器)对象、多个HandlerInterceptor拦截器对象）
- ViewResolver : 视图解析器，找谁来处理返回的页面。把逻辑视图解析为具体的View,进行这种策略模式，很容易更换其他视图技术；
- 如InternalResourceViewResolver将逻辑视图名映射为JSP视图
- LocalResolver：本地化、国际化
- MultipartResolver：文件上传解析器
- HandlerExceptionResolver：异常处理器
6、永远的HelloWorld
步骤：
- 新建Web工程，加入 jar 包
spring-aop-4.0.0.RELEASE.jar spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELEASE.jar spring-core-4.0.0.RELEASE.jar spring-expression-4.0.0.RELEASE.jar commons-logging-1.1.3.jar spring-web-4.0.0.RELEASE.jar spring-webmvc-4.0.0.RELEASE.jar |
- 在 web.xml 中配置 DispatcherServlet
<!-- 配置SpringMVC核心控制器： --> <servlet> <servlet-name>springDispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!-- 配置DispatcherServlet的初始化參數：设置文件的路径和文件名称 --> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springDispatcherServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> |
解释配置文件的名称定义规则:
实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
- 加入 Spring MVC 的配置文件：springmvc.xml
- 增加名称空间
增加配置
<!-- 设置扫描组件的包： --> <context:component-scan base-package="com.atguigu.springmvc"/>
<!-- 配置映射解析器：如何将控制器返回的结果字符串，转换为一个物理的视图文件--> <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/"/> <property name="suffix" value=".jsp"/> </bean> |
- 需要创建一个入口页面，index.jsp
<a href="${pageContext.request.contextPath }/helloworld">Hello World</a> |
- 编写处理请求的处理器，并标识为处理器
package com.atguigu.springmvc.controller;
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping;
@Controller //声明Bean对象，为一个控制器组件 public class HelloWorldController {
/** * 映射请求的名称：用于客户端请求；类似Struts2中action映射配置的action名称 * 1. 使用 @RequestMapping 注解来映射请求的 URL * 2. 返回值会通过视图解析器解析为实际的物理视图, 对于 InternalResourceViewResolver 视图解析器, * 会做如下的解析: * 通过 prefix + returnVal + suffix 这样的方式得到实际的物理视图, 然后做转发操作. * /WEB-INF/views/success.jsp */ @RequestMapping(value="/helloworld",method=RequestMethod.GET) public String helloworld(){ System.out.println("hello,world"); return "success"; //结果如何跳转呢？需要配置映射解析器 } } |
- 编写视图
/WEB-INF/views/success.jsp
<h4>Sucess Page</h4> |
- 部署测试：
http://localhost:8080/SpringMVC_01_HelloWorld/index.jsp
7、HelloWorld深度解析
- 开发中大家需要注意的问题，总结如下：
- HelloWorld请求流程图解：
- 一般请求的映射路径名称和处理请求的方法名称最好一致（实质上方法名称任意）
@RequestMapping(value="/helloworld",method=RequestMethod.GET) public String helloworld(){ //public String abc123(){ System.out.println("hello,world"); return "success"; } |
- 处理请求方式有哪几种
public enum RequestMethod GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE } |
- @RequestMapping可以应用在什么地方
@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Mapping public @interface RequestMapping |
- 源码Debug,走起…
- 流程图分析
- 基本步骤：
- 客户端请求提交到DispatcherServlet
- 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller
- DispatcherServlet将请求提交到Controller（也称为Handler）
- Controller调用业务逻辑处理后，返回ModelAndView
- DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
视图负责将结果显示到客户端
二、 @RequestMapping映射
- @RequestMapping 映射请求注解
- SpringMVC使用@RequestMapping注解为控制器指定可以处理哪些 URL 请求
- 在控制器的类定义及方法定义处都可标注 @RequestMapping
- 标记在类上：提供初步的请求映射信息。相对于 WEB 应用的根目录
- 标记在方法上：提供进一步的细分映射信息。相对于标记在类上的 URL。
- 若类上未标注 @RequestMapping，则方法处标记的 URL 相对于 WEB 应用的根目录
作用：DispatcherServlet 截获请求后，就通过控制器上 @RequestMapping 提供的映射信息确定请求所对应的处理方法。
2、实验代码
- 定义页面链接、控制器方法
<a href="springmvc/helloworld">test @RequestMapping</a> |
@Controller //声明Bean对象，为一个控制器组件 @RequestMapping("/springmvc") public class HelloWorldController { /** * 映射请求的名称：用于客户端请求；类似Struts2中action映射配置的，action名称 *1 使用@RequestMapping 注解来映射请求的 URL *2 返回值会通过视图解析器解析为实际的物理视图, 对于 InternalResourceViewResolver 视图解析器, * 会做如下的解析: * 通过 prefix + returnVal + 后缀 这样的方式得到实际的物理视图, 然会做转发操作. * /WEB-INF/views/success.jsp */ @RequestMapping(value="/helloworld") public String helloworld(){ System.out.println("hello,world"); return "success"; //结果如何跳转呢？需要配置映射解析器 } } |
3、RequestMapping映射请求方式
标准的 HTTP 请求报头
- 映射请求参数、请求方法或请求头
@RequestMapping 除了可以使用请求 URL 映射请求外，还可以使用请求方法、请求参数及请求头映射请求
@RequestMapping 的 value【重点】、method【重点】、params【了解】 及 heads【了解】
分别表示请求 URL、请求方法、请求参数及请求头的映射条件，他们之间是与的关系，联合使用多个条件可让请求映射更加精确化。
- params 和 headers支持简单的表达式：
param1: 表示请求必须包含名为 param1 的请求参数
!param1: 表示请求不能包含名为 param1 的请求参数
param1 != value1: 表示请求包含名为 param1 的请求参数，但其值不能为 value1
{"param1=value1", "param2"}: 请求必须包含名为 param1 和param2 的两个请求参数，且 param1 参数的值必须为 value1
4、实验代码
- 定义控制器方法
@Controller @RequestMapping("/springmvc") public class SpringMVCController { @RequestMapping(value="/testMethord",method=RequestMethod.POST) public String testMethord(){ System.out.println("testMethord..."); return "success"; } } |
- 以get方式请求
<a href="springmvc/testMethord">testMethord</a> |
- 发生请求错误
- 以POST方式请求
<form action="springmvc/testMethord" method="post"> <input type="submit" value="submit"> </form> |
5、RequestMapping映射请求参数&请求头
- RequestMapping_请求参数&请求头【了解】
//了解: 可以使用 params 和 headers 来更加精确的映射请求. params 和 headers 支持简单的表达式. @RequestMapping(value="/testParamsAndHeaders", params= {"username","age!=10"}, headers = { "Accept-Language=en-US,zh;q=0.8" }) public String testParamsAndHeaders(){ System.out.println("testParamsAndHeaders..."); return "success"; } |
- 请求URL
<!--设置请求参数和请求头信息 --> <a href="springmvc/testParamsAndHeaders">testParamsAndHeaders</a> |
- 测试:使用火狐或Chrom浏览器debug测试
- 测试有参数情况(不正确)：
- <a href="springmvc/testParamsAndHeaders">testParamsAndHeaders</a>
四月 11, 2016 4:48:08 下午 org.springframework.web.servlet.PageNotFound handleNoSuchRequestHandlingMethod 警告: No matching handler method found for servlet request: path '/springmvc/testParamsAndHeaders', method 'GET', parameters map[[empty]] |
- <a href="springmvc/testParamsAndHeaders?username=atguigu&age=10">testParamsAndHeaders</a>
四月 11, 2016 4:51:01 下午 org.springframework.web.servlet.PageNotFound handleNoSuchRequestHandlingMethod 警告: No matching handler method found for servlet request: path '/springmvc/testParamsAndHeaders', method 'GET', parameters map['username' -> array<String>['atguigu'], 'age' -> array<String>['10']] |
- <a href="springmvc/testParamsAndHeaders?age=11">testParamsAndHeaders</a>
四月 11, 2016 5:05:24 下午 org.springframework.web.servlet.PageNotFound handleNoSuchRequestHandlingMethod 警告: No matching handler method found for servlet request: path '/springmvc/testParamsAndHeaders', method 'GET', parameters map['age' -> array<String>['11']] |
- 测试有参数情况(正确)：
<a href="springmvc/testParamsAndHeaders?username=atguigu&age=15">testParamsAndHeaders</a>
6、RequestMapping支持Ant 路径风格
- Ant 风格资源地址支持 3 种匹配符：【了解】
?：匹配文件名中的一个字符
*：匹配文件名中的任意字符
**：** 匹配多层路径
- @RequestMapping 还支持 Ant 风格的 URL：
/user/*/createUser 匹配 /user/aaa/createUser、/user/bbb/createUser 等 URL /user/**/createUser 匹配 /user/createUser、/user/aaa/bbb/createUser 等 URL /user/createUser?? 匹配 /user/createUseraa、/user/createUserbb 等 URL |
7、实验代码
- 定义控制器方法
//Ant 风格资源地址支持 3 种匹配符 //@RequestMapping(value="/testAntPath/*/abc") //@RequestMapping(value="/testAntPath/**/abc") @RequestMapping(value="/testAntPath/abc??") public String testAntPath(){ System.out.println("testAntPath..."); return "success"; } |
- 页面链接
<!-- Ant 风格资源地址支持 3 种匹配符 --> <a href="springmvc/testAntPath/*/abc">testAntPath</a> <a href="springmvc/testAntPath/xxx/yyy/abc">testAntPath</a> <a href="springmvc/testAntPath/abcxx">testAntPath</a> |
8、RequestMapping映射请求占位符PathVariable注解
@PathVariable 映射 URL 绑定的占位符
带占位符的 URL 是 Spring3.0 新增的功能，该功能在 SpringMVC 向 REST 目标挺进发展过程中具有里程碑的意义
通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中：
URL 中的 {xxx} 占位符可以通过 @PathVariable("xxx") 绑定到操作方法的入参中。
9、实验代码
- 定义控制器方法
//@PathVariable 注解可以将请求URL路径中的请求参数，传递到处理请求方法的入参中 @RequestMapping(value="/testPathVariable/{id}") public String testPathVariable(@PathVariable("id") Integer id){ System.out.println("testPathVariable...id="+id); return "success"; } |
- 请求链接
<!-- 测试 @PathVariable --> <a href="springmvc/testPathVariable/1">testPathVariable</a> |
三、 HiddenHttpMethodFilter (REST)
1、REST风格是什么？
- REST：即 Representational State Transfer。（资源）表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用
- 资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。
它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。
可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的 URI 。
获取这个资源，访问它的URI就可以，因此 URI 即为每一个资源的独一无二的识别符。
- 表现层（Representation）：把资源具体呈现出来的形式，叫做它的表现层（Representation）。比如，文本可以用 txt 格式表现，也可以用 HTML 格式、XML 格式、JSON 格式表现，甚至可以采用二进制格式。
- 状态转化（State Transfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”（State Transfer）。
而这种转化是建立在表现层之上的，所以就是 “表现层状态转化”。
- 具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。
- URL风格
示例：
/order/1 HTTP GET ：得到 id = 1 的 order
/order/1 HTTP DELETE：删除 id = 1的 order
/order/1 HTTP PUT：更新id = 1的 order
/order HTTP POST：新增 order
- HiddenHttpMethodFilter
浏览器 form 表单只支持 GET 与 POST 请求，而DELETE、PUT 等 method 并不支持，
Spring3.0 添加了一个过滤器，可以将这些请求转换为标准的 http 方法，使得支持 GET、POST、PUT 与 DELETE 请求。
2、实验代码
- 配置HiddenHttpMethodFilter过滤器
<!-- 支持REST风格的过滤器：可以将POST请求转换为PUT或DELETE请求 --> <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> |
- 代码
/** * 1.测试REST风格的 GET,POST,PUT,DELETE 操作 * 以CRUD为例： * 新增: /order POST * 修改: /order/1 PUT update?id=1 * 获取: /order/1 GET get?id=1 * 删除: /order/1 DELETE delete?id=1
* 2.如何发送PUT请求或DELETE请求? * ①.配置HiddenHttpMethodFilter * ②.需要发送POST请求 * ③.需要在发送POST请求时携带一个 name="_method"的隐含域，值为PUT或DELETE
* 3.在SpringMVC的目标方法中如何得到id值呢? * 使用@PathVariable注解 */ @RequestMapping(value="/testRESTGet/{id}",method=RequestMethod.GET) public String testRESTGet(@PathVariable(value="id") Integer id){ System.out.println("testRESTGet id="+id); return "success"; }
@RequestMapping(value="/testRESTPost",method=RequestMethod.POST) public String testRESTPost(){ System.out.println("testRESTPost"); return "success"; }
@RequestMapping(value="/testRESTPut/{id}",method=RequestMethod.PUT) public String testRESTPut(@PathVariable("id") Integer id){ System.out.println("testRESTPut id="+id); return "success"; }
@RequestMapping(value="/testRESTDelete/{id}",method=RequestMethod.DELETE) public String testRESTDelete(@PathVariable("id") Integer id){ System.out.println("testRESTDelete id="+id); return "success"; } |
- 请求链接
<fieldset> <!-- 实验1 测试 REST风格 GET 请求 --> <a href="springmvc/testRESTGet/1">testREST GET</a><br/><br/>
<!-- 实验2 测试 REST风格 POST 请求 --> <form action="springmvc/testRESTPost" method="POST"> <input type="submit" value="testRESTPost"> </form>
<!-- 实验3 测试 REST风格 PUT 请求 --> <form action="springmvc/testRESTPut/1" method="POST"> <input type="hidden" name="_method" value="PUT"> <input type="submit" value="testRESTPut"> </form>
<!-- 实验4 测试 REST风格 DELETE 请求 --> <form action="springmvc/testRESTDelete/1" method="POST"> <input type="hidden" name="_method" value="DELETE"> <input type="submit" value="testRESTDelete"> </form> </fieldset> |
3、HiddenHttpMethodFilter过滤器源码分析
- 为什么请求隐含参数名称必须叫做”_method”
四、请求数据传入
1、请求处理方法签名
2、@RequestParam注解
3、实验代码
- Spring MVC 通过分析处理方法的签名，HTTP请求信息绑定到处理方法的相应人参中。
- Spring MVC 对控制器处理方法签名的限制是很宽松的，几乎可以按喜欢的任何方式对方法进行签名。
- 必要时可以对方法及方法入参标注相应的注解（ @PathVariable 、@RequestParam、@RequestHeader 等）、
- Spring MVC 框架会将 HTTP 请求的信息绑定到相应的方法入参中，并根据方法的返回值类型做出相应的后续处理。
- 在处理方法入参处使用 @RequestParam 可以把请求参数传递给请求方法
- value：参数名
- required：是否必须。默认为 true, 表示请求参数中必须包含对应的参数，若不存在，将抛出异常
- defaultValue: 默认值，当没有传递参数时使用该值
- 增加控制器方法
/** * @RequestParam 注解用于映射请求参数 * value 用于映射请求参数名称 * required 用于设置请求参数是否必须的 * defaultValue 设置默认值，当没有传递参数时使用该值 */ @RequestMapping(value="/testRequestParam") public String testRequestParam( @RequestParam(value="username") String username, @RequestParam(value="age",required=false,defaultValue="0") int age){ System.out.println("testRequestParam - username="+username +",age="+age); return "success"; } |
- 增加页面链接
<!--测试 请求参数 @RequestParam 注解使用 --> <a href="springmvc/testRequestParam?username=atguigu&age=10">testRequestParam</a> |
4、@RequestHeader 注解
5、实验代码
- 使用 @RequestHeader 绑定请求报头的属性值
- 请求头包含了若干个属性，服务器可据此获知客户端的信息，通过 @RequestHeader 即可将请求头中的属性值绑定到处理方法的入参中
//了解: 映射请求头信息 用法同 @RequestParam @RequestMapping(value="/testRequestHeader") public String testRequestHeader(@RequestHeader(value="Accept-Language") String al){ System.out.println("testRequestHeader - Accept-Language："+al); return "success"; } |
<!-- 测试 请求头@RequestHeader 注解使用 --> <a href="springmvc/testRequestHeader">testRequestHeader</a> |
6、@CookieValue 注解
7、实验代码
- 使用 @CookieValue 绑定请求中的 Cookie 值
- @CookieValue 可让处理方法入参绑定某个 Cookie 值
- 增加控制器方法
//了解:@CookieValue: 映射一个 Cookie 值. 属性同 @RequestParam @RequestMapping("/testCookieValue") public String testCookieValue(@CookieValue("JSESSIONID") String sessionId) { System.out.println("testCookieValue: sessionId: " + sessionId); return "success"; } |
增加页面链接
<!--测试 请求Cookie @CookieValue 注解使用 --> <a href="springmvc/testCookieValue">testCookieValue</a> |
8、使用POJO作为参数
9、实验代码
- 使用 POJO 对象绑定请求参数值
- Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配，自动为该对象填充属性值。支持级联属性。如：dept.deptId、dept.address.tel 等
- 增加控制器方法、表单页面
/** * Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配， 自动为该对象填充属性值。 * 支持级联属性 * 如：dept.deptId、dept.address.tel 等 */ @RequestMapping("/testPOJO") public String testPojo(User user) { System.out.println("testPojo: " + user); return "success"; } |
<!-- 测试 POJO 对象传参，支持级联属性 --> <form action=" testPOJO" method="POST"> username: <input type="text" name="username"/><br> password: <input type="password" name="password"/><br> email: <input type="text" name="email"/><br> age: <input type="text" name="age"/><br> city: <input type="text" name="address.city"/><br> province: <input type="text" name="address.province"/> <input type="submit" value="Submit"/> </form> |
|
- 增加实体类
package com.atguigu.springmvc.entities;
public class Address {
private String province; private String city;
//get/set
} | package com.atguigu.springmvc.entities;
public class User { private Integer id ; private String username; private String password;
private String email; private int age;
private Address address;
//get/set } |
- 执行结果：
如果中文有乱码，需要配置字符编码过滤器，且配置其他过滤器之前，
如（HiddenHttpMethodFilter），否则不起作用。（思考method=”get”请求的乱码问题怎么解决的）
<!-- 配置字符集 --> <filter> <filter-name>encodingFilter</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>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>encodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> |
10、使用Servlet原生API作为参数
- MVC 的 Handler 方法可以接受哪些 ServletAPI 类型的参数
- HttpServletRequest
- HttpServletResponse
- HttpSession
- java.security.Principal
- Locale
- InputStream
- OutputStream
- Reader
- Writer
- 源码参考：AnnotationMethodHandlerAdapter L866
@Override protected Object resolveStandardArgument(Class<?> parameterType, NativeWebRequest webRequest) throws Exception { HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class); HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
if (ServletRequest.class.isAssignableFrom(parameterType) || MultipartRequest.class.isAssignableFrom(parameterType)) { Object nativeRequest = webRequest.getNativeRequest(parameterType); if (nativeRequest == null) { throw new IllegalStateException( "Current request is not of type [" + parameterType.getName() + "]: " + request); } return nativeRequest; } else if (ServletResponse.class.isAssignableFrom(parameterType)) { this.responseArgumentUsed = true; Object nativeResponse = webRequest.getNativeResponse(parameterType); if (nativeResponse == null) { throw new IllegalStateException( "Current response is not of type [" + parameterType.getName() + "]: " + response); } return nativeResponse; } else if (HttpSession.class.isAssignableFrom(parameterType)) { return request.getSession(); } else if (Principal.class.isAssignableFrom(parameterType)) { return request.getUserPrincipal(); } else if (Locale.class.equals(parameterType)) { return RequestContextUtils.getLocale(request); } else if (InputStream.class.isAssignableFrom(parameterType)) { return request.getInputStream(); } else if (Reader.class.isAssignableFrom(parameterType)) { return request.getReader(); } else if (OutputStream.class.isAssignableFrom(parameterType)) { this.responseArgumentUsed = true; eturn response.getOutputStream(); } else if (Writer.class.isAssignableFrom(parameterType)) { this.responseArgumentUsed = true; return response.getWriter(); } return super.resolveStandardArgument(parameterType, webRequest); } |
11、实验代码
/** * 可以使用 Serlvet 原生的 API 作为目标方法的参数 具体支持以下类型 * * HttpServletRequest * HttpServletResponse * HttpSession * java.security.Principal * Locale InputStream * OutputStream * Reader * Writer * @throws IOException */ @RequestMapping("/testServletAPI") public void testServletAPI(HttpServletRequest request,HttpServletResponse response, Writer out) throws IOException { System.out.println("testServletAPI, " + request + ", " + response); out.write("hello springmvc"); //return "success"; } |
<!-- 测试 Servlet API 作为处理请求参数 --> <a href="springmvc/testServletAPI">testServletAPI</a> |
四、响应数据传出
1、SpringMVC 输出模型数据概述
提供了以下几种途径输出模型数据：
- ModelAndView: 处理方法返回值类型为 ModelAndView 时, 方法体即可通过该对象添加模型数据
- Map 及 Model: 入参为 org.springframework.ui.Model、
org.springframework.ui.ModelMap 或 java.uti.Map 时，处理方法返回时，Map 中的数据会自动添加到模型中。
- @SessionAttributes: 将模型中的某个属性暂存到 HttpSession 中，以便多个请求之间可以共享这个属性
- @ModelAttribute: 方法入参标注该注解后, 入参的对象就会放到数据模型中
处理模型数据之 ModelAndView
- 控制器处理方法的返回值如果为 ModelAndView, 则其既包含视图信息，也包含模型数据信息。
- 添加模型数据:
MoelAndView addObject(String attributeName, Object attributeValue)
ModelAndView addAllObject(Map<String, ?> modelMap)
设置视图:
void setView(View view)
void setViewName(String viewName)
2、实验代码
- 增加控制器方法
/** * 目标方法的返回类型可以是ModelAndView类型 * 其中包含视图信息和模型数据信息 */ @RequestMapping("/testModelAndView") public ModelAndView testModelAndView(){ System.out.println("testModelAndView"); String viewName = "success"; ModelAndView mv = new ModelAndView(viewName ); mv.addObject("time",new Date().toString()); //实质上存放到request域中 return mv; } |
- 增加页面链接
<!--测试 ModelAndView 作为处理返回结果 --> <a href="springmvc/testModelAndView">testModelAndView</a> |
- 增加成功页面，显示数据
time: ${requestScope.time } |
- 断点调试
4、源码参考
| |
|
|
|
|
|
|
|
|
|
|
5、处理模型数据之 Map
- Spring MVC 在内部使用了一个 org.springframework.ui.Model 接口存储模型数据
具体使用步骤
- Spring MVC 在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。
- 如果方法的入参为 Map 或 Model 类型，Spring MVC 会将隐含模型的引用传递给这些入参。
- 在方法体内，开发者可以通过这个入参对象访问到模型中的所有数据，也可以向模型中添加新的属性数据
6、实验代码
- 增加控制器方法
//目标方法的返回类型也可以是一个Map类型参数（也可以是Model,或ModelMap类型） @RequestMapping("/testMap") public String testMap(Map<String,Object> map){ //【重点】 System.out.println(map.getClass().getName()); //org.springframework.validation.support.BindingAwareModelMap map.put("names", Arrays.asList("Tom","Jerry","Kite")); return "success"; } |
- 增加页面链接
<!-- 测试 Map 作为处理返回结果 --> <a href="springmvc/testMap">testMap</a> |
- 增加成功页面，显示结果
names: ${requestScope.names } |
- 显示结果截图
|
- 注意问题：Map集合的泛型，key为String,Value为Object,而不是String
- 测试参数类型
//目标方法的返回类型也可以是一个Map类型参数（也可以是Model,或ModelMap类型） @RequestMapping("/testMap2") public String testMap2(Map<String,Object> map,Model model,ModelMap modelMap){ System.out.println(map.getClass().getName()); map.put("names", Arrays.asList("Tom","Jerry","Kite")); model.addAttribute("model", "org.springframework.ui.Model"); modelMap.put("modelMap", "org.springframework.ui.ModelMap");
System.out.println(map == model); System.out.println(map == modelMap); System.out.println(model == modelMap);
System.out.println(map.getClass().getName()); System.out.println(model.getClass().getName()); System.out.println(modelMap.getClass().getName());
/* true true true org.springframework.validation.support.BindingAwareModelMap org.springframework.validation.support.BindingAwareModelMap org.springframework.validation.support.BindingAwareModelMap */ return "success"; } |
- 类层次结构
- 推荐：Map, 便于框架移植。
- 源码参考
public class BindingAwareModelMap extends ExtendedModelMap {
@Override public Object put(String key, Object value) { removeBindingResultIfNecessary(key, value); return super.put(key, value); }
@Override public void putAll(Map<? extends String, ?> map) { for (Map.Entry<? extends String, ?> entry : map.entrySet()) { removeBindingResultIfNecessary(entry.getKey(), entry.getValue()); } super.putAll(map); }
private void removeBindingResultIfNecessary(Object key, Object value) { if (key instanceof String) { String attributeName = (String) key; if (!attributeName.startsWith(BindingResult.MODEL_KEY_PREFIX)) { String bindingResultKey = BindingResult.MODEL_KEY_PREFIX + attributeName; BindingResult bindingResult = (BindingResult) get(bindingResultKey); if (bindingResult != null && bindingResult.getTarget() != value) { remove(bindingResultKey); } } } } } |
7、处理模型数据之 SessionAttributes 注解
- 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个 @SessionAttributes, Spring MVC 将在模型中对应的属性暂存到 HttpSession 中。
- @SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外，还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中
例如：
- @SessionAttributes(types=User.class) 会将隐含模型中所有类型为 User.class 的属性添加到会话中。
- @SessionAttributes(value={“user1”, “user2”})
- @SessionAttributes(types={User.class, Dept.class})
- @SessionAttributes(value={“user1”, “user2”}, types={Dept.class})
8、@SessionAttributes 源码
package org.springframework.web.bind.annotation;
import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;
@Target({ElementType.TYPE}) //说明这个注解只能应用在类型上面 @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface SessionAttributes { String[] value() default {}; //推荐使用 Class<?>[] types() default {}; //范围太广 } |
9、实验代码
@Controller //@SessionAttributes("user") @SessionAttributes(value={"user"},types={String.class}) public class SpringMVCController { /** * @SessionAttributes * 除了可以通过属性名指定需要放到会话中的属性外(实际上是通过value指定key值)， * 还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中(实际上是通过types指定类型) * 注意：只能放在类的上面，不能修饰方法 */ @RequestMapping("/testSessionAttributes") public String testSessionAttributes(Map<String,Object> map){ User user = new User("Tom","123","tom@atguigu.com",22); map.put("user", user); map.put("school", "atguigu"); //默认是被存放到request 域，如果设置了@SessionAttribute注解，就同时存放到session域中 return "success"; } } |
<!--测试 @SessionAttribute 将数据存放到session域中 --> <a href="testSessionAttributes">testSessionAttributes</a> |
request user : ${requestScope.user } <br><br> session user : ${sessionScope.user } <br><br> request school : ${requestScope.school } <br><br> session school : ${sessionScope.school } <br><br> |
五、@ModelAttribute注解
1、@ModelAttribute注解之使用场景
2、@ModelAttribute注解之示例代码
- 在方法定义上使用 @ModelAttribute 注解：Spring MVC 在调用目标处理方法前，会先逐个调用在方法级上标注了 @ModelAttribute 的方法。
- 在方法的入参前使用 @ModelAttribute 注解：可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数绑定到对象中，再传入入参
- 将方法入参对象添加到模型中
- 页面表单
<!--测试 @ModelAttribute 类似Struts2框架的模型驱动 --> <!-- 模拟修改操作： 1.原始数据为：1,Tom,123456,tom@atguigu.com,12 2.密码不需要修改 3.表单回显，模拟操作直接在表单value属性上赋值 --> <form action="springmvc/testModelAttribute" method="POST"> <input type="hidden" name="id" value="1"><br> username: <input type="text" name="username" value="Tom"/><br> email: <input type="text" name="email" value="tom@atguigu.com"/><br> age: <input type="text" name="age" value="12"/><br> <input type="submit" value="Submit"/> </form> |
- 增加@ModelAttribute注解
//1. 由 @ModelAttribute 标记的方法, 会在每个目标方法执行之前被 SpringMVC 调用! @RequestMapping("/testModelAttribute") public String testModelAttribute(User user){ System.out.println("user="+user); return "success"; }
@ModelAttribute public void getUser(@RequestParam(value="id",required=false) Integer id,Map<String,Object> map){ if(id!=null){ //模拟从数据库中获取到的user对象 User user = new User(1,"Tom","123456","tom@atguigu.com",12); System.out.println("从数据库中查询的对象：user="+user ); map.put("user", user); } } |
- 测试
- 异常
//org.springframework.web.HttpSessionRequiredException: Session attribute 'user' required - not found in session
//出现这个异常，是@SessionAttributes(value={"user"},types={String.class})导致的，去掉类上的这个注解
3、@ModelAttribute源码参考
@Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface ModelAttribute { /** * The name of the model attribute to bind to. * <p>The default model attribute name is inferred from the declared * attribute type (i.e. the method parameter type or method return type), * based on the non-qualified class name: * e.g. "orderAddress" for class "mypackage.OrderAddress", * or "orderAddressList" for "List<mypackage.OrderAddress>". */ String value() default ""; } |
4、@ModelAttribute注解之运行原理★
- 运行原理：
- 执行@ModelAttribute注解所修饰的方法，将从数据库中获取的对象存放到Map集合中，key为user
- SpringMVC从Map集合中获取 user对象，将表单数据封装到与参数名称对应的user对象属性上
- SpringMVC将user对象作为参数，传递给目标方法。
- 注意：@ModelAttribute 注解修饰的方法中，放入到Map集合中的key值，应该和目标方法参数类型的类名称首字母小写一致。
5、@ModelAttribute注解之源码分析★
- 源代码分析的流程
- 调用 @ModelAttribute 注解修饰的方法. 实际上把 @ModelAttribute 方法中 Map 中的数据放在了 implicitModel 中.
- 解析请求处理器的目标参数, 实际上该目标参数来自于 WebDataBinder 对象的 target 属性
1). 创建 WebDataBinder 对象:
【1】确定 objectName 属性: 若传入的 attrName 属性值为 "", 则 objectName 为类名第一个字母小写.
*注意: attrName. 若目标方法的 POJO 属性使用了 @ModelAttribute 来修饰, 则 attrName 值即为 @ModelAttribute 的 value 属性值
【2】确定 target 属性:
> 在 implicitModel 中查找 attrName 对应的属性值. 若存在, ok
> *若不存在: 则验证当前 Handler 是否使用了 @SessionAttributes 进行修饰, 若使用了, 则尝试从 Session 中获取 attrName 所对应的属性值.
若 session 中没有对应的属性值, 则抛出了异常.
> 若 Handler 没有使用 @SessionAttributes 进行修饰, 或 @SessionAttributes 中没有使用 value 值指定的 key和 attrName 相匹配, 则通过反射创建了 POJO 对象
2). SpringMVC 把表单的请求参数赋给了 WebDataBinder 的 target 对应的属性.
3). *SpringMVC 会把 WebDataBinder 的 attrName 和 target 给到 implicitModel. 进而传到 request 域对象中.
4). 把 WebDataBinder 的 target 作为参数传递给目标方法的入参.
6、SpringMVC 确定目标方法 POJO 类型入参的过程
- 确定一个 key:
1). 若目标方法的 POJO 类型的参数木有使用 @ModelAttribute 作为修饰, 则 key 为 POJO 类名第一个字母的小写
2). 若使用了@ModelAttribute 来修饰, 则 key 为 @ModelAttribute 注解的 value 属性值.
- 在 implicitModel 中查找 key 对应的对象, 若存在, 则作为入参传入
1). 若在 @ModelAttribute 标记的方法中在 Map 中保存过, 且 key 和 ① 确定的 key 一致, 则会获取到.
- 若 implicitModel 中不存在 key 对应的对象, 则检查当前的 Handler 是否使用 @SessionAttributes 注解修饰,
- 若使用了该注解, 且 @SessionAttributes 注解的 value 属性值中包含了 key, 则会从 HttpSession 中来获取 key 所对应的 value 值, 若存在则直接传入到目标方法的入参中. 若不存在则将抛出异常.
- 若 Handler 没有标识 @SessionAttributes 注解或 @SessionAttributes 注解的 value 值中不包含 key, 则会通过反射来创建 POJO 类型的参数, 传入为目标方法的参数
- SpringMVC 会把 key 和 POJO 类型的对象保存到 implicitModel 中, 进而会保存到 request 中.
7、@ModelAttribute注解修饰POJO类型的入参
@RequestMapping("/testModelAttribute") //public String testModelAttribute(User user){
public String testModelAttribute(@ModelAttribute("abc")User user){
System.out.println("修改 user="+user); return "success"; }
/** * @ModelAttribute 注解也可以来修饰目标方法 POJO 类型的入参, 其 value 属性值有如下的作用: 1). SpringMVC 会使用 value 属性值在 implicitModel 中查找对应的对象, 若存在则会直接传入到目标方法的入参中. 2). SpringMVC 会以 value 为 key, POJO 类型的对象为 value, 存入到 request 中. */ @ModelAttribute public void getUser(@RequestParam(value="id",required=false) Integer id,Map<String,Object> map){ if(id!=null){ //模拟从数据库中获取到的user对象 User user = new User(1,"Tom","123456","tom@atguigu.com",12); System.out.println("从数据库中查询的对象：user="+user ); //map.put("user", user); //BindingAwareModelMap
//map.put("abc", user); //BindingAwareModelMap } } |
user user: ${requestScope.user } <br><br> abc user: ${requestScope.abc } <br><br> |
8、@sessionAttributes注解引发的异常
- 由@SessionAttributes引发的异常
- 如果在处理类定义处标注了@SessionAttributes(“xxx”)，则尝试从会话中获取该属性，并将其赋给该入参，然后再用请求消息填充该入参对象。如果在会话中找不到对应的属性，则抛出 HttpSessionRequiredException 异常
七、视图解析
1、SpringMVC如何解析视图概述
- 不论控制器返回一个String,ModelAndView,View都会转换为ModelAndView对象，由视图解析器解析视图，然后，进行页面的跳转。
- 视图解析源码分析：重要的两个接口
- 断点调试源码
- 流程图
2、视图和视图解析器
- 请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 ModelAndView 对象，它包含了逻辑名和模型对象的视图
- Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是 Excel、JFreeChart等各种表现形式的视图
- 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦
3、视图
- 视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。
- 为了实现视图模型和具体实现技术的解耦，Spring 在 org.springframework.web.servlet 包中定义了一个高度抽象的 View 接口：
- 视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题
4、常用的视图实现类
5、视图解析器
- SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB 上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
- 视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。
- 所有的视图解析器都必须实现 ViewResolver 接口：
6、常用的视图解析器实现类
- 程序员可以选择一种视图解析器或混用多种视图解析器
- 每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order 越小优先级越高。
- SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则将抛出 ServletException 异常
- InternalResourceViewResolver
- JSP 是最常见的视图技术，可以使用 InternalResourceViewResolve作为视图解析器：
7、JstlView
- 若项目中使用了JSTL，则SpringMVC 会自动把视图由InternalResourceView转为 JstlView （断点调试，将JSTL的jar包增加到项目中，视图解析器会自动修改为JstlView）
- 若使用 JSTL 的 fmt 标签则需要在 SpringMVC 的配置文件中配置国际化资源文件
- 若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:view-controller 标签实现
8、实验代码
i18n.properties | i18n_en_US.properties | i18n_zh_CN.properties |
i18n.username=username i18n.password=password | i18n.username=Username i18n.password=Password | i18n.username=\u7528\u6237\u540D i18n.password=\u5BC6\u7801 |
①增加jstl标签 jar包（断点调试，这时的View对象就是JstlView）
②设置国际化资源文件
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basename" value="i18n"></property> </bean> |
③控制器代码
package com.atguigu.springmvc.controller;
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping;
@Controller @RequestMapping("springmvc") public class SpringMVCController { @RequestMapping("/testViewAndViewResolver") public String testViewAndViewResolver(){ System.out.println("testViewAndViewResolver"); return "success"; } } |
④成功页面(/WEB-INF/views/success.jsp)使用fmt标签库
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h4>Sucess Page</h4> <br><br> <fmt:message key="i18n.username"/>
<br><br> <fmt:message key="i18n.password"/>
</body> </html> |
9、mvc:view-controller标签
- 若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:view-controller 标签实现
<!-- 直接配置响应的页面：无需经过控制器来执行结果 --> <mvc:view-controller path="/success" view-name="success"/> |
- 请求的路径：
http://localhost:8080/SpringMVC_02_View/success |
- 配置<mvc:view-controller>会导致其他请求路径失效
- 解决办法：
<!-- 在实际开发过程中都需要配置mvc:annotation-driven标签和<mvc:default-servlet-handler/>标签，后面讲，这里先配置上 --> <mvc:default-servlet-handler/> <mvc:annotation-driven/> |
10、自定义视图
- 自定义视图（需要加入SpringMVC，那么，一定需要实现框架的接口）
- 若希望使用 Excel 展示数据列表，仅需要扩展 SpringMVC 提供的 AbstractExcelView 或 AbstractJExcelView 即可。
- 实现 buildExcelDocument() 方法，在方法中使用模型数据对象构建 Excel 文档就可以了。
- AbstractExcelView 基于 POI API，而 AbstractJExcelView 是基于 JExcelAPI 的。
- 视图对象需要配置 IOC 容器中的一个 Bean，使用 BeanNameViewResolver 作为视图解析器即可
- 若希望直接在浏览器中直接下载 Excel 文档，则可以设置响应头 Content-Disposition 的值为 attachment;filename=xxx.xls
11、实验代码
- 页面链接
<a href="springmvc/testView">testView</a> |
- 控制器方法
@RequestMapping("/testView") public String testView(){ System.out.println("testView..."); return "helloView"; //与视图Bean 对象的id一致 } |
- 自定义视图
package com.atguigu.springmvc.view;
import java.util.Date; import java.util.Map;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component; import org.springframework.web.servlet.View;
@Component public class HelloView implements View {
@Override public String getContentType() { return "text/html"; }
@Override public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception { response.getWriter().println("HelloView - time = " + new Date()); } } |
- 声明视图解析器
<!-- 配置视图解析器：按照bean的名称查找视图 --> <bean class="org.springframework.web.servlet.view.BeanNameViewResolver"> <property name="order" value="100"></property> </bean> |
InternalResourceViewResolver默认的优先级：private int order = Integer.MAX_VALUE;
12、源码参考
public class BeanNameViewResolver extends WebApplicationObjectSupport implements ViewResolver, Ordered {
private int order = Integer.MAX_VALUE; // default: same as non-Ordered
public void setOrder(int order) { this.order = order; }
@Override public int getOrder() { return order; }
@Override public View resolveViewName(String viewName, Locale locale) throws BeansException { ApplicationContext context = getApplicationContext(); if (!context.containsBean(viewName)) { //说明视图组件必须增加到Spring的IOC 容器中，所以需要@Component // Allow for ViewResolver chaining. return null; } return context.getBean(viewName, View.class); } } |
13、重定向
- 关于重定向
- 一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理
- 如果返回的字符串中带 forward: 或 redirect: 前缀时，SpringMVC 会对他们进行特殊处理：将 forward: 和 redirect: 当成指示符，其后的字符串作为 URL 来处理
- redirect:success.jsp：会完成一个到 success.jsp 的重定向的操作
- forward:success.jsp：会完成一个到 success.jsp 的转发操作
- 定义页面链接
<a href="springmvc/testRedirect">testRedirect</a> |
- 定义控制器方法
@RequestMapping("/testRedirect") public String testRedirect(){ System.out.println("testRedirect"); return "redirect:/index.jsp"; //return "forward:/index.jsp"; } |
- 源码分析：重定向原理
- 源码分析：重定向原理
- return "forward:/index.jsp"
