控制器的主要作用就是处理特定URL发过来的HTTP请求，然后进行业务逻辑处理，将结果返回给某个特定的视图。
处理请求
在Spring中定义控制器非常简单，新建一个类然后应用@Controller注解即可，当然一般习惯上将控制器类也命名为XXController。
每个控制器可以有若干方法，分别处理不同的请求。要指定处理请求的URL，使用@RequestMapping注解。控制器的方法处理之后，返回一个字符串，指定要使用的视图名称，然后该名称交给视图解析器转换成真正的视图，然后返回给客户端。
@RequestMapping还可以注解到控制器类上，这样一来每个方法处理的URL就是控制器和方法上URL的组合。
@Controller
@RequestMapping("/mvc")
public class MainController {
@RequestMapping("/hello")
public String hello(Model model) {
model.addAttribute("name", "name");
return "hello";
}
@RequestMapping("/index")
public String index() {
return "index";
}
}
默认情况下@RequestMapping会处理所有请求，如果希望只处理GET或者POST等请求，可以使用@RequestMapping的method属性。
@RequestMapping(value = "/index", method = {RequestMethod.GET})
public String index() {
return "index";
}
当然也可以直接使用Spring定义的几个Mapping注解，包括了GET、POST、DELETE、PUT等。需要注意这几个注解只能应用于方法上。
路径参数
有些网站的URL很特别，类似<code>http://mysite.com/list/yitian</code>这样的。Spring也支持这样的路径参数。
这时候路径模式中相应部分需要用花括号括起来，然后在方法中使用@PathVariable注解（注解中的名称需要和花括号中的参数相同）。
这样对应的路径参数就会由Spring自动赋给方法中的参数，我们直接在方法中使用即可。
@RequestMapping("/hello/{name}")
public String hey(@PathVariable("name") String username, Model model) {
model.addAttribute("name", username);
return "hello";
}
如果方法参数和路径中花括号部分相同，那么@PathVariable中的名称可以省略。
@RequestMapping("/hello/{name}")
public String hey(@PathVariable String name, Model model) {
model.addAttribute("name", name);
return "hello";
}
另外，方法中可以有多个路径参数。而且路径参数并不一定只能是字符串，也可以是<code>int</code>、<code>long</code>、<code>Date</code>这样的简单类型，Spring会自动进行转换，如果转换失败，就会抛出<code>TypeMismatchException</code>。
正则表达式匹配
有时候可能需要匹配一个比较复杂的路径，这时候可以使用正则表达式，语法是{varName:regex}。
例如为了匹配"/spring-web/spring-web-3.0.5.jar"，我们需要这样一个方法。
@RequestMapping("/spring-web/{symbolicName:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{extension:\\.[a-z]+}")
public void handle(@PathVariable String version, @PathVariable String extension) {
// ...
}
另外路径模式中还支持通配符，例如<code>/myPath/*.do</code>。
最后一个问题就是这些路径优先级的问题。如果一个请求匹配了多个路径模式，那么最具体的那个会被使用。规则如下：
- 路径中路径参数和通配符越少，路径越具体。
- 路径参数和通配符个数相同的话，路径越长越具体。
- 个数和长度都相同的话，通配符个数越少路径越具体。
- 默认匹配/**优先级最低。
- 前缀模式例如<code>/public/**</code>比其他两个通配符的模式优先级更低。
矩阵变量（Matrix Variables）
可以在路径中添加键值对，这样的键值对叫做矩阵变量。
Spring默认没有启用矩阵变量。要启用它，在dispatcher-servlet.xml中添加或修改如下一行：
<mvc:annotation-driven enable-matrix-variables="true"/>
矩阵变量可以用在路径的任何部分，需要和路径之间使用分号<code>;</code>分隔开，每个矩阵变量之间也是用分号分隔。
如果一个矩阵变量有多个值，使用逗号<code>,</code>分隔，
例如<code>"/matrix/42;colors=red,blue,yellow;year=2012"</code>。
对应的控制器方法如下：
// 处理请求 /matrix/42;colors=red,blue,yellow;year=2012
@RequestMapping("/matrix/{count}")
public String matrix(@PathVariable int count, @MatrixVariable String[] colors, @MatrixVariable int year, Model model) {
model.addAttribute("colors", colors);
model.addAttribute("year", year);
return "matrix";
}
还可以将所有矩阵变量映射成一个Map。
// 处理请求 /matrix2/42;colors=red,blue,yellow;year=2012
@RequestMapping("/matrix2/{count}")
public String matrix2(@PathVariable int count, @MatrixVariable MultiValueMap<String, String> map, Model model) {
model.addAttribute("map", map);
return "matrix";
}
对应的视图文件是<code>matrix.jsp</code>。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>矩阵变量</title>
<meta charset="utf-8"/>
</head>
<body>
<p>颜色是:
<c:forEach var="color" items="${colors}">
${color},
</c:forEach>
</p>
<p>年份是:${year}</p>
<p>矩阵变量:${map}</p>
</body>
</html>
媒体类型
通过使用@RequestMapping的consumes属性，还可以指定某个处理方法只处理某个或某些媒体类型的请求。
下面的请求方法只处理<code>Content-Type</code>是<code>application/json</code>的请求。
@RequestMapping(path = "/pets", consumes = "application/json")
public void addPet(@RequestBody Pet pet, Model model) {
// implementation omitted
}
另外comsumes部分还可以写为非的形式，表示匹配不是某种类型的请求。
例如<code>comsumes="!text/html"</code>表示处理Content-Type不是text/html的请求。
除了直接指定字符串，还可以指定org.springframework.http.MediaType提供的一组常量。
另外@RequestMapping还有一个produces属性，指定匹配Accept是某种类型的请求，并且使用指定的类型来编码返回的响应。
@GetMapping(path = "/pets/{petId}", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
@ResponseBody
public Pet getPet(@PathVariable String petId, Model model) {
// implementation omitted
}
定义处理方法
前面我们通过@RequestMapping和另外几个注解，来匹配特定的请求。下面来学习一下如何定义处理方法。
方法参数
处理方法的参数并不是任意的，Spring处理方法支持的参数列表很长，可以参考Spring文档。
这些参数可以分为几类：
- 一是Servlet相关的类，例如HttpServletRequest、HttpServletResponse、HttpSession等；
- 二是应用程序相关的，例如Timezone、Locale等；
- 三是Spring提供的各类注解；
- 四是输入输出流，用于直接操作HTTP请求和响应。
返回类型
处理方法的返回类型也不是任意的。详细的返回类型参见Spring官方文档。
常用的一些返回类型如下：
- String，表示要返回视图的名称。
- View，会由RequestToViewNameTranslator翻译实际视图的名称。
- void，表示方法会自己生成响应，不需要视图支持。
- Callable<?>，表示异步请求的返回。
绑定请求参数
我们还记得直接使用Servlet API中getParameter方法的恐惧吧，对于每个Servlet我们都要调用多次getParameter方法获取参数，而且获取到的是字符串，我们需要手动转换类型。
在Spring中就非常简单了，我们可以将请求参数绑定到方法参数上，使用@RequestParam即可。
该注解有三个属性：
- name表示请求参数的名称；
- defaultValue表示请求参数的默认值；
- required表示请求参数是否是必需的。
如果请求参数的名称和方法参数相同，那么name还可以省略。
// GET /hello?name=yitian
@RequestMapping("/hello")
public String hello(@RequestParam(defaultValue = "苟") String name, Model model) {
model.addAttribute("name", name);
return "hello";
}
向视图传递数据
如果处理方法的拥有一个org.springframework.ui.Model类型参数，那么我们就可以调用该参数的addAttribute方法添加属性，然后在视图中就可以访问这些属性了。
绑定请求体和响应体
绑定请求体使用@RequestBody注解。
下面的例子将请求体直接返回给响应。这里的处理方法用到了Writer参数直接输出HTTP响应，不需要视图，因此这里返回空。为了运行这个例子，需要一个表单，发送到该控制器上，然后我们就可以看到表单对应的请求体了。
@PostMapping("/requestBody")
public void handle(@RequestBody String body, Writer writer) throws IOException {
writer.write(body);
}
另外，与绑定响应体类似，我们需要使用@ResponseBody注解到方法上，这会告诉Spring直接将该方法的返回结果作为响应返回给客户端。
@GetMapping("/something")
@ResponseBody
public String helloWorld() {
return "Hello World";
}
在底层，Spring会使用<code>HttpMessageConverter</code>来将请求信息转换成我们需要的类型。Spring Web MVC为我们自动注册了一些<code>HttpMessageConverter</code>，详细情况参见Spring 参考文档 Section 22.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”。
Rest控制器
@RestController会向所有@RequestMapping方法添加@ResponseBody注解。如果控制器需要实现REST API，那么这时候就很方便。
使用HttpEntity
HttpEntity和请求体、响应体这两个类似，可以在一个地方同时处理请求和响应。
下面是Spring官方的一个例子，获取了请求HttpEntity，处理之后返回一个响应HttpEntity。Spring会使用<code>HttpMessageConverter</code>做必要的转换。
@RequestMapping("/something")
public ResponseEntity<String> handle(HttpEntity<byte[]> requestEntity) throws UnsupportedEncodingException {
String requestHeader = requestEntity.getHeaders().getFirst("MyRequestHeader"));
byte[] requestBody = requestEntity.getBody();
// do something with request header and body
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("MyResponseHeader", "MyValue");
return new ResponseEntity<String>("Hello World", responseHeaders, HttpStatus.CREATED);
}
使用ModelAttribute
@ModelAttribute注解用于向模型添加属性。可以作用到方法，这时候该方法会在该控制器的所有处理方法前执行。在方法中可以接受多个参数和一个模型参数，然后将这些参数处理之后添加到模型中。这样每次处理方法执行前都会先执行一次该方法。因此如果控制器中有多个处理方法要小心使用这个注解。
@ModelAttribute
public void addModel(@RequestParam String name, Model model) {
model.addAttribute("name",name);
// add more ...
}
@ModelAttribute还可以作用到方法参数上。这种情况更常见也更加有用。这时候Spring会先从model中寻找@ModelAttribute参数，如果没找到则实例化一个（因此这个类必须有无参构造函数），然后添加到model中。然后将请求参数（下面例子中是name=易天&age=24&gender=男）添加到模型中。这样当我们查看视图的时候，一个完整的实体类已经准备就绪了。
// 请求 /modelAttribute?name=易天&age=24&gender=男
@RequestMapping("/modelAttribute")
public String modelAttribute(@ModelAttribute User user, Model model) {
model.addAttribute("user", user);
return "modelAttribute";
}
User类的内容如下， 各种方法已省略。
public class User {
private String name;
private int age;
private String gender;
}
使用SessionAttribute
@SessionAttribute可以用于控制器上，这时候它会将上面介绍的ModelAttribute保存到Session中，方便多个方法间使用。
@Controller
@SessionAttributes("user")
public class MainController {
// 请求 /modelAttribute?name=易天&age=24&gender=男
@RequestMapping("/modelAttribute")
public String modelAttribute(@ModelAttribute User user, Model model) {
model.addAttribute("user", user);
return "modelAttribute";
}
}
@SessionAttributes还可以用到处理方法的参数上，这时候可以获取到Session中相应名称的属性，需要注意这个属性必须是已存在的。如果该属性不存在Spring就会抛出异常，然后将我们导向400页面。
@RequestMapping("/accessSession")
public String accessSession(@SessionAttribute User user, Model model) {
model.addAttribute("user", user);
return "accessSession";
}
如果需要还可以直接使用HttpSession，方法很简单，将方法参数定义为HttpSession，然后Spring就会将session对象注入到方法中。我们可以直接进行操作。
@RequestMapping("/httpSession")
public String httpSession(HttpSession session, Model model) {
User user = new User("林妹妹", 24, "女");
session.setAttribute("user", user);
model.addAttribute("session", session);
return "accessSession";
}
使用@RequestAttribute
@RequestAttribute用于获取RequestAttribute，这些请求属性可能是由过滤器或拦截器产生的。
@RequestMapping("/")
public String handleInfo(@RequestAttribute String info) {
// ...
}
处理application/x-www-form-urlencoded数据
浏览器会使用GET或者POST方法发送数据，非浏览器客户端可以使用PUT方法发送数据。
但是PUT发送过来的数据，不能被Servlet系列方法<code>ServletRequest.getParameter()</code>获取到。
Spring提供了一个过滤器<code>HttpPutFormContentFilter</code>，用于支持非浏览器的PUT信息发送。
<code>HttpPutFormContentFilter</code>需要在web.xml中配置。<servlet-name>配置的是Spring的DispatcherServlet的名称。
<filter>
<filter-name>httpPutFormFilter</filter-name>
<filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>httpPutFormFilter</filter-name>
<servlet-name>dispatcherServlet</servlet-name>
</filter-mapping>
这个过滤器会拦截Content-Type是<code>application/x-www-form-urlencoded</code>的PUT请求，读取其请求体然后包装到ServletRequest中，以便<code>ServletRequest.getParameter()</code>可以获取到参数。
使用@CookieValue
@CookieValue可以获取某个Cookie的值。如果该cookie不存在，就会抛出异常，可以使用required和defaultValue指定是否必须和默认值相等。
@RequestMapping("/cookie")
public void cookie(@CookieValue("JSESSIONID") String cookie) {
//...
}
@RequestHeader
@RequestHeader注解可以获取RequestHeader的信息，可以使用required和defaultValue指定是否必须和默认值相等。
@RequestMapping("/header")
public String headerInfo(@RequestHeader("Accept-Encoding") String encoding, Model model) {
model.addAttribute("encoding", encoding);
return "info";
}
控制器通知
先来介绍一下@InitBinder注解，它可以放到控制器的一个方法上，这个方法有一个WebDataBinder参数，用它可以对控制器进行定制，添加格式转换、验证等功能。
@InitBinder
protected void initBinder(WebDataBinder binder) {
//添加功能
}
然后就可以介绍@ControllerAdvice和@RestControllerAdvice这两个注解了。
它们可以定义控制器通知，这个和AOP中的Advice概念是一样的。这些注解需要应用到类上，这些类可以包括@ExceptionHandler， @InitBinder和 @ModelAttribute注解的方法，然后这些方法就会在恰当的时机来执行。
// 注解了RestController的控制器
@ControllerAdvice(annotations = RestController.class)
public class AnnotationAdvice {}
// 特定包下的控制器
@ControllerAdvice("org.example.controllers")
public class BasePackageAdvice {}
// 特定类型的控制器
@ControllerAdvice(assignableTypes = {MainController.class})
public class AssignableTypesAdvice {}
拦截请求
我们可以使用拦截器拦截请求并进行处理，这一点有点像Servlet的过滤器。
我们需要实现org.springframework.web.servlet.HandlerInterceptor接口，不过更好的方法是继承HandlerInterceptorAdapter类，这个类将几个拦截方法进行了默认实现。我们只需要重写需要的方法即可。
下面定义了一个简单的拦截器，作用仅仅是输出拦截时间。我们可以看到有四个拦截时机，处理请求前，处理请求后，完成请求后和异步处理开始后，这些拦截方法的参数是Http请求和响应，使用很方便。
public class LogInterceptor extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle:" + LocalTime.now());
return super.preHandle(request, response, handler);
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle:" + LocalTime.now());
super.postHandle(request, response, handler, modelAndView);
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion:" + LocalTime.now());
super.afterCompletion(request, response, handler, ex);
}
@Override
public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("afterConcurrentHandlingStarted:" + LocalTime.now());
super.afterConcurrentHandlingStarted(request, response, handler);
}
}
有了拦截器之后，我们还需要注册它。首先将其注册为一个Spring Bean。然后定义一个RequestMappingHandlerMapping并将拦截器传递给它。
<beans>
<bean id="handlerMapping"
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">
<property name="interceptors">
<list>
<ref bean="logInterceptor"/>
</list>
</property>
</bean>
<bean id="logInterceptor"
class="samples.LogInInterceptor"/>
</beans>
定义拦截器的这部分配置可以使用mvc命名空间简化。
<mvc:interceptors>
<ref bean="logInterceptor"/>
</mvc:interceptors>
默认情况下拦截器针对所有处理方法。如果希望只匹配某些URL，可以定义一个org.springframework.web.servlet.handler.MappedInterceptor，使用它的构造方法设置映射。
<bean class="org.springframework.web.servlet.handler.MappedInterceptor">
<constructor-arg index="0">
<list>
<value>/</value>
</list>
</constructor-arg>
<constructor-arg index="1" ref="logInterceptor"/>
</bean>
也可以直接使用mvc命名空间。
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/"/>
<ref bean="logInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
拦截器可能不适用@ResponseBody和ResponseEntity方法，因为这些方法会使用HttpMessageConverter来输出响应。这时候我们可以实现ResponseBodyAdvice接口，然后使用@ControllerAdvice注解或者直接在RequestMappingHandlerAdapter.配置它们来拦截这些方法。
网友评论