spring(5)构建 spring web 应用程序

【0】README

1）本文部分文字描述转自：“Spring In Action（中/英文版）”，旨在review  “spring(5)构建 spring web 应用程序” 的相关知识；

【1】spring mvc 起步

【1.1】跟踪spring mvc的请求

1）请求时一个十分繁忙的家伙，下图展示了请求使用spring mvc所经历的 站点；

对以上调用过程的分析（Analysis）：（不能再干货——请求使用spring mvc 所经历的调用过程）

step1）请求旅程的第一站是spring 的 DispatchServlet： 与大多数java web 框架一样，spring mvc所有请求都会通过一个前端控制器 servlet，而DispatchServlet就是前端控制器；

step2）接着，DispatchServlet的任务是将请求发送给 spring mvc控制器。因为应用程序中有很多控制器，在发送之前DispatchServlet需要查询一个或多个控制器映射来确定请求的下一站在哪里；处理器映射会根据所携带的URL信息来进行决策；

step3）DispatchServlet会将请求发送给选中的控制器；到了控制器 ， 请求会卸下其负载（用于提交的info），并耐心等待控制器处理这些 info；

step4）处理器完成逻辑处理后，会产生一些info，这些info 需要返回给用户并在浏览器上显示。这些info 被称为 模型；（干货——模型的定义）；这些info 需要以用户友好的方式进行格式化，一般会是 HTML，所以，info需要发送给一个视图（view），通常会是 JSP；控制器所做的最后一件事情是将模型数据打包，并标示出用于渲染输出的视图名。它接下来会将请求连同模型和视图名发送回 DispatchServlet；（总结：这样，控制器就不会与特定的视图相耦合了，传递给DispatchServlet的视图名并不直接表示某个特定的JSP，。实际上，它仅仅传递了一个逻辑名称，这个名字将会用来产生结果的真正视图）（干货——引入了逻辑名称，由控制器传递给DispatchServlet，前者还传递了模型（响应info的打包））

step5）DispatchServlet将会使用视图解析器来将逻辑视图名匹配为一个特定的视图实现，可能是也可能不是JSP；

step6）通过控制器传递过来的逻辑名称，DispatchServlet知道由哪个视图渲染结果。DispatchServlet交付模型数据到某个视图的实现，请求的任务完成了；

step7）视图将使用模型数据渲染输出，这个输出会通过响应对象传递给客户端；

【1.2】搭建spring mvc

【1.2.1】配置DispatchServlet

1）intro to DispatchServlet：DispatchServlet 是 spring mvc的核心，它负责将请求路由到其他组件中；（干货——引入了路由的概念，路由分发）

2）使用java 将 DispatchServlet 配置在 servlet容器中，而不会再使用 web.xml 文件；

