[原创]java WEB学习笔记70：Struts2 学习之路-- struts2拦截器源码分析，运行流程

本博客的目的：①总结自己的学习过程，相当于学习笔记 ②将自己的经验分享给大家，相互学习，互相交流，不可商用

内容难免出现问题，欢迎指正，交流，探讨，可以留言，也可以通过以下方式联系。

本人互联网技术爱好者，互联网技术发烧友

微博：伊直都在0221

QQ：951226918

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.运行流程

　　

相关的几个 API

　　

ActionMapping：Simple class that holds the action mapping information used to invoke a Struts action. The name and namespace are required

ActionMapper：When given an HttpServletRequest, the ActionMapper may return null if no action invocation request matches, or it may return an ActionMapping that describes an action invocation for the framework to try

ActionProxy：ActionProxy is an extra layer between XWork and the action so that different proxies are possible.

ActionInvocation：An ActionInvocation represents the execution state of an Action. It holds the Interceptors and the Action instance. By repeated re-entrant execution of the invoke() method, initially by the ActionProxy, then by the Interceptors, the Interceptors are all executed, and then the Action and the Result.

Struts2 运行流程分析：

　　1. 请求发送给 StrutsPrepareAndExecuteFilter

　　2. StrutsPrepareAndExecuteFilter 询问 ActionMapper： 该请求是否是一个 Struts2 请求（即是否返回一个非空的 ActionMapping 对象）

　　3. 若 ActionMapper 认为该请求是一个 Struts2 请求，则 StrutsPrepareAndExecuteFilter 把请求的处理交给 ActionProxy

　　4. ActionProxy 通过 Configuration Manager 询问框架的配置文件，确定需要调用的 Action 类及 Action 方法

　　5. ActionProxy 创建一个 ActionInvocation 的实例，并进行初始化

　　6. ActionInvocation 实例在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。

　　7. Action 执行完毕，ActionInvocation 负责根据 struts.xml 中的配置找到对应的返回结果。调用结果的 execute 方法，渲染结果。在渲染的过程中可以使用Struts2 框架中的标签。

　　8. 执行各个拦截器 invocation.invoke() 之后的代码

　　9. 把结果发送到客户端

实际代码：

　　　　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);
             prepare.createActionContext(request, response);
             prepare.assignDispatcherToThread();
             if (excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
                 chain.doFilter(request, response);
             } else {
                 request = prepare.wrapRequest(request);
                 ActionMapping mapping = prepare.findActionMapping(request, response, true);
                 if (mapping == null) {
                     boolean handled = execute.executeStaticResourceRequest(request, response);
                     if (!handled) {
                         chain.doFilter(request, response);
                     }
                 } else {
                     execute.executeAction(request, response, mapping);
                 }
             }
         } finally {
             prepare.cleanupRequest(request);
         }
     }

PrepareOperations

  public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup) {
         ActionMapping mapping = (ActionMapping) request.getAttribute(STRUTS_ACTION_MAPPING_KEY);
         if (mapping == null || forceLookup) {
             try {
                 mapping = dispatcher.getContainer().getInstance(ActionMapper.class).getMapping(request, dispatcher.getConfigurationManager());
                 if (mapping != null) {
                     request.setAttribute(STRUTS_ACTION_MAPPING_KEY, mapping);
                 }
             } catch (Exception ex) {
                 dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
             }
         }

         return mapping;
     }

DefaultActionMapper

   public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
         ActionMapping mapping = new ActionMapping();
         String uri = getUri(request);

         int indexOfSemicolon = uri.indexOf(";");
         uri = (indexOfSemicolon > -1) ? uri.substring(0, indexOfSemicolon) : uri;

         uri = dropExtension(uri, mapping);
         if (uri == null) {
             return null;
         }

         parseNameAndNamespace(uri, mapping, configManager);
         handleSpecialParameters(request, mapping);
         return parseActionName(mapping);
     }

 public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException {
         dispatcher.serviceAction(request, response, servletContext, mapping);
     }

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();
             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 {
                 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 {
                 if (LOG.isWarnEnabled()) {
                     LOG.warn("Could not find action or result", e);
                 }
             }
             sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
         } catch (Exception e) {
             if (handleException || devMode) {
                 sendError(request, response, context, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
             } else {
                 throw new ServletException(e);
             }
         } finally {
             UtilTimerStack.pop(timerKey);
         }
     }

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);
     }

 public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName, boolean executeResult, boolean cleanupContext) {

         DefaultActionProxy proxy = new DefaultActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext);
         container.inject(proxy);
         proxy.prepare();
         return proxy;
     }

DefaultActionProxy

  public String execute() throws Exception {
         ActionContext nestedContext = ActionContext.getContext();
         ActionContext.setContext(invocation.getInvocationContext());

         String retCode = null;

         String profileKey = "execute: ";
         try {
             UtilTimerStack.push(profileKey);

             retCode = invocation.invoke();
         } finally {
             if (cleanupContext) {
                 ActionContext.setContext(nestedContext);
             }
             UtilTimerStack.pop(profileKey);
         }

         return retCode;
     }

DefaultActionInvocation

 public String invoke() throws Exception {
         String profileKey = "invoke: ";
         try {
             UtilTimerStack.push(profileKey);

             if (executed) {
                 throw new IllegalStateException("Action has already executed");
             }

             if (interceptors.hasNext()) {
11                 final InterceptorMapping interceptor = interceptors.next();
12                 String interceptorMsg = "interceptor: " + interceptor.getName();
13                 UtilTimerStack.push(interceptorMsg);
14                 try {
15                                 resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
16                             }
17                 finally {
18                     UtilTimerStack.pop(interceptorMsg);
19                 }
20             } else {
21                 resultCode = invokeActionOnly();
22             }

             // 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);
         }
     }