前言

本文分两部分，第一部分剖析SpringMVC的源代码，看看一个请求响应是如何处理，第二部分主要介绍一些使用中的最佳实践，这些best practices有些比较common，有些比较tricky，旨在展示一个框架的活力以及一些能在日常项目中能够应用的技巧，这些技巧的线索都可以在第一部分的代码剖析中找到，所以读读源代码对于使用好任何框架都是非常有帮助的，正所谓“知其然，还要知其所以然”。

另外，本文中所涉及的Spring版本是3.1.2RELEASE。

Part 1. SpringMVC请求响应模型

SpringMVC一直活跃在后端MVC框架的最前沿，很多web系统都是构建在此之上。最常见就是编写一个Controller，代码片段如下：

@RequestMapping(value = "/getTemplateInfo", method = RequestMethod.GET)
@ResponseBody
public JsonObject<?> getTemplateInfo(@RequestParam(value = "userId", required = true) int userId, @RequestParam(value = "groupType") int groupType) {
 
    // ... logic here
 
}

以该例子为背景，先简单剖析下SpringMVC源代码看看它的HTTP请求响应模型是怎样的，跟着流程走一遍。

众所周知，SpringMVC是建立在Servlet基础之上，一般来说配置所有的请求都由DispatcherServlet来处理，从web.xml的配置中就可以看出来。

<servlet>          
    <servlet-name>spring</servlet-name>          
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  </servlet>
<servlet-mapping>          
    <servlet-name>spring</servlet-name>          
    <url-pattern>/</url-pattern>  
</servlet-mapping>

DispatcherServlet是整个框架的核心所在，它既是一个标准的HttpServlet，也是利用开放封闭原则（Open-Closed）进行设计的经典框架。一句英文概括就是“对扩展开发，对修改封闭”：

A key design principle in Spring Web MVC and in Spring in general is the "Open for extension,closed for modification" principle.

在DispatcherServlet中可以明显看到：

1）类中所有的变量声明，几乎都以接口的形式给出，并没有绑定在具体的实现类上。

举例来说，SpringMVC利用IoC动态初始化HandlerAdapter实例，也就说在applicationContext.xml中配置的一切接口实现的bean，如果名称match，框架实际都默默的注入到了DispatcherServlet。

public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
 
private List handlerAdapters;

2）使用模版方法模式，方便扩展。

所谓模板模式就是定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。SpringMVC在保证整个框架流程稳定的情况下，预留很多口子，而这些口子都是所谓的模板方法，可以自由指定，从而保证了灵活性，接下来的很多使用最佳实践都是基于这种设计模式才可以实现。

例如，下面的代码中doResolveException(..)就是一个口子，子类方法doResolveException(..)可以定义具体如何处理异常。

public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
        Exception ex) {
    if (shouldApplyTo(request, handler)) {
        logException(ex, request);
        prepareResponse(ex, response);
        return doResolveException(request, response, handler, ex);
    } else {
        return null;
    }
}
 
protected abstract ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response,
        Object handler, Exception ex);

3）良好的抽象设计，是整个框架变得非常灵活。
举例来说，在doDispatch(HttpServletRequest request, HttpServletResponse response)方法中有一段流程处理，大致可以看出是获取所有的拦截器，遍历之，调用preHandle进行前置处理。

// Apply preHandle methods of registered interceptors.
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
if (interceptors != null) {
    for (int i = 0; i < interceptors.length; i++) {
        HandlerInterceptor interceptor = interceptors[i];
        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
            return;
        }
        interceptorIndex = i;
    }
}

而所有的拦截器都是HandlerInterceptor接口的实现，框架充分使用接口来回调这些开发人员指定的拦截器，这就是所谓的口子。

public interface HandlerInterceptor {
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
}

带着这些设计的思想，下面，真正进入请求响应处理的剖析。

整个流程可以被大致描述为：

一个http请求到达服务器，被DispatcherServlet接收。DispatcherServlet将请求委派给合适的处理器Controller，此时处理控制权到达Controller对象。Controller内部完成请求的数据模型的创建和业务逻辑的处理，然后再将填充了数据后的模型即model和控制权一并交还给DispatcherServlet，委派DispatcherServlet来渲染响应。DispatcherServlet再将这些数据和适当的数据模版视图结合，向Response输出响应。

这个流程如下图所示：

围绕DispatcherServlet的流程处理如下图：

UML序列图如下：

具体剖析DispatcherServlet，首先，客户端发起请求，假如是一个GET请求，会由doGet(HttpServletRequest request, HttpServletResponse response)来处理，内部调用
void processRequest(HttpServletRequest request, HttpServletResponse response)。

在processRequest这一阶段主要就是调用void doDispatch(HttpServletRequest request, HttpServletResponse response)方法。

在doDispatch主要有一下几步操作。

（1）调用DispatcherServlet#getHandler(HttpServletRequest request)方法返回一个HandlerExecutionChain对象。

内部实现如下：

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;
}

首先是遍历初始化好的HandlerMapping，具体查看HandlerMapping实现类，例如框架提供的最常用的实现RequestMappingHandlerMapping，先看下HandlerMapping是如何初始化的，下面代码从AbstractHandlerMethodMapping中摘取，描述了其过程：

// 在Spring容器中初始化
public void afterPropertiesSet() {
    initHandlerMethods();
}
 
// 初始化HandlerMethod
protected void initHandlerMethods() {
    String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ? BeanFactoryUtils
            .beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) : getApplicationContext()
            .getBeanNamesForType(Object.class));
 
    for (String beanName : beanNames) {
        if (isHandler(getApplicationContext().getType(beanName))) {
            detectHandlerMethods(beanName);
        }
    }
    handlerMethodsInitialized(getHandlerMethods());
}
 
// 看某个bean是否是controller
protected boolean isHandler(Class<?> beanType) {
    return ((AnnotationUtils.findAnnotation(beanType, Controller.class) != null) || (AnnotationUtils
            .findAnnotation(beanType, RequestMapping.class) != null));
}
 
// 获取某个controller下所有的Method，做url path->Method的简单关联
protected void detectHandlerMethods(final Object handler) {
    Class<?> handlerType = (handler instanceof String) ? getApplicationContext().getType((String) handler)
            : handler.getClass();
 
    final Class<?> userType = ClassUtils.getUserClass(handlerType);
 
    Set methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
        public boolean matches(Method method) {
            return getMappingForMethod(method, userType) != null;
        }
    });
 
    for (Method method : methods) {
        T mapping = getMappingForMethod(method, userType);
        registerHandlerMethod(handler, method, mapping);
    }
}

HandlerMapping一般是在applicationContext.xml中定义的，在Spring启动时候就会注入到DispatcherServlet中，它的初始化方式主要依赖于AbstractHandlerMethodMapping这个抽象类，利用initHandlerMethods(..)方法获取所有Spring容器托管的bean，然后调用isHandler(..)看是否是@Controller注解修饰的bean，之后调用detectHandlerMethods(..)尝试去解析bean中的方法，也就是去搜索@RequestMapping注解修饰的方法，将前端请求的url path，例如“/report/query”和具体的Method来做关联映射，例如一个HandlerMapping内含的属性如下，将前端的“/portal/ad/getTemplateInfo”与SiConfController.getTemplateInfo(int,int)方法相绑定。如下所示：

[/portal/ad/getTemplateInfo],methods=[GET],params=[],headers=[],consumes=[],produces=[],custom=[]}=public com.baidu.beidou.ui.web.common.vo.JsonObject<?>com.baidu.beidou.ui.web.portal.ad.controller.SiConfController.getTemplateInfo(int,int)]

完成所有的搜索bean搜索后，调用registerHandlerMethod(..)将Method构造为HandlerMethod，添加到HandlerMapping内含的属性列表中：

private final Map<T, HandlerMethod> handlerMethods = new LinkedHashMap<T, HandlerMethod>();

保存，这里的T是泛型的，具体存放的最简单就是url path信息。

继续返回到DispatcherServlet#getHandler(HttpServletRequest request)方法中，遍历上面讲到的HandlerMapping，调用hm.getHandler(request)方法：

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    Object handler = getHandlerInternal(request);
    if (handler == null) {
        handler = getDefaultHandler();
    }
    if (handler == null) {
        return null;
    }
    // Bean name or resolved handler?
    if (handler instanceof String) {
        String handlerName = (String) handler;
        handler = getApplicationContext().getBean(handlerName);
    }
    return getHandlerExecutionChain(handler, request);
}
 
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
    HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain) ? (HandlerExecutionChain) handler
            : new HandlerExecutionChain(handler);
 
    chain.addInterceptors(getAdaptedInterceptors());
 
    String lookupPath = urlPathHelper.getLookupPathForRequest(request);
    for (MappedInterceptor mappedInterceptor : mappedInterceptors) {
        if (mappedInterceptor.matches(lookupPath, pathMatcher)) {
            chain.addInterceptor(mappedInterceptor.getInterceptor());
        }
    }
 
    return chain;
}

内部调用父类的AbstractHandlerMapping#getHandlerInternal(HttpServletRequest request)，也就是说根据url path返回一个具体的HandlerMethod，然后调用getHandlerExecutionChain构造成一个HandlerExecutionChain，可以看到就是在这个时候将所有根据xml的配置将拦截器添加到HandlerExecutionChain中的，这里使用到了职责链模式。

（2）继续回到主流程，调用DispatcherServlet#getHandlerAdapter(Object handler)，代码如下，

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    for (HandlerAdapter ha : this.handlerAdapters) {
        if (logger.isTraceEnabled()) {
            logger.trace("Testing handler adapter [" + ha + "]");
        }
        if (ha.supports(handler)) {
            return ha;
        }
    }
    throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

这里会遍历所有配置在Spring容器已经配好的handlerAdapters，调用supports(..)方法，得到第一个返回为true的HandlerAdapter，这里的参数实际上就是上面提到的就是HandlerMethod。 supports主要就是验证某个HandlerMethod上定义的参数、返回值解析，是否能由该handlerAdapter处理。

HandlerAdapter最主要的方法就是处理http请求，在下面会更详细的讲解。

public interface HandlerAdapter {
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
}

（3）开始进行拦截器处理，代码如下：

// Apply preHandle methods of registered interceptors.
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
if (interceptors != null) {
    for (int i = 0; i < interceptors.length; i++) {
        HandlerInterceptor interceptor = interceptors[i];
        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
            return;
        }
        interceptorIndex = i;
    }
}

首先获取所有的拦截器，然后依次遍历调用HandlerExecutionChain#applyPreHandle(HttpServletRequest request, HttpServletResponse response)开始应用拦截器，一个一个调用其preHandle方法，如果有错误，直接退出调用afterCompletion方法，返回false。

（4）接着调用HandlerAdapter.handle(…)得到一个ModelAndView对象，里面封装了数据对象及具体的View对象。

具体实现需要查看HandlerAdapter实现类。例如RequestMappingHandlerAdapter，以下代码即从该类中截取。

private ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response,
        HandlerMethod handlerMethod) throws Exception {
 
    ServletWebRequest webRequest = new ServletWebRequest(request, response);
 
    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);
 
    ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
    modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);
    mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
 
    requestMappingMethod.invokeAndHandle(webRequest, mavContainer);
    // ... return ModelAndView
}

首先，getDataBinderFactory(..)获取所有指定Controller里加入的@InitBinder注解，自定义做数据转换用，之后调用getModelFactory获取一个最终生成model的工厂，然后构造ServletInvocableHandlerMethod方法，重点在于ServletInvocableHandlerMethod#invokeAndHandle(webRequest, mavContainer)方法，截取内部的实现如下：

public final Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    Object returnValue = invoke(args);
    return returnValue;
}
 
private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {
 
    MethodParameter[] parameters = getMethodParameters();
    Object[] args = new Object[parameters.length];
    for (int i = 0; i < parameters.length; i++) {
        MethodParameter parameter = parameters[i];
        parameter.initParameterNameDiscovery(parameterNameDiscoverer);
        GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
 
        args[i] = resolveProvidedArgument(parameter, providedArgs);
        if (args[i] != null) {
            continue;
        }
 
        if (argumentResolvers.supportsParameter(parameter)) {
            try {
                args[i] = argumentResolvers.resolveArgument(parameter, mavContainer, request, dataBinderFactory);
                continue;
            } catch (Exception ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);
                }
                throw ex;
            }
        }
 
        if (args[i] == null) {
            String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);
            throw new IllegalStateException(msg);
        }
    }
    return args;
}

依次遍历目标调用方法上面的参数，尝试从请求中解析参数与值并且做映射与bind，可以看到这里面argumentResolvers是核心，这个口子用于将前端请求与Controller上定义的参数类型相绑定，可以自然想到这个抽象的设计，可以给予框架使用者很多的灵活选择。

（5）然后调用HandlerExecutionChain#applyPostHandle(…)再次应用拦截器，调用其postHandle方法。HandlerExecutionChain#applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv)

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
    if (getInterceptors() == null) {
        return;
    }
    for (int i = getInterceptors().length - 1; i >= 0; i--) {
        HandlerInterceptor interceptor = getInterceptors()[i];
        interceptor.postHandle(request, response, this.handler, mv);
    }
}

（6）最后一步processDispatchResult处理结果，相应给客户端。

在processDispatchResult首先调用了render(mv, request, response)方法。

最后是HandlerExecutionChain#triggerAfterCompletion(..),调用拦截器的afterCompletion方法。拦截器处理流程至此结束。

至此一个请求响应过程结束。

Part 2. 一些最佳实践

1. 使用WebDataBinder来做参数的个性化绑定

通常情况下，框架可以很好的处理前端传递k1=v2&k2=v2形式的POST data和GET请求参数，并将其转换、映射为Controller里method的args[]类型，但是在某些情况下，我们有很多自定义的需求，例如对于字符串yyyyMMDD转换为Date对象，这时候自定义DataBinder就非常有用了，在上面源码剖析的第（4）点介绍过。

一个更加trick的需求是，前端传递两种cases的urls参数：

urls= http://c.admaster.com.cn/c/a25774,b200663567,c3353,i0,m101,h&urls=http://www.baidu.com urls= http://c.admaster.com.cn/c/a25774,b200663567,c3353,i0,m101,h

对于第一种，后端接收到的urls.size()=2，符合预期，而对于第二种，后端接收的urls.size()=5,不是预期的urls.size()=1，原因就是SpringMVC进行参数映射绑定时，默认会自动把按照逗号分隔的参数映射成数组或者list的元素。对这个问题，同样可以使用WebDataBinder解决，解决代码如下，只需要在Controller里加入一个@InitBinder修饰的方法，去在binder里面加入自定义的参数解析方法即可。

@RequestMapping(value = "/getUrls", method = RequestMethod.GET)
@ResponseBody
public JsonObject<?> getUrls(@RequestParam(value = "urls") List urls) {
    JsonObject<?> result = JsonObject.create();
    System.out.println(urls);
    result.addData("urls", urls);
    return result;
}
 
@InitBinder
public void dataBinder(WebDataBinder binder) {
    PropertyEditor urlEditor = new PropertyEditorSupport() {
        @Override
        public void setValue(Object value) throws IllegalArgumentException {
            if (value instanceof List) {
                super.setValue(value);
            } else if (value.getClass().isArray() && value instanceof String[]) {
                super.setValue(Lists.newArrayList((String[]) value));
            }
        }
 
        @Override
        public void setAsText(String text) throws java.lang.IllegalArgumentException {
            if (text instanceof String) {
                setValue(Lists.newArrayList(text));
                return;
            }
            throw new IllegalArgumentException(text);
        }
    };
    binder.registerCustomEditor(List.class, urlEditor);
}

2. 使用高级的HandlerMethodArgumentResolver来实现参数的个性化解析

通常情况下，对于参数key的解析、映射，框架会帮助我们完成到对象的绑定，但是在某些遗留系统中，前端传递的参数与后端Form表单定义的命名不会相同，例如在某些系统中参数为qp.page=1&qp.pageSize=50，而后端的Form表单类属性命名不可能带有点号，这时候我们可以自定义一个ArgumentResolver来自己设置参数对象。

例如，我们的query方法签名如下，QueryParamForm中的属性名称为page、pageSize：

@RequestMapping("/dtList")
@ResponseBody
public JsonObject<genderviewitem> query(@Qp QueryParamForm form) {     ResultBundle<genderviewitem> res = reportService.queryGenderReport(toQP(form));     return toResponse(res, form); }</genderviewitem></genderviewitem>

Qp是一个注解：

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Qp {
}

在handlerAdapter中自定义customArgumentResolvers：

<bean id="handlerAdapter"
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="customArgumentResolvers">
        <util:list>
            <ref bean="reportArgumentResolver" />
        </util:list>
    </property>
</bean>

ArgumentResolver的实现如下，只需要覆盖两个方法即可，在上面源码剖析（4）中介绍过对于参数的解析介绍过。在这里省略了QueryParamFormBuilder类，这个类主要就是去webRequest中主动取"qp.page"与"qp.pageSize"参数的值，利用反射去动态的set到一个空QueryParamForm对象的属性中。

@Component
public class ReportArgumentResolver implements HandlerMethodArgumentResolver {
 
    @Resource
    private QueryParamFormBuilder formBuilder;
 
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(Qp.class);
    }
 
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        if (parameter.getParameterType() == QueryParamForm.class) {
            return formBuilder.buildForm(webRequest);
        }
        return WebArgumentResolver.UNRESOLVED;
    }
 
}

3. 使用aspectj拦截器

以上面那个例子为背景，如果要做全局的参数校验，没必要在每个方法中主动写方法，可以利用AspectJ与Spring的集成，编入指定类到方法上的AOP切面，统一来做验证。详细代码如下：

@Component
@Aspect
public class ReportQueryParamInterceptor {
 
    private static final Logger LOG = LoggerFactory.getLogger(ReportQueryParamInterceptor.class);
 
    @Around("execution(* com.baidu.beidou.ui.web.portal.report.controller.*ReportController.query*(..))")
    public Object validate4Query(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature methodSignature = getMethodSignature(pjp);
        Object[] args = pjp.getArgs();
        if (args == null || args.length < 1 || !(args[0] instanceof QueryParamForm)) {
            LOG.warn("Request param is null or not instanceof QueryParamForm! " + args);
            throw new IllegalArgumentException("Request param error which should not happen!");
        }
 
        QueryParamForm form = (QueryParamForm) args[0];
        JsonObject response = (JsonObject) (methodSignature.getReturnType().newInstance());
 
        validateAndPrepareQueryParamForm(response, form);
        if (response.getStatus() != GlobalResponseStatusMsg.OK.getCode()) {
            return response;
        }
 
        return pjp.proceed();
    }
}

4. 全局错误处理，隐藏后端异常以及友好提示

通常情况下，一个web系统，不应该像外部暴露过多的内部异常细节，那么我们可以覆盖掉SpringMVC提供的默认异常处理handler，定义自己的GlobalExceptionHandler，这里面为了覆盖掉默认的handler，需要实现Ordered，并且赋值order为Ordered.HIGHEST_PRECEDENCE。

在配置文件中使用自己的handler。

<bean id="exceptionHandler"
class="com.baidu.beidou.ui.web.common.handler.GlobalExceptionHandler">
</bean>

resolveException(..)方法内，可以针对各种异常信息，去返回给前端不同的信息，包括错误返回码等等。

public class GlobalExceptionHandler implements HandlerExceptionResolver, ApplicationContextAware, Ordered {
 
    protected ApplicationContext context;
 
    /**
     * 默认HandlerExceptionResolver优先级，设置为最高，用于覆盖系统默认的异常处理器
     */
    private int order = Ordered.HIGHEST_PRECEDENCE;
 
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object o, Exception e) {
        ModelAndView model = new ModelAndView(new MappingJacksonJsonView());
        try {
            if (e instanceof TypeMismatchException) {
                LOG.warn("TypeMismatchException occurred. " + e.getMessage());
                return buildBizErrors((TypeMismatchException) e, model);
            } else if (e instanceof BindException) {
                LOG.warn("BindException occurred. " + e.getMessage());
                return buildBizErrors((BindException) e, model);
            } else if (e instanceof HttpRequestMethodNotSupportedException) {
                LOG.warn("HttpRequestMethodNotSupportedException occurred. " + e.getMessage());
                return buildError(model, GlobalResponseStatusMsg.REQUEST_HTTP_METHOD_ERROR);
            } else if (e instanceof MissingServletRequestParameterException) {
                LOG.warn("MissingServletRequestParameterException occurred. " + e.getMessage());
                return buildError(model, GlobalResponseStatusMsg.PARAM_MISS_ERROR);
            } else {
                LOG.error("System error occurred. " + e.getMessage(), e);
                return buildError(model, GlobalResponseStatusMsg.SYSTEM_ERROR);
            }
        } catch (Exception ex) {
            // Omit all detailed error message including stack trace to external user
            LOG.error("Unexpected error occurred! This should never happen! " + ex.getMessage(), ex);
            model.addObject("status", SYS_ERROR_CODE);
            model.addObject("msg", SYS_ERROR_MSG);
            return model;
        }
    }
}

public class GlobalExceptionHandler implements HandlerExceptionResolver, ApplicationContextAware, Ordered { protected ApplicationContext context; /** * 默认HandlerExceptionResolver优先级，设置为最高，用于覆盖系统默认的异常处理器 */ private int order = Ordered.HIGHEST_PRECEDENCE; @Override public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object o, Exception e) { ModelAndView model = new ModelAndView(new MappingJacksonJsonView()); try { if (e instanceof TypeMismatchException) { LOG.warn("TypeMismatchException occurred. " + e.getMessage()); return buildBizErrors((TypeMismatchException) e, model); } else if (e instanceof BindException) { LOG.warn("BindException occurred. " + e.getMessage()); return buildBizErrors((BindException) e, model); } else if (e instanceof HttpRequestMethodNotSupportedException) { LOG.warn("HttpRequestMethodNotSupportedException occurred. " + e.getMessage()); return buildError(model, GlobalResponseStatusMsg.REQUEST_HTTP_METHOD_ERROR); } else if (e instanceof MissingServletRequestParameterException) { LOG.warn("MissingServletRequestParameterException occurred. " + e.getMessage()); return buildError(model, GlobalResponseStatusMsg.PARAM_MISS_ERROR); } else { LOG.error("System error occurred. " + e.getMessage(), e); return buildError(model, GlobalResponseStatusMsg.SYSTEM_ERROR); } } catch (Exception ex) { // Omit all detailed error message including stack trace to external user LOG.error("Unexpected error occurred! This should never happen! " + ex.getMessage(), ex); model.addObject("status", SYS_ERROR_CODE); model.addObject("msg", SYS_ERROR_MSG); return model; } } }

5. Spring自带拦截器

拦截器最常见的使用场景就是日志、登陆、权限验证等。下面以权限验证为例，一般情况下，登陆的用户会有不同的访问权限，对于controller里定义的方法进行有限制的调用，为了更好的解耦，可以定义一个公共的拦截器。

public class PriviledgeInterceptor implements HandlerInterceptor {
 
    @Override
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取线程上下文的visitor
        Visitor visitor = ThreadContext.getSessionVisitor();
        Preconditions.checkNotNull(visitor, "Visitor should NOT be null in ThreadContext!");
 
        // 获取权限集合
        Set authSet = visitor.getAuths();
        if (CollectionUtils.isEmpty(authSet)) {
            LOG.error("Visitor does NOT get any auths, userid=" + visitor.getUserid());
            returnJsonSystemError(request, response, GlobalResponseStatusMsg.AUTH_DENIED);
            return false;
        }
 
        // 结合controller里定义方法的注解来做验证
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Privilege privilege = handlerMethod.getMethodAnnotation(Privilege.class);
        if (privilege != null) {
            if (authSet.contains(privilege.value())) {
                return true;
            }
            LOG.error("Visitor does NOT have auth={} on controller={}, userid={}", new Object[] { privilege.value(),
                    getBeanTypeAndMethodName(handlerMethod), visitor.getUserid() });
            returnJsonSystemError(request, response, GlobalResponseStatusMsg.AUTH_DENIED);
            return false;
        }
 
    }
}

controller定义如下：

@Controller
@RequestMapping("/test")
@Privilege(PriviledgeConstant.BEIDOU_CPROUNIT)
public class SiConfController {
}

6. 使用模板方法来简化代码开发

对于很多的相似逻辑，可以利用模板模式，把公共的操作封装到父类controller中。例如对于一个下载报表的需求，可以隐藏具体的写流等底层操作，将这些模板抽象化到父类BaseController中，子类只需要去实现传入一个调用获取报表数据Callback来，这和Hibernate的callback思想异曲同工。

@RequestMapping(value = "/downloadDtList")
@ResponseBody
public HttpEntity<byte[]> download(@RequestParam(value = PortalReportConstants.DOWNLOAD_POST_PARAM, required = true) String iframePostParams) {
    return toHttpEntity(new ReportCallback<ResultBundle<?>>() {
        public ResultBundle<GenderViewItem> call(QueryParamForm form) {
            return reportService.queryGenderReport(toQP(form));
        }
    });
}

总结

上面的记录是在2014年春做报表系统重构出web-ui模块的一些最佳实践，可作为一个系统中的portal，可前端js或者API客户端打交道的公共复用模块。深入到SpringMVC的源代码才感受的到其强大之处，希望你与我共勉，知其然还要知其所以然。

SpringMVC源码分析和一些常用最佳实践

前言