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里那位作者的图吧。