本文深入剖析了Struts2框架的内部工作原理，包括体系结构、工作机制及核心类的源码分析，详细介绍了如何通过ActionMapper获取Action以及FilterDispatcher如何处理请求。
推荐两篇不错的struts2源码分析文章：
http://www.blogjava.net/lzhidj/archive/2008/07/10/213898.html
http://www.blogjava.net/myyate/articles/Struts2_source_java.html
入门教程：http://java.chinaitlab.com/special/struts2/
一. Strut2的体系结构图：
二. Struts2的工作机制
如上图，一个请求在 Struts2框架中的处理大概分为以下几个步骤：
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。
三. struts2源码分析
1、关键类介绍
ConfigurationProvider就是Struts2中配置文件的解析器，Struts2中的配置文件主要是尤其实现类 XmlConfigurationProvider及其子类StrutsXmlConfigurationProvider来解析
2、源码分析
和 Struts1.x不同， Struts2的启动是通过 FilterDispatcher过滤器实现的。下面是该过滤器在 web.xml文件中的配置：
代码清单 6 ： web.xml （截取）
< filter >
< filter-name > struts2 </ filter-name >
< filter-class >
org.apache.struts2.dispatcher.FilterDispatcher
</ filter-class >
</ filter >
< filter-mapping >
< filter-name > struts2 </ filter-name >
< url-pattern > /* </ url-pattern >
</ filter-mapping >
Struts2建议，在对 Struts2的配置尚不熟悉的情况下，将 url-pattern配置为 /*，这样该过滤器将截拦所有请求。
实际上， FilterDispatcher 除了实现 Filter 接口以外，还实现了 StrutsStatics 接口，继承代码如下：
代码清单 7 ： FilterDispatcher 结构
public class FilterDispatcher implements StrutsStatics, Filter {
}
StrutsStatics 并没有定义业务方法，只定义了若干个常量。 Struts2 对常用的接口进行了重新封装，比如 HttpServletRequest 、 HttpServletResponse 、 HttpServletContext 等。 以下是 StrutsStatics 的定义：
代码清单 8 ： StrutsStatics.java
public interface StrutsStatics {
/**
* Constant for the HTTP request object.
*/
public static final String HTTP_REQUEST = "com.opensymphony.xwork2.dispatcher.HttpServletRequest" ;
/**
* Constant for the HTTP response object.
*/
public static final String HTTP_RESPONSE = "com.opensymphony.xwork2.dispatcher.HttpServletResponse" ;
/**
* Constant for an HTTP request dispatcher} .
*/
public static final String SERVLET_DISPATCHER = "com.opensymphony.xwork2.dispatcher.ServletDispatcher" ;
/**
* Constant for the servlet context} object.
*/
public static final String SERVLET_CONTEXT = "com.opensymphony.xwork2.dispatcher.ServletContext" ;
/**
* Constant for the JSP page context} .
*/
public static final String PAGE_CONTEXT = "com.opensymphony.xwork2.dispatcher.PageContext" ;
/** Constant for the PortletContext object */
public static final String STRUTS_PORTLET_CONTEXT = "struts.portlet.context" ;
}
容器启动后， FilterDispatcher 被实例化，调用 init(FilterConfig filterConfig) 方法。该方法创建 Dispatcher 类的对象，并且将 FilterDispatcher 配置的初始化参数传到对象中（详情请参考代码清单 10 ），并负责 Action 的执行。然后得到参数 packages ，值得注意的是，还有另外三个固定的包和该参数进行拼接，分别是 org.apache.struts2.static 、 template 、和 org.apache.struts2.interceptor.debugging ，中间用空格隔开，经过解析将包名变成路径后存储到一个名叫 pathPrefixes 的数组中，这些目录中的文件会被自动搜寻。
代码清单 9 ： FilterDispatcher.init() 方法
public void init(FilterConfig filterConfig) throws ServletException {
this .filterConfig = filterConfig;
dispatcher = createDispatcher(filterConfig);
dispatcher.init();
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);
}
代码清单 10 ： FilterDispatcher.createDispatcher() 方法
protected Dispatcher createDispatcher(FilterConfig filterConfig) {
Map<String,String> params = new HashMap<String,String>();
for (Enumeration e = filterConfig.getInitParameterNames(); e.hasMoreElements(); ) {
String name = (String) e.nextElement();
String value = filterConfig.getInitParameter(name);
params.put(name, value);
}
return new Dispatcher(filterConfig.getServletContext(), params);
}
当用户向 Struts2 发送请求时， FilterDispatcher 的 doFilter() 方法自动调用，这个方法非常关键。首先， Struts2 对请求对象进行重新包装，此次包装根据请求内容的类型不同，返回不同的对象，如果为 multipart/form-data 类型，则返回 MultiPartRequestWrapper 类型的对象，该对象服务于文件上传，否则返回 StrutsRequestWrapper 类型的对象， MultiPartRequestWrapper 是 StrutsRequestWrapper 的子类，而这两个类都是 HttpServletRequest 接口的实现。包装请求对象如代码清单 11 所示：
代码清单 11 ： FilterDispatcher. prepareDispatcherAndWrapRequest() 方法
protected HttpServletRequest prepareDispatcherAndWrapRequest(
HttpServletRequest request,
HttpServletResponse response) throws ServletException {
Dispatcher du = Dispatcher.getInstance();
if (du == null ) {
Dispatcher.setInstance(dispatcher);
dispatcher.prepare(request, response);
} else {
dispatcher = du;
}
try {
request = dispatcher.wrapRequest(request, getServletContext());
} catch (IOException e) {
String message = "Could not wrap servlet request with MultipartRequestWrapper!" ;
LOG.error(message, e);
throw new ServletException(message, e);
}
return request;
}
request 对象重新包装后，通过 ActionMapper 的 getMapping() 方法得到请求的 Action ， Action 的配置信息存储在 ActionMapping 对象中，该语句如下： mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager()); 。下面是 ActionMapping 接口的实现类 DefaultActionMapper 的 getMapping() 方法的源代码：
代码清单 12 ： DefaultActionMapper.getMapping() 方法
public ActionMapping getMapping(HttpServletRequest request,
ConfigurationManager configManager) {
ActionMapping mapping = new ActionMapping();
String uri = getUri(request); // 得到请求路径的 URI ，如： testAtcion.action 或 testAction!method
uri = dropExtension(uri); // 删除扩展名，默认扩展名为 action ，在代码中的定义是 List extensions = new ArrayList() {{ add("action");}};
if (uri == null ) {
return null ;
}
parseNameAndNamespace(uri, mapping, configManager); // 从 uri 变量中解析出 Action 的 name 和 namespace
handleSpecialParameters(request, mapping); // 将请求参数中的重复项去掉
// 如果 Action 的 name 没有解析出来，直接返回
if (mapping.getName() == null ) {
return null ;
}
// 下面处理形如 testAction!method 格式的请求路径
if ( allowDynamicMethodCalls ) {
// handle "name!method" convention.
String name = mapping.getName();
int exclamation = name.lastIndexOf( "!" );// ! 是 Action 名称和方法名的分隔符
if (exclamation != -1) {
mapping.setName(name.substring(0, exclamation)); // 提取左边为 name
mapping.setMethod(name.substring(exclamation + 1)); // 提取右边的 method
}
}
return mapping;
}
该代码的活动图如下：
（图 16 ）
从代码中看出， getMapping() 方法返回 ActionMapping 类型的对象，该对象包含三个参数： Action 的 name 、 namespace 和要调用的方法 method 。
如果 getMapping() 方法返回 ActionMapping 对象为 null ，则 FilterDispatcher 认为用户请求不是 Action ，自然另当别论， FilterDispatcher 会做一件非常有意思的事：如果请求以 /struts 开头，会自动查找在 web.xml 文件中配置的 packages 初始化参数，就像下面这样 ( 注意粗斜体部分 ) ：
代码清单 13 ： web.xml( 部分 )
< filter >
< filter-name > struts2 </ filter-name >
< filter-class >
org.apache.struts2.dispatcher.FilterDispatcher
</ filter-class >
< init-param >
< param-name > packages </ param-name >
< param-value > com.lizanhong.action </ param-value >
</ init-param >
</ filter >
FilterDispatcher 会将 com.lizanhong.action 包下的文件当作静态资源处理，即直接在页面上显示文件内容，不过会忽略扩展名为 class 的文件。比如在 com.lizanhong.action 包下有一个 aaa.txt 的文本文件，其内容为“中华人民共和国”，访问 http://localhost:8081/Struts2Demo/struts/aaa.txt 时会有如图 17 的输出：
（图 17 ）
查找静态资源的源代码如清单 14 ：
代码清单 14 ： FilterDispatcher.findStaticResource() 方法
protected void findStaticResource(String name, HttpServletRequest request, HttpServletResponse response) throws IOException {
if (!name.endsWith( ".class" )) { // 忽略 class 文件
// 遍历 packages 参数
for (String pathPrefix : pathPrefixes ) {
InputStream is = findInputStream(name, pathPrefix); // 读取请求文件流
if (is != null ) {
……（省略部分代码）
// set the content-type header
String contentType = getContentType(name); // 读取内容类型
if (contentType != null ) {
response.setContentType(contentType); // 重新设置内容类型
}
……（省略部分代码）
try {
// 将读取到的文件流以每次复制 4096 个字节的方式循环输出
copy(is, response.getOutputStream());
} finally {
is.close();
}
return ;
}
}
}
}
如果用户请求的资源不是以 /struts 开头——可能是 .jsp 文件，也可能是 .html 文件，则通过过滤器链继续往下传送，直到到达请求的资源为止。
如果 getMapping() 方法返回有效的 ActionMapping 对象，则被认为正在请求某个 Action ，将调用 Dispatcher.serviceAction(request, response, servletContext, mapping) 方法，该方法是处理 Action 的关键所在。上述过程的源代码如清单 15 所示。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
