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
@EnableWebMvc
public 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 {

@Test
public 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;"> //拆分前
@Controller
public 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;
}

@Override
public boolean equals(Object that) {
return EqualsBuilder.reflectionEquals(this, that, "id", "time");
}

@Override
public 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 来断言新的处理器方法中你所期望的行为）

@Test
public 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;

@Autowired
public 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方法依然会被调用；