Structs ActionProxy深度阅读

ActionProxy是Action的一个代理类，也就是说Action的调用是通过ActionProxy实现的，其实就是调用了ActionProxy.execute()方法，而该方法又调用了ActionInvocation.invoke()方法。归根到底，最后调用的是DefaultActionInvocation.invokeAction()方法。
DefaultActionInvocation()->init()->createAction()。 
最后通过调用ActionProxy.exute()-->ActionInvocation.invoke()-->Intercepter.intercept()-->ActionInvocation.invokeActionOnly()-->invokeAction()
这里的步骤是先由ActionProxyFactory创建ActionInvocation和ActionProxy.

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

 下面先看DefaultActionInvocation的init方法

 public void init(ActionProxy proxy) {
     this.proxy = proxy;
     Map<String, Object> contextMap = createContextMap();

     // Setting this so that other classes, like object factories, can use the ActionProxy and other
     // contextual information to operate
     ActionContext actionContext = ActionContext.getContext();

     if (actionContext != null) {
         actionContext.setActionInvocation(this);
     }
     //创建Action,struts2中每一个Request都会创建一个新的Action
     createAction(contextMap);

     if (pushAction) {
         stack.push(action);
         contextMap.put("action", action);
     }

     invocationContext = new ActionContext(contextMap);
     invocationContext.setName(proxy.getActionName());

     // get a new List so we don't get problems with the iterator if someone changes the list
     List<InterceptorMapping> interceptorList = new ArrayList<InterceptorMapping>(proxy.getConfig().getInterceptors());
     interceptors = interceptorList.iterator();
 }

 protected void createAction(Map<String, Object> contextMap) {
     // load action
     String timerKey = "actionCreate: " + proxy.getActionName();
     try {
         UtilTimerStack.push(timerKey);
         //默认为SpringObjectFactory:struts.objectFactory=spring.这里非常巧妙,在struts.properties中可以重写这个属性
         //在前面BeanSelectionProvider中通过配置文件为ObjectFactory设置实现类
         //这里以Spring为例,这里会调到SpringObjectFactory的buildBean方法,可以通过ApplicationContext的getBean()方法得到Spring的Bean
         action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
     } catch (InstantiationException e) {
         throw new XWorkException("Unable to intantiate Action!", e, proxy.getConfig());
     } catch (IllegalAccessException e) {
         throw new XWorkException("Illegal access to constructor, is it public?", e, proxy.getConfig());
     } catch (Exception e) {
        ...
     } finally {
         UtilTimerStack.pop(timerKey);
     }

     if (actionEventListener != null) {
         action = actionEventListener.prepare(action, stack);
     }
 }
 //SpringObjectFactory
 public Object buildBean(String beanName, Map<String, Object> extraContext, boolean injectInternal) throws Exception {
     Object o = null;
     try {
         //SpringObjectFactory会通过web.xml中的context-param:contextConfigLocation自动注入ClassPathXmlApplicationContext
         o = appContext.getBean(beanName);
     } catch (NoSuchBeanDefinitionException e) {
         Class beanClazz = getClassInstance(beanName);
         o = buildBean(beanClazz, extraContext);
     }
     if (injectInternal) {
         injectInternalBeans(o);
     }
     return o;
 }

 

 //接下来看看DefaultActionInvocation 的invoke方法
 public String invoke() throws Exception {
     String profileKey = "invoke: ";
     try {
         UtilTimerStack.push(profileKey);

         if (executed) {
             throw new IllegalStateException("Action has already executed");
         }
         //递归执行interceptor
         if (interceptors.hasNext()) {
             //interceptors是InterceptorMapping实际上是像一个像FilterChain一样的Interceptor链
             //通过调用Invocation.invoke()实现递归牡循环
             final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();
             String interceptorMsg = "interceptor: " + interceptor.getName();
             UtilTimerStack.push(interceptorMsg);
             try {
                  //在每个Interceptor的方法中都会return invocation.invoke()
                  resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
                 }
             finally {
                 UtilTimerStack.pop(interceptorMsg);
             }
         } else {
             //当所有interceptor都执行完,最后执行Action,invokeActionOnly会调用invokeAction()方法
             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
         //在Result返回之前调用preResultListeners
         //通过executed控制,只执行一次
         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
             //执行Result
             if (proxy.getExecuteResult()) {
                 executeResult();
             }

             executed = true;
         }

         return resultCode;
     }
     finally {
         UtilTimerStack.pop(profileKey);
     }
 }

 //invokeAction
 protected String invokeAction(Object action,ActionConfig actionConfig)throws Exception{
     String methodName = proxy.getMethod();

     String timerKey = "invokeAction: " + proxy.getActionName();
     try {
         UtilTimerStack.push(timerKey);

         boolean methodCalled = false;
         Object methodResult = null;
         Method method = null;
         try {
             //java反射机制得到要执行的方法
             method = getAction().getClass().getMethod(methodName, new Class[0]);
         } catch (NoSuchMethodException e) {
             // hmm -- OK, try doXxx instead
             //如果没有对应的方法，则使用do+Xxxx来再次获得方法
             try {
                 String altMethodName = "do" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
                 method = getAction().getClass().getMethod(altMethodName, new Class[0]);
             } catch (NoSuchMethodException e1) {
                 // well, give the unknown handler a shot
                 if (unknownHandlerManager.hasUnknownHandlers()) {
                     try {
                         methodResult = unknownHandlerManager.handleUnknownMethod(action, methodName);
                         methodCalled = true;
                     } catch (NoSuchMethodException e2) {
                         // throw the original one
                         throw e;
                     }
                 } else {
                     throw e;
                 }
             }
         }
         //执行Method
         if (!methodCalled) {
             methodResult = method.invoke(action, new Object[0]);
         }
         //从这里可以看出可以Action的方法可以返回String去匹配Result,也可以直接返回Result类
         if (methodResult instanceof Result) {
             this.explicitResult = (Result) methodResult;

             // Wire the result automatically
             container.inject(explicitResult);
             return null;
         } else {
             return (String) methodResult;
         }
     } catch (NoSuchMethodException e) {
         throw new IllegalArgumentException("The " + methodName + "() is not defined in action " + getAction().getClass() + "");
     } catch (InvocationTargetException e) {
         // We try to return the source exception.
         Throwable t = e.getTargetException();

         if (actionEventListener != null) {
             String result = actionEventListener.handleException(t, getStack());
             if (result != null) {
                 return result;
             }
         }
         if (t instanceof Exception) {
             throw (Exception) t;
         } else {
             throw e;
         }
     } finally {
         UtilTimerStack.pop(timerKey);
     }
 }

 action执行完了，还要根据ResultConfig返回到view，也就是在invoke方法中调用executeResult方法。

 

 private void executeResult() throws Exception {
     //根据ResultConfig创建Result
     result = createResult();

     String timerKey = "executeResult: " + getResultCode();
     try {
         UtilTimerStack.push(timerKey);
         if (result != null) {
         //开始执行Result,
         //可以参考Result的实现，如用了比较多的ServletDispatcherResult,ServletActionRedirectResult,ServletRedirectResult
             result.execute(this);
         } else if (resultCode != null && !Action.NONE.equals(resultCode)) {
             throw new ConfigurationException("No result defined for action " + getAction().getClass().getName()
                     + " and result " + getResultCode(), proxy.getConfig());
         } else {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("No result returned for action " + getAction().getClass().getName() + " at " + proxy.getConfig().getLocation());
             }
         }
     } finally {
         UtilTimerStack.pop(timerKey);
     }
 }

 public Result createResult() throws Exception {
     //如果Action中直接返回的Result类型,在invokeAction()保存在explicitResult
     if (explicitResult != null) {
         Result ret = explicitResult;
         explicitResult = null;

         return ret;
     }
     //返回的是String则从config中得到当前Action的Results列表
     ActionConfig config = proxy.getConfig();
     Map<String, ResultConfig> results = config.getResults();

     ResultConfig resultConfig = null;

     synchronized (config) {
         try {
             //通过返回的String来匹配resultConfig
             resultConfig = results.get(resultCode);
         } catch (NullPointerException e) {
             // swallow
         }
         if (resultConfig == null) {
             // If no result is found for the given resultCode, try to get a wildcard '*' match.
             //如果找不到对应name的ResultConfig，则使用name为*的Result
             //说明可以用*通配所有的Result
             resultConfig = results.get("*");
         }
     }

     if (resultConfig != null) {
         try {
             //创建Result
             return objectFactory.buildResult(resultConfig, invocationContext.getContextMap());
         } catch (Exception e) {
             LOG.error("There was an exception while instantiating the result of type " + resultConfig.getClassName(), e);
             throw new XWorkException(e, resultConfig);
         }
     } else if (resultCode != null && !Action.NONE.equals(resultCode) && unknownHandlerManager.hasUnknownHandlers()) {
         return unknownHandlerManager.handleUnknownResult(invocationContext, proxy.getActionName(), proxy.getConfig(), resultCode);
     }
     return null;
 }

 public Result buildResult(ResultConfig resultConfig, Map<String, Object> extraContext) throws Exception {
     String resultClassName = resultConfig.getClassName();
     Result result = null;

     if (resultClassName != null) {
         //buildBean中会用反射机制Class.newInstance来创建bean
         result = (Result) buildBean(resultClassName, extraContext);
         Map<String, String> params = resultConfig.getParams();
         if (params != null) {
             for (Map.Entry<String, String> paramEntry : params.entrySet()) {
                 try {
                      //reflectionProvider参见OgnlReflectionProvider；
               //resultConfig.getParams()就是result配置文件里所配置的参数<param></param>
                      //setProperties方法最终调用的是Ognl类的setValue方法
               //这句其实就是把param名值设置到根对象result上
                     reflectionProvider.setProperty(paramEntry.getKey(), paramEntry.getValue(), result, extraContext, true);
                 } catch (ReflectionException ex) {
                     if (LOG.isErrorEnabled())
                         LOG.error("Unable to set parameter [#0] in result of type [#1]", ex,
                                 paramEntry.getKey(), resultConfig.getClassName());
                     if (result instanceof ReflectionExceptionHandler) {
                         ((ReflectionExceptionHandler) result).handle(ex);
                     }
                 }
             }
         }
     }

     return result;
 }