Struts2源码阅读

Struts包介绍

（ http://www.blogjava.net/lzhidj/archive/2008/07/10/213898.html ）（大部分叙述性的文字和图从其文中拷贝）：

包名	说明
org.apache.struts2. components	该包封装视图组件， Struts2在视图组件上有了很大加强，不仅增加了组件的属性个数，更新增了几个非常有用的组件，如 updownselect、 doubleselect、 datetimepicker、 token、 tree等。 另外， Struts2可视化视图组件开始支持主题 (theme)，缺省情况下，使用自带的缺省主题，如果要自定义页面效果，需要将组件的 theme属性设置为 simple。
org.apache.struts2. config	该包定义与配置相关的接口和类。实际上，工程中的 xml和 properties文件的读取和解析都是由 WebWork完成的， Struts只做了少量的工作。
org.apache.struts2.dispatcher	Struts2的核心包，最重要的类都放在该包中。
org.apache.struts2.impl	该包只定义了 3个类，他们是 StrutsActionProxy、 StrutsActionProxyFactory、 StrutsObjectFactory，这三个类都是对 xwork的扩展。
org.apache.struts2.interceptor	定义内置的截拦器。
org.apache.struts2.util	实用包。
org.apache.struts2.validators	只定义了一个类： DWRValidator。
org.apache.struts2.views	提供 freemarker、 jsp、 velocity等不同类型的页面呈现。

下表是对一些重要类的说明：

