SpringMVC学习笔记之一

1.Spring MVC的配置过程

注意：web.xml 的加载顺序是：context-param -> listener -> filter -> servlet
1.加入jar包
2.配置web.xml文件

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 id="WebApp_ID" version="2.5">
 
 <filter>
  <filter-name>HiddenHttpMethodFilterfilter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
 filter>
 <filter-mapping>
  <filter-name>HiddenHttpMethodFilterfilter-name>
  <url-pattern>/*url-pattern>
 filter-mapping>
 
 <servlet>
  <servlet-name>dispatcherServletservlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
  
   
  <init-param>
   <param-name>contextConfigLocationparam-name>
   <param-value>classpath:springmvc.xmlparam-value>
  init-param>
  <load-on-startup>1load-on-startup>
 servlet>
 <servlet-mapping>
  <servlet-name>dispatcherServletservlet-name>
  <url-pattern>/url-pattern>
 servlet-mapping>
web-app>

配置DispatcherServlet：DispatcherServlet默认加载/WEB-•INF/.xml 的Spring 配置文件, 启动WEB 层的Spring 容器。可以通过contextConfigLocation初始化参数自定义配置文件的位置和名称
在src的路径下配置文件springmvc.xml

 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
 
 <context:component-scan base-package="com.atguigu.springmvc">context:component-scan>
 
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/WEB-INF/views/">property>
  <property name="suffix" value=".jsp">property>
 bean> 
beans>

创建请求处理器类

 @RequestMapping("/testRequestMapping")
 public String testRequestMapping() {
  System.out.println("testRequestMapping");
  return SUCCESS;
 }

1.2ServletConfig和ServletContext的区别及应用

链接

2.使用@RequestMapping映射请求

Spring MVC 使用@RequestMapping注解为控制器指定可以处理哪些URL请求
@RequestMapping类定义处：提供初步的请求映射信息。相对于WEB 应用的根目录–方法处：提供进一步的细分映射信息。相对于类定义处的URL。若–类定义处未标注@RequestMapping，则方法处标记的URL 相对于WEB 应用的根目录
DispatcherServlet截获请求后，就通过控制器上•@RequestMapping提供的映射信息确定请求所对应的处理方法。

@RequestMapping("/springmvc")
@Controller
public class SpringMVCTest {
 private static final String SUCCESS = "success";
 @RequestMapping("/testRequestMapping")
 public String testRequestMapping() {
  System.out.println("testRequestMapping");
  return SUCCESS;
 }
}

@RequestMapping除了可以使用请求URL 映射请求外，还可以使用请求方法、请求参数及请求头映射请求
@RequestMapping的value、method、params及heads 分别表示请求URL、请求方法、请求参数及请求头的映射条件，他们之间是与的关系，联合使用多个条件可让请求映射更加精确化。

 @RequestMapping(value = "/testMethod", method = RequestMethod.POST)//只能是表单提交
 public String testMethod() {
  System.out.println("testMethod");
  return SUCCESS;
 }

params和headers支持简单的表达式：
param1: 表示请求必须包含名为param1 的请求参数
!param1: 表示请求不能包含名为param1 的请求参数
param1 != value1: 表示请求包含名为param1 的请求参数，但其值不能为value1
{“param1=value1”, “param2”}: 请求必须包含名为param1 和param2的两个请求参数，且param1 参数的值必须为value1

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

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

 @RequestMapping("/testAntPath/*/abc")
 public String testAntPath() {
  System.out.println("testAntPath");
  return SUCCESS;
 }

3.@PathVariable映射URL 绑定的占位符

带占位符的URL 是Spring3.0 新增的功能，该功能在SpringMVC向REST目标挺进发展过程中具有里程碑的意义。
通过@PathVariable可以将URL 中占位符参数绑定到控制器处理方法的入参中：URL 中的{xxx} 占位符可以通过@PathVariable(“xxx”) 绑定到操作方法的入参中。

@RequestMapping("/testPathVariable/{id}")
 public String testPathVariable(@PathVariable("id") Integer id) {
  System.out.println("testPathVariable: " + id);
  return SUCCESS;
 }

4.REST

HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。
REST：即Representational State Transfer。（资源）表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用
资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的URI。要获取这个资源，访问它的URI就可以，因此URI 即为每一个资源的独一无二的识别符。
表现层（Representation）：把资源具体呈现出来的形式，叫做它的表现层（Representation）。比如，文本可以用txt 格式表现，也可以用HTML 格式、XML 格式、JSON 格式表现，甚至可以采用二进制格式。
状态转化（State Transfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”（State Transfer）。而这种转化是建立在表现层之上的，所以就是“表现层状态转化”。
配置web.xml文件中配置HiddenHttpMethodFilter

 <filter>
  <filter-name>HiddenHttpMethodFilterfilter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
 filter>
 <filter-mapping>
  <filter-name>HiddenHttpMethodFilterfilter-name>
  <url-pattern>/*url-pattern>
 filter-mapping>

jsp请求页面,需要在发送POST请求中携带一个name="_method"的隐藏域，值为DELETE或PUT

 <form action="springmvc/testRest/1" method="post">
  <input type="hidden" name="_method" value="PUT"/>
  <input type="submit" value="TestRest PUT"/>
 form>
 <br><br>
 <form action="springmvc/testRest/1" method="post">
  <input type="hidden" name="_method" value="DELETE"/>
  <input type="submit" value="TestRest DELETE"/>
 form>
 <br><br>
 <form action="springmvc/testRest" method="post">
  <input type="submit" value="TestRest POST"/>
 form>
 <a href="springmvc/testRest/1">Test Rest Geta>

java中定义四个方法

  @RequestMapping(value = "/testRest/{id}", method = RequestMethod.PUT)
 public String testRestPut(@PathVariable Integer id) {
  System.out.println("testRest Put: " + id);
  return SUCCESS;
 }
 @RequestMapping(value = "/testRest/{id}", method = RequestMethod.DELETE)
 public String testRestDelete(@PathVariable Integer id) {
  System.out.println("testRest Delete: " + id);
  return SUCCESS;
 }
 @RequestMapping(value = "/testRest", method = RequestMethod.POST)
 public String testRest() {
  System.out.println("testRest POST");
  return SUCCESS;
 }
 @RequestMapping(value = "/testRest/{id}", method = RequestMethod.GET)
 public String testRest(@PathVariable Integer id) {
  System.out.println("testRest GET: " + id);
  return SUCCESS;
 }

5.请求处理方法签名

1.@RequestParam

@RequestMapping(value = "/testRequestParam")
 public String testRequestParam(
   @RequestParam(value = "username") String un,
   @RequestParam(value = "age", required = false, defaultValue = "0") int age) {
  System.out.println("testRequestParam, username: " + un + ", age: "
    + age);
  return SUCCESS;
 }

jsp中的配置

<a href="springmvc/testRequestParam?username=atguigu&age=11">Test RequestParama>

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

@RequestMapping("/testRequestHeader")
public String testRequestHeader(
  @RequestHeader(value = "Accept-Language") String al) {
 System.out.println("testRequestHeader, Accept-Language: " + al);
 return SUCCESS;
}

6.获取cookie值

使用@CookieValue绑定请求中的Cookie 值

@RequestMapping("/testCookieValue")
 public String testCookieValue(@CookieValue("JSESSIONID") String sessionId) {
  System.out.println("testCookieValue: sessionId: " + sessionId);
  return SUCCESS;
 }

7.使用POJO 对象绑定请求参数值

Spring MVC 会按请求参数名和POJO 属性名进行自动匹•配，自动为该对象填充属性值。支持级联属性。如：dept.deptId、dept.address.tel等

@RequestMapping("/testPojo")
public String testPojo(User user) {
 System.out.println("testPojo: " + user);
 return SUCCESS;
}
<form action="springmvc/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"/>
 <br>
 <input type="submit" value="Submit"/>
</form>

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

HttpServletRequest
HttpServletResponse
HttpSession
java.security.Principal
Locale
InputStream
OutputStream
Reader
Writer

 @RequestMapping("/testServletAPI")
 public void testServletAPI(HttpServletRequest request,
   HttpServletResponse response, Writer out) throws IOException {
  System.out.println("testServletAPI, " + request + ", " + response);
  out.write("hello springmvc");//response.getWriter
//  return SUCCESS;
 }

9.处理模型数据

Spring MVC 提供了以下几种途径输出模型数据：
ModelAndView: 处理方法返回值类型为ModelAndView–时, 方法体即可通过该对象添加模型数据和视图，Spring MVC会把ModelAndView的model中数据放到request域对象中。
Map 及Model: 入参为–org.springframework.ui.Model、org.springframework.ui.ModelMap或java.uti.Map时，处理方法返回时，Map 中的数据会自动添加到模型中。
@SessionAttributes: 将模型中的某个属性暂存到–HttpSession中，以便多个请求之间可以共享这个属性
@ModelAttribute: 方法入参标注该注解后, 入参的对象–就会放到数据模型中

 @RequestMapping("/testModelAndView")
 public ModelAndView testModelAndView(){
  String viewName = SUCCESS;
  ModelAndView modelAndView = new ModelAndView(viewName);
  modelAndView.addObject("time", new Date());
  return modelAndView;
 }

在success页面查看的代码为：

 time: ${requestScope.time }
 <br><br>

添加模型数据

MoelAndViewaddObject(String attributeName, Object –attributeValue)
ModelAndViewaddAllObject(Map<String, ?> modelMap)

设置视图:

void setView(View view)
void setViewName(String viewName)

10.

@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", "Mike"));
 return SUCCESS;
}

调用jsp获取结果

 names: ${requestScope.names }
 <br><br>

11.若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注哪个注解？

@SessionAttributes
Spring MVC将在模型中对应的属性暂存到HttpSession中。
@SessionAttributes除了可以通过属性名指定需要放到会话中的属性外，还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中

@SessionAttributes(value={"user"}, types={String.class})
@RequestMapping("/springmvc")
@Controller
public class SpringMVCTest {
 @RequestMapping("/testSessionAttributes")
 public String testSessionAttributes(Map<String, Object> map){
  User user = new User("Tom", "123456", "[email protected]", 15);
  map.put("user", user);
  map.put("school", "atguigu");
  return SUCCESS;
 }
}

通过jsp获取信息

 request user: ${requestScope.user }
 <br><br>
 session user: ${sessionScope.user }
 <br><br>
  request school: ${requestScope.school }
 <br><br>
 session school: ${sessionScope.school }
 <br><br>

12.

 @ModelAttribute
 public void getUser(@RequestParam(value="id",required=false) Integer id, 
   Map<String, Object> map){
  System.out.println("modelAttribute method");
  if(id != null){
   User user = new User(1, "Tom", "123456", "[email protected]", 12);
   System.out.println(user);
   map.put("user", user);
  }
 }

 @RequestMapping("/testModelAttribute")
 public String testModelAttribute(User user){
  System.out.println("修改: "+user);
  return SUCCESS;
 }

调用过程
1.执行@ModelAttribute注解修饰的方法：从数据库中取出对象，把对象放入到Map中，键为：user
2.SpringMVC从Map中取出User对象，并把表单的请求参数赋给User对象的对应属性
3.SpringMVC把上述对象传入目标方法的参数
在方法定义上使用@ModelAttribute注解：Spring MVC 在调用目标处理方法前，会先逐个调用在方法级上标注了@ModelAttribute的方法。在方法的入参前使用@ModelAttribute注解：
可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数–绑定到对象中，再传入入参将方法入参对象添加到模型中
注意：在@ModelAttribute修饰的方法中，放入Map时的键需要和目标方法入参类型的第一个字母小写的字符串一致。

源代码分析的流程

1. 调用 @ModelAttribute 注解修饰的方法. 实际上把 @ModelAttribute 方法中 Map 中的数据放在了 implicitModel 中.
2. 解析请求处理器的目标参数, 实际上该目标参数来自于 WebDataBinder 对象的 target 属性
   1). 创建 WebDataBinder 对象:
   ①. 确定 objectName 属性: 若传入的 attrName 属性值为 “”, 则 objectName 为类名第一个字母小写.
   *注意: attrName. 若目标方法的 POJO 属性使用了 @ModelAttribute 来修饰, 则 attrName 值即为 @ModelAttribute的 value 属性值
   ②. 确定 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 作为参数传递给目标方法的入参.

简化过程描述如下：
SpringMVC 确定目标方法 POJO 类型入参的过程

1. 确定一个 key:
   1). 若目标方法的 POJO 类型的参数木有使用 @ModelAttribute 作为修饰, 则 key 为 POJO 类名第一个字母的小写
   2). 若使用了 @ModelAttribute 来修饰, 则 key 为 @ModelAttribute 注解的 value 属性值.
2. 在 implicitModel 中查找 key 对应的对象, 若存在, 则作为入参传入
   1). 若在 @ModelAttribute 标记的方法中在 Map 中保存过, 且 key 和 1 确定的 key 一致, 则会获取到.
3. 若 implicitModel 中不存在 key 对应的对象, 则检查当前的 Handler 是否使用 @SessionAttributes 注解修饰,
   若使用了该注解, 且 @SessionAttributes 注解的 value 属性值中包含了 key, 则会从 HttpSession 中来获取 key 所对应的 value 值, 若存在则直接传入到目标方法的入参中. 若不存在则将抛出异常.
4. 若 Handler 没有标识 @SessionAttributes 注解或 @SessionAttributes 注解的 value 值中不包含 key, 则会通过反射来创建 POJO 类型的参数, 传入为目标方法的参数
5. SpringMVC 会把 key 和 POJO 类型的对象保存到 implicitModel 中, 进而会保存到 request 中.

13.视图和视图解析器

请求处理方法执行完成后，最终返回一个 ModelAndView对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个ModelAndView 对象，它包含了逻辑名和模型对象的视图。
Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是Excel、JFreeChart 等各种表现形式的视图
对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦
视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题
为了实现视图模型和具体实现技术的解耦，Spring 在org.springframework.web.servlet 包中定义了一个高度抽象的 View接口

14.视图解析器

SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB 上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。
所有的视图解析器都必须实现 ViewResolver 接口：
程序员可以选择一种视图解析器或混用多种视图解析器
每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order 越小优先级越高。
SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则将抛出 ServletException 异常
JSP 是最常见的视图技术，可以使用InternalResourceViewResolver 作为视图解析器

15.

调用方法之后返回的String、Model、view类型->modelAndView->通过视图解析器->view对象->调用里面的方法得到结果

16.

若项目中使用了 JSTL，则 SpringMVC 会自动把视图由InternalResourceView 转为 JstlView
若使用 JSTL 的 fmt 标签则需要在 SpringMVC 的配置文件中配置国际化资源文件
若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:viewcontroller 标签实现

 
 <bean id="messageSource"
  class="org.springframework.context.support.ResourceBundleMessageSource">
  <property name="basename" value="i18n">property> 
 bean>

 <fmt:message key="i18n.username"></fmt:message>
 <br><br>
<fmt:message key="i18n.password"></fmt:message>
 <br><br>

17.配置直接转发

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

18.自定义视图

@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().print("hello view, time: " + new Date());
}
}

配置视图解析器

<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
 <property name="order" value="100">property>
bean>

调用请求的方法

 @RequestMapping("/testView")
 public String testView(){
  System.out.println("testView");
  return "helloView";
 }

19.excel视图解析器的实现类

实现示例

public class ObjectExcelViewZong extends AbstractExcelView{
 @Override
 protected void buildExcelDocument(Map<String, Object> model,
   HSSFWorkbook workbook, HttpServletRequest request,
   HttpServletResponse response) throws Exception {
  // TODO Auto-generated method stub
  Date date = new Date();
  //总后台数据.xlsx
  String filenameTemp = Tools.date2Str(date, "yyyyMMddHHmmss");//生成时间
  String filenameTemp2="总后台数据";
  String filename=filenameTemp.concat(filenameTemp2);//时间字符拼接
  String name=new String(filename.getBytes(),"iso-8859-1");
  HSSFSheet sheet;
  HSSFCell cell;
  response.setContentType("application/octet-stream;charset=UTF-8");
  response.setHeader("Content-Disposition", "attachment;filename="+name+".xlsx");
  sheet = workbook.createSheet("sheet1");//创建表
  List<String> titles = (List<String>) model.get("titles");//获取表头信息，之前放进去的键值对<"title",title>
  int len = titles.size();
  HSSFCellStyle headerStyle = workbook.createCellStyle(); //标题样式
  headerStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  headerStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  HSSFFont headerFont = workbook.createFont(); //标题字体
  //headerFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
  headerFont.setFontName("宋体");
  headerFont.setFontHeightInPoints((short)12);
  headerStyle.setFont(headerFont);
  short width = 20,height=20*20;
  sheet.setDefaultColumnWidth(width);
  for(int i=0; i<len; i++){ //设置标题
   String title = titles.get(i);
   cell = getCell(sheet, 0, i);
   cell.setCellStyle(headerStyle);
   setText(cell,title);
  }
  sheet.getRow(0).setHeight(height);
  HSSFCellStyle contentStyle = workbook.createCellStyle(); //内容样式
  contentStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  contentStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直居中
  HSSFFont textFont = workbook.createFont(); //标题字体
  textFont.setFontName("宋体");
  textFont.setFontHeightInPoints((short)11);
  contentStyle.setFont(textFont);
  List<PageData> varList = (List<PageData>) model.get("varList");
  //获取之前放进去的简直对，是表的内容信息，<"varList",List>,其中PageData是Map
  int varCount = varList.size();
  for(int i=0; i<varCount; i++){
   PageData vpd = varList.get(i);
   for(int j=0;j<len;j++){
    String varstr = vpd.getString("var"+(j+1)) != null ? vpd.getString("var"+(j+1)) : "";
    cell = getCell(sheet, i+1, j);
    cell.setCellStyle(contentStyle);
    setText(cell,varstr);
   } 
   sheet.getRow(i+1).setHeight(height);
  } 
 }
}

20.重定向与请求转发有什么区别？

转发是服务器行为:对于用户的请求服务器可以实现转发，并且是在同一个web容器下进行的。发的是两次request, 在重定向的过程中，传输的信息会被丢失。
重定向是客户端行为：服务器根据此请求寻找资源并发送给客户。请求转发是服务器内部把对一个request/response的处理权，移交给另外一。对于客户端而言，它只知道自己最早请求的那个A，而不知道中间的B，甚至C、D。 传输的信息不会丢失。

21.在SpringMVC中如何实现重定向

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

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

redirect:开头的会返回RedirectView
forward:开头的会返回InternalResourceView