SpringMVC常用注解

@requestMapping

Spring MVC 使用@requestMapping 注解为控制器指定可以处理哪些 URL
DispatcherServlet 截获请求后，就通过控制器上的@requestMapping 提供的映射信息确定请求所对应的处理方法
在控制器的类定义和方法定义出都可以标注

@Controller
@RequestMapping("/springmvc")
public class SpringMVCTest {

    /**
     * 1. @RequestMapping 除了修饰方法, 还可来修饰类 
     * 2. 
     * 1). 类定义处: 提供初步的请求映射信息。相对于 WEB 应用的根目录
     * 2). 方法处:提供进一步的细分映射信息。 相对于类定义处的 URL。若类定义处未标注 @RequestMapping，则方法处标记的 URL 相对于 WEB 应用的根目录
     * 
     * GET: http://localhost:8081/springmvc/testRequestMapping
     */
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping() {
        System.out.println("testRequestMapping");
        return "success";
    }
}

@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

使用 method 属性来指定请求方式

/**
 * 常用: 使用 method 属性来指定请求方式 POST: http://localhost:8081/springmvc/testMethod
 */
@RequestMapping(value = "/testMethod", method = RequestMethod.POST)
public String testMethod() {
    System.out.println("testMethod");
    return "success";
}

使用 params 和 headers 来更加精确的映射请求. params 和 headers 支持简单的表达式.

/**
 * 了解: 可以使用 params 和 headers 来更加精确的映射请求. params 和 headers 支持简单的表达式. GET:
 * http://localhost:8081/springmvc/testParamsAndHeaders?username=admin&age=101
 * 
 * @return
 */
@RequestMapping(value = "testParamsAndHeaders", params = { "username", "age!=10" }, headers = { "Accept-Language=zh-CN,zh;q=0.8" })
public String testParamsAndHeaders() {
    System.out.println("testParamsAndHeaders");
    return "success";
}

@RequestMapping映射的url还可以使用通配符（需要使用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

/**
 * 
 * @Title: testAntPath
 * @Description: TODO(这里用一句话描述这个方法的作用)
 * @RequestMapping 支持Ant风格的UEL Ant 风格资源地址支持三种匹配符 ?:匹配文件名中的一个字符 *:匹配文件名中的任意字符 **：匹配多层路径
 * @param: @return
 * @return: String
 * @throws GET: http://localhost:8081/springmvc/testAntPath/xxx/abc
 */
@RequestMapping("/testAntPath/*/abc")
public String testAntPath() {
    System.out.println("testAntPath");
    return "success";
}

@PathVariable

• 带占位符的 URL 是Spring3.0 新增的功能，该功能在 SpringMVC 向 REST 目标挺进发展过程中具有里程碑的意义

• 通过@PathVariable可以将URL 中占位符参数绑定到控制器处理方法的参数中： URL 中的 {xxx} 占位符可以通过 @PathVariable("xxx") 绑定到操作方法的入参中。

(占位符中的名字需要和@PathVariable中的名字一样)

/**
     * @PathVariable 可以来映射 URL 中的占位符到目标方法的参数中.
     * @param id
     * @return GET: http://localhost:8081/springmvc/testPathVariable/1
     */
    @RequestMapping("/testPathVariable/{id}")
    public String testPathVariable(@PathVariable("id") Integer id) {
        System.out.println("testPathVariable: " + id);
        return "success";
    }

Restful 风格：

HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。
HiddenHttpMethodFilter：浏览器form 表单只支持GET 与POST 请求，而DELETE、PUT 等method 并不支持，Spring3.0 添加了一个过滤器，可以将这些请求转换为标准的http 方法，使得支持GET、POST、PUT 与DELETE 请求。

在web.xml中配置

<!-- 
配置 org.springframework.web.filter.HiddenHttpMethodFilter: 可以把 POST 请求转为 DELETE 或 POST 请求 
-->
<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>

/**
 * Rest 风格的 URL. 以 CRUD 为例: 
 * 新增: /order POST 修改: /order/1 PUT update?id=1 
 * 获取: /order/1 GET get?id=1 
 * 删除: /order/1 DELETE delete?id=1
 * 
 * 如何发送 PUT 请求和 DELETE 请求呢 ? 1. 需要配置 HiddenHttpMethodFilter 2. 需要发送 POST 请求 3. 需要在发送 POST请求时携带一个
 * name="_method" 的隐藏域, 值为 DELETE 或 PUT
 * 
 * 在 SpringMVC 的目标方法中如何得到 id 呢? 使用 @PathVariable 注解
 * 
 */
// PUT: http://localhost:8081/springmvc/testRest/1
@RequestMapping(value = "/testRest/{id}", method = RequestMethod.PUT)
public String testRestPut(@PathVariable("id") Integer id) {
    System.out.println("testRest Put: " + id);
    return "success";
}

// DELETE: http://localhost:8081/springmvc/testRest/1
@RequestMapping(value = "/testRest/{id}", method = RequestMethod.DELETE)
public String testRestDelete(@PathVariable("id") Integer id) {
    System.out.println("testRest Delete: " + id);
    return "success";
}

