spring MVC的总体设计
在一个工程中如果想要使用 spring MVC的话，只需要两个步骤
在web.xml中配置一个DispatcherServlet。
需要配置一个org.springframework.web.servlet.DispatcherServlet的servlet。
再定义一个dispatcherServlet-servlet.xml配置文件。
在这个配置文件里面我们只需要扩展一个路径映射关系，定义一个视图解析器，再定义一个业务逻辑的处理流程规则。
这样就可以搞定一个最基本的Spring MVC的应用了。
对于DispatcherServlet初始化的时候初始了哪些东西，这些可以在initStrategies中看到。
/**
* Initialize the strategy objects that this servlet uses.
* <p>May be overridden in subclasses in order to initialize further strategy objects.
*/
protected void initStrategies(ApplicationContext context) {
//初始化MultipartResolver，主要是处理文件上传服务。
initMultipartResolver(context);
//用于处理应用的国际化问题
initLocaleResolver(context);
//用于定义一个主题
initThemeResolver(context);
//用于定义用户设置的请求映射关系
initHandlerMappings(context);
//用于根据Handler的类型定义不同的处理规则
initHandlerAdapters(context);
//当Handler处理错误的时候，通过这个handler来做统一的处理
initHandlerExceptionResolvers(context);
//将指定的ViewName按照定义的RequestToViewNameTranslator替换成想要的格式。
initRequestToViewNameTranslator(context);
//用于将view解析成页面
initViewResolvers(context);
//用于映射flash管理的。
initFlashMapManager(context);
}
小结： 对于spring MVC框架中，有三个组件是用户必须定义和扩展的：
定义URL映射规则：handlerMapping
实现业务逻辑的handler实例对象：handlerAdapter
渲染模版资源：ViewResolver
看看DispatcherServlet启用的时候做了哪些工作？
调用HttpServletBean的init()方法。在init()方法中，创建了BeanWrapper对象，并且执行了initServletBean()方法；
/**
* Map config parameters onto bean properties of this servlet, and
* invoke subclass initialization.
* @throws ServletException if bean properties are invalid (or required
* properties are missing), or if subclass initialization fails.
*/
@Override
public final void init() throws ServletException {
if (logger.isDebugEnabled()) {
logger.debug("Initializing servlet '" + getServletName() + "'");
}
// Set bean properties from init parameters.
try {
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.environment));
initBeanWrapper(bw);
bw.setPropertyValues(pvs, true);
}
catch (BeansException ex) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
throw ex;
}
// Let subclasses do whatever initialization they like.
initServletBean();
if (logger.isDebugEnabled()) {
logger.debug("Servlet '" + getServletName() + "' configured successfully");
}
}
调用FrameworkServlet的createWebApplicationContext方法，初始化spring容器。
调用FrameworkServlet的onRefresh方法完成配置文件的加载，配置文件的加载同样是先查找servlet的init-param参数中设置的路径，如果没有，就会根据namespace+Servlet的名称来查找XML文件。
Spring容器加载的时候会调用DispatcherServlet的initStrategies方法来初始化springMVC框架所需要的八个组件，这八个组件对应的八个bean对应都保存在DispatcherServlet类中。
这样：spring MVC的初始化工作就完成了。这样就可以接受你的http请求了。
Control设计
Spring MVC 的Control主要是由HandlerMapping(interface)和HandlerAdapter(interface)两个组件提供。
org.springframework.web.servlet.HandlerMapping
org.springframework.web.servlet.HandlerAdapter
对于HandlerMapping:主要负责映射用户的URL和对应的处理类，HandlerMapping并没有规定这个URL与应用的处理类如何映射，HandlerMapping接口中只定义了根据一个URL必须返回一个由HandlerExceptionChain代表的处理链，我们可以在这个处理链中添加任意的HandlerAdapter实例来处理这个URL对应的请求，这个设计思路和Servlet规范中的Filter处理是类似的。
/**
* Return a handler and any interceptors for this request. The choice may be made
* on request URL, session state, or any factor the implementing class chooses.
* <p>The returned HandlerExecutionChain contains a handler Object, rather than
* even a tag interface, so that handlers are not constrained in any way.
* For example, a HandlerAdapter could be written to allow another framework's
* handler objects to be used.
* <p>Returns <code>null</code> if no match was found. This is not an error.
* The DispatcherServlet will query all registered HandlerMapping beans to find
* a match, and only decide there is an error if none can find a handler.
* @param request current HTTP request
* @return a HandlerExecutionChain instance containing handler object and
* any interceptors, or <code>null</code> if no mapping found
* @throws Exception if there is an internal error
*/
HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
HandlerMapping初始化
Spring MVC本身也提供了很多HandlerMapping 的实现，默认使用的是BeanNameUrlHandlerMapping,也可以根据Bean的name属性映射到URL中。
public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
/**
* Checks name and aliases of the given bean for URLs, starting with "/".
*/
@Override
protected String[] determineUrlsForHandler(String beanName) {
List<String> urls = new ArrayList<String>();
if (beanName.startsWith("/")) {
urls.add(beanName);
}
String[] aliases = getApplicationContext().getAliases(beanName);
for (String alias : aliases) {
if (alias.startsWith("/")) {
urls.add(alias);
}
}
return StringUtils.toStringArray(urls);
}
}
对于HandlerMapping，可以帮助我们管理URL和处理类的映射关系，简单的说就是可以帮助我们将一个或者多个URL映射到一个或者多个spring Bean中。
下面总结下spring MVC是如何将请求的URL映射到我们定义的bean中的。
对于HandlerMapping是如何初始化的。spring MVC提供了一个HandlerMapping的抽象类 AbstractHandlerMapping。
public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport
implements HandlerMapping, Ordered {
}
可以通过让HandlerMapping设置setOrder方法提高优先级和通过覆盖initApplicationContext方法实现初始化的工作。
@Override
protected void initApplicationContext() throws BeansException {
extendInterceptors(this.interceptors);
detectMappedInterceptors(this.mappedInterceptors);
initInterceptors();
}
对于SimpleUrlHandlerMapping类是如何初始化的：
首先调用ApplicationObjectSupport的setApplicationContext()方法。
public final void setApplicationContext(ApplicationContext context) throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
}
else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
}
this.applicationContext = context;
this.messageSourceAccessor = new MessageSourceAccessor(context);
initApplicationContext(context);
}
else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is [" +
this.applicationContext + "], passed-in one is [" + context + "]");
}
}
}
调用SimpleUrlHandlerMapping的initApplicationContext()方法
/**
* Calls the {@link #registerHandlers} method in addition to the
* superclass's initialization.
*/
@Override
public void initApplicationContext() throws BeansException {
super.initApplicationContext();
registerHandlers(this.urlMap);
}
调用super.initApplicationContext(),调用了AbstractHandlerMapping的initApplicationContext()方法
/**
* Initializes the interceptors.
* @see #extendInterceptors(java.util.List)
* @see #initInterceptors()
*/
@Override
protected void initApplicationContext() throws BeansException {
extendInterceptors(this.interceptors);
detectMappedInterceptors(this.mappedInterceptors);
initInterceptors();
}
初始化initInterceptors()方法：将SimpleUrlHandlerMapping中定义的interceptors包装成handlerInterceptor对象保存在adaptedInterceptors数组中。
SimpleUrlHandlerMapping继续执行registerHandlers(this.urlMap)方法；
在方法registerHandlers中，调用了AbstractUrlHandlerMapping的registerHandler(url, handler)方法；
在方法registerHandler(url, handler)中，将在SimpleUrlHandlerMapping中定义的mappings注册到handlerMap集合中。
protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
if (urlMap.isEmpty()) {
logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
}
else {
for (Map.Entry<String, Object> entry : urlMap.entrySet()) {
String url = entry.getKey();
Object handler = entry.getValue();
// Prepend with slash if not already present.
if (!url.startsWith("/")) {
url = "/" + url;
}
// Remove whitespace from handler bean name.
if (handler instanceof String) {
handler = ((String) handler).trim();
}
registerHandler(url, handler);
}
}
}
在registerHandler方法中；
/**
* Register the specified handler for the given URL path.
* @param urlPath the URL the bean should be mapped to
* @param handler the handler instance or handler bean name String
* (a bean name will automatically be resolved into the corresponding handler bean)
* @throws BeansException if the handler couldn't be registered
* @throws IllegalStateException if there is a conflicting handler registered
*/
小结： HandlerMapping初始化工作完成的两个最重要的工作就是：
将URL与Handler的对应关系保存在HandlerMapping集合中，并将所有的interceptors对象保存在adaptedInterceptors数组中，等请求到来的时候执行所有的adaptedIntercoptors数组中的interceptor对象。
所有的interceptor必须实现HandlerInterceptor接口。
HandlerAdapter初始化
HandlerMapping 可以完成URL与Handler的映射关系，那么HandlerAdapter就可以帮助自定义各种handler了。因为SpringMVC首先帮助我们把特别的URL对应到一个Handler，那么这个Handler必定要符合某种规则，最常见的方法就是我们的所有handler都继承某个接口，然后SpringMVC 自然就调用这个接口中定义的特性方法。
对于spring MVC提供了三种典型的handlerAdapter实现类。
SimpleServletHandlerAdapter：可以直接继承Servlet接口。
SimpleControllerHandlerAdapter:可以继承Controller接口。
SimpleRequestHandlerAdapter:可以继承HttpRequsetHandler接口。
对于handlerAdapter的初始化没有什么特别之处，只是简单的创建一个handlerAdapter对象，将这个对象保存在DispatcherServlet的HandlerAdapters集合中。当Spring MVC将某个URL对应到某个Handler时候，在handlerAdapters集合中查询那个handlerAdapter对象supports这个Handler，handlerAdapter对象将会被返回，用了调用这个handlerAdapter接口对应的方法。
Control的调用逻辑
整个Spring MVC的调用是从DispatcherServlet的doService方法开始的，在doService方法中会将ApplicationContext、localeResolver、themeResolver等对象添加到request中便于在后面使用，接着就调用doDispatch方法，这个方法是主要的处理用户请求的地方。
Control的调用
对于control的处理关键就是：DispatcherServlet的handlerMappings集合中根据请求的URL匹配每一个handlerMapping对象中的某个handler,匹配成功之后将会返回这个handler的处理连接handlerExecutionChain对象。而这个handlerExecutionChain对象中将会包含用户自定义的多个handlerInterceptor对象。
/**
* Return the HandlerExecutionChain for this request.
* <p>Tries all handler mappings in order.
* @param request current HTTP request
* @return the HandlerExecutionChain, or <code>null</code> if no handler could be found
*/
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
for (HandlerMapping hm : this.handlerMappings) {
if (logger.isTraceEnabled()) {
logger.trace(
"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
}
HandlerExecutionChain handler = hm.getHandler(request);
if (handler != null) {
return handler;
}
}
return null;
}
而对于handlerInterceptor接口中定义的三个方法中，preHandler和postHandler分别在handler的执行前和执行后执行，afterCompletion在view渲染完成、在DispatcherServlet返回之前执行。
PS:这么我们需要注意的是：当preHandler返回false时，当前的请求将在执行完afterCompletion后直接返回,handler也将不会执行。
在类HandlerExecutionChain中的getHandler()方法是返回object对象的；
/**
* Return the handler object to execute.
* @return the handler object
*/
public Object getHandler() {
return this.handler;
}
这里的handler是没有类型的，handler的类型是由handlerAdapter决定的。dispatcherServlet会根据handler对象在其handlerAdapters集合中匹配哪个HandlerAdapter实例支持该对象。接下来去执行handler对象的相应方法了，如果该handler对象的相应方法返回一个ModelAndView对象接下来就是去执行View渲染了。
/**
* Return the handler object to execute.
* @return the handler object
*/
public Object getHandler() {
return this.handler;
}
Model设计
如果handler兑现返回了ModelAndView对象，那么说明Handler需要传一个Model实例给view去渲染模版。除了渲染页面需要model实例，在业务逻辑层通常也有Model实例。
ModelAndView对象是连接业务逻辑层与view展示层的桥梁，对spring MVC来说它也是连接Handler与view的桥梁。ModelAndView对象顾名思义会持有一个ModelMap对象和一个View对象或者View的名称。ModelMap对象就是执行模版渲染时候所需要的变量对应的实例，如jsp的通过request.getAttribute(String)获取的JSTL标签名对应的对象。velocity中context.get(String)获取$foo对应的变量实例。
public class ModelAndView {
/** View instance or view name String */
private Object view;
/** Model Map */
private ModelMap model;
/** Indicates whether or not this instance has been cleared with a call to {@link #clear()} */
private boolean cleared = false;
.....
}
ModelMap其实也是一个Map,Handler中将模版中需要的对象存在这个Map中，然后传递到view对应的ViewResolver中。
public interface ViewResolver {
View resolveViewName(String viewName, Locale locale) throws Exception;
}
不同的ViewResolver会对这个Map中的对象有不同的处理方式；
velocity中将这个Map保存到VelocityContext中。
JSP中将每一个ModelMap中的元素分别设置到request.setAttribute(modelName,modelValue);
view设计
在spring MVC中，view模块需要两个组件来支持：RequestToViewNameTranslator和ViewResolver
public interface RequestToViewNameTranslator {
/**
* Translate the given {@link HttpServletRequest} into a view name.
* @param request the incoming {@link HttpServletRequest} providing
* the context from which a view name is to be resolved
* @return the view name (or <code>null</code> if no default found)
* @throws Exception if view name translation fails
*/
String getViewName(HttpServletRequest request) throws Exception;
}
对于 ViewResolver，前面有写到了，就不写了；
RequestToViewNameTranslator：主要支持用户自定义对viewName的解析，如将请求的ViewName加上前缀或者后缀，或者替换成特定的字符串等。
ViewResolver：主要是根据用户请求的viewName创建适合的模版引擎来渲染最终的页面，ViewResolver会根据viewName创建一个view对象，调用view对象的Void render方法渲染出页面；
public interface View {
void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception;
}
下面来总结下 Spring MVC解析View的逻辑：
dispatcherServlet方法调用getDefaultViewName（）方法；
/**
* Translate the supplied request into a default view name.
* @param request current HTTP servlet request
* @return the view name (or <code>null</code> if no default found)
* @throws Exception if view name translation failed
*/
protected String getDefaultViewName(HttpServletRequest request) throws Exception {
return this.viewNameTranslator.getViewName(request);
}
调用了RequestToViewNameTranslator的getViewName方法；
public interface RequestToViewNameTranslator {
/**
* Translate the given {@link HttpServletRequest} into a view name.
* @param request the incoming {@link HttpServletRequest} providing
* the context from which a view name is to be resolved
* @return the view name (or <code>null</code> if no default found)
* @throws Exception if view name translation fails
*/
String getViewName(HttpServletRequest request) throws Exception;
}
调用LocaleResolver接口的resolveLocale方法；
Locale resolveLocale(HttpServletRequest request);
调用ViewResolver接口的resolveViewName方法，返回view对象
View resolveViewName(String viewName, Locale locale) throws Exception;
调用render方法渲染出页面