类名	说明
org.apache.struts2.dispatcher. Dispatcher	该类有两个作用： 1、初始化 2、调用指定的 Action的 execute()方法。
org.apache.struts2.dispatcher. FilterDispatcher	这是一个过滤器。文档中已明确说明，如果没有经验，配置时请将 url-pattern的值设成 /*。     该类有四个作用：     1、执行 Action     2、清理 ActionContext，避免内存泄漏     3、处理静态内容（ Serving static content）     4、为请求启动 xwork’s的截拦器链。
com.opensymphony.xwork2. ActionProxy	Action的代理接口。
com.opensymphony.xwork2. ctionProxyFactory	生产 ActionProxy的工厂。
com.opensymphony.xwork2.ActionInvocation	负责调用 Action和截拦器。
com.opensymphony.xwork2.config.providers. XmlConfigurationProvider	负责 Struts2的配置文件的解析。

Struts体系结构

Struts工作机制

    1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；

    2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；

    3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；

    4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；

    5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；

    6、ActionProxy创建一个ActionInvocation的实例。

    7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。

    8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总 是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper。

Struts源码分析

    从org.apache.struts2.dispatcher.FilterDispatcher开始

   //创建Dispatcher，此类是一个Delegate，它是真正完成根据url解析，读取对应Action。。。的地方    public   void  init(FilterConfig filterConfig)  throws  ServletException {           this .filterConfig = filterConfig;                   dispatcher = createDispatcher(filterConfig);         dispatcher.init();         //读取初始参数pakages，调用parse()，解析成类似/org/apache/struts2/static,/template的数组         String param = filterConfig.getInitParameter( "packages" );         String packages =  "org.apache.struts2.static template org.apache.struts2.interceptor.debugging" ;          if  (param !=  null ) {             packages = param +  " "  + packages;         }          this .pathPrefixes = parse(packages);     }

    顾名思义，init方法里就是初始读取一些属性配置文件，先看init_DefaultProperties。

1.      public   void  init() {
3.          if  (configurationManager ==  null ) {
4.             configurationManager =  new  ConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);
5.         }
7.         init_DefaultProperties();  // [1]
8.         init_TraditionalXmlConfigurations();  // [2]
9.         init_LegacyStrutsProperties();  // [3]
10.         init_ZeroConfiguration();  // [4]
11.         init_CustomConfigurationProviders();  // [5]
12.         init_MethodConfigurationProvider();
13.         init_FilterInitParameters() ;  // [6]
14.         init_AliasStandardObjects() ;  // [7]
16.         Container container = init_PreloadConfiguration();
17.         init_CheckConfigurationReloading(container);
18.         init_CheckWebLogicWorkaround(container);
20.     }
21.      private   void  init_DefaultProperties() {
22.         configurationManager.addConfigurationProvider( new  DefaultPropertiesProvider());
23.     }
24.      //DefaultPropertiesProvider
25.      public   void  register(ContainerBuilder builder, LocatableProperties props)
26.              throws  ConfigurationException {
27.         
28.         Settings defaultSettings =  null ;
29.          try  {
30.             defaultSettings =  new  PropertiesSettings( "org/apache/struts2/default" );
31.         }  catch  (Exception e) {
32.              throw   new  ConfigurationException( "Could not find or error in org/apache/struts2/default.properties" , e);
33.         }
34.         
35.         loadSettings(props, defaultSettings);
36.     }
37.      //PropertiesSettings
38.      //读取org/apache/struts2/default.properties的配置信息，如果项目中需要覆盖，可以在classpath里的struts.properties里覆写
39.      public  PropertiesSettings(String name) {
40.         
41.         URL settingsUrl = ClassLoaderUtils.getResource(name +  ".properties" , getClass());
42.         
43.          if  (settingsUrl ==  null ) {
44.             LOG.debug(name +  ".properties missing" );
45.             settings =  new  LocatableProperties();
46.              return ;
47.         }
48.          //settings的类型为LocatableProperties，继承Properties
49.         settings =  new  LocatableProperties( new  LocationImpl( null , settingsUrl.toString()));
51.          // Load settings
52.         InputStream in =  null ;
53.          try  {
54.             in = settingsUrl.openStream();
55.             settings.load(in);
56.         }  catch  (IOException e) {
57.              throw   new  StrutsException( "Could not load "  + name +  ".properties:"  + e, e);
58.         }  finally  {
59.              if (in !=  null ) {
60.                  try  {
61.                     in.close();
62.                 }  catch (IOException io) {
63.                     LOG.warn( "Unable to close input stream" , io);
64.                 }
65.             }
66.         }
67.     }

    再来看init_TraditionalXmlConfigurations方法，这个是读取Action配置的方法。

1.      private   void  init_TraditionalXmlConfigurations() {
2.          //首先读取web.xml中的config初始参数值
3.          //如果没有配置就使用默认的"struts-default.xml,struts-plugin.xml,struts.xml"，
4.          //这儿就可以看出为什么默认的配置文件必须取名为这三个名称了
5.          //如果不想使用默认的名称，直接在web.xml中配置config初始参数即可
6.         String configPaths = initParams.get( "config" );
7.          if  (configPaths ==  null ) {
8.             configPaths = DEFAULT_CONFIGURATION_PATHS;
9.         }
10.         String[] files = configPaths.split( "//s*[,]//s*" );
11.          //依次解析配置文件，xwork.xml单独解析
12.          for  (String file : files) {
13.              if  (file.endsWith( ".xml" )) {
14.                  if  ( "xwork.xml" .equals(file)) {
15.                     configurationManager.addConfigurationProvider( new  XmlConfigurationProvider(file,  false ));
16.                 }  else  {
17.                     configurationManager.addConfigurationProvider( new  StrutsXmlConfigurationProvider(file,  false , servletContext));
18.                 }
19.             }  else  {
20.                  throw   new  IllegalArgumentException( "Invalid configuration file name" );
21.             }
22.         }
23.     }

     对于其它配置文件只用StrutsXmlConfigurationProvider，此类继承XmlConfigurationProvider，而XmlConfigurationProvider又实现ConfigurationProvider接口。 类 XmlConfigurationProvider 负责配置文件的读取和解析， addAction() 方法负责读取 <action> 标签，并将数据保存在 ActionConfig 中； addResultTypes() 方法负责将 <result-type> 标签转化为 ResultTypeConfig 对象； loadInterceptors() 方法负责将 <interceptor> 标签转化为 InterceptorConfi 对象； loadInterceptorStack() 方法负责将 <interceptor-ref> 标签转化为 InterceptorStackConfig 对象； loadInterceptorStacks() 方法负责将 <interceptor-stack> 标签转化成 InterceptorStackConfig 对象。而上面的方法最终会被 addPackage() 方法调用，将所读取到的数据汇集到 PackageConfig 对象中 。

1.      protected  PackageConfig addPackage(Element packageElement)  throws  ConfigurationException {
2.         PackageConfig.Builder newPackage = buildPackageContext(packageElement);
4.          if  (newPackage.isNeedsRefresh()) {
5.              return  newPackage.build();
6.         }
8.          if  (LOG.isDebugEnabled()) {
9.             LOG.debug( "Loaded "  + newPackage);
10.         }
12.          // add result types (and default result) to this package
13.         addResultTypes(newPackage, packageElement);
15.          // load the interceptors and interceptor stacks for this package
16.         loadInterceptors(newPackage, packageElement);
18.          // load the default interceptor reference for this package
19.         loadDefaultInterceptorRef(newPackage, packageElement);
21.          // load the default class ref for this package
22.         loadDefaultClassRef(newPackage, packageElement);
24.          // load the global result list for this package
25.         loadGlobalResults(newPackage, packageElement);
27.          // load the global exception handler list for this package
28.         loadGobalExceptionMappings(newPackage, packageElement);
30.          // get actions
31.         NodeList actionList = packageElement.getElementsByTagName( "action" );
33.          for  ( int  i =  0 ; i < actionList.getLength(); i++) {
34.             Element actionElement = (Element) actionList.item(i);
35.             addAction(actionElement, newPackage);
36.         }
38.          // load the default action reference for this package
39.         loadDefaultActionRef(newPackage, packageElement);
41.         PackageConfig cfg = newPackage.build();
42.         configuration.addPackageConfig(cfg.getName(), cfg);
43.          return  cfg;
44.     }

    这儿发现一个配置上的小东西，我的xwork2.0.*是没有的，但是看源码是看到xwork2.1.*是可以的。看如下代码：

1.      private  List loadConfigurationFiles(String fileName, Element includeElement) {
2.         List<Document> docs =  new  ArrayList<Document>();
3.          if  (!includedFileNames.contains(fileName)) {
4.             ...........
5.                 Element rootElement = doc.getDocumentElement();
6.                 NodeList children = rootElement.getChildNodes();
7.                  int  childSize = children.getLength();
9.                  for  ( int  i = 0; i < childSize; i++) {
10.                     Node childNode = children.item(i);
12.                      if  (childNode instanceof Element) {
13.                         Element child = (Element) childNode;
15.                         final String nodeName = child.getNodeName();
16.                          //解析每个action配置是，对于include文件可以使用通配符*来进行配置
17.                          //如Struts.xml中可配置成<include file="actions_*.xml"/>
18.                          if  (nodeName.equals( "include" )) {
19.                             String includeFileName = child.getAttribute( "file" );
20.                              if (includeFileName.indexOf( '*' ) != -1 ) {
21.                                  // handleWildCardIncludes(includeFileName, docs, child);
22.                                 ClassPathFinder wildcardFinder =  new  ClassPathFinder();
23.                                 wildcardFinder.setPattern(includeFileName);
24.                                 Vector<String> wildcardMatches = wildcardFinder.findMatches();
25.                                  for  (String match : wildcardMatches) {
26.                                     docs.addAll(loadConfigurationFiles(match, child));
27.                                 }
28.                             }
29.                              else  {
30.                                 
31.                                 docs.addAll(loadConfigurationFiles(includeFileName, child));    
32.                             }    
33.                     }
34.                 }
35.                 }
36.                 docs.add(doc);
37.                 loadedFileUrls.add(url.toString());
38.             }
39.         }
40.          return  docs;
41.     }

    init_CustomConfigurationProviders方式初始自定义的Provider，配置类全名和实现ConfigurationProvider接口就可以。

1.      public   void  doFilter(ServletRequest req, ServletResponse res, FilterChain chain)  throws  IOException, ServletException {
4.         HttpServletRequest request = (HttpServletRequest) req;
5.         HttpServletResponse response = (HttpServletResponse) res;
6.         ServletContext servletContext = getServletContext();
8.         String timerKey =  "FilterDispatcher_doFilter: " ;
9.          try  {
10.             UtilTimerStack.push(timerKey);
11.              //根据content type来使用不同的Request封装，可以参见Dispatcher的wrapRequest
12.             request = prepareDispatcherAndWrapRequest(request, response);
13.             ActionMapping mapping;
14.              try  {
15.                  //根据url取得对应的Action的配置信息--ActionMapping，actionMapper是通过Container的inject注入的
16.                 mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());
17.             }  catch  (Exception ex) {
18.                 LOG.error( "error getting ActionMapping" , ex);
19.                 dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
20.                  return ;
21.             }
23.              //如果找不到对应的action配置，则直接返回。比如你输入***.jsp等等
24.             //这儿有个例外，就是如果path是以“/struts”开头，则到初始参数packages配置的包路径去查找对应的静态资源并输出到页面流中，当然.class文件除外。如果再没有则跳转到404
25.           if  (mapping ==  null ) {
26.                  // there is no action in this request, should we look for a static resource?
27.                 String resourcePath = RequestUtils.getServletPath(request);
29.                  if  ( "" .equals(resourcePath) &&  null  != request.getPathInfo()) {
30.                     resourcePath = request.getPathInfo();
31.                 }
33.                  if  (serveStatic && resourcePath.startsWith( "/struts" )) {
34.                     String name = resourcePath.substring( "/struts" .length());
35.                     findStaticResource(name, request, response);
36.                 }  else  {
37.                      // this is a normal request, let it pass through
38.                     chain.doFilter(request, response);
39.                 }
40.                  // The framework did its job here
41.                  return ;
42.             }
43.              //正式开始执行Action的方法了
44.             dispatcher.serviceAction(request, response, servletContext, mapping);
46.         }  finally  {
47.              try  {
48.                 ActionContextCleanUp.cleanUp(req);
49.             }  finally  {
50.                 UtilTimerStack.pop(timerKey);
51.             }
52.         }
53.     }

    来看Dispatcher类的serviceAction方法：

1.      public   void  serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
2.                               ActionMapping mapping)  throws  ServletException {
4.         Map<String, Object> extraContext = createContextMap(request, response, mapping, context);
6.          // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
7.         ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
8.          if  (stack !=  null ) {
9.             extraContext.put(ActionContext.VALUE_STACK, ValueStackFactory.getFactory().createValueStack(stack));
10.         }
12.         String timerKey =  "Handling request from Dispatcher" ;
13.          try  {
14.             UtilTimerStack.push(timerKey);
15.             String namespace = mapping.getNamespace();
16.             String name = mapping.getName();
17.             String method = mapping.getMethod();
19.             Configuration config = configurationManager.getConfiguration();
20.             ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory. class ).createActionProxy(namespace, name, extraContext,  true ,  false );
21.             proxy.setMethod(method);
22.             request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
24.              // if the ActionMapping says to go straight to a result, do it!
25.              if  (mapping.getResult() !=  null ) {
26.                 Result result = mapping.getResult();
27.                 result.execute(proxy.getInvocation());
28.             }  else  {
29.                 proxy.execute();
30.             }
32.              // If there was a previous value stack then set it back onto the request
33.              if  (stack !=  null ) {
34.                 request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
35.             }
36.         }  catch  (ConfigurationException e) {
37.             LOG.error( "Could not find action or result" , e);
38.             sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
39.         }  catch  (Exception e) {
40.              throw   new  ServletException(e);
41.         }  finally  {
42.             UtilTimerStack.pop(timerKey);
43.         }
44.     }

    第一句 createContextMap() 方法，该方法主要把Application、Session、Request的key value值拷贝到Map中，并放在HashMap<String,Object>中，可以参见createContextMap方法：

1.      public  HashMap<String,Object> createContextMap(Map requestMap,
2.                                     Map parameterMap,
3.                                     Map sessionMap,
4.                                     Map applicationMap,
5.                                     HttpServletRequest request,
6.                                     HttpServletResponse response,
7.                                     ServletContext servletContext) {
8.         HashMap<String,Object> extraContext =  new  HashMap<String,Object>();
9.         extraContext.put(ActionContext.PARAMETERS,  new  HashMap(parameterMap));
10.         extraContext.put(ActionContext.SESSION, sessionMap);
11.         extraContext.put(ActionContext.APPLICATION, applicationMap);
13.         Locale locale;
14.          if  (defaultLocale !=  null ) {
15.             locale = LocalizedTextUtil.localeFromString(defaultLocale, request.getLocale());
16.         }  else  {
17.             locale = request.getLocale();
18.         }
20.         extraContext.put(ActionContext.LOCALE, locale);
21.          //extraContext.put(ActionContext.DEV_MODE, Boolean.valueOf(devMode));
23.         extraContext.put(StrutsStatics.HTTP_REQUEST, request);
24.         extraContext.put(StrutsStatics.HTTP_RESPONSE, response);
25.         extraContext.put(StrutsStatics.SERVLET_CONTEXT, servletContext);
27.          // helpers to get access to request/session/application scope
28.         extraContext.put( "request" , requestMap);
29.         extraContext.put( "session" , sessionMap);
30.         extraContext.put( "application" , applicationMap);
31.         extraContext.put( "parameters" , parameterMap);
33.         AttributeMap attrMap =  new  AttributeMap(extraContext);
34.         extraContext.put( "attr" , attrMap);
36.          return  extraContext;
37.     }

    后面才是最主要的--ActionProxy，ActionInvocation。ActionProxy是Action的一个代理类，也就是说 Action的调用是通过ActionProxy实现的，其实就是调用了ActionProxy.execute()方法，而该方法又调用了 ActionInvocation.invoke()方法。归根到底，最后调用的是 DefaultActionInvocation.invokeAction()方法。先看DefaultActionInvocation的init方 法。

1.      public   void  init(ActionProxy proxy) {
2.          this .proxy = proxy;
3.         Map contextMap = createContextMap();
4.          //设置ActionContext，把ActionInvocation和Action压入ValueStack
5.         ActionContext actionContext = ActionContext.getContext();
7.          if (actionContext !=  null ) {
8.             actionContext.setActionInvocation( this );
9.         }
10.          //创建Action，可以看出Struts2里是每次请求都新建一个Action，careateAction方法可以自己参考
11.         createAction(contextMap);
12.          if  (pushAction) {
13.             stack.push(action);
14.             contextMap.put( "action" , action);
15.         }
16.         invocationContext =  new  ActionContext(contextMap);
17.         invocationContext.setName(proxy.getActionName());
18.         List interceptorList =  new  ArrayList(proxy.getConfig().getInterceptors());
19.         interceptors = interceptorList.iterator();
20.     }

1.      protected   void  createAction(Map contextMap) {
3.         String timerKey =  "actionCreate: " +proxy.getActionName();
4.          try  {
5.             UtilTimerStack.push(timerKey);
6.              //这儿默认建立Action是StrutsObjectFactory，实际中我使用的时候都是使用Spring创建的Action，这个时候使用的是SpringObjectFactory
7.             action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
8.         }
9.          ....... 
10.           catch  (Exception e) {
11.             ........
12.              throw   new  XWorkException(gripe, e, proxy.getConfig());
13.         }  finally  {
14.             UtilTimerStack.pop(timerKey);
15.         }
17.          if  (actionEventListener !=  null ) {
18.             action = actionEventListener.prepare(action, stack);
19.         }
20.     }

    接下来看看DefaultActionInvocation 的invoke方法。

1.      public  String invoke()  throws  Exception {
2.         String profileKey =  "invoke: " ;
3.          try  {
4.             UtilTimerStack.push(profileKey);
5.             
6.              if  (executed) {
7.                  throw   new  IllegalStateException( "Action has already executed" );
8.             }
9.                  //先执行interceptors
10.              if  (interceptors.hasNext()) {
11.                  final  InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();
12.                 UtilTimerStack.profile( "interceptor: " +interceptor.getName(), 
13.                          new  UtilTimerStack.ProfilingBlock<String>() {
14.                              public  String doProfiling()  throws  Exception {
15.                                 resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation. this );
16.                                  return   null ;
17.                             }
18.                 });
19.             }  else  {
20.                          //interceptor执行完了之后执行action
21.                 resultCode = invokeActionOnly();
22.             }
24.              if  (!executed) {
25.                  if  (preResultListeners !=  null ) {
26.                      for  (Iterator iterator = preResultListeners.iterator();
27.                         iterator.hasNext();) {
28.                         PreResultListener listener = (PreResultListener) iterator.next();
29.                         
30.                         String _profileKey= "preResultListener: " ;
31.                          try  {
32.                             UtilTimerStack.push(_profileKey);
33.                             listener.beforeResult( this , resultCode);
34.                         }
35.                          finally  {
36.                             UtilTimerStack.pop(_profileKey);
37.                         }
38.                     }
39.                 }
41.                  // now execute the result, if we're supposed to
42.                  if  (proxy.getExecuteResult()) {
43.                     executeResult();
44.                 }
46.                 executed =  true ;
47.             }
49.              return  resultCode;
50.         }
51.          finally  {
52.             UtilTimerStack.pop(profileKey);
53.         }
54.     }

     看程序中的if(interceptors.hasNext() )语句，当然，interceptors里存储的是 interceptorMapping列表（它包括一个Interceptor和一个name）， 所有的截拦器必须实现 Interceptor的intercept 方法，而该方法的参数恰恰又是 ActionInvocation ，在 intercept 方法中还是调用 invocation.invoke() ，从而实现了一个 Interceptor链的调用。当所有的Interceptor执行完，最后调用invokeActionOnly方法来执行Action相应的方法。

1.      protected  String invokeAction(Object action, ActionConfig actionConfig)  throws  Exception {
2.         String methodName = proxy.getMethod();
4.         String timerKey =  "invokeAction: " +proxy.getActionName();
5.          try  {
6.             UtilTimerStack.push(timerKey);
7.             
8.              boolean  methodCalled =  false ;
9.             Object methodResult =  null ;
10.             Method method =  null ;
11.              try  {
12.                  //获得Action对应的方法
13.                 method = getAction().getClass().getMethod(methodName,  new  Class[ 0 ]);
14.             }  catch  (NoSuchMethodException e) {
16.                  try  {
17.                      //如果没有对应的方法，则使用do+Xxxx来再次获得方法
18.                     String altMethodName =  "do"  + methodName.substring( 0 ,  1 ).toUpperCase() + methodName.substring( 1 );
19.                     method = getAction().getClass().getMethod(altMethodName,  new  Class[ 0 ]);
20.                 }  catch  (NoSuchMethodException e1) {
21.                     .....
22.                 }
23.             }
24.             
25.              if  (!methodCalled) {
26.                 methodResult = method.invoke(action,  new  Object[ 0 ]);
27.             }
28.              //根据不同的Result类型返回不同值
29.              if  (methodResult  instanceof  Result) {
30.                  this .explicitResult = (Result) methodResult;
31.                  return   null ;
32.             }  else  {
33.                  return  (String) methodResult;
34.             }
35.         }
36.         ....
37.         }  finally  {
38.             UtilTimerStack.pop(timerKey);
39.         }
40.     }

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

1.      private   void  executeResult()  throws  Exception {
2.          //根据ResultConfig创建Result
3.         result = createResult();
5.         String timerKey =  "executeResult: " +getResultCode();
6.          try  {
7.             UtilTimerStack.push(timerKey);
8.              if  (result !=  null ) {
9.                  //这儿正式执行:)
10.                 //可以参考Result的实现，如用了比较多的 ServletDispatcherResult,ServletActionRedirectResult,ServletRedirectResult
11.                 result.execute( this );
12.             }  else   if  (resultCode !=  null  && !Action.NONE.equals(resultCode)) {
13.                  throw   new  ConfigurationException( "No result defined for action "  + getAction().getClass().getName() 
14.                         +  " and result "  + getResultCode(), proxy.getConfig());
15.             }  else  {
16.                  if  (LOG.isDebugEnabled()) {
17.                     LOG.debug( "No result returned for action " +getAction().getClass().getName()+ " at " +proxy.getConfig().getLocation());
18.                 }
19.             }
20.         }  finally  {
21.             UtilTimerStack.pop(timerKey);
22.         }
23.     }

1.      public  Result createResult()  throws  Exception {
3.          if  (explicitResult !=  null ) {
4.             Result ret = explicitResult;
5.             explicitResult =  null ;;
6.              return  ret;
7.         }
8.         ActionConfig config = proxy.getConfig();
9.         Map results = config.getResults();
11.         ResultConfig resultConfig =  null ;
13.          synchronized  (config) {
14.              try  {
15.                  //根据result名称获得ResultConfig，resultCode就是result的name
16.                 resultConfig = (ResultConfig) results.get(resultCode);
17.             }  catch  (NullPointerException e) {
18.             }
19.              if  (resultConfig ==  null ) {
20.                  //如果找不到对应name的ResultConfig，则使用name为*的Result
21.                 resultConfig = (ResultConfig) results.get( "*" );
22.             }
23.         }
25.          if  (resultConfig !=  null ) {
26.              try  {
27.                  //参照StrutsObjectFactory的代码
28.                 Result result = objectFactory.buildResult(resultConfig, invocationContext.getContextMap());
29.                  return  result;
30.             }  catch  (Exception e) {
31.                 LOG.error( "There was an exception while instantiating the result of type "  + resultConfig.getClassName(), e);
32.                  throw   new  XWorkException(e, resultConfig);
33.             }
34.         }  else   if  (resultCode !=  null  && !Action.NONE.equals(resultCode) && unknownHandler !=  null ) {
35.              return  unknownHandler.handleUnknownResult(invocationContext, proxy.getActionName(), proxy.getConfig(), resultCode);
36.         }
37.          return   null ;
38.     }
40.     // StrutsObjectFactory
41.     public  Result buildResult(ResultConfig resultConfig, Map extraContext)  throws  Exception {
42.         String resultClassName = resultConfig.getClassName();
43.          if  (resultClassName ==  null )
44.              return   null ;
45.          //创建Result，因为Result是有状态的，所以每次请求都新建一个
46.         Object result = buildBean(resultClassName, extraContext);
47.         reflectionProvider.setProperties(resultConfig.getParams(), result, extraContext);
49.          if  (result  instanceof  Result)
50.              return  (Result) result;
51.          throw   new  ConfigurationException(result.getClass().getName() +  " does not implement Result." );
52.     }

    最后的时序图我拷贝开头url里那位作者的图吧。