struts2 拦截器原理

拦截器是struts2处理的核心，本文主要说struts2的拦截器的基本原理/实现，其它框架处理的东西就不说了，得自己再看了。
struts2版本：2.2.3

当一个请求来了后，从org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter 开始处理

     public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {        HttpServletRequest request = (HttpServletRequest) req;        HttpServletResponse response = (HttpServletResponse) res;        try {            //设置编码            prepare.setEncodingAndLocale(request, response);            //创建actionContext            prepare.createActionContext(request, response);            prepare.assignDispatcherToThread();   //如果不是struts的请求则继续由其它过滤器执行            if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {                chain.doFilter(request, response);            } else {//包装request，对有文件上传的特殊处理下                request = prepare.wrapRequest(request);//查找对应的ActionMapping                ActionMapping mapping = prepare.findActionMapping(request, response, true);//如果找不到ActionMapping则当作静态资源来处理                if (mapping == null) {                    boolean handled = execute.executeStaticResourceRequest(request, response);                    if (!handled) {                        chain.doFilter(request, response);                    }                } else {  //使用ActionMapping来执行action                    execute.executeAction(request, response, mapping);                }            }        } finally {            prepare.cleanupRequest(request);        }    }

跟踪execute.executeAction()，则到了 org.apache.struts2.dispatcher.Dispatcher，如下：

     public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,                              ActionMapping mapping) throws ServletException {        Map<String, Object> extraContext = createContextMap(request, response, mapping, context);        // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action        ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);        boolean nullStack = stack == null;        if (nullStack) {            ActionContext ctx = ActionContext.getContext();            if (ctx != null) {                stack = ctx.getValueStack();            }        }        if (stack != null) {            extraContext.put(ActionContext.VALUE_STACK, valueStackFactory.createValueStack(stack));        }        String timerKey = "Handling request from Dispatcher";        try {            UtilTimerStack.push(timerKey);            String namespace = mapping.getNamespace();            String name = mapping.getName();            String method = mapping.getMethod();            Configuration config = configurationManager.getConfiguration();   //使用StrutsActionProxyFactory(ActionProxyFactory的一个实现)创建action代理对象   //proxy实际上是org.apache.struts2.impl.StrutsActionProxy类型            ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(                    namespace, name, method, extraContext, true, false);            request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());            // if the ActionMapping says to go straight to a result, do it!            if (mapping.getResult() != null) {                Result result = mapping.getResult();                result.execute(proxy.getInvocation());            } else {//执行action                proxy.execute();            }            // If there was a previous value stack then set it back onto the request            if (!nullStack) {                request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);            }        } catch (ConfigurationException e) {            // WW-2874 Only log error if in devMode            if(devMode) {                String reqStr = request.getRequestURI();                if (request.getQueryString() != null) {                    reqStr = reqStr + "?" + request.getQueryString();                }                LOG.error("Could not find action or result\n" + reqStr, e);            }            else {                LOG.warn("Could not find action or result", e);            }            sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);        } catch (Exception e) {            sendError(request, response, context, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);        } finally {            UtilTimerStack.pop(timerKey);        }    }

DefaultActionProxyFactory创建ActionProxy，在com.opensymphony.xwork2.DefaultActionProxyFactory：

     public ActionProxy createActionProxy(String namespace, String actionName, String methodName, Map<String, Object> extraContext, boolean executeResult, boolean cleanupContext) {                ActionInvocation inv = new DefaultActionInvocation(extraContext, true);        container.inject(inv);        return createActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext);    }

接下来看看 org.apache.struts2.impl.StrutsActionProxy的execute()方法，如下：

     public String execute() throws Exception {        ActionContext previous = ActionContext.getContext();        ActionContext.setContext(invocation.getInvocationContext());        try {        //这里就是调用拦截器的入口了            return invocation.invoke();        } finally {            if (cleanupContext)                ActionContext.setContext(previous);        }    }

最关键的，com.opensymphony.xwork2.DefaultActionInvocation.invoke()方法，这个DefaultActionInvocation是ActionInvocation的一个实现类，如下：

  //保存了执行当前action方法时需要调用的拦截器栈，按照struts.xml中配制的拦截器顺序，从前到后，依次加入到了这个Iterator里面  protected Iterator<InterceptorMapping> interceptors;   public String invoke() throws Exception {        String profileKey = "invoke: ";        try {            UtilTimerStack.push(profileKey);            if (executed) {                throw new IllegalStateException("Action has already executed");            }            //如果当前还有下一个，则继续执行拦截器            if (interceptors.hasNext()) {                final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();                String interceptorMsg = "interceptor: " + interceptor.getName();                UtilTimerStack.push(interceptorMsg);                try {     //执行拦截器的intercept()方法，并将当前ActionInvocation对象传递给这个方法     //这样，当一个拦截器执行完自己的处理后，需要让框架继续执行下一个拦截器的时候，直接使用actionInvocation.invoke()方法，当前这个方法又会被调一次，这其实就是一个递归了，递归方法是ActionInvocation.invoke()，结束条件是interceptors.hasNext()                                resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);                            }                finally {                    UtilTimerStack.pop(interceptorMsg);                }            } else { //拦截器全部都执行了，那么最后来执行action，跳出递归了                resultCode = invokeActionOnly();            }            // this is needed because the result will be executed, then control will return to the Interceptor, which will            // return above and flow through again            if (!executed) {                if (preResultListeners != null) {                    for (Object preResultListener : preResultListeners) {                        PreResultListener listener = (PreResultListener) preResultListener;                        String _profileKey = "preResultListener: ";                        try {                            UtilTimerStack.push(_profileKey);                            listener.beforeResult(this, resultCode);                        }                        finally {                            UtilTimerStack.pop(_profileKey);                        }                    }                }                // now execute the result, if we're supposed to                if (proxy.getExecuteResult()) {                    executeResult();                }                executed = true;            }            return resultCode;        }        finally {            UtilTimerStack.pop(profileKey);        }    }

基本原理到此为止，下面弄个小例子再说明一下：

//拦截器，相当于struts2的拦截器 public interface Interceptor {    String intercept(InvocationContext context);}

//很多拦截器的实现public class ExceptionInterceptor implements Interceptor {    public String intercept(InvocationContext context) {        // 对异常的处理        System.out.println("\t\t\tExceptionInterceptor 处理异常");        return context.invoke();    }}public class FileUploadInterceptor implements Interceptor {    public String intercept(InvocationContext context) {        // 处理文件上传相关        System.out.println("\t\t\tFileUploadInterceptor 处理文件上传");        return context.invoke();    }}public class ParameterInterceptor implements Interceptor {    public String intercept(InvocationContext context) {        // 处理请求的参数        System.out.println("\t\t\tParameterInterceptor 处理请求参数");        return context.invoke();    }}

//执行拦截器的invocation上下文，相当于struts2的ActionInvocationpublic class InvocationContext {    // 这里存放当前执行当前action所需要执行的拦截器栈    private Iterator<Interceptor> interceptorIterator = null;    private String prefix = "";    public InvocationContext() {        // 模拟从配制文件中相应的规则取拦截器栈        ArrayList<Interceptor> list = new ArrayList<Interceptor>();        list.add(new ExceptionInterceptor());        list.add(new FileUploadInterceptor());        list.add(new ParameterInterceptor());        interceptorIterator = list.iterator();    }    public String invoke() {        // 是否还有拦截器需要执行        if (interceptorIterator.hasNext()) {            // 获取下一个需要执行的拦截器            Interceptor interceptor = interceptorIterator.next();            String name = interceptor.getClass().getName();            name = prefix + name;            System.out.println(name + " intercept start...");            prefix += "\t";            // Interceptor的所有intercept方法实现里面，最后都调用了InvocationContext.invoke()方法            // 其实就是一个递归，只不过invoke()的下一个递归是在Interceptor.intercept()里面调用的            // 所以说为什么Interceptor.intercept()方法要加个InvocationContext的参数呢，作用就在于此            String result = interceptor.intercept(this);            System.out.println(name + " intercept end...");            return result;        } else {// 所有的拦截器都执行完了，那就来执行action对应的方法            return executeAction();        }    }    private String executeAction() {        System.out.println(prefix + "executeAction success.");        return "success";    }}

//模拟请求进行测试public class Test {    public static void main(String[] args) {        InvocationContext context = new InvocationContext();        System.out.println("请求开始了...");        context.invoke();        System.out.println("请求处理完了...");    }}

参考链接：

http://sunjun041640.blog.163.com/blog/static/25626832201171510525222/