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的ActionInvocation
public 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("请求处理完了...");
    }
}