Spring的AOP，Struts2的拦截器（Interceptor），以及springMVC的（interceptor）

参考外链：http://www.ibm.com/developerworks/cn/java/j-lo-springaopfilter/

1.首先，spring的AOP作用范围很广，可以使用Aspectj的execution表达式自定以切面的位置。

比如下面的配置service方法执行日志：

 <!-- 系统日志 -->
    <bean id="logUtils" class="com.tabchanj.crm.utils.SystemLogUtils">
        <property name="logService" ref="systemLogService"></property>
    </bean>
    
    <aop:config>
        <aop:pointcut expression="execution(* com.tabchanj.crm.service..*.*(..))" id="logPointcut"/>
        <aop:aspect ref="logUtils">
            <aop:after method="writeLog" pointcut-ref="logPointcut" />
        </aop:aspect>
    </aop:config>

2.而struts2的拦截器，继承于AbstractInterceptor，并覆盖其中的intercept方法，它只能作用于action，对所有的action进行拦截。

package com.tabchanj.pss.web.interceptor;

import java.util.Arrays;
import java.util.List;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import com.tabchanj.pss.domain.Employee;
import com.tabchanj.pss.service.IEmployeeService;
import com.tabchanj.pss.web.action.BaseAction;

public class LoginInterceptor extends AbstractInterceptor {

    private static final long serialVersionUID = 3673324815465858383L;
    private List<String> actionList;
    private IEmployeeService employeeService;

    public void setEmployeeService(IEmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    public void setActionList(String actionList) {

        this.actionList = Arrays.asList(actionList.split(","));
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        Object action = invocation.getAction();
        if (actionList.contains(action.getClass().getSimpleName())) {
            return invocation.invoke();
        }
        Employee employee = (Employee) ActionContext.getContext().getSession().get(BaseAction.LOGIN_USER);
        if (employee == null) {
            return Action.LOGIN;
        }
        // 查询出该action的全类名
        String className = action.getClass().getName();
        // 查询出当前所要访问的方法
        String methodName = invocation.getProxy().getMethod();
        // 将当前要访问的全类名和要访问的方法拼在一起
        String classMethodName = className + "." + methodName;
        // 拼出该action下的所有方法
        String allclassMethodName = className + ".ALL";
        // 查询出所有的资源method名称
        List<String> allResourceMethod = employeeService.getAllResourcesMethod();
        if (allResourceMethod.contains(classMethodName) || allResourceMethod.contains(allclassMethodName)) {
            // 查询出该当前用户所用的资源列表
            List<String> loginUserMethods = employeeService.findAllResourcesByLogin(employee.getId());
            System.out.println("用户的资源2" + loginUserMethods);
            if (loginUserMethods.contains(classMethodName) || loginUserMethods.contains(allclassMethodName)) {
                return invocation.invoke();
            } else {
                return "auth";
            }
        }
        return invocation.invoke();
    }

}

3.而springMVC的拦截器，只拦截Controller，其实现于HandlerInterceptor接口，并根据需要覆盖其中的3个分别在controller前后执行的方法，

package com.tabchanj.crm.web.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import com.tabchanj.crm.domain.Employee;
import com.tabchanj.crm.utils.UserContext;

public class AuthInterceptor implements HandlerInterceptor {

    public AuthInterceptor() {
        System.out.println("AuthInterceptor初始化。。。。");
    }

    public static final String LOGIN_PATH = "/checkLogin";

    /**
     * 1.在调用控制器方法前，拦截
     * 
     * 返回值为false，代表拦截 返回值为true，代表放行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // System.out.println("AuthInterceptor....preHandle");
        /**
         * 1、登陆验证
         */
        // 获取session用户
        Employee user = UserContext.getUser();
        // 检查用户是否存在
        if (user == null && !LOGIN_PATH.equals(request.getRequestURI())) {
            response.sendRedirect("/login.jsp");
            return false;
        }

        /**
         * 2、URL权限验证
         */
        // 1、获取用户请求的地址
        // 把handler转变成HandlerMethod对象
        if (handler instanceof HandlerMethod) {
            HandlerMethod hm = (HandlerMethod) handler;
            // 获取控制器名称
            String controllerName = hm.getBean().getClass().getName();
            // 获取方法名;
            String methodName = hm.getMethod().getName();
            // 拼装resource名称
            String resourceName = controllerName + ":" + methodName;
            // 4.验证用户上，是否有请求资源对应的权限
            if (UserContext.checkUserResPermission(resourceName)) {
                return true;// 放行
            } else {
                response.sendRedirect("/data/noPermission.json");// 拦截，返回提示界面
                return false;

            }
        }

        return true;// 放行

    }

    /**
     * 2.在调用控制器方法后，拦截（在生成视图之前）
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // System.out.println("AuthInterceptor..postHandle.....");

    }

    /**
     * 3.在视图生成之后（后台所有所有逻辑都完成后）
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // System.out.println("AuthInterceptor...afterCompletion.....");

    }

}