// POST: http://localhost:8081/springmvc/testRest
@RequestMapping(value = "/testRest", method = RequestMethod.POST)
public String testRest() {
    System.out.println("testRest POST");
    return "success";
}

// GET:http://localhost:8081/springmvc/testRest/1
@RequestMapping(value = "/testRest/{id}", method = RequestMethod.GET)
public String testRest(@PathVariable("id") Integer id) {
    System.out.println("testRest GET: " + id);
    return "success";
}

@RequestParam

在处理方法入参处使用@RequestParam可以把请求参数传递给请求方法

– value：参数名

– required：是否必须。默认为true, 表示请求参数中必须包含对应的参数，若不存在，将抛出异常

/**
 * @RequestParam 来映射请求参数. value 值即请求参数的参数名 required 该参数是否必须. 默认为 true defaultValue 请求参数的默认值
 */
// GET: http://localhost:8081/springmvc/testRequestParam?username=admin&age=11
@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";
}

@RequestHeader

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

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

@CookieValue

@CookieValue 可让处理方法入参绑定某个 Cookie 值

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

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

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

Address.java

public class Address {
    private String province;
    private String city;
   //gettter And setter
}

User.java

public class User {

    private Integer id;
    
    private String name;
    
    private Integer age;
    
    private String email;
    
    private Address address;

    //getter And Setter
}

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

使用ServletAPI作为入参

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

• HttpServletRequest

• HttpServletResponse

• HttpSession

• Java.security.Principal•Locale

• InputStream

• OutputStream

• Reader

• Writer

/**
 * 可以使用 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;
}

处理模型数据

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

– 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)j

/**
 * 目标方法的返回值可以是 ModelAndView 类型。 其中可以包含视图和模型信息 SpringMVC 会把 ModelAndView 的 model 中数据放入到 request
 * 域对象中.
 * @return
 */
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView() {
    String viewName = "success";
    ModelAndView modelAndView = new ModelAndView(viewName);
    // 添加模型数据到 ModelAndView 中.
    modelAndView.addObject("time", new Date());
    return modelAndView;
}

Map及Model

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

• 具体步骤：

– Spring MVC 在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。

– 如果方法的入参为Map 或Model 类型，Spring MVC 会将隐含模型的引用传递给这些入参。在方法体内，开发者可以通过这个入参对象访问到模型中的所有数据，也可以向模型中添加新的属性数据

/**
 * 目标方法可以添加 Map 类型(实际上也可以是 Model 类型或 ModelMap 类型)的参数.
 * @param map
 * @return
 */
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) {
    System.out.println(map.getClass().getName());
    map.put("names", Arrays.asList("Tom", "Jerry", "Mike"));
    return "success";
}

@SessionAttributes

前边几种方法都是把模型数据放到request域对象中，也可以放在session中
     • 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个@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})

@Controller
@RequestMapping("/springmvc")
@SessionAttributes(value = { "user" }, types = { String.class })
public class SpringMVCTest {
    /**
     * @SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外(实际上使用的是 value 属性值),
     *                    还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中(实际上使用的是 types 属性值)
     *  注意: 该注解只能放在类的上面. 而不能修饰放方法.
     */
    @RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Map<String, Object> map) {
        User user = new User("Tom", 23, "[email protected]");
        map.put("user", user);
        map.put("school", "zto");
        return "success";
    }
}

@ModelAttribute

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

需求：模拟修改操作
1. 原始数据为: 1, "Tom", 23, "[email protected]"
2. 邮箱不能被修改.
3. 表单回显, 模拟操作直接在表单填写对应的属性值

/**
 * 1. 有 @ModelAttribute 标记的方法, 会在每个目标方法执行之前被 SpringMVC 调用! 
 * 2. @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) {
    System.out.println("modelAttribute method");
    if (id != null) {
        // 模拟从数据库中获取对象
        User user = new User(1, "Tom", 23, "[email protected]");
        System.out.println("从数据库中获取一个对象: " + user);

        map.put("user", user);
    }
}

/**
 * 模拟修改操作  
 * 1. 原始数据为: 1, "Tom", 23, "[email protected]"
 * 2. 邮箱不能被修改.  
 * 3. 表单回显, 模拟操作直接在表单填写对应的属性值  
 * @Title: testModelAttribute   
 * @Description: TODO(这里用一句话描述这个方法的作用)   
 * @param: @param user
 * @param: @return      
 * @return: String      
 * @throws
 */
@RequestMapping("/testModelAttribute")
public String testModelAttribute(User user) {
    System.out.println("修改: " + user);
    return "success";
}

结果：

@responseStatus

视图和视图解析器

Spring MVC如何解析视图

• 请求处理方法执行完成后，最终返回一个ModelAndView对象。对于那些返回String，View或ModeMap等类型的处理方法，spring MVC 都会在内部将它们装配成一个ModelAndView对象，它包含了逻辑名和模型对象的视图

• Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是JSP也可是Excell、

JFreeChart等各种表现形式的视图

• 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现MVC 的充分解耦

视图

• 视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。

• 为了实现视图模型和具体实现技术的解耦，Spring 在org.springframework.web.servlet包中定义了一个高度抽象的View接口