<span style="font-family:SimSun;font-size:18px;">public class SpitterWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {      @Override  protected Class<?>[] getRootConfigClasses() {    return new Class<?>[] { RootConfig.class };  }  @Override  protected Class<?>[] getServletConfigClasses() {  // 指定配置类.    return new Class<?>[] { WebConfig.class };  }  @Override  protected String[] getServletMappings() { // 将DispatcherServlet映射到 "/"    return new String[] { "/" };  }}</span>

<span style="font-family:SimSun;font-size:18px;">public abstract class AbstractAnnotationConfigDispatcherServletInitializer  extends AbstractDispatcherServletInitializer {    // org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer @Override protected WebApplicationContext createRootApplicationContext() {  Class<?>[] configClasses = getRootConfigClasses();  if (!ObjectUtils.isEmpty(configClasses)) {   AnnotationConfigWebApplicationContext rootAppContext = new AnnotationConfigWebApplicationContext();   rootAppContext.register(configClasses);   return rootAppContext;  }  else {   return null;  } } @Override protected WebApplicationContext createServletApplicationContext() {  AnnotationConfigWebApplicationContext servletAppContext = new AnnotationConfigWebApplicationContext();  Class<?>[] configClasses = getServletConfigClasses();  if (!ObjectUtils.isEmpty(configClasses)) {   servletAppContext.register(configClasses);  }  return servletAppContext; } protected abstract Class<?>[] getRootConfigClasses(); protected abstract Class<?>[] getServletConfigClasses(); }</span>

对上述代码的分析（Analysis）：要理解上述代码是如何工作的？我们只需要知道扩展 AbstractAnnotationConfigDispatcherServletInitializer 的任意类都会自动配置 DispatcherServlet 和 Spring 应用上下文，spring应用上下文会位于应用程序的 servlet上下文中；

3）关于 AbstractAnnotationConfigDispatcherServletInitializer 的剖析：在 servlet3.0环境中，容器会在类路径中查找实现 javax.servlet.ServletContainerInitializer 接口的类，如果能发现的话，就会用来配置 servlet容器；

3.1）spring 提供了这个接口的实现，名为 SpringServletContainerInitializer：这个类反过来又会查找实现 WebApplicationInitializer 的类并将配置的任务交给它们来完成；

3.2）spring3.2 引入了一个便利的 WebApplicationInitializer 基础实现，也就是AbstractAnnotationConfigDispatcherServletInitializer。因为我们的SpitterWebInitializer扩展了 AbstractAnnotationConfigDispatcherServletInitializer（同时也就实现了 WebApplicationInitializer） ，。因此当部署到 servlet3.0 容器的时候，容器会自动发现它，并用它来配置servlet上下文；

4）上述代码中的SpitterWebInitializer 类 重写了三个AbstractAnnotationConfigDispatcherServletInitializer 的方法：

method1）getServletMappings方法：它会将一个或多个路径映射到 DispatcherServlet上；在本例中，它映射的是“/“，这表示它会是 应用的默认 servlet，它会处理进入应用的所有请求；（为了理解其他两个方法，首先要理解 DispatcherServlet和一个 servlet 监听器的关系）

【1.2.2】 两个应用上下文之间的故事

1）当 DispatcherServlet启动的时候，它会创建spring 应用上下文，并加载配置文件或配置类中所声明的 bean；在getServletConfigClasses()方法中，我们要求 DispatcherServlet 加载应用上下文时，使用定义在 WebConfig配置类（使用java  配置）中的 bean；（在spring 应用中，还有另外一个应用上下文，由 ContextLoaderListener 创建）

2）我们希望 DispatcherServlet加载包含 Web组件的bean，如控制器，视图解析器以及处理器映射，而 ContextLoaderListener 要加载应用中的其他bean。这些bean 通常是 驱动应用后端的中间层 和 数据层组件；

3）实际上，AbstractAnnotationConfigDispatcherServletInitializer 会同时创建 DispatcherServlet 和 ContextLoaderListener。

3.1）getServletConfigClasses()方法：返回的带有 @Configuration注解的类将会用来定义 DispatcherServlet应用上下文中的bean。

3.2）getRootConfigClasses()方法：返回的带有@Configuration注解的类将会用来配置 ContextLoaderListener 创建的应用上下文中的bean；

4）如果按照这种方式配置 DispatcherServlet，而不使用web.xml的话。唯一的问题在于：它只能部署到支持 servlet3.0 的服务器中才能正常工作；

【1.2.3】启用spring mvc

1）启动 spring mvc组件的方法也不止一种：可以使用 <mvc: annotation-driven>启用注解驱动的spring mcv；

2）我们创建的最简单的spring mvc 配置是一个带有 @EnableWebMvc注解的类：

<span style="font-family:SimSun;font-size:18px;">@Configuration@EnableWebMvcpublic class WebConfig {}</span>

2.1）以上代码的确能够启用 spring mvc，但还有不少问题要解决：（problems）

problem1）没有配置视图解析器：这样的话，spring默认会使用 BeanNameViewResolver，这个视图解析器会查找ID 与 视图名称匹配的bean，并且查找的bean 要实现 View 接口，它以这样的方式来解析视图；

problem2）没有启用组件扫描：这样的话，spring 只能找到显式声明在配置类中的控制器；

problem3）这样配置的话，这样配置的话，DispatcherServlet 会映射为 应用的默认servlet：所以它会处理所有的请求，包括对静态资源的请求，如图片等；（大多数cases下，这不是你想要的效果）

2.2）修改WebConfig这个spring mvc配置类， 修改后的内容为：

<span style="font-family:SimSun;font-size:18px;">@Configuration@EnableWebMvc //启用spring mvc.@ComponentScan("com.spring.chapter5.spittr.web") // 启用组件扫描.public class WebConfig extends WebMvcConfigurerAdapter {  @Bean  public ViewResolver viewResolver() { // 配置JSP视图解析器.    InternalResourceViewResolver resolver = new InternalResourceViewResolver();    resolver.setPrefix("/WEB-INF/views/");    resolver.setSuffix(".jsp");    return resolver;  }   @Override  public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { // 配置静态资源处理.    configurer.enable();  }   @Override  public void addResourceHandlers(ResourceHandlerRegistry registry) {    // TODO Auto-generated method stub    super.addResourceHandlers(registry);  }}</span>

对以上代码的分析（Analysis）：新的 WebConfig 扩展了WebMvcConfigurerAdapter类，重写了其 configureDefaultServletHandling()方法，通过调用 DefaultServletHandlerConfigurer .enable()方法，我们要求 DispatcherServlet 将对静态资源的请求转发到 Servlet容器中默认的Servlet上，而不是使用 DispatcherServlet 本身来处理此类请求；

3）RootConfig 的源码定义如下：

@Configuration@ComponentScan(basePackages={"com.spring.chapter5.spittr"},     excludeFilters={        @Filter(type=FilterType.ANNOTATION, value=EnableWebMvc.class)    })public class RootConfig {}

【1.3】Spittr 应用简介（Spittr 应用 == Twitter系统）

1）Spitter 应用有两个基本的概念：　应用用户 和 用户发布的info（Spittle）

2）通过配置 DispatcherServlet来启用基本的 spring mvc 组件并确定了目标应用，让我们进入核心内容：使用 spring mvc 控制器处理 web 请求；

【2】编写基本的控制器

1）intro：控制器只是方法上添加了 @RequestMapping 注解 的类，该注解声明了它们所要处理的请求；（干货——注解@RequestMapping的作用）

2）看个荔枝：若控制器类要处理 ”/“ 请求，并渲染应用的首页，控制器定义如下：

<span style="font-family:SimSun;font-size:18px;">@Controller // 声明一个控制器@RequestMapping("/")public class HomeController {  @RequestMapping(method = GET) // 处理对 ”/“ 的get请求；  public String home(Model model) {    return "home"; //视图名为home  }}</span>

对上述代码的分析（Analysis）：

A1）@Controller注解：是一个构造型注解，它基于 @Component注解。在这里，它的目的是 辅助实现组件扫描，因为 HomeController 带有 @Controller注解，因此组件扫描器会自动找到 HomeController，并将其声明为 spring应用上下文中的一个 bean；（干货——@Controller注解的作用）

A2）@RequestMapping注解：它的value属性指定了这个方法所要处理的请求路径，method细化了所要处理的HTTP方法；

3）鉴于配置InternalResourceViewResolver的方式，视图名"home" 将会解析为 "WEB-INF/views/home.jsp"路径的JSP（参见【1.2.3】章节下面的2.2）下面的InternalResourceViewResolver定义及其其前缀和后缀）；Spitter 应用的首页为：

<span style="font-family:SimSun;font-size:18px;"><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><%@ page session="false" %><html>  <head>    <title>Spitter</title>    <link rel="stylesheet"           type="text/css"           href="<c:url value="/resources/style.css" />" >  </head>  <body>    <h1>Welcome to Spitter</h1>    <a href="<c:url value="/spittles" />">Spittles</a> |     <a href="<c:url value="/spitter/register" />">Register</a>  </body></html></span>

【2.1】测试控制器

1）测试用例如下：上面的测试用例貌似很low，没有断言当接收到针对 ”/“ GET 请求时会调用home()方法；

2）spring包含了一种 mock spring mvc 并针对控制器执行 HTTP 请求的机制：这样的话，就没有必要再启动web 服务器和浏览器了；（干货——引入了mock spring mvc 并针对控制器执行 HTTP 请求的机制）

3）如何测试 spring mvc的控制器？

public class HomeControllerTest {@Testpublic void testHomePage() throws Exception {HomeController controller = new HomeController();String result = controller.home(null);System.out.println(result);}}

对以上代码的分析（Analysis）： 这次没有直接调用 home()方法，而是发起了对 "/" 的 GET 请求，并断言结果视图 名称为 home；（这个测试用例，一点干货都没得，哎）

【2.2】定义类级别的请求处理

1）拆分 @RequestMapping注解，并将其路径映射部分放到类级别上；

<span style="font-family:SimSun;font-size:18px;"> //拆分前@Controllerpublic class HomeController {  @RequestMapping(value="/", method = GET)  public String home(Model model) {    return "home";  }}//拆分后@Controller@RequestMapping("/")public class HomeController {  @RequestMapping(method = GET)  public String home(Model model) {    return "home";  }}</span>

2）也可以设置多个映射路径，修改@RequestMapping注解如下：

<span style="font-family:SimSun;font-size:18px;">@Controller@RequestMapping({"/" ,"/homepage"}) // 设置多个映射路径.public class HomeController() {    ......}</span>

【2.3】传递模型数据到视图中

1）在 Spittr 应用中，需要有一个页面展现最近提交的 Spittle列表；

2）处理steps：

step1）首先，需要定义一个数据访问的 Repository（能够获取 Spittle列表的 Repository）；

<span style="font-family:SimSun;font-size:18px;">public interface SpittleRepository {  List<Spittle> findRecentSpittles();  List<Spittle> findSpittles(long max, int count);      Spittle findOne(long id);  void save(Spittle spittle);}// 为了获取最新的20个 Spittle 对象，我们可以这样调用 findSpittles(long max, int count)：// List<Spittle> recent =  spittleRepository.findSpittles(Long.MAX_VALUE, 20);</span>

step2）Spittle 的源码如下：

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(null, message, time, null, null);}public Spittle(Long id, String message, Date time, Double longitude,Double latitude) {this.id = id;this.message = message;this.time = time;this.longitude = longitude;this.latitude = latitude;}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;}@Overridepublic boolean equals(Object that) {return EqualsBuilder.reflectionEquals(this, that, "id", "time");}@Overridepublic int hashCode() {return HashCodeBuilder.reflectionHashCode(this, "id", "time");}}

