书籍是全世界的营养品。生活里没有书籍，就好像没有阳光；智慧里没有书籍，就好像鸟儿没有翅膀。
Spring mvc在Spring特征里面处于满核心的地位，在官网上的对Spring 特征（FEATURES）罗列中，对应这是“MODERN WEB”（现代web），也就是Spring特征的第一项。也反映了其重要作用，另一方面也是因为mvc在Spring项目中诞生比较早。
只要是同网络应用相关的，无论是有同用户互动的(带UI的)或者没有互动的情况，spring mvc都是种成熟、功能齐全的架构。阅读下面的内容需要对java、spring(依赖注入dependency injection)、servlet需要有些基本的了解。
Spring的MVC框架如下图所示：
在Spring MVC中前端的控制器就是DispatcherServlet这个Servlet来掌管着用户的请求及最后的系统回应。这个DispatcherServlet同具体的业务逻辑一点都不着边，而是把所有的事情委派给控制器去做(Controller)，当然DispatcherServlet是知道该把当前的事情交个那个控制器去做，这个后面会讲；然后当控制器把事情都做完了后，这个时候轮到视图（View）上场了，简单的理解好比我们做PPT，那么这里的视图好比PPT里面的模板，它可以把数据以不同的展现形式交给客户，可以是jsp、xml、json等等。下面来看看如何具体实现的：
1、Servlet部分，上面说到前端控制器是DispatcherServlet这个Servlet，那很显然需要在web.xml中加入一个servlet，然后把用户的请求都让DispatcherServlet去处理，下面是web.xml文件：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
<?xmlversion="1.0"encoding="UTF-8"?>
<web-appversion="2.5"xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
|
关于上下文的配置，这里使用的是xml的配置方式，上面代码指定了配置文件是/WEB-INF/spring/appServlet/servlet-context.xml，这个也可以使用java的配置方式，这里需要在DispatcherServlet的初始参数中加入AnnotationConfigWebApplicationContext。另外在下面的例子中我们会看到组件即可以在XML中配置但也可以使用java代码来做。接下来看看第一个controller
2、Controller类，下面是一个最mini的控制类了：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package xyz.sample.baremvc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* Handles requests for the application home page.
*/
@Controller
public class HomeController {
@RequestMapping(value = "/")
public String home() {
System.out.println("HomeController: Passing through...");
return "WEB-INF/views/home.jsp";
}
}
|
1、使用了@Controller这个annotation(这个可以翻译成“注释”，表示下面的类的作用)，来表示HomeController这个类是作为Spring MVC中的Controller(控制器)，根据上面的那个图也就是表示这个类具有处理用户请求的能力。另外@Controller是@Component这个annotation中的特定annotation(有点类似@Component是@Controller的父类一样，@Component相当于抽象程度比较高，@Controller是属于一种特定的@Component)，所以这里HomeController也是作为一个组件(Component)，在Spring初始化扫描的时候它会被自动检测到并且加入到Spring container中(Spring容器或者叫Spring上下文，都是类似的概念)，然后生成对应的类实例，最后像其他任何Spring组件一样允许注入到系统中。
2、home这个方法使用了@RequestMapping这个注释，表示home这个方法可以用来处理对应于路径“/”（根路径）的用户请求
3、这里home的处理就是在log中打印一个字符串，然后返回WEB-INF/views/home.jsp，这个是交给View去处理的，这里就是个jsp文件，默认情况下，如果我们没有设置特定的View的话，Spring会使用默认的View来处理WEB-INF/views/home.jsp这个Response(回应)；对应View在后面将详细讲，这里只要知道View会把系统的home.jsp这个文件呈现给客户就好
下面是对应的home.jsp文件，文件很简单，只是个Hello：
|
1
2
3
4
5
6
7
8
9
10
|
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<title>Home</title>
</head>
<body>
<h1>Hello world!</h1>
</body>
</html>
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Scans within the base package of the application for @Components to configure as beans -->
<!-- @Controller, @Service, @Configuration, etc. -->
<context:component-scanbase-package="xyz.sample.baremvc"/>
<!-- Enables the Spring MVC @Controller programming model -->
<mvc:annotation-driven/>
</beans>
|
2、这里一共有三个名字空间，第一个是默认的beans、然后是mvc和context。
3、<context:component-scan/>表示要求Spring 容器(Spring container)对类进行扫描、检查，这样所有代码中包含有属于@Component子类型的注释(例如上面的@Controller就是属于@Component的子类型)都会被检查到，然后为了提高效率，这里自动检查的范围只在xyz..sample.baremvc这个包下面进行。
4、<mvc:annotation-driven />，表示可以使用annotation来进行工作，也就是支持Spring MVC将请求转给@Controller去处理；当然还可以涉及到如转换、格式化、有效性
通过上面的几个步骤后，启动服务器，在地址栏输入http://localhost:8080/baremvc，可以看到下面的效果：
上面的这个例子十分简单吧，但是却涉及到了Spring MVC应用的关键部分，来看看这个应用的调用流程：
A、当Tomcat启动，我们的Spring MVC应用被启动起来，DispatcherServlet被加载进来，这是因为我们在Web.xml中定了这个Servlet。
B、DispatcherServlet去加载基于注释(annotation)的Spring应用上下文，这里是通过对指定的包(指定的包可以使用正则表达式)进行scan的方式来获得带注释的组件。
C、这些带注释的组件被Spring 的 container检测到。
D、http://localhost:8080/baremvc的HTTP请求匹配了我们DispatcherServlet中的servlet-mapping，所以DispatcherServlet将去处理这个HTTP请求
E、在上面的HTTP请求中暗示着用户的请求路径为“/”，然后DispatcherServlet发现他里面有相应该路径请求的映射(这个其实是我们第二张图里面的那个Handler Mapping)
F、Dispatcher进行决定要如何处理请求，它使用到的策略叫做HandlerAdapter，这个可以这么理解，对于request(请求)来说必须要有对应的handler(处理办法)去处理，而这些handler可能根据当前所处的不同情况，而使用不同类别的handler，所以这里还需要一个HandlerAdapter来作为不同情况下的来转换不同类别的handler去处理request。这个HandlerAdapter(或者多个，可以将它们链接起来)我们可以去指定，但是没有指定的情况下将使用系统默认的HandlerAdapter，这里就是使用注释驱动(annotation-based)的策略了。这里就是把请求转给@Controller，然后找到匹配对应路径的@RequestMapping方法，将输入的参数给该方法，并让该方法处理请求。使用其他HandlerAdapter的例子还没做，但是暂时我们不去关心这些，只要有个了解就ok了
G、然后home这个方法做它的事情，打印一个log，然后返回一个字符串，这个字符串暗示了要呈现给用户的东西，也帮助View选择合适呈现方式。
H、然后从第一个图中我们知道，Controller做完事情后，任务又交到DispatcherServlet手上了，对于如何选择合适的视图，同样DispatcherServlet需要策略，这次的策略叫做ViewResolver，通过这个ViewResolver（视图仲裁员）去仲裁那个视图(View)将回应呈现给用户，这个ViewResolver也是可以自己定义的。如果默认没有配置的情况下系统将使用InternalResourceViewResolver，这个ViewResolver将创建一个JSTLView，而这个View只是简单的把任务委托给Servlet内部的RequestDispatcher去呈现资源，所以这种View很适合于使用JSP或者HTML页面的情况
I、最后Servlet将回应通过制定的jsp呈现给用户
4、对View进行抽象，让Controller返回一个纯粹的逻辑性的名称。
上面的home函数中我们看到返回的是个纯粹的物理地址，为了减少耦合，让应用有更好的弹性，当然是不能使用这种硬编码的方式；要让Controller返回一个逻辑的名称，而最终的物理路径由View来决定，这样让Controller只关心逻辑上的处理，把展示留给View去做，真正做到C和V分离。看下改造了得Controller：
|
1
2
3
4
5
6
7
8
9
|
@Controller
publicclassHomeController {
@RequestMapping(value = "/")
publicString home() {
System.out.println("HomeController: Passing through...");
return"home";
}
}
|
接下来我们要做的就是把”home“这个名称映射到”WEB-INF/views/home.jsp“这个文件上面。上面我们说过默认情况下这种映射是通过InternalResourceViewResolver类来处理的。我们可以使用自己的ViewResolver来处理这种逻辑到物理的映射，但是这个例子里面我们只需要对InternalResourceViewResolver做一点点调整就可以达到我们的目的了。
InternalResourceViewResolver对Controller返回过来（其实最后是DispatcherServlet发过来的）的名称，只是在其前后加上可选的前后缀(默认情况为空)，然后把这个字符串交给由它自己创建的JSTLView，然后JSTLView再委托Servlet引擎中的RequestDispatcher去干真正的活，呈现视图模板，这里是jsp做视图的模板。这个例子里比较简单，只要对View的名称返回增加相应的前后缀就可以了，前缀”WEB-INF/views/“，后缀".jsp"。一种简单的配置ViewResolver的方式是使用以java为基本的容器配置（另外就是以XML为基础的容器配置/上下文配置），把我们的Resolver定义为一个Bean，下面是对应的代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
packagexyz.sample.baremvc;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.web.servlet.ViewResolver;
importorg.springframework.web.servlet.view.InternalResourceViewResolver;
@Configuration
publicclassAppConfig {
// Resolve logical view names to .jsp resources in the /WEB-INF/views directory
@Bean
ViewResolver viewResolver() {
InternalResourceViewResolver resolver = newInternalResourceViewResolver();
resolver.setPrefix("WEB-INF/views/");
resolver.setSuffix(".jsp");
returnresolver;
}
}
|
由于@Configuration也是一个@Component，所以扫描的时候也会被扫描到，然后这个配置组件(Configuration)会被加入到Spring容器中，Spring容器还会扫描所有的Bean并发现ViewResolver（也就是我们的容器里多了个由viewResolver函数里面创建的resolver，作为一个bean），然后使用这个ViewResolver来处理逻辑的View名称。
上面的使用的是java的方式，有些人喜欢xml的方式，如下面：
|
1
2
3
4
5
|
<!-- Resolve logical view names to .jsp resources in the /WEB-INF/views directory -->
<beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
<propertyname="prefix"value="/WEB-INF/views/"/>
<propertyname="suffix"value=".jsp"/>
</bean>
|
5、处理用户输入
我们总是要和用户互动的，让我们看看如何处理些简单的用户输入，然后再输出结果给用户。在Spring MVC中有多种输入、输出的方式，让我们看看最简单的一种。这里我们把上面的HomeController中增加一个的处理请求的方法，让它能获得两个用户输入的字符，然后进行比较，并且把结果通过jsp输出给用户，看看增加的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
packagexyz.sample.baremvc;
importjava.util.Comparator;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Controller;
importorg.springframework.ui.Model;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RequestMethod;
importorg.springframework.web.bind.annotation.RequestParam;
/**
* Handles requests for the application home page.
*/
@Controller
publicclassHomeController {
@Autowired
Comparator<String> comparator;
@RequestMapping(value = "/")
publicString home() {
System.out.println("HomeController: Passing through...");
return"home";
}
@RequestMapping(value = "/compare", method = RequestMethod.GET)
publicString compare(@RequestParam("input1") String input1,
@RequestParam("input2") String input2, Model model) {
intresult = comparator.compare(input1, input2);
String inEnglish = (result < 0) ? "less than": (result > 0? "greater than": "equal to");
String output = "According to our Comparator, '"+ input1 + "' is "+ inEnglish + "'"+ input2 + "'";
model.addAttribute("output", output);
return"compareResult";
}
}
|
2、这个函数希望用户通过GET请求的方式传入两个字符作为其参数，如果用户没有传两个指定名称（input1和input2）的字符串来，则会提示HTTP 400的错误，然后这里compare函数获得用户GET请求中的参数是通过@RequestParam这个注释来实现的。
3、我们使用自己定义的比较器来比较这两个字符串。这里注意到@Autowired，也就Spring通过在container中寻找类型同comparator相同(Comparator<String>)的组件，然后wired(连接)到comparator上面（可以理解为调用setComparator这样）
4、最后我们使用了Model来放置比较的结果，这样View将可以获得放在Model中的结果，这里只要把Model看做一个HashMap就可以了，名称->数据的一个对应。放到Model中的数据主要为了View能够访问这些有用的数据。上面的例子中只是个字符串，将来呈现到jsp上面。
我们创建一个对应的jsp文件来显示结果，WEB-INF/views/compareResult.jsp：
|
1
2
3
4
5
6
7
8
9
10
|
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<title>Result</title>
</head>
<body>
<h1><c:outvalue="${output}"></c:out></h1>
</body>
</html>
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
packagexyz.sample.baremvc;
importjava.util.Comparator;
importorg.springframework.stereotype.Component;
@Service
publicclassCaseInsensitiveComparator implementsComparator<String> {
publicintcompare(String s1, String s2) {
asserts1 != null&& s2 != null;
returnString.CASE_INSENSITIVE_ORDER.compare(s1, s2);
}
}
|
现在我们可以输入一个地址看看 http://localhost:8080/baremvc/compare?input1=Donkey&input2=dog：
最后想了解更多Spring MVC的特性的话，可以看看这个 show case