• 视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题

常用的视图实现类

视图解析器（将逻辑视图转为物理视图）

SpringMVC为逻辑视图名的解析提供了不同的策略，可以在Spring WEB上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。

• 视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。

• 所有的视图解析器都必须实现ViewResolver接口：

常用的视图解析器实现类

• 程序员可以选择一种视图解析器或混用多种视图解析器

• 每个视图解析器都实现了Ordered 接口并开放出一个order属性，可以通过order 属性指定解析器的优先顺序，order 越小优先级越高。

• SpringMVC会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，则抛出ServletException 异常

ViewResolve和View的作用

1. ViewResolve的作用就是通过解析MdoelAndView，将MdoelAndView中的逻辑视图名变为一个真正的View对象，并将MdoelAndView中的Model取出。

2.View的作用就是在获取到ViewResolve传来的View和Model，对Model进行渲染，通过View对象找到要展示给用户的物理视图，将渲染后的视图展示给用户。用很直白的话将就是将数据通过request存储起来，找到要展示给用户的页面，将这些数据放在页面中，并将页面呈现给用户。http://blog.csdn.net/wangbiao007/article/details/50689021

InternalResourceViewResolver

JSP 是最常见的视图技术，可以使用InternalResourceViewResolver作为视图解析器：

<!-- 配置视图解析器: 如何把 handler 方法返回值解析为实际的物理视图 -->
<bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/views/"></property>
	<property name="suffix" value=".jsp"></property>
</bean>

JstlView与国际化

• 若项目中使用了JSTL，则SpringMVC会自动把视图由InternalResourceView转为JstlView

• 若使用JSTL 的fmt标签则需要在SpringMVC的配置文件中配置国际化资源文件

i18n_en_US.properties

i18n.username=username
i18n.password=password

i18n_zh_CN.properties

i18n.username=\u7528\u6237\u540D
i18n.password=\u5BC6\u7801

<!--  配置国际化资源文件 -->     
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">  
	<property name="basename" value="i18n"></property>      
</bean>

jsp:

<%@ 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>
	
	<fmt:message key="i18n.username"></fmt:message>
	<fmt:message key="i18n.password"></fmt:message>
</body>
</html>

切换浏览器语言即可看到效果.

mvc:view-controller

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

<!-- 配置直接转发的页面 -->      
<!-- 可以直接相应转发的页面, 而无需再经过 Handler 的方法.  -->  
<mvc:view-controller path="/success" view-name="success"/>  

<!-- 在实际开发中通常都需配置 mvc:annotation-driven 标签，  之前的页面才不会因为配置了直接转发页面而受到影响 -->  
<mvc:annotation-driven></mvc:annotation-driven>

自定义视图

@Component
public class HelloView implements View{

    /**
     * 设置返回内容类型
     * <p>Title: getContentType</p>   
     * <p>Description: </p>   
     * @return   
     * @see org.springframework.web.servlet.View#getContentType()
     */
    @Override
    public String getContentType() {
        // TODO Auto-generated method stub
        return "text/html";
    }

    @Override
    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        response.getWriter().print("hello view ,time:"+new Date());
        
    }
}

配置视图解析器

<!--自定义视图解析器  ， 配置 BeanNameViewResolver 解析器：使用视图的名字来解析视图-->
<!-- 通过order 属性来定义视图解析器的优先级，order 值越小优先级越高 -->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
	<property name="order" value="100"></property>
</bean>

/**
 * 
 * @Title: testCustomView   
 * @Description: 测试自定义视图解析器
 * @param: @return      
 * @return: String      
 * @throws
 */
@RequestMapping(value="testCustomView")
public String testCustomView(){
    System.out.println("test custom view");
    return "helloView";
}

Excel 视图

若希望使用Excel 展示数据列表，仅需要扩展SpringMVC提供的AbstractExcelView或AbstractJExcelView 即可。实现buildExcelDocument()方法，在方法中使用模型数据对象构建Excel 文档就可以了。

• AbstractExcelView基于POI API，而AbstractJExcelView是基于JExcelAPI的。

• 视图对象需要配置IOC 容器中的一个Bean，使用BeanNameViewResolver作为视图解析器即可

• 若希望直接在浏览器中直接下载Excel 文档，则可以设置响应头Content-Disposition的值为attachment;filename=xxx.xls

关于重定向

• 一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理

• 如果返回的字符串中带forward:或redirect:前缀时，SpringMVC会对他们进行特殊处理：将forward: 和redirect: 当成指示符，其后的字符串作为URL 来处理

– redirect:success.jsp：会完成一个到success.jsp的重定向的操作

– forward:success.jsp：会完成一个到success.jsp的转发操作

@Controller  
@RequestMapping("springmvc")  
//@SessionAttributes(value={"user"},types={String.class})  
public class SpringMVCTest {  
@RequestMapping(value="/testRedirect")  
public String testRedirect(){  
	System.out.println("testRedirect...");  
	return "redirect:/index2.jsp";       //如果是转发就写为forward:             
}}

SpringMVC学习总结(二).SpringMVC常用注解及视图