java学习笔记——springmvc 之 @RequestMapping映射与RESTful、请求数据传入 与 响应数据传出、@ModelAttribute 与 视图解析

一 SpringMVC 概述

1、SpringMVC 概述

• Spring 为展现层提供的基于 MVC 设计理念的优秀的 Web 框架，是目前最主流的 MVC 框架之一。
• Spring3.0 后全面超越 Struts2，成为最优秀的 MVC 框架。
• Spring MVC 通过一套 MVC 注解，让 POJO 成为处理请求的控制器，而无须实现任何接口。
• 支持 REST 风格的 URL 请求。
• 采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性。

2、是什么

• 一种轻量级的、基于MVC的Web层应用框架。偏前端而不是基于业务逻辑层。
• 是Spring框架的一个后续产品。

1. Spring框架结构图(新版本)：

1. Spring框架结构图(老版本)：

 

3、能干什么

1. 天生与Spring框架集成，如：(IOC,AOP)
2. 支持Restful风格
3. 进行更简洁的Web层开发
4. 支持灵活的URL到页面控制器的映射
5. 非常容易与其他视图技术集成，如:Velocity、FreeMarker等等。
6. 因为模型数据不存放在特定的API里，而是放在一个Model里(Map数据结构实现，因此很容易被其他框架使用)
7. 非常灵活的数据验证、格式化和数据绑定机制、能使用任何对象进行数据绑定，不必实现特定框架的API
8. 更加简单、强大的异常处理
9. 对静态资源的支持
10. 支持灵活的本地化、主题等解析

 

4、去哪下

1. 基于Spring框架，多了个web的jar包

   

 

 

5、怎么玩

1. 将Web层进行了职责解耦，也就和struts2一样，基于请求-响应模型
2. 常用主要组件
   1. 1. DispatcherServlet：前端控制器
      2. Controller：处理器/页面控制器，做的是MVC中的C的事情，但控制逻辑转移到前端控制器了，用于对请求进行处理
      3. HandlerMapping ：请求映射到处理器，找谁来处理，如果映射成功返回一个HandlerExecutiongChain对象（包含一个Handler处理器(页面控制器)对象、多个HandlerInterceptor拦截器对象）
      4. ViewResolver : 视图解析器，找谁来处理返回的页面。把逻辑视图解析为具体的View,进行这种策略模式，很容易更换其他视图技术；
         1. 1. 如InternalResourceViewResolver将逻辑视图名映射为JSP视图
      5. LocalResolver：本地化、国际化
      6. MultipartResolver：文件上传解析器
      7. 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
• 

springDispatcherServlet org.springframework.web.servlet.DispatcherServlet contextConfigLocation classpath:springmvc.xml 1 springDispatcherServlet /

解释配置文件的名称定义规则:

实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.默认的配置文件为: /WEB-INF/-servlet.xml

• 加入 Spring MVC 的配置文件：springmvc.xml
• 增加名称空间

增加配置

class="org.springframework.web.servlet.view.InternalResourceViewResolver">

• 需要创建一个入口页面，index.jsp

Hello World

• 编写处理请求的处理器，并标识为处理器

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

Sucess Page

• 部署测试：

http://localhost:8080/SpringMVC_01_HelloWorld/index.jsp

 

 

7、HelloWorld深度解析

 

1. 开发中大家需要注意的问题，总结如下：

• 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,走起…

1. 流程图分析

1. 基本步骤：

1. 客户端请求提交到DispatcherServlet
2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller
3. DispatcherServlet将请求提交到Controller（也称为Handler）
4. Controller调用业务逻辑处理后，返回ModelAndView
5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图

视图负责将结果显示到客户端

 

 

 

二、 @RequestMapping映射 

1. @RequestMapping 映射请求注解
   1. SpringMVC使用@RequestMapping注解为控制器指定可以处理哪些 URL 请求
   2. 在控制器的类定义及方法定义处都可标注 @RequestMapping
      1. 标记在类上：提供初步的请求映射信息。相对于  WEB 应用的根目录
      2. 标记在方法上：提供进一步的细分映射信息。相对于标记在类上的 URL。
   3. 若类上未标注 @RequestMapping，则方法处标记的 URL 相对于 WEB 应用的根目录

作用：DispatcherServlet 截获请求后，就通过控制器上 @RequestMapping 提供的映射信息确定请求所对应的处理方法。 

2、实验代码

1. 定义页面链接、控制器方法

test @RequestMapping

 

@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方式请求

testMethord

 