对以上代码的分析（Analysis）：使用了 Apache Common Lang 包来实现了 equals()方法 和 hashCode()方法；（downloading from apache commons lang）

step3）测试 SpittleController处理针对 "/spittles" 的GET请求：（使用 spring 的 MockMvc 来断言新的处理器方法中你所期望的行为）

@Testpublic void shouldShowRecentSpittles() throws Exception {List<Spittle> expectedSpittles = createSpittleList(20);SpittleRepository mockRepository = mock(SpittleRepository.class);when(mockRepository.findSpittles(Long.MAX_VALUE, 20)).thenReturn(expectedSpittles);SpittleController controller = new SpittleController(mockRepository);SpittleController controller = new SpittleController(mockRepository);MockMvc mockMvc = standaloneSetup(controller).setSingleView(new InternalResourceView("/WEB-INF/views/spittles.jsp")).build();mockMvc.perform(get("/spittles")).andExpect(view().name("spittles")).andExpect(model().attributeExists("spittleList")).andExpect(model().attribute("spittleList",hasItems(expectedSpittles.toArray())));}private List<Spittle> createSpittleList(int count) {List<Spittle> spittles = new ArrayList<Spittle>();for (int i = 0; i < count; i++) {spittles.add(new Spittle("Spittle " + i, new Date()));}return spittles;}

