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