struts2源码浅析（四）

接上一篇讲了filter后，现在request到了action内了。

 

//Load Action class for mapping and invoke the appropriate Action method, or go directly to the Result.
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
                              ActionMapping mapping) throws ServletException {
        //createContextMap方法主要把Application、Session、Request的key value值拷贝到Map中
        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();
            //创建一个Action的代理对象，ActionProxyFactory是创建ActionProxy的工厂
            //参考实现类:DefaultActionProxy和DefaultActionProxyFactory
            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!
            //如果是Result,则直接转向,关于Result,ActionProxy,ActionInvocation下一讲中再分析
            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) {
        		LOG.error("Could not find action or result", 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);
        }
    }

 

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

 执行action时，要通过一系列拦截器的拦截，这也是struts2的一大特色。

拦截器中的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;   
}

 

 

这样，经过拦截器拦截，action调用业务code，返回result，再处理result交予前端，一个request的处理也告一段落。

附图一张，是关于action开始执行到处理返回result的整个过程。

 

 

结语：

      发文数量不多，不怎么会写这样子的文章，造成了文字很少，代码很多，图也画的不甚专业，大家多多包涵。

      入行时间不久，看源码难免有遗漏，错误的地方，还请大家多多指教。

 

评论

1 楼 wucaifang819787 2014-03-05  

你好！麻烦问下

不知道哪个图片行不行的：http://dl.iteye.com/upload/picture/pic/129620/7557b68c-460b-393f-b427-d0f04e5f1b50.png这个地址可以看的到的，有时间麻烦看下。