前言
本文分两部分，第一部分剖析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;
}
}
}
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的源代码才感受的到其强大之处，希望你与我共勉，知其然还要知其所以然。