step4）SpittleController：在模型中放入最新的 Spittle列表

@Controller@RequestMapping("/spittles")public class SpittleController {private static final String MAX_LONG_AS_STRING = "9223372036854775807";private SpittleRepository spittleRepository;@Autowiredpublic SpittleController(SpittleRepository spittleRepository) {this.spittleRepository = spittleRepository;}@RequestMapping(method = RequestMethod.GET)public String spittles(Model model) { // Model实际上就是一个Map，他会传递给视图，这样就能渲染到client.model.addAttribute(spittleRepository.findSpittles(Long.MAX_VALUE, 20));return "spittles";}}

对上述代码的分析（Analysis）：

A1）当调用 addAttribute()方法而不指定key时，那么key 会根据值的对象类型推断确定。因为它是一个List<Spittle>，所以推断key == spittleList。
A2）如果你想显示指定模型的key的话，可以这样指定：

@RequestMapping(method = RequestMethod.GET)public String spittles(Model model) {model.addAttribute("spittleList", spittleRepository.findSpittles(Long.MAX_VALUE, 20));return "spittles";}

A3）我们还可以将该方法改写为：当处理器方法像这样返回对象或集合时，这个值会被放到模型中，且模型key会被推断为 spittleList；且逻辑视图的名称将会根据请求路径推断得出，因为请求路径是 "/spittles" 的 GET请求，所以视图名称会是  spittles（去掉斜线即可）；

@RequestMapping(method=RequestMethod.GET)public List<Spittle> spittles() {return spittleRepository.findSpittles(Long.MAX_VALUE, 20));}

Attention）不管选择哪种方式编写 spittles()方法，所达到的效果是一样的。

A1）模型中会存储一个Spittle列表，key 为 spitleList，然后该列表会被发送到 spittles的视图中；

A2）按照 InternalResourceViewResolver, 视图解析器的配置，视图的JSP将是 /WEB-INF/views/spittles.jsp；该jsp的源码如下：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%><%@ taglib prefix="s" uri="http://www.springframework.org/tags"%><%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %><html>  <head>    <title>Spitter</title>    <link rel="stylesheet" type="text/css" href="<c:url value="/resources/style.css" />" >  </head>  <body>    <div class="spittleForm">      <h1>Spit it out...</h1>      <form method="POST" name="spittleForm">        <input type="hidden" name="latitude">        <input type="hidden" name="longitude">        <textarea name="message" cols="80" rows="5"></textarea><br/>        <input type="submit" value="Add" />      </form>    </div>    <div class="listTitle">      <h1>Recent Spittles</h1>      <ul class="spittleList">        <c:forEach items="${spittleList}" var="spittle" >          <li id="spittle_<c:out value="spittle.id"/>">            <div class="spittleMessage"><c:out value="${spittle.message}" /></div>            <div>              <span class="spittleTime"><c:out value="${spittle.time}" /></span>              <span class="spittleLocation">(<c:out value="${spittle.latitude}" />, <c:out value="${spittle.longitude}" />)</span>            </div>          </li>        </c:forEach>      </ul>      <c:if test="${fn:length(spittleList) gt 20}">        <hr />        <s:url value="/spittles?count=${nextCount}" var="more_url" />        <a href="${more_url}">Show more</a>      </c:if>    </div>  </body></html>

【3】接收请求的输入

1）spring mvc 以多种方式将客户端中的数据传送到控制器的处理器方法中包括：查询参数， 表单参数，路径变量等；

【3.1】处理查询参数

1）Spittr应用需求的第一件事： 展现分页的 Spittle列表；

2）为了实现分页，处理器方法要接受如下参数：

parameter1）before参数：表明查询出的id 要在这个值之前；

parameter2）count参数：表明每页的 Spittle 数量；

<span style="font-family:SimSun;font-size:18px;">@Test public void shouldShowPagedSpittles() throws Exception {  List<Spittle> expectedSpittles = createSpittleList(50);  SpittleRepository mockRepository = mock(SpittleRepository.class);  when(mockRepository.findSpittles(238900, 50)).thenReturn(    expectedSpittles);  SpittleController controller = new SpittleController(mockRepository);  MockMvc mockMvc = standaloneSetup(controller).setSingleView(    new InternalResourceView("/WEB-INF/views/spittles.jsp"))    .build();  mockMvc.perform(get("/spittles?max=238900&count=50"))    .andExpect(view().name("spittles"))    .andExpect(model().attributeExists("spittleList"))    .andExpect(      model().attribute("spittleList",        hasItems(expectedSpittles.toArray())));</span>

对以上代码的分析（Analysis）：上述方法的关键区别在于它针对 "/spittles" 发送 GET 请求，同时还传入了 max 和 count参数；

<span style="font-family:SimSun;font-size:18px;">@RequestMapping(method=RequestMethod.GET)public List<Spittle> spittles(@RequestParam("max") long max,@RequestParam("count") int count) {return spittleRepository.findSpittles(max, count);}</span>

<span style="font-family:SimSun;font-size:18px;">@RequestMapping(method = RequestMethod.GET) public List<Spittle> spittles(    @RequestParam("max") long max,   @RequestParam("count") int count) {  return spittleRepository.findSpittles(max, count); }</span>

3）SpittleController中的处理器方法要同时处理有参数和没有参数的case，修改 @RequestParam注解，让它能够接收参数；@RequestParam注解的 defaultValue 属性可以完成这个任务.

<span style="font-family:SimSun;font-size:18px;">@RequestMapping(method = RequestMethod.GET) public List<Spittle> spittles(   @RequestParam(value = "max", defaultValue = MAX_LONG_AS_STRING) long max,   @RequestParam(value = "count", defaultValue = "20") int count) {  return spittleRepository.findSpittles(max, count); }</span>

4）请求中的查询参数是往控制器中传递信息的常用手段。另外一种方式很流行，就是将传递参数作为请求路径的一部分；

【3.2】通过路径参数接收输入

1）应用需求：工具给定 Id 来展现某个 Spittle 记录，通过使用 @RequestParam 注解，让它接收ID 作为查询参数；

<span style="font-family:SimSun;font-size:18px;">@RequestMapping(value = "/show", method = RequestMethod.GET) public String showSpittle(@RequestParam("spittle_id") long spittleId,   Model model) {  model.addAttribute(spittleRepository.findOne(spittleId));  return "spittle"; }</span>

对以上代码的分析（Analysis）：对 "/spittles/12345" 发起 GET 请求要优于对 "/spittles/show/spittle_id=12345" 发起请求。前者能够识别出查询的资源，而后者描述的是带有参数的一个操作——本质上是通过 HTTP 发起的 RPC（远程过程调用协议）；

2）Spittr应用以面向资源的控制器作为目标，下面给出测试用例

<span style="font-family:SimSun;font-size:18px;">@Test public void testSpittle() throws Exception {  Spittle expectedSpittle = new Spittle("Hello", new Date());  SpittleRepository mockRepository = mock(SpittleRepository.class);  when(mockRepository.findOne(12345)).thenReturn(expectedSpittle);  SpittleController controller = new SpittleController(mockRepository);  MockMvc mockMvc = standaloneSetup(controller).build();  mockMvc.perform(get("/spittles/12345"))    .andExpect(view().name("spittle"))    .andExpect(model().attributeExists("spittle"))    .andExpect(model().attribute("spittle", expectedSpittle)); }</span>

3）我们编写的 @RequestMapping注解要包含变量部分，这部分代表了 Spittle ID；为了实现这种路径变量，spring mvc 允许我们 在  @RequestMapping 路径中添加占位符。占位符的名称要用 大括号"({})" 括起来；下面的方法使用了占位符：

<span style="font-family:SimSun;font-size:18px;">@RequestMapping(value = "/{spittleId}", method = RequestMethod.GET) public String spittle(@PathVariable("spittleId") long spittleId, Model model) {  model.addAttribute(spittleRepository.findOne(spittleId));  return "spittle"; }</span>

<span style="font-family:SimSun;font-size:18px;">// 因为 方法的参数名与占位符的名称相同，所以可以去掉 @PathVariable 中的value属性；// 如果@PathVariable 中 没有 value属性，它会假设占位符的名称与方法的参数名相同；@RequestMapping(value = "/{spittleId}", method = RequestMethod.GET) public String spittle(@PathVariable long spittleId, Model model) {  model.addAttribute(spittleRepository.findOne(spittleId));  return "spittle"; }</span>

【4】处理表单

1）展现一个表单，允许用户注册

<span style="font-family:SimSun;font-size:18px;">@Controller @RequestMapping("/spitter") public class SpitterController {  @RequestMapping(value = "/register", method = GET)  // 这意味 这将会使用 /WEB-INF/views/registerForm.jsp 这个JSP 来渲染注册表单；  public String showRegistrationForm() {   return "registerForm";  } }</span>

2）测试展现表单的控制器方法；

<span style="font-family:SimSun;font-size:18px;">public void shouldShowRegistration() throws Exception {  SpitterController controller = new SpitterController();  MockMvc mockMvc = standaloneSetup(controller).build();  mockMvc.perform(get("/spitter/register")).andExpect(    view().name("registerForm")); }</span>

3）注册表单的JSP

【4.1】编写处理表单的控制器

1）intro：控制器需要接受表单数据并将其保存为 Spitter对象；

2）测试处理表单的控制器方法

<span style="font-family:SimSun;font-size:18px;">@Test public void shouldProcessRegistration() throws Exception {  SpitterRepository mockRepository = mock(SpitterRepository.class);  Spitter unsaved = new Spitter("jbauer", "24hours", "Jack", "Bauer");  Spitter saved = new Spitter(24L, "jbauer", "24hours", "Jack", "Bauer");  when(mockRepository.save(unsaved)).thenReturn(saved);  SpitterController controller = new SpitterController(mockRepository);  MockMvc mockMvc = standaloneSetup(controller).build();  mockMvc.perform(    post("/spitter/register").param("firstName", "Jack")      .param("lastName", "Bauer").param("username", "jbauer")      .param("password", "24hours")).andExpect(    redirectedUrl("/spitter/jbauer"));  verify(mockRepository, atLeastOnce()).save(unsaved); }</span>

2）处理所提交的表单并注册新用户

<span style="font-family:SimSun;font-size:18px;">@Controller @RequestMapping("/spitter") public class SpitterController {  private SpitterRepository spitterRepository;  @Autowired  public SpitterController(SpitterRepository spitterRepository) {   this.spitterRepository = spitterRepository;  }  @RequestMapping(value = "/register", method = GET)  public String showRegistrationForm() {   return "registerForm";  }  @RequestMapping(value = "/register", method = POST)  public String processRegistration(Spitter spitter) {   spitterRepository.save(spitter);   return "redirect:/spitter/" + spitter.getUsername();  // 当InternalResourceViewResolver 视图解析器看到 "redirect:" 前缀时，它就知道要将其解析为重定向的规则，而不是视图名称；  } }</span>

Attention）除了前缀  "redirect:"， InternalResourceViewResolver 视图解析器哈可以识别 "forward:"前缀：当发现此前缀时，请求将会前往(forward) 指定的URL 路径，而不是重定向了；

【4.2】校验表单

1）intro：如果输入的username 或 password为空的话，如果不处理的话，就会出现安全问题；

2）使用spring 对 java 校验API的支持： 从spring3.0 开始，在 spring mvc中提供了对ajva 校验API的支持。在spring mvc中要使用 java校验API的话，并不需要什么额外的配置。只要保证在类路径下包含这个java API的实现即可；

3）java校验API 定义了多个注解，位于 javax.validataion.constraints 包中；

4）Spitter 包含了要提交到 Spittle Post 请求中的域；

<span style="font-family:SimSun;font-size:18px;">public class Spitter {  private Long id;  @NotNull  @Size(min=5, max=16)  private String username;  @NotNull  @Size(min=5, max=25)  private String password;  @NotNull  @Size(min=2, max=30)  private String firstName;  @NotNull  @Size(min=2, max=30)  private String lastName;  ...  }</span>

2）启用校验功能的processRegistration()方法；

<span style="font-family:SimSun;font-size:18px;">@RequestMapping(value = "/register", method = POST) public String processRegistration(@Valid Spitter spitter, Errors errors) {  if (errors.hasErrors()) {   return "registerForm";  }  spitterRepository.save(spitter);  return "redirect:/spitter/" + spitter.getUsername(); }</span>

Attention）

A1）@Valid注解：告知spring， 需要确保这个对象满足校验限制；

A2）在 Spiter属性上添加校验限制并不能阻止表单提交。即便用户没有填写某个域或者某个域所给定的值超过了最大长度，processRegistration方法依然会被调用；