1. 发生请求错误

• 以POST方式请求

 

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

testParamsAndHeaders

• 测试:使用火狐或Chrom浏览器debug测试

1. 测试有参数情况(不正确)：

1. testParamsAndHeaders

四月 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]]

1. testParamsAndHeaders

四月 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['atguigu'], 'age' -> array['10']]

1. testParamsAndHeaders

四月 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['11']]

1. 测试有参数情况(正确)：

testParamsAndHeaders 

 

6、RequestMapping支持Ant 路径风格

1. Ant 风格资源地址支持 3 种匹配符：【了解】

?：匹配文件名中的一个字符

*：匹配文件名中的任意字符

**：** 匹配多层路径

1. @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"; }

• 页面链接

testAntPath testAntPath testAntPath

 

 

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"; }

• 请求链接

testPathVariable

 

 

 

三、 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过滤器

HiddenHttpMethodFilter org.springframework.web.filter.HiddenHttpMethodFilter HiddenHttpMethodFilter /*

• 代码

/**  * 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"; }

• 请求链接

testREST GET     hidden" name="_method" value="PUT">   hidden" name="_method" value="DELETE"> </fieldset>

 

3、HiddenHttpMethodFilter过滤器源码分析

1. 为什么请求隐含参数名称必须叫做”_method”

 

 

四、请求数据传入 

1、请求处理方法签名

 2、@RequestParam注解

 

 3、实验代码

1. Spring MVC 通过分析处理方法的签名，HTTP请求信息绑定到处理方法的相应人参中。
2. Spring MVC 对控制器处理方法签名的限制是很宽松的，几乎可以按喜欢的任何方式对方法进行签名。
3. 必要时可以对方法及方法入参标注相应的注解（ @PathVariable 、@RequestParam、@RequestHeader 等）、
4. Spring MVC 框架会将 HTTP 请求的信息绑定到相应的方法入参中，并根据方法的返回值类型做出相应的后续处理。
5. 在处理方法入参处使用 @RequestParam 可以把请求参数传递给请求方法
6. value：参数名
7. required：是否必须。默认为 true, 表示请求参数中必须包含对应的参数，若不存在，将抛出异常
8. defaultValue: 默认值，当没有传递参数时使用该值
9. 增加控制器方法

/**  * @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"; }

• 增加页面链接

?username=atguigu&age=10">testRequestParam

 4、@RequestHeader 注解

 

 

 5、实验代码

1. 使用 @RequestHeader 绑定请求报头的属性值
2. 请求头包含了若干个属性，服务器可据此获知客户端的信息，通过 @RequestHeader 即可将请求头中的属性值绑定到处理方法的入参中 

//了解: 映射请求头信息 用法同 @RequestParam @RequestMapping(value="/testRequestHeader") public String testRequestHeader(@RequestHeader(value="Accept-Language") String al){ System.out.println("testRequestHeader - Accept-Language："+al); return "success"; }

testRequestHeader

 6、@CookieValue 注解

 

7、实验代码

 

1. 使用 @CookieValue 绑定请求中的 Cookie 值
2. @CookieValue 可让处理方法入参绑定某个 Cookie 值
3. 增加控制器方法

//了解:@CookieValue: 映射一个 Cookie 值. 属性同 @RequestParam @RequestMapping("/testCookieValue") public String testCookieValue(@CookieValue("JSESSIONID") String sessionId) { System.out.println("testCookieValue: sessionId: " + sessionId); return "success"; }

增加页面链接

testCookieValue

 

 8、使用POJO作为参数

 

 9、实验代码

1. 使用 POJO 对象绑定请求参数值
2. Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配，自动为该对象填充属性值。支持级联属性。如：dept.deptId、dept.address.tel 等
3. 增加控制器方法、表单页面

/**  * Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配， 自动为该对象填充属性值。  * 支持级联属性  *                 如：dept.deptId、dept.address.tel 等  */ @RequestMapping("/testPOJO") public String testPojo(User user) { System.out.println("testPojo: " + user); return "success"; }

 

username: password: email: age: city: province:

• 增加实体类

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>encodingFilterfilter-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>forceEncodingparam-name>                             <param-value>trueparam-value>                    init-param>          filter>          <filter-mapping>                    <filter-name>encodingFilterfilter-name>                    <url-pattern>/*url-pattern>          filter-mapping>

 

10、使用Servlet原生API作为参数

1. MVC 的 Handler 方法可以接受哪些 ServletAPI 类型的参数

1. HttpServletRequest
2. HttpServletResponse
3. HttpSession
4. java.security.Principal
5. Locale
6. InputStream
7. OutputStream
8. Reader
9. Writer

1. 源码参考：AnnotationMethodHandlerAdapter L866
2. 

@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"; }

 

testServletAPI

 

 

 

四、响应数据传出 

1、SpringMVC 输出模型数据概述

提供了以下几种途径输出模型数据：

1. ModelAndView: 处理方法返回值类型为 ModelAndView 时, 方法体即可通过该对象添加模型数据
2. Map 及 Model: 入参为 org.springframework.ui.Model、

org.springframework.ui.ModelMap 或 java.uti.Map 时，处理方法返回时，Map 中的数据会自动添加到模型中。

1. @SessionAttributes: 将模型中的某个属性暂存到 HttpSession 中，以便多个请求之间可以共享这个属性
2. @ModelAttribute: 方法入参标注该注解后, 入参的对象就会放到数据模型中

 

1. 处理模型数据之 ModelAndView

   • 控制器处理方法的返回值如果为 ModelAndView, 则其既包含视图信息，也包含模型数据信息。
   • 添加模型数据:

MoelAndView addObject(String attributeName, Object attributeValue)

ModelAndView addAllObject(Map 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; }

• 增加页面链接

testModelAndView

• 增加成功页面，显示数据

time: ${requestScope.time }

• 断点调试

 

4、源码参考

 

5、处理模型数据之 Map

1. Spring MVC 在内部使用了一个 org.springframework.ui.Model 接口存储模型数据

具体使用步骤

1. Spring MVC 在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。
2. 如果方法的入参为 Map 或 Model 类型，Spring MVC 会将隐含模型的引用传递给这些入参。
3. 在方法体内，开发者可以通过这个入参对象访问到模型中的所有数据，也可以向模型中添加新的属性数据

 

 

6、实验代码

• 增加控制器方法

//目标方法的返回类型也可以是一个Map类型参数（也可以是Model,或ModelMap类型） @RequestMapping("/testMap") public String testMap(Map map){ //【重点】 System.out.println(map.getClass().getName()); //org.springframework.validation.support.BindingAwareModelMap map.put("names", Arrays.asList("Tom","Jerry","Kite")); return "success"; }

• 增加页面链接

testMap

• 增加成功页面，显示结果

names: ${requestScope.names }

• 显示结果截图

• 注意问题：Map集合的泛型，key为String,Value为Object,而不是String  
• 测试参数类型

//目标方法的返回类型也可以是一个Map类型参数（也可以是Model,或ModelMap类型） @RequestMapping("/testMap2") public String testMap2(Map 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 map) { for (Map.Entry 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 注解

1. 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个 @SessionAttributes, Spring MVC 将在模型中对应的属性暂存到 HttpSession 中。
2. @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 map){ User user = new User("Tom","123","[email protected]",22);                 map.put("user", user); map.put("school", "atguigu");  //默认是被存放到request 域，如果设置了@SessionAttribute注解，就同时存放到session域中 return "success"; } }

 

testSessionAttributes

 

request user : ${requestScope.user } session user : ${sessionScope.user } request school : ${requestScope.school } session school : ${sessionScope.school }

 

 

五、@ModelAttribute注解 

1、@ModelAttribute注解之使用场景

 

 

2、@ModelAttribute注解之示例代码

1. 在方法定义上使用 @ModelAttribute 注解：Spring MVC 在调用目标处理方法前，会先逐个调用在方法级上标注了 @ModelAttribute 的方法。
2. 在方法的入参前使用 @ModelAttribute 注解：可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数绑定到对象中，再传入入参
3. 将方法入参对象添加到模型中

• 页面表单

username: email: age:

• 增加@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 map){ if(id!=null){         //模拟从数据库中获取到的user对象 User user = new User(1,"Tom","123456","[email protected]",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.  * 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注解之运行原理★

1. 运行原理：

• 执行@ModelAttribute注解所修饰的方法，将从数据库中获取的对象存放到Map集合中，key为user
• SpringMVC从Map集合中获取 user对象，将表单数据封装到与参数名称对应的user对象属性上
• SpringMVC将user对象作为参数，传递给目标方法。
• 注意：@ModelAttribute 注解修饰的方法中，放入到Map集合中的key值，应该和目标方法参数类型的类名称首字母小写一致。

 

5、@ModelAttribute注解之源码分析★

1. 源代码分析的流程

• 调用 @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 map){ if(id!=null){         //模拟从数据库中获取到的user对象 User user = new User(1,"Tom","123456","[email protected]",12); System.out.println("从数据库中查询的对象：user="+user ); //map.put("user", user); //BindingAwareModelMap   //map.put("abc", user); //BindingAwareModelMap } }

 

user user: ${requestScope.user }    abc user: ${requestScope.abc }

 

8、@sessionAttributes注解引发的异常

• 由@SessionAttributes引发的异常

• 如果在处理类定义处标注了@SessionAttributes(“xxx”)，则尝试从会话中获取该属性，并将其赋给该入参，然后再用请求消息填充该入参对象。如果在会话中找不到对应的属性，则抛出 HttpSessionRequiredException 异常

 

 

 

七、视图解析 

1、SpringMVC如何解析视图概述

• 不论控制器返回一个String,ModelAndView,View都会转换为ModelAndView对象，由视图解析器解析视图，然后，进行页面的跳转。  

• 视图解析源码分析：重要的两个接口

• 断点调试源码

• 流程图

 

2、视图和视图解析器

1. 请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 ModelAndView 对象，它包含了逻辑名和模型对象的视图
2. Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是 Excel、JFreeChart等各种表现形式的视图
3. 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦

 

3、视图

1. 视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。
2. 为了实现视图模型和具体实现技术的解耦，Spring 在 org.springframework.web.servlet 包中定义了一个高度抽象的 View 接口：
3. 
4. 视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题

 

4、常用的视图实现类

 

5、视图解析器

1. SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB 上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
2. 视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。
3. 所有的视图解析器都必须实现 ViewResolver 接口：
4. 

 

6、常用的视图解析器实现类

1. 程序员可以选择一种视图解析器或混用多种视图解析器
2. 每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order  越小优先级越高。
3. SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则将抛出 ServletException 异常
4. InternalResourceViewResolver
   1. JSP 是最常见的视图技术，可以使用 InternalResourceViewResolve作为视图解析器：
   2. 

 

7、JstlView

1. 若项目中使用了JSTL，则SpringMVC 会自动把视图由InternalResourceView转为 JstlView  （断点调试，将JSTL的jar包增加到项目中，视图解析器会自动修改为JstlView）
2. 若使用 JSTL 的 fmt 标签则需要在 SpringMVC 的配置文件中配置国际化资源文件

1. 若希望直接响应通过 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）

②设置国际化资源文件

messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

③控制器代码

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" %> Sucess Page

 

9、mvc:view-controller标签

1. 若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:view-controller 标签实现

1. 请求的路径：

http://localhost:8080/SpringMVC_02_View/success

1. 配置会导致其他请求路径失效
2. 解决办法：

 

10、自定义视图

1. 自定义视图（需要加入SpringMVC，那么，一定需要实现框架的接口）
2. 若希望使用 Excel 展示数据列表，仅需要扩展 SpringMVC 提供的 AbstractExcelView 或 AbstractJExcelView 即可。
3. 实现 buildExcelDocument() 方法，在方法中使用模型数据对象构建 Excel 文档就可以了。
4. AbstractExcelView 基于 POI API，而 AbstractJExcelView 是基于 JExcelAPI 的。
5. 视图对象需要配置 IOC 容器中的一个 Bean，使用 BeanNameViewResolver 作为视图解析器即可
6. 若希望直接在浏览器中直接下载 Excel 文档，则可以设置响应头 Content-Disposition 的值为 attachment;filename=xxx.xls

 

11、实验代码

• 页面链接

testView

• 控制器方法

@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 model, HttpServletRequest request, HttpServletResponse response) throws Exception { response.getWriter().println("HelloView - time = " + new Date()); } }

• 声明视图解析器

100">

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、重定向

• 关于重定向

1. 一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理
2. 如果返回的字符串中带 forward: 或 redirect: 前缀时，SpringMVC 会对他们进行特殊处理：将 forward: 和 redirect: 当成指示符，其后的字符串作为 URL 来处理
3. redirect:success.jsp：会完成一个到 success.jsp 的重定向的操作
4. forward:success.jsp：会完成一个到 success.jsp 的转发操作

• 定义页面链接

testRedirect

• 定义控制器方法

@RequestMapping("/testRedirect") public String testRedirect(){ System.out.println("testRedirect"); return "redirect:/index.jsp"; //return "forward:/index.jsp"; }

• 源码分析：重定向原理

1. 源码分析：重定向原理

 

• return "forward:/index.jsp"