下面就说说个人对struts2对请求处理流程的理解：
下面是StrutsPrepareAndExecuteFilter过滤器的doFilter方法中的主要代码：
prepare.setEncodingAndLocale(request, response);
prepare.createActionContext(request, response);
prepare.assignDispatcherToThread();
if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
chain.doFilter(request, response);
} else {
request = prepare.wrapRequest(request);
ActionMapping mapping = prepare.findActionMapping(request, response, true);
if (mapping == null) {
boolean handled = execute.executeStaticResourceRequest(request, response);
if (!handled) {
chain.doFilter(request, response);
}
} else {
execute.executeAction(request, response, mapping);
}
}
在系统初始化的时候StrutsPrepareAndExecuteFilter的init方法被执行，实例化出了PrepareOperations和ExecuteOperations两个对象，第一个对象是对真正响应请求之前所作的一些准备操作封装，ExecuteOperations是对响应请求所作的封装，但其实这两个对象最终调用的都是核心分发器Dispatcher对象的方法。
prepare.setEncodingAndLocale(request, response);这一句处理请求编码与响应Locale，其内部调用的就是Dipatcher的prepare方法，下面是源码：
/**
* Sets the request encoding and locale on the response
*/
public void setEncodingAndLocale(HttpServletRequest request, HttpServletResponse response) {
dispatcher.prepare(request, response);
}
其逻辑是如果在在struts2的配置文件中指写了i18n编码则使用配置文件中的编码，否则不会调用request.setCharacterEncoding()方法。至于响应Locale的取值与encoding的原理是一样的，但具体的逻辑源码有点多，但不难，这里就不作解释了，大家应该都看得懂。
prepare.createActionContext(request, response);
ActionContext oldContext = ActionContext.getContext();
if (oldContext != null) {
// detected existing context, so we are probably in a forward
//因为项目一般都不会是分布式应用，也就不会执行这里
ctx = new ActionContext(new HashMap
} else {
//这里是会执行的代码
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
stack.getContext().putAll(dispatcher.createContextMap(request, response, null, servletContext));
ctx = new ActionContext(stack.getContext());
}
request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
ActionContext.setContext(ctx);
return ctx;
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();从struts2容器中获取ValueStackFactory并创建出ValueStack
stack.getContext().putAll(dispatcher.createContextMap(request, response, null, servletContext));把ActionContext中的数据复制一份到ValueStack中，所以从ActionContext与ValueStack都能拿到我们想要的所有数据。
dispatcher.createContextMap
// request map wrapping the http request objects
Map requestMap = new RequestMap(request);
// parameters map wrapping the http parameters. ActionMapping parameters are now handled and applied separately
Map params = new HashMap(request.getParameterMap());
// session map wrapping the http session
Map session = new SessionMap(request);
// application map wrapping the ServletContext
Map application = new ApplicationMap(context);
Map
if (mapping != null) {
extraContext.put(ServletActionContext.ACTION_MAPPING, mapping);
}
return extraContext;
该方法中把Servlet原生的Request,Parameters,Session,ServletContext都转换成了Map，然后将转换后的Map与原生的Servlet对象都传进了Dispatcher另一个重载的createContextMap方法，下面是其源码：
public HashMap
Map parameterMap,
Map sessionMap,
Map applicationMap,
HttpServletRequest request,
HttpServletResponse response,
ServletContext servletContext) {
HashMap
extraContext.put(ActionContext.PARAMETERS, new HashMap(parameterMap));
extraContext.put(ActionContext.SESSION, sessionMap);
extraContext.put(ActionContext.APPLICATION, applicationMap);
Locale locale;
if (defaultLocale != null) {
locale = LocalizedTextUtil.localeFromString(defaultLocale, request.getLocale());
} else {
locale = request.getLocale();
}
extraContext.put(ActionContext.LOCALE, locale);
//extraContext.put(ActionContext.DEV_MODE, Boolean.valueOf(devMode));
extraContext.put(StrutsStatics.HTTP_REQUEST, request);
extraContext.put(StrutsStatics.HTTP_RESPONSE, response);
extraContext.put(StrutsStatics.SERVLET_CONTEXT, servletContext);
// helpers to get access to request/session/application scope
extraContext.put("request", requestMap);
extraContext.put("session", sessionMap);
extraContext.put("application", applicationMap);
extraContext.put("parameters", parameterMap);
AttributeMap attrMap = new AttributeMap(extraContext);
extraContext.put("attr", attrMap);
return extraContext;
}
该方法主要就是把转换后的Map与Servlet原生对象外加一个AttributeMap都存进了一个大Map中，然后返回。
这样就即能获取转换后的Map，又可以获取Servlet原生对象。
现在回到prepare.createActionContext方法中
ActionContext.setContext(ctx);把创建的ActionContext对象放进ThreadLocal
再加到核心过滤器中，prepare.assignDispatcherToThread();从该方法的名称就知道是把Dispatcher对象绑定到当前线程，也就是放进了一个ThreadLocal
if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
chain.doFilter(request, response);
}该判断是因为struts2支持不包含的URL模式匹配，一个请求虽然进入了struts2过滤器，但如果该请求的URL在不包含之列的话sturts2只是单纯地调用chain.doFilter方法放行。其它情况就会进入else部分，调用Action处理请求。
request = prepare.wrapRequest(request);对HttpServletRequest进行包装，参看其源码就可以知道如果是文件上传把HttpServletRequest包装成了一个MultiPartRequestWrapper对象，该对象专门处理文件上传请求。如果不是文件上传进把HttpServletRequest包装成了StrutsRequestWrapper，StrutsRequestWrapper类覆盖了其父类的getAttribute方法，对该方法的行为作了一点修改，其父类即javax.servlet.http.HttpServletRequestWrapper中的getAttribute方法只是从request对象查找指定属性，而StrutsRequestWrapper的getAttribute方法是先在request对象中进行查找，如果没有找到还会去ValueStack中进行查找，下面的源码即是证明：
// If not found, then try the ValueStack
ctx.put("__requestWrapper.getAttribute", Boolean.TRUE);
ValueStack stack = ctx.getValueStack();
if (stack != null) {
attribute = stack.findValue(s);
}
这就是为什么在JSP页面中用EL表达式也能访问到ValueStack中值的属性的原因。
ActionMapping mapping = prepare.findActionMapping(request, response, true);这句就没什么说了，就是得到Action映射信息。
如果请求的静态页面就会执行execute.executeStaticResourceRequest(request, response);在方法内部会判断有无能力对该请求进行处理，如果有则处理没有则调用chain.doFilter放行，实现基本都一样就是原样返回给客户端了。
真正会执行Action的是这一句：execute.executeAction(request, response, mapping);该方法调用的是Dispatcher的serviceAction方法，我们进入该方法看看，下面是该方法中的重要代码：
Configuration config = configurationManager.getConfiguration();
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!
if (mapping.getResult() != null) {
Result result = mapping.getResult();
result.execute(proxy.getInvocation());
} else {
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);
}
先获取Configuration对象，通过Configuration得到容器对象，再从容器中获取ActionProxyFactory，ActionProxy工厂类，然后创建ActionProxy，大家都知道struts2内部包装的是webwork框架，而ActionProxy正是sturts与webwork的分界线，ActionProxy是进行webwork框架的门户。
struts2默认使用的是DefaultActionProxyFactory创建ActionProxy对象的，下面是其createActionFactor方法：
public ActionProxy createActionProxy(String namespace, String actionName, String methodName, Map
ActionInvocation inv = new DefaultActionInvocation(extraContext, true);
container.inject(inv);
return createActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext);
}
public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName, boolean executeResult, boolean cleanupContext) {
DefaultActionProxy proxy = new DefaultActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext);
container.inject(proxy);
proxy.prepare();
return proxy;
}
这是两个重载的方法，第一个方法调用了第二个方法，在第一个方法中创建了ActionInvocation对象，并对其依赖的对象使用容器进行注入，紧接着就创建了ActionProxy对象，也对其依赖对象进行了注入，如果ObjectFctory，Configuration对象等。然后高用proxy.prepare()方法，其中有一个resolveMethod();的方法，该方法很简单，就是如果在配置Action的时候没有指定method属性的时候会把method属性值赋为execute，这就是为什么execute是Action默认的执行方法的原因。还有一个很重要的方法叫invocation.init(this);即调用ActionInvocation的init方法，把ActionProxy自己传了进行，当然ActionInvocation中会对ActionProxy进行缓存。
struts2对ActionInvocation的默认实现是DefaultActionInvocation类，进放该类的init方法，下面是该方法中重要的代码：
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
interceptors = interceptorList.iterator();
第一句即创建Action，如果大家对struts2的对象创建有所了解的话就知道，Action，Result，Intercepter的创建都是由ObjectFactory的buildBean方法来创建的，其内部就是调用Class.newInstance();创建的，所以Action一定要有一个无参构造方法。
注意这句：stack.push(action);这里把创建的Action压进了ValuesStack中，这就是为什么默认Action在栈顶的原因。下面就是获取该Action配置的所有拦截器并进行缓存在ActionInvocation中，Action也是如此，因为Action与Interceptor的执行调度就是由ActionInvocation实现的。
现在回到Dispatcher的serviceAction方法中，创建出来ActionProxy对象后的下一句代码把ValueStack对象放进了request中，这也就意味着我们通过HttpServletRequest对象也是可获取，只要知道key就行了。
proxy.execute();这一句执行ActionProxy的execute方法，struts2中ActionProxy的默认实现是StrutsActionProxy，下面进行该类的execute方法，源码如下：
public String execute() throws Exception {
ActionContext previous = ActionContext.getContext();
ActionContext.setContext(invocation.getInvocationContext());
try {
// This is for the new API:
// return RequestContextImpl.callInContext(invocation, new Callable
// public String call() throws Exception {
// return invocation.invoke();
// }
// });
return invocation.invoke();
} finally {
if (cleanupContext)
ActionContext.setContext(previous);
}
}
代码很简单，就是调用ActionInvocation的invoke方法，执行拦截器与Action，下面是invoke方法的源码，因该方法中附属代码较多，这里只捡出了重要代码：
if (interceptors.hasNext()) {
final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();
String interceptorMsg = "interceptor: " + interceptor.getName();
UtilTimerStack.push(interceptorMsg);
try {
resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
}
finally {
UtilTimerStack.pop(interceptorMsg);
}
} else {
resultCode = invokeActionOnly();
}
//这里省略了一些代码...
// now execute the result, if we're supposed to
if (proxy.getExecuteResult()) {
executeResult();
}
显示这里就是在执行拦截器栈中的所有拦截器，当拦截器执行完后就会根据配置执行Action中相应的方法，执行完后得到了一个resultCode字符串，系统就是根据这个字符串去查找相应的Result。
紧凑着就是执行executeResult方法，该方法中就是根据Result配置创建出相应的Result对象，然后执行Result的execute方法，例如用得最多的ServletDispatcherResult，其execute方法主要就是调用dispatcher.forward(request, response)方法，返回一个页面给Tomcat进行解析，然后将解析后的内容呈现给客户端浏览器。
至此，struts2的整个执行流程基本上就讲完了，如果有错误之处，尽请指正。
下面上传的是个人为struts2执行流程画的一个时序图，有兴趣的可以看看，因图片太大所以要放大了才看得清，希望有所帮助：