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. 非常容易与其他视图技术集成,如:VelocityFreeMarker等等。
  6. 因为模型数据不存放在特定的API里,而是放在一个Model(Map数据结构实现,因此很容易被其他框架使用)
  7. 非常灵活的数据验证、格式化和数据绑定机制、能使用任何对象进行数据绑定,不必实现特定框架的API
  8. 更加简单、强大的异常处理
  9. 对静态资源的支持
  10. 支持灵活的本地化、主题等解析

 

4、去哪下

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

   

 

 

5、怎么玩

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

<!-- 配置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深度解析

 

  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. 定义页面链接、控制器方法

<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>

 

  1. 发生请求错误

  • 以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测试
  1. 测试有参数情况(不正确):
  1. <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]]

  1. <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']]

  1. <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']]

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

<a href="springmvc/testParamsAndHeaders?username=atguigu&age=15">testParamsAndHeaders</a> 

 

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

}

  • 页面链接

<!-- 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过滤器源码分析

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

}

  • 增加页面链接

<!--测试 请求参数 @RequestParam 注解使用 -->

<a href="springmvc/testRequestParam?username=atguigu&age=10">testRequestParam</a>

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

}

<!-- 测试 请求头@RequestHeader 注解使用 -->

<a href="springmvc/testRequestHeader">testRequestHeader</a>

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

}

增加页面链接

<!--测试 请求Cookie @CookieValue 注解使用 -->

<a href="springmvc/testCookieValue">testCookieValue</a>

 

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

}

 

<!-- 测试 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作为参数

  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

@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 输出模型数据概述

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

  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<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

  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<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 注解

  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<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注解之示例代码

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

<!--测试 @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&lt;mypackage.OrderAddress&gt;".

 */

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<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、视图和视图解析器

  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、常用的视图实现类

 

5、视图解析器

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

 

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

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

 

7、JstlView

  1. 若项目中使用了JSTL,则SpringMVC 会自动把视图由InternalResourceView转为 JstlView  (断点调试,将JSTLjar包增加到项目中,视图解析器会自动修改为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

②设置国际化资源文件

<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标签

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

<!-- 直接配置响应的页面:无需经过控制器来执行结果 -->

<mvc:view-controller path="/success" view-name="success"/>

  1. 请求的路径:

http://localhost:8080/SpringMVC_02_View/success

  1. 配置<mvc:view-controller>会导致其他请求路径失效
  2. 解决办法:

<!-- 在实际开发过程中都需要配置mvc:annotation-driven标签和<mvc:default-servlet-handler/>标签,后面讲,这里先配置上 -->

<mvc:default-servlet-handler/>

<mvc:annotation-driven/>

 

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、实验代码

  • 页面链接

<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)) {

//说明视图组件必须增加到SpringIOC 容器中,所以需要@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 的转发操作
  • 定义页面链接

<a href="springmvc/testRedirect">testRedirect</a>

  • 定义控制器方法

@RequestMapping("/testRedirect")

public String testRedirect(){

System.out.println("testRedirect");

return "redirect:/index.jsp";

//return "forward:/index.jsp";

}

  • 源码分析:重定向原理
  1. 源码分析:重定向原理

 

  • return "forward:/index.jsp"

 

发布了65 篇原创文章 · 获赞 46 · 访问量 1万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览