摘要：的框架用于解决上述提到的问题，基于模型，可以帮助开发人员构建灵活易扩展的应用。在这一章中，将专注于构建该应用的层，创建控制器和显示，以及处理用户注册的表单。类有两个静态接口，代表两种模拟服务的方式独立测试和集成测试。
主要内容
将web请求映射到Spring控制器
绑定form参数
验证表单提交的参数
写在前面：关于Java Web，首先推荐一篇文章——写给java web一年左右工作经验的人，这篇文章的作者用精练的话语勾勒除了各种Java框架的缘由和最基本的原理。我们在学习Spring的过程中也要切记，不仅要知道怎么做？还要深究背后的思考和权衡。
对于很多Java程序员来说，他们的主要工作就是开发Web应用，如果你也在做这样的工作，那么你一定会了解到构建这类系统所面临的挑战，例如状态管理、工作流和参数验证等。HTTP协议的无状态性使得这些任务极具挑战性。
Spring的web框架用于解决上述提到的问题，基于Model-View-Controller（MVC）模型，Spring MVC可以帮助开发人员构建灵活易扩展的Web
应用。
这一章将涉及Spring MVC框架的主要知识，由于基于注解开发是目前Spring社区的潮流，因此我们将侧重介绍如何使用注解创建控制器，进而处理各类web请求和表单提交。在深入介绍各个专题之前，首先从一个比较高的层面观察和理解下Spring MVC的工作原理。
5.1 Spring MVC入门 5.1.1 request的处理过程用户每次点击浏览器界面的一个按钮，都发出一个web请求（request）。一个web请求的工作就像一个快递员，负责将信息从一个地方运送到另一个地方。
从web请求离开浏览器（1）到返回响应，中间经历了几个节点，在每个节点都进行一些操作用于交换信息。下图展示了Spring MVC应用中web请求会遇到的几个节点。
请求旅行的第一站是Spring的DispatcherServlet，和大多数Javaweb应用相同，Spring MVC通过一个多带带的前端控制器过滤分发请求。当Web应用委托一个servlet将请求分发给应用的其他组件时，这个servlert称为前端控制器（front controller）。在Spring MVC中，DispatcherServlet就是前端控制器。
DispatcherServlet的任务是将请求发送给某个Spring控制器。控制器（controller）是Spring应用中处理请求的组件。一般在一个应用中会有多个控制器，DispatcherServlet来决定把请求发给哪个控制器处理。DispatcherServlet会维护一个或者多个处理器映射（2），用于指出request的下一站——根据请求携带的URL做决定。
一旦选好了控制器，DispatcherServlet会把请求发送给指定的控制器（3），控制器中的处理方法负责从请求中取得用户提交的信息，然后委托给对应的业务逻辑组件（service objects）处理。
控制器的处理结果包含一些需要传回给用户或者显示在浏览器中的信息。这些信息存放在模型（model）中，但是直接把原始信息返回给用户非常低效——最好格式化成用户友好的格式，例如HTML或者JSON格式。为了生成HTML格式的文件，需要把这些信息传给指定的视图（view），一般而言是JSP。
控制器的最后一个任务就是将数据打包在模型中，然后指定一个视图的逻辑名称（由该视图名称解析HTML格式的输出），然后将请求和模型、视图名称一起发送回DispatcherServlet（4）。
注意，控制器并不负责指定具体的视图，返回给DispatcherServlet的视图名称也不会指定具体的JSP页面（或者其他类型的页面）；控制器返回的仅仅是视图的逻辑名称，DispatcherServlet用这个名称查找对应的视图解析器（5），负责将逻辑名称转换成对应的页面实现，可能是JSP也可能不是。
现在DispatcherServlet就已经知道将由哪个视图渲染结果，至此一个请求的处理就基本完成了。最后一步就是视图的实现（6），最经典的是JSP。视图会使用模型数据填充到视图实现中，然后将结果放在HTTP响应对象中（7）。
5.1.2 设置Spring MVC如上一小节的图展示的，看起来需要填写很多配置信息。幸运地是，Spring的最新版本提供了很多容易配置的选项，降低了Spring MVC的学习门槛。这里我们先简单配置一个Spring MVC应用，作为这一章将会不断完善的例子。
CONFIGURING DISPATCHERSERVLETDispatcherServlet是Spring MVC的核心，每当应用接受一个HTTP请求，由DispatcherServlet负责将请求分发给应用的其他组件。
在旧版本中，DispatcherServlet之类的servlet一般在web.xml文件中配置，该文件一般会打包进最后的war包种；但是Spring 3引入了注解，我们在这一章将展示如何基于注解配置Spring MVC。
既然不适用web.xml文件，你需要在servlet容器中使用Java配置DispatcherServlet，具体的代码列举如下：
package org.test.spittr.config;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class SpittrWebAppInitializer
extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class[] getRootConfigClasses() { //根容器
return new Class[] { RootConfig.class };
}
@Override
protected Class[] getServletConfigClasses() { //Spring mvc容器
return new Class[] { WebConfig.class };
}
@Override
protected String[] getServletMappings() { //DispatcherServlet映射,从"/"开始
return new String[] { "/" };
}
}
spitter这个单词是我们应用的名称，SpittrWebAppInitializer类是整个应用的总配置类。
AbstractAnnotationConfigDispatcherServletInitializer这个类负责配置DispatcherServlet、初始化Spring MVC容器和Spring容器。getRootConfigClasses()方法用于获取Spring应用容器的配置文件，这里我们给定预先定义的RootConfig.class；getServletConfigClasses负责获取Spring MVC应用容器，这里传入预先定义好的WebConfig.class；getServletMappings()方法负责指定需要由DispatcherServlet映射的路径，这里给定的是"/"，意思是由DispatcherServlet处理所有向该应用发起的请求。
A TALE OF TWO APPLICATION CONTEXT当DispatcherServlet启动时，会创建一个Spring MVC应用容器并开始加载配置文件中定义好的beans。通过getServletConfigClasses()方法，可以获取由DispatcherServlet加载的定义在WebConfig.class中的beans。
在Spring Web应用中，还有另一个Spring应用容器，这个容器由ContextLoaderListener创建。
我们希望DispatcherServlet仅加载web组件之类的beans，例如controllers（控制器）、view resolvers（视图解析器）和处理器映射（handler mappings）；而希望ContextLoaderListener加载应用中的其他类型的beans——例如业务逻辑组件、数据库操作组件等等。
实际上，AbstractAnnotationConfigDispatcherServletInitializer创建了DispatcherServlet和ContextLoaderListener：getServletConfigClasses()返回的配置类定义了Spring MVC应用容器中的beans；getRootConfigClasses()返回的配置类定义了Spring应用根容器中的beans。【书中没有说的】：Spring MVC容器是根容器的子容器，子容器可以看到根容器中定义的beans，反之不行。
注意：通过AbstractAnnotationConfigDispatcherServletInitializer配置DispatcherServlet仅仅是传统的web.xml文件方式的另一个可选项。尽管你也可以使用AbstractAnnotationConfigDispatcherServletInitializer的一个子类引入web.xml文件来配置，但这没有必要。
这种方式配置DispatcherServlet需要支持Servlert 3.0的容器，例如Apache Tomcat 7或者更高版本的。
ENABLING SPRING MVC正如可以通过多种方式配置DispatcherServlet一样，也可以通过多种方式启动Spring MVC特性。原来我们一般在xml文件中使用
这里我们仍然使用JavaConfig配置，最简单的Spring MVC配置类代码如下：
package org.test.spittr.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
@Configuration
@EnableWebMvc
public class WebConfig {
}
@Configuration表示这是Java配置类；@EnableWebMvc注解用于启动Spring MVC特性。
仅仅这些代码就可以启动Spring MVC了，虽然它换缺了一些必要的组件：
没有配置视图解析器。这种情况下，Spring会使用BeanNameViewResolver，这个视图解析器通过查找ID与逻辑视图名称匹配且实现了View接口的beans。
没有启动Component-scanning。
DispatcherServlet作为默认的servlet，将负责处理所有的请求，包括对静态资源的请求，例如图片和CSS文件等。
因此，我们还需要在配置文件中增加一些配置，使得这个应用可以完成最简单的功能，代码如下：
package org.test.spittr.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
@Configuration
@EnableWebMvc
@ComponentScan("org.test.spittr.web")
public class WebConfig extends WebMvcConfigurerAdapter{
@Bean
public ViewResolver viewResolver() { //配置JSP视图解析器
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
//可以在JSP页面中通过${}访问beans
resolver.setExposeContextBeansAsAttributes(true);
return resolver;
}
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable(); //配置静态文件处理
}
}
首先，通过@ComponentScan("org.test.spittr.web")注解指定bean的自动发现机制作用的范围，待会会看到，被@Controller等注解修饰的web的bean将被发现并加载到spring mvc应用容器。这样就不需要在配置类中显式定义任何控制器bean了。
然后，你通过@Bean注解添加一个ViewResolverbean，具体来说是InternalResourceViewResolver。后面我们会专门探讨视图解析器，这里的三个函数的含义依次是：setPrefix()方法用于设置视图路径的前缀；setSuffix()用于设置视图路径的后缀，即如果给定一个逻辑视图名称——"home"，则会被解析成"/WEB-INF/views/home.jsp"； setExposeContextBeansAsAttributes(true)使得可以在JSP页面中通过${ }访问容器中的bean。
最后，WebConfig继承了WebMvcConfigurerAdapter类，然后覆盖了其提供的configureDefaultServletHandling()方法，通过调用configer.enable()，DispatcherServlet将会把针对静态资源的请求转交给servlert容器的default servlet处理。
RootConfig的配置就非常简单了，唯一需要注意的是，它在设置扫描机制的时候，将之前WebConfig设置过的那个包排除了；也就是说，这两个扫描机制作用的范围正交。RootConfig的代码如下：
package org.test.spittr.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
@Configuration
@ComponentScan(basePackages = {"org.test.spittr"},
excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = EnableWebMvc.class)})
public class RootConfig {
}
5.1.3 Spittr应用简介
这一章要用的例子应用，从Twitter获取了一些灵感，因此最开始叫Spitter；然后又借鉴了最近比较流行的网站Flickr，因此我们也把e去掉，最终形成Spittr这个名字。这也有利于区分领域名称（类似于twitter，这里用spring实现，因此叫spitter）和应用名称。
Spittr应用有两个关键的领域概念：spitters（应用的用户）和spittles（用户发布的状态更新）。在这一章中，将专注于构建该应用的web层，创建控制器和显示spittles，以及处理用户注册的表单。
基础已经打好了，你已经配置好了DispatcherServlet，启动了Spring MVC特性等，接下来看看如何编写Spring MVC控制器。
5.2 编写简单的控制器在Spring MVC应用中，控制器类就是含有被@RequestMapping注解修饰的方法的类，其中该注解用于指出这些方法要处理的请求类型。
我们从最简单的请求"/"开始，用于渲染该应用的主页，HomeController的代码列举如下：
package org.test.spittr.web;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class HomeController {
@RequestMapping(value = "/", method = RequestMethod.GET)
public String home() {
return "home";
}
}
@Controller是一个模式化的注解，它的作用跟@Component一样；Component-scanning机制会自动发现该控制器，并在Spring容器中创建对应的bean。
HomeController中的home()方法用于处理http://localhost:8080/这个URL对应的"/"请求，且仅处理GET方法，方法的内容是返回一个逻辑名称为"home"的视图。DispatcherServlet将会让视图解析器通过这个逻辑名称解析出真正的视图。
根据之前配置的InternalResourceViewResolver，最后解析成/WEB-INF/views/home.jsp，home.jsp的内容列举如下：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" session="false" %>
Spittr
Welcome to Spittr
">Spittles
">Register
启动应用，然后访问http://localhost:8080/，Spittr应用的主页如下图所示：
控制器的测试通过Mockito框架进行，首先在pom文件中引入需要的依赖库：
org.springframework spring-test org.mockito mockito-all ${mockito.version} junit junit ${junit.version}
然后，对应的单元测试用例HomeControllerTest的代码如下所示：
package org.test.spittr.web;
import org.junit.Before;import org.junit.Test;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.*;
public class HomeControllerTest {
MockMvc mockMvc;
@Before
public void setupMock() {
HomeController controller = new HomeController();
mockMvc = standaloneSetup(controller).build();
}
@Test
public void testHomePage() throws Exception {
mockMvc.perform(get("/"))
.andExpect(view().name("home"));
}
}
首先stanaloneSetup()方法通过HomeController的实例模拟出一个web服务，然后使用perform执行对应的GET请求，并检查返回的视图的名称。MockMvcBuilders类有两个静态接口，代表两种模拟web服务的方式：独立测试和集成测试。上面这段代码是独立测试，我们也尝试了集成测试的方式，最终代码如下：
package org.test.spittr.web;
import org.junit.Before;import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.ContextHierarchy;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.web.context.WebApplicationContext;
import org.test.spittr.config.RootConfig;
import org.test.spittr.config.WebConfig;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.*;
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration(value = "src/main/webapp")
@ContextHierarchy({
@ContextConfiguration(name = "parent", classes = RootConfig.class),
@ContextConfiguration(name = "child", classes = WebConfig.class)})
public class HomeControllerTest {
@Autowired
private WebApplicationContext context;
MockMvc mockMvc;
@Before
public void setupMock() {
//HomeController controller = new HomeController();
//mockMvc = standaloneSetup(controller).build();
mockMvc = webAppContextSetup(context).build();
}
@Test
public void testHomePage() throws Exception {
mockMvc.perform(get("/"))
.andExpect(view().name("home"));
}
}
5.2.2 定义类级别的请求处理
上面一节对之前的HomeController进行了简单的测试，现在可以对它进行进一步的完善：将@RequestMapping从修饰函数改成修饰类，代码如下：
package org.test.spittr.web;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
@RequestMapping(value = "/")
public class HomeController {
@RequestMapping(method = RequestMethod.GET)
public String home() {
return "home";
}
}
在新的HomeController中，"/"被移动到类级别的@RequestMapping中，而定义HTTP方法的@RequestMapping仍然用于修饰home()方法。RequestMapping注解可以接受字符串数组，即可以同时映射多个路径，因此我们还可以按照下面这种方式修改：
@Controller
@RequestMapping({"/", "/homepage"})
public class HomeController {
}
}
5.2.3 给视图传入模型数据
对于DispatcherServlet传来的请求，控制器通常不会实现具体的业务逻辑，而是调用业务层的接口，并且将业务层服务返回的数据放在模型对象中返回给DispatcherServlet。
在Spittr应用中，需要一个页面显示最近的spittles列表。首先需要定义数据库存取接口，这里不需要提供具体实现，只需要用Mokito框架填充模拟测试数据即可。SpittleRepository接口的代码列举如下：
package org.test.spittr.data;
import java.util.List;
public interface SpittleRepository {
List findSpittles(long max, int count);
}
SpittleRepository接口中的findSpittles()方法有两个参数：max表示要返回的Spittle对象的最大ID；count表示指定需要返回的Spittle对象数量。为了返回20个最近发表的Spittle对象，则使用List
package org.test.spittr.data;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import java.util.Date;
public class Spittle {
private final Long id;
private final String message;
private final Date time;
private Double latitude;
private Double longitude;
public Spittle(String message, Date time) {
this(message, time, null, null);
}
public Spittle(String message,Date time, Double latitude, Double longitude) {
this.id = null;
this.time = time;
this.latitude = latitude;
this.longitude = longitude;
this.message = message;
}
public Long getId() {
return id;
}
public String getMessage() {
return message;
}
public Date getTime() {
return time;
}
public Double getLongitude() {
return longitude;
}
public Double getLatitude() {
return latitude;
}
@Override
public boolean equals(Object obj) {
return EqualsBuilder.reflectionEquals(this, obj,
new String[]{"message","latitude", "longitude"});
}
@Override
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this,
new String[]{"message", "latitude", "longitude"});
}
}
Spittle对象还是POJO，并没什么复杂的。唯一需要注意的就是，利用Apache Commons Lang库的接口，用于简化equals和hashCode方法的实现。参考Apache Commons EqualsBuilder and HashCodeBuilder
首先为新的控制器接口写一个测试用例，利用Mockito框架模拟repository对象，并模拟出request请求，代码如下：
package org.test.spittr.web;
import org.junit.Test;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.web.servlet.view.InternalResourceView;
import org.test.spittr.data.Spittle;import org.test.spittr.data.SpittleRepository;import java.util.ArrayList;
import java.util.Date;import java.util.List;
import static org.hamcrest.Matchers.hasItems;
import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.*;
public class SpittleControllerTest {
@Test
public void shouldShowRecentSpittles() throws Exception {
//step1 准备测试数据
List expectedSpittles = createSpittleList(20);
SpittleRepository mockRepository = mock(SpittleRepository.class);
when(mockRepository.findSpittles(Long.MAX_VALUE, 20))
.thenReturn(expectedSpittles);
SpittleController controller = new SpittleController(mockRepository);
MockMvc mockMvc = standaloneSetup(controller)
.setSingleView(new InternalResourceView("/WEB-INF/views/spittles.jsp"))
.build();
//step2 and step3
mockMvc.perform(get("/spittles"))
.andExpect(view().name("spittles"))
.andExpect(model().attributeExists("spittleList"))
.andExpect(model().attribute("spittleList",
hasItems(expectedSpittles.toArray())));
}
private List createSpittleList(int count) {
List spittles = new ArrayList();
for (int i = 0; i < count; i++) {
spittles.add(new Spittle("Spittle " + i, new Date()));
}
return spittles;
}
}
单元测试的基本组成是：准备测试数据、调用待测试接口、校验接口的执行结果。对于shouldShowRecentSpittles()这个用例我们也可以这么分割：首先规定在调用SpittleRepository接口的findSpittles()方法时将返回20个Spittle对象。
这里选择独立测试，跟HomeControllerTest不同的地方在于，这里构建MockMvc对象时还调用了setSingleView()函数，这是为了防止mock框架从控制器解析view名字。在很多情况下并没有这个必要，但是对于SpittleController控制器来说，视图名称和路径名称相同，如果使用默认的视图解析器，则MockMvc会混淆这两者而失败，报出如下图所示的错误：
在这里其实可以随意设置InternalResourceView的路径，但是为了和WebConfig中的配置相同。
通过get方法构造GET请求，访问"/spittles"，并确保返回的视图名称是"spittles"，返回的model数据中包含spittleList属性，且对应的值为我们之前创建的测试数据。
最后，为了使用hasItems，需要在pom文件中引入hamcrest库，代码如下
org.hamcrest hamcrest-library 1.3
现在跑单元测试的话，必然会失败，因为我们还没有提供SpittleController的对应方法，代码如下：
package org.test.spittr.web;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.test.spittr.data.SpittleRepository;
@Controller
@RequestMapping("/spittles")
public class SpittleController {
private SpittleRepository spittleRepository;
@Autowired
SpittleController(SpittleRepository spittleRepository) {
this.spittleRepository = spittleRepository;
}
@RequestMapping(method = RequestMethod.GET)
public String spittles(Model model) {
model.addAttribute(
spittleRepository.findSpittles(Long.MAX_VALUE, 20));
return "spittles";
}
}
Model对象本质上是一个Map，spittles方法负责填充数据，然后跟视图的逻辑名称一起回传给DispatcherServlet。在调用addAttribute方法的时候，如果不指定key字段，则key字段会从value的类型推导出，在这个例子中默认的key字段是spittleList。
如果你希望显式指定key字段，则可以按照如下方式指定：
@RequestMapping(method = RequestMethod.GET)
public String spittles(Model model) {
model.addAttribute("spittleList",
spittleRepository.findSpittles(Long.MAX_VALUE, 20));
return "spittles";
}
另外，如果你希望尽量少使用Spring规定的数据类型，则可以使用Map代替Model。
还有另一种spittles方法的实现，如下所示：
@RequestMapping(method = RequestMethod.GET) public Listspittles() { return spittleRepository.findSpittles(Long.MAX_VALUE, 20)); }
这个版本和之前的不同，并没有返回一个逻辑名称以及显式设置Model对象，这个方法直接返回Spittle列表。在这种情况下，Spring会将返回值直接放入Model对象，并从值类型推导出对应的关键字key；然后从路径推导出视图逻辑名称，在这里是spittles。
无论你选择那种实现，最终都需要一个页面——spittles.jsp。JSP页面使用JSTL库的
