HandlerInterceptor是springMVC项目中的拦截器，它拦截的目标是请求的地址，比MethodInterceptor先执行。实现一个HandlerInterceptor拦截器可以直接实现HandlerInterceptor接口，也可以继承HandlerInterceptorAdapter类。这两种方法殊途同归，其实HandlerInterceptorAdapter也就是声明了HandlerInterceptor接口中所有方法的默认实现，而我们在继承他之后只需要重写必要的方法。下面就是HandlerInterceptorAdapter的代码，可以看到一个方法只是默认返回true，另外两个是空方法

1. public abstract class HandlerInterceptorAdapter implements HandlerInterceptor {
2. /**
3. * This implementation always returns <code>true</code>.
4. */
5. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
6. throws Exception {
7. return true;
8. }
9. /**
10. * This implementation is empty.
11. */
12. public void postHandle(
13. HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
14. throws Exception {
15. }
16. /**
17. * This implementation is empty.
18. */
19. public void afterCompletion(
20. HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
21. throws Exception {
22. }
23. }
24. MethodInterceptor是AOP项目中的拦截器，它拦截的目标是方法，即使不是controller中的方法。实现MethodInterceptor拦截器大致也分为两种，一种是实现MethodInterceptor接口，另一种利用AspectJ的注解或配置
25. 1. public class MethodInvokeInterceptor implements MethodInterceptor {
    2. @Override
    3. public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    4. System.out.println("before method invoke");
    5. Object object = methodInvocation.proceed();
    6. System.out.println("after method invoke");
    7. return object;
    8. }
    9. }

    下面是基于注解的AspectJ方式
    

    1. @Component
    2. @Aspect
    3. public class AutoAspectJInterceptor {
    4. @Around("execution (* com.test.controller..*.*(..))")
    5. public Object around(ProceedingJoinPoint point) throws Throwable{
    6. System.out.println("AutoAspectJInterceptor begin around");
    7. Object object = point.proceed();
    8. System.out.println("AutoAspectJInterceptor end around");
    9. return object;
    10. }
    11. }

    下面是一个用于支持AspectJ方式拦截的普通的bean，当然你也可以在配置文件中声明这个bean 

    1. @Component
    2. public class AspectJInterceptor {
    3. public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    4. System.out.println("AspectJInterceptor around before");
    5. Object object = proceedingJoinPoint.proceed();
    6. System.out.println("AspectJInterceptor around after");
    7. return object;
    8. }
    9. }

    当然，这一切都离不开配置，具体看配置中的注释

    1. <!-- 自定义拦截器 ，先过mvc:interceptors-->
    2. <bean id="methodInvokeInterceptor" class="com.test.interceptor.MethodInvokeInterceptor"/>
    3. <bean id="aspectInterceptor" class="com.test.interceptor.AspectJInterceptor"/>
    4. <aop:config>
    5. <!--切入点,controlller -->
    6. <aop:pointcut id="pointcut_test"   expression="execution(* com.test.controller..*.*(..))" />
    7. <!--在该切入点使用自定义拦截器 ,按照先后顺序执行 -->
    8. <aop:advisor pointcut-ref="pointcut_test" advice-ref="methodInvokeInterceptor" />
    9. <aop:aspect ref="aspectInterceptor">
    10. <aop:around method="around" pointcut="execution(* com.test.controller..*.*(..))"/>
    11. </aop:aspect>
    12. </aop:config>
    13. <!-- 自动扫描使用了aspectj注解的类 -->
    14. <aop:aspectj-autoproxy/>