Java struts2请求源码分析案例详解
Struts2是Struts社区和WebWork社区的共同成果，我们甚至可以说，Struts2是WebWork的升级版，他采用的正是WebWork的核心，所以，Struts2并不是一个不成熟的产品，相反，构建在WebWork基础之上的Struts2是一个运行稳定、性能优异、设计成熟的WEB框架。
我这里的struts2源码是从官网下载的一个最新的struts-2.3.15.1-src.zip，将其解压即可。里面的目录页文件非常的多，我们只需要定位到struts-2.3.15.1\src\core\src\main\java\org\apache\struts2查看源文件。目录结构如下图
Struts2框架的正常运行，除了占核心地位的xwork的支持以外，Struts2本身也提供了许多类，这些类被分门别类组织到不同的包中。从源代码中发现，基本上每一个Struts2类都访问了WebWork提供的功能，从而也可以看出Struts2与WebWork千丝万缕的联系。但无论如何，Struts2的核心功能比如将请求委托给哪个Action处理都是由xwork完成的，Struts2只是在WebWork的基础上做了适当的简化、加强和封装，并少量保留Struts1.x中的习惯。
以下是包说明：
| 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.servlet | 用HttpServletRequest相关方法实现principalproxy接口。 |
| org.apache.struts2.util | 实用包。 |
| org.apache.struts2.views | 提供freemarker、jsp、velocity等不同类型的页面呈现。 |
根目录下的5个文件说明：
| StrutsStatics | Struts常数。常数可以用来获取或设置对象从行动中或其他集合。 |
| RequestUtils | 请求处理程序类。此类只有一个方法getServletPath，作用检索当前请求的servlet路径 |
| ServletActionContext | 网站的特定的上下文信息 |
| StrutsConstants | 该类提供了框架配置键的中心位置用于存储和检索配置设置。 |
| StrutsException | 通用运行时异常类 |
struts2 架构图如下图所示：
依照上图，我们可以看出一个请求在struts的处理大概有如下步骤：
- 客户端初始化一个指向Servlet容器（例如Tomcat）的请求；
- 这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；
- 接着StrutsPrepareAndExecuteFilter被调用，StrutsPrepareAndExecuteFilter询问ActionMapper来决定这个请求是否需要调用某个Action；
- 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；
- ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；
- ActionProxy创建一个ActionInvocation的实例。
- ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
- 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper。
strut2源码分析：
首先我们使用struts2框架都会在web.xml中注册和映射struts2，配置内容如下：
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
注：在早期的struts2中，都是使用FilterDispathcer，从Struts 2.1.3开始，它已不推荐使用。如果你使用的Struts的版本 >= 2.1.3，推荐升级到新的Filter，StrutsPrepareAndExecuteFilter。在此研究的是StrutsPrepareAndExecuteFilter。
StrutsPrepareAndExecuteFilter中的方法：
| void init(FilterConfig filterConfig) | 继承自Filter，过滤器的初始化 |
| doFilter(ServletRequest req, ServletResponse res, FilterChain chain) | 继承自Filter，执行过滤器 |
| void destroy() | 继承自Filter，用于资源释放 |
| void postInit(Dispatcher dispatcher, FilterConfig filterConfig) | Callback for post initialization（一个空的方法，用于方法回调初始化） |
web容器一启动，就会初始化核心过滤器StrutsPrepareAndExecuteFilter，并执行初始化方法，初始化方法如下：
public void init(FilterConfig filterConfig) throws ServletException {
InitOperations init = new InitOperations();
Dispatcher dispatcher = null;
try {
//封装filterConfig，其中有个主要方法getInitParameterNames将参数名字以String格式存储在List中
FilterHostConfig config = new FilterHostConfig(filterConfig);
//初始化struts内部日志
init.initLogging(config);
//创建dispatcher ，并初始化
dispatcher = init.initDispatcher(config);
init.initStaticContentLoader(config, dispatcher);
//初始化类属性：prepare 、execute
prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);
execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);
this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);
//回调空的postInit方法
postInit(dispatcher, filterConfig);
} finally {
if (dispatcher != null) {
dispatcher.cleanUpAfterInit();
}
init.cleanup();
}
}
关于封装filterConfig，首先看下FilterHostConfig ，源码如下：
public class FilterHostConfig implements HostConfig {
private FilterConfig config;
//构造方法
public FilterHostConfig(FilterConfig config) {
this.config = config;
}
//根据init-param配置的param-name获取param-value的值
public String getInitParameter(String key) {
return config.getInitParameter(key);
}
//返回初始化参数名的迭代器
public Iterator<String> getInitParameterNames() {
return MakeIterator.convert(config.getInitParameterNames());
}
//返回Servlet上下文
public ServletContext getServletContext() {
return config.getServletContext();
}
}
只有短短的几行代码，getInitParameterNames是这个类的核心，将Filter初始化参数名称有枚举类型转为Iterator。此类的主要作为是对filterConfig 封装。
接下来，看下StrutsPrepareAndExecuteFilter中init方法中dispatcher = init.initDispatcher(config);这是初始化dispatcher的，是通过init对象的initDispatcher方法来初始化的，init是InitOperations类的对象，我们看看InitOperations中initDispatcher方法：
public Dispatcher initDispatcher( HostConfig filterConfig ) {
Dispatcher dispatcher = createDispatcher(filterConfig);
dispatcher.init();
return dispatcher;
}
创建Dispatcher，会读取 filterConfig 中的配置信息，将配置信息解析出来，封装成为一个Map，然后根绝servlet上下文和参数Map构造Dispatcher ：
private Dispatcher createDispatcher( HostConfig filterConfig ) {
//存放参数的Map
Map<String, String> params = new HashMap<String, String>();
//将参数存放到Map
for ( Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) {
String name = (String) e.next();
String value = filterConfig.getInitParameter(name);
params.put(name, value);
}
//根据servlet上下文和参数Map构造Dispatcher
return new Dispatcher(filterConfig.getServletContext(), params);
}
这样dispatcher对象创建完成，接着就是dispatcher对象的初始化，打开Dispatcher类，看到它的init方法如下：
public void init() {
if (configurationManager == null) {
configurationManager = createConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);
}
try {
init_FileManager();
//加载org/apache/struts2/default.properties
init_DefaultProperties(); // [1]
//加载struts-default.xml,struts-plugin.xml,struts.xml
init_TraditionalXmlConfigurations(); // [2]
init_LegacyStrutsProperties(); // [3]
//用户自己实现的ConfigurationProviders类
init_CustomConfigurationProviders(); // [5]
//Filter的初始化参数
init_FilterInitParameters() ; // [6]
init_AliasStandardObjects() ; // [7]
Container container = init_PreloadConfiguration();
container.inject(this);
init_CheckWebLogicWorkaround(container);
if (!dispatcherListeners.isEmpty()) {
for (DispatcherListener l : dispatcherListeners) {
l.dispatcherInitialized(this);
}
}
} catch (Exception ex) {
if (LOG.isErrorEnabled())
LOG.error("Dispatcher initialization failed", ex);
throw new StrutsException(ex);
}
}
这里主要是加载一些配置文件的，将按照顺序逐一加载：default.properties，struts-default.xml,struts-plugin.xml,struts.xml，……关于文件是如何加载的，大家可以自己取看源文件，主要是由xwork核心类加载的，代码在xwork-core\src\main\java\com\opensymphony\xwork2\config\providers包里面。
现在，我们回到StrutsPrepareAndExecuteFilter类中，刚才我们分析了StrutsPrepareAndExecuteFilter类的init方法，该方法在web容器一启动就会调用的，当用户访问某个action的时候，首先调用核心过滤器StrutsPrepareAndExecuteFilter的doFilter方法，该方法内容如下：
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
try {
//设置编码和国际化
prepare.setEncodingAndLocale(request, response);
//创建action上下文
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);
//如果mapping为空，则认为不是调用action,会调用下一个过滤器链，直到获取到mapping才调用action
if (mapping == null) {
boolean handled = execute.executeStaticResourceRequest(request, response);
if (!handled) {
chain.doFilter(request, response);
}
} else {
//执行action
execute.executeAction(request, response, mapping);
}
}
} finally {
prepare.cleanupRequest(request);
}
}
下面对doFilter方法中的重点部分一一讲解：
(1)prepare.setEncodingAndLocale(request, response);
第8行是调用prepare对象的setEncodingAndLocale方法，prepare是PrepareOperations类的对象，PrepareOperations类是用来做请求准备工作的。我们看下PrepareOperations类中的setEncodingAndLocale方法：
public void setEncodingAndLocale(HttpServletRequest request, HttpServletResponse response) {
dispatcher.prepare(request, response);
}
在这方法里面我们可以看到它只是调用了dispatcher的prepare方法而已，下面我们看看dispatcher的prepare方法：
public void prepare(HttpServletRequest request, HttpServletResponse response) {
String encoding = null;
if (defaultEncoding != null) {
encoding = defaultEncoding;
}
// check for Ajax request to use UTF-8 encoding strictly http://www.w3.org/TR/XMLHttpRequest/#the-send-method
if ("XMLHttpRequest".equals(request.getHeader("X-Requested-With"))) {
encoding = "UTF-8";
}
Locale locale = null;
if (defaultLocale != null) {
locale = LocalizedTextUtil.localeFromString(defaultLocale, request.getLocale());
}
if (encoding != null) {
applyEncoding(request, encoding);
}
if (locale != null) {
response.setLocale(locale);
}
if (paramsWorkaroundEnabled) {
request.getParameter("foo"); // simply read any parameter (existing or not) to "prime" the request
}
}
我们可以看到该方法只是简单的设置了encoding 和locale ，做的只是一些辅助的工作。
(2)prepare.createActionContext(request, response)
我们回到StrutsPrepareAndExecuteFilter的doFilter方法，看到第10行代码：prepare.createActionContext(request, response);这是action上下文的创建，ActionContext是一个容器，这个容易主要存储request、session、application、parameters等相关信 息.ActionContext是一个线程的本地变量，这意味着不同的action之间不会共享ActionContext，所以也不用考虑线程安全问 题。其实质是一个Map，key是标示request、session、……的字符串，值是其对应的对象，我们可以看到com.opensymphony.xwork2.ActionContext类中时如下定义的：
static ThreadLocal<ActionContext> actionContext = new ThreadLocal<ActionContext>();
我们看下PrepareOperations类的createActionContext方法：
/**
* Creates the action context and initializes the thread local
*/
public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
ActionContext ctx;
Integer counter = 1;
Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);
if (oldCounter != null) {
counter = oldCounter + 1;
}
//此处是从ThreadLocal中获取此ActionContext变量
ActionContext oldContext = ActionContext.getContext();
if (oldContext != null) {
// detected existing context, so we are probably in a forward
ctx = new ActionContext(new HashMap<String, Object>(oldContext.getContextMap()));
} else {
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
stack.getContext().putAll(dispatcher.createContextMap(request, response, null, servletContext));
//stack.getContext()返回的是一个Map<String，Object>，根据此Map构造一个ActionContext
ctx = new ActionContext(stack.getContext());
}
request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
//将ActionContext存到ThreadLocal
ActionContext.setContext(ctx);
return ctx;
}
上面第18行代码中dispatcher.createContextMap，如何封装相关参数：
public Map<String,Object> createContextMap(HttpServletRequest request, HttpServletResponse response,
ActionMapping mapping, ServletContext context) {
// 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);
//requestMap、params、session等Map封装成为一个上下文Map
Map<String,Object> extraContext = createContextMap(requestMap, params, session, application, request, response, context);
if (mapping != null) {
extraContext.put(ServletActionContext.ACTION_MAPPING, mapping);
}
return extraContext;
}
(3)request = prepare.wrapRequest(request)
我们再次回到StrutsPrepareAndExecuteFilter的doFilter方法中，看到第15行：request = prepare.wrapRequest(request);这一句是对request进行包装的，我们看下prepare的wrapRequest方法：
public HttpServletRequest wrapRequest(HttpServletRequest oldRequest) throws ServletException {
HttpServletRequest request = oldRequest;
try {
// Wrap request first, just in case it is multipart/form-data
// parameters might not be accessible through before encoding (ww-1278)
request = dispatcher.wrapRequest(request, servletContext);
} catch (IOException e) {
throw new ServletException("Could not wrap servlet request with MultipartRequestWrapper!", e);
}
return request;
}
由第6行我们可以看到它里面调用的是dispatcher的wrapRequest方法，并且将servletContext对象也传进去了，我们看下dispatcher的wrapRequest：
public HttpServletRequest wrapRequest(HttpServletRequest request, ServletContext servletContext) throws IOException {
// don't wrap more than once
if (request instanceof StrutsRequestWrapper) {
return request;
}
String content_type = request.getContentType();
//如果content_type是multipart/form-data类型，则将request包装成MultiPartRequestWrapper对象，否则包装成StrutsRequestWrapper对象
if (content_type != null && content_type.contains("multipart/form-data")) {
MultiPartRequest mpr = getMultiPartRequest();
LocaleProvider provider = getContainer().getInstance(LocaleProvider.class);
request = new MultiPartRequestWrapper(mpr, request, getSaveDir(servletContext), provider);
} else {
request = new StrutsRequestWrapper(request, disableRequestAttributeValueStackLookup);
}
return request;
}
此次包装根据请求内容的类型不同，返回不同的对象，如果为multipart/form-data类型，则返回MultiPartRequestWrapper类型的对象，该对象服务于文件上传，否则返回StrutsRequestWrapper类型的对象，MultiPartRequestWrapper是StrutsRequestWrapper的子类，而这两个类都是HttpServletRequest接口的实现。
(4)ActionMapping mapping = prepare.findActionMapping(request, response, true)
包装request后，通过ActionMapper的getMapping()方法得到请求的Action，Action的配置信息存储在ActionMapping对象中，如StrutsPrepareAndExecuteFilter的doFilter方法中第16行：ActionMapping mapping = prepare.findActionMapping(request, response, true);我们找到prepare对象的findActionMapping方法：
public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup) {
//首先从request对象中取mapping对象，看是否存在
ActionMapping mapping = (ActionMapping) request.getAttribute(STRUTS_ACTION_MAPPING_KEY);
//不存在就创建一个
if (mapping == null || forceLookup) {
try {
//首先创建ActionMapper对象，通过ActionMapper对象创建mapping对象
mapping = dispatcher.getContainer().getInstance(ActionMapper.class).getMapping(request, dispatcher.getConfigurationManager());
if (mapping != null) {
request.setAttribute(STRUTS_ACTION_MAPPING_KEY, mapping);
}
} catch (Exception ex) {
dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
}
}
return mapping;
}
下面是ActionMapper接口的实现类DefaultActionMapper的getMapping()方法的源代码：
public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
ActionMapping mapping = new ActionMapping();
//获得请求的uri，即请求路径URL中工程名以后的部分，如/userAction.action
String uri = getUri(request);
//修正url的带;jsessionid 时找不到的bug
int indexOfSemicolon = uri.indexOf(";");
uri = (indexOfSemicolon > -1) ? uri.substring(0, indexOfSemicolon) : uri;
//删除扩展名，如.action或者.do
uri = dropExtension(uri, mapping);
if (uri == null) {
return null;
}
//从uri中分离得到请求的action名、命名空间。
parseNameAndNamespace(uri, mapping, configManager);
//处理特殊的请求参数
handleSpecialParameters(request, mapping);
//如果允许动态方法调用，即形如/userAction!getAll.action的请求，分离action名和方法名
return parseActionName(mapping);
}
下面对getMapping方法中的重要部分一一讲解：
①：parseNameAndNamespace(uri, mapping, configManager)
我们主要看下第14行的parseNameAndNamespace(uri, mapping, configManager);这个方法的主要作用是分离出action名和命名空间：
protected void parseNameAndNamespace(String uri, ActionMapping mapping, ConfigurationManager configManager) {
String namespace, name;
int lastSlash = uri.lastIndexOf("/"); //最后的斜杆的位置
if (lastSlash == -1) {
namespace = "";
name = uri;
} else if (lastSlash == 0) {
// ww-1046, assume it is the root namespace, it will fallback to
// default
// namespace anyway if not found in root namespace.
namespace = "/";
name = uri.substring(lastSlash + 1);
//允许采用完整的命名空间,即设置命名空间是否必须进行精确匹配
} else if (alwaysSelectFullNamespace) {
// Simply select the namespace as everything before the last slash
namespace = uri.substring(0, lastSlash);
name = uri.substring(lastSlash + 1);
} else {
// Try to find the namespace in those defined, defaulting to ""
Configuration config = configManager.getConfiguration();
String prefix = uri.substring(0, lastSlash); //临时的命名空间，将会用来进行匹配
namespace = "";//将命名空间暂时设为""
boolean rootAvailable = false;//rootAvailable作用是判断配置文件中是否配置了命名空间"/"
// Find the longest matching namespace, defaulting to the default
for (Object cfg : config.getPackageConfigs().values()) { //循环遍历配置文件中的package标签
String ns = ((PackageConfig) cfg).getNamespace(); //获取每个package标签的namespace属性
//进行匹配
if (ns != null && prefix.startsWith(ns) && (prefix.length() == ns.length() || prefix.charAt(ns.length()) == '/')) {
if (ns.length() > namespace.length()) {
namespace = ns;
}
}
if ("/".equals(ns)) {
rootAvailable = true;
}
}
name = uri.substring(namespace.length() + 1);
// Still none found, use root namespace if found
if (rootAvailable && "".equals(namespace)) {
namespace = "/";
}
}
if (!allowSlashesInActionNames) {
int pos = name.lastIndexOf('/');
if (pos > -1 && pos < name.length() - 1) {
name = name.substring(pos + 1);
}
}
//将分离后的acion名和命名空间保存到mapping对象
mapping.setNamespace(namespace);
mapping.setName(cleanupActionName(name));
}
看到上面代码的第14行，参数alwaysSelectFullNamespace我们可以通过名字就能大概猜出来"允许采用完整的命名空间"，即设置命名空间是否必须进行精确匹配，true必须，false可以模糊匹配，默认是false。进行精确匹配时要求请求url中的命名空间必须与配置文件中配置的某个命名空间必须相同，如果没有找到相同的则匹配失败。这个参数可通过struts2的"struts.mapper.alwaysSelectFullNamespace"常量配置，如：<constant name="struts.mapper.alwaysSelectFullNamespace" value="true" />。当alwaysSelectFullNamespace为true时，将uri以lastSlash为分割，左边的为namespace，右边的为name。如：http://localhost:8080/myproject/home/actionName!method.action,此时uri为/home/actionName!method.action(不过前面把后缀名去掉了，变成/home/actionName!method)，lastSlash的,当前值是5，这样namespace为"/home", name为actionName!method。
我们再看到上面代码第18行到第44行：当上面的所有条件都不满足时，其中包括alwaysSelectFullNamespace 为false(命名空间进行模糊匹配)，将由此部分处理，进行模糊匹配。第1句，通过configManager.getConfiguration()从配置管理器中获得配置对象Configuration，Configuration中存放着struts2的所有配置，形式是将xml文档的相应元素封装为java bean，如<package>元素被封装到PackageConfig类中，这个一会儿会用到。第2句按lastSlash将uri截取出prefix，这是一个临时的命名空间，之后将会拿prefix进行模糊匹配。第3句namespace = ""，将命名空间暂时设为""。第4句创建并设置rootAvailable，rootAvailable作用是判断配置文件中是否配置了命名空间"/"，true为配置了，false未配置，下面for语句将会遍历我们配置的所有包(<package>)，同时设置rootAvailable。第5句for，通过config.getPackageConfigs()获得所有已经配置的包，然后遍历。String ns = ((PackageConfig) cfg).getNamespace()获得当前包的命名空间ns，之后的if句是进行模糊匹配的核心，我摘出来单独说，如下：
if (ns != null && prefix.startsWith(ns) && (prefix.length() == ns.length() || prefix.charAt(ns.length()) == '/')) {
if (ns.length() > namespace.length()) {
namespace = ns;
}
}
ns != null && prefix.startsWith(ns)这部分判断当ns不等于空并且ns是prefix的前缀。prefix.length() == ns.length()当二者长度相等时，结合前面部分就是ns是prefix的前缀并且二者长度相等，最终结论就是ns和prefix相等。如果前面的条件不成立，则说明prefix的长度大于ns。prefix.charAt(ns.length()) == '/')意思是prefix中与ns不相等的字符中的第一个字符必须是"/"，也就是说，在命名空间采用斜杠分级的形式中，ns必须是prefix的某一子集，如：/common/home 是用户配置的命名空间，则在http的请求url中，/common/home/index1、/common/home/index2、/common/home/index/aaa 都是正确的，都可以成功的匹配到/common/home，而/common/homeaa、/common/homea/aaa都是错误的。接着if (ns.length() > namespace.length()) 句，目的是找出字符长度最长的。因为命名空间采用的是分级的，则长度越长所表示的越精确，如/common/home/index比/common/home精确。之后将namespace = ns。
我们接着往下看if ("/".equals(ns)) 当我们配置了"/"这个命名空间时，将rootAvailable = true。name = uri.substring(namespace.length() + 1)句不涉及到命名空间就不说了。if (rootAvailable && "".equals(namespace))如果通过上面的for循环没有找到匹配的命名空间即namespace的值仍然是当初设置的""，但却配置了"/"时，将命名空间设为"/"。
我们再看到第46到51行那个if语句：
if (!allowSlashesInActionNames) {
int pos = name.lastIndexOf('/');
if (pos > -1 && pos < name.length() - 1) {
name = name.substring(pos + 1);
}
}
allowSlashesInActionNames代表是否允许"/"出现在Action的名称中，默认为false，如果不允许"/"出现在Action名中，并且这时的Action名中有"/"，则取"/"后面的部分。
下面是命名空间匹配规则的总结：
(1). 如果请求url中没有命名空间时，将采用"/"作为命名空间。
(2). 当我们将常量 struts.mapper.alwaysSelectFullNamespace设为true时，那么请求url的命名空间必须和配置文件配置的完全相同才能匹配。
当将常量 struts.mapper.alwaysSelectFullNamespace设为false时，那么请求url的命名空间和配置文件配置的可按模糊匹配。规则：
a.如果配置文件中配置了/common 而url中的命名空间/common、/common/home、/common/home/index等等都是可匹配的，即子命名空间可匹配父命名空间。
b.如果对于某个url请求中的命名空间同时匹配了俩个或俩个以上的配置文件中配置的命名空间，则选字符最长的，如：当前请求的命名空间为/common/home/index/aaaa, 而我们在配置时同时配置 了/common/home、/common/home/index 则将会匹配命名空间最长的，即/common/home/index。
(3).最后，如果请求的命名空间在配置中没有匹配到时，将采用""作为命名空间。如果没有设置为""的命名空间将抛出404错误。
②：parseActionName(mapping)
好了，到这里parseNameAndNamespace方法已经分析完了，我们再次回到getMapping方法中去，看到16行：handleSpecialParameters(request, mapping);好像是处理特殊参数的函数吧，里面有点看不懂，暂时就不管，以后有时间再研究。我们看到18行：return parseActionName(mapping);主要是用来处理形如/userAction!getAll.action的请求，分离action名和方法名：
protected ActionMapping parseActionName(ActionMapping mapping) {
if (mapping.getName() == null) {
return null;
}
//如果允许动态方法调用
if (allowDynamicMethodCalls) {
// handle "name!method" convention.
String name = mapping.getName();
int exclamation = name.lastIndexOf("!");
//如果包含"!"就进行分离
if (exclamation != -1) {
//分离出action名
mapping.setName(name.substring(0, exclamation));
//分离出方法名
mapping.setMethod(name.substring(exclamation + 1));
}
}
return mapping;
}
到此为止getMapping方法已经分析结束了！
(5)execute.executeAction(request, response, mapping)
上面我们分析完了mapping的获取，继续看doFilter方法：
//如果mapping为空，则认为不是调用action,会调用下一个过滤器链，直到获取到mapping才调用action
if (mapping == null) {
boolean handled = execute.executeStaticResourceRequest(request, response);
if (!handled) {
chain.doFilter(request, response);
}
} else {
//执行action
execute.executeAction(request, response, mapping);
}
如果mapping对象不为空，则会执行action，我们看到上面代码第9行：execute是ExecuteOperations类的对象，ExecuteOperations类在包org.apache.struts2.dispatcher.ng下面，我们找到它里面的executeAction方法：
public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException {
dispatcher.serviceAction(request, response, servletContext, mapping);
}
我们可以看到它里面只是简单的调用了dispatcher的serviceAction方法：我们找到dispatcher的serviceAction方法：
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
ActionMapping mapping) throws ServletException {
//封转上下文环境，主要将requestMap、params、session等Map封装成为一个上下文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();//从mapping对象获取命名空间
String name = mapping.getName(); //获取请求的action名
String method = mapping.getMethod(); //获取请求方法
//得到配置对象
Configuration config = configurationManager.getConfiguration();
//根据执行上下文参数，命名空间，名称等创建用户自定义Action的代理对象
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!
//如果配置文件中执行的这个action配置了result，就直接转到result
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);
}
} catch (ConfigurationException e) {
// WW-2874 Only log error if in devMode
if (devMode) {
String reqStr = request.getRequestURI();
if (request.getQueryString() != null) {
reqStr = reqStr + "?" + request.getQueryString();
}
LOG.error("Could not find action or result\n" + reqStr, e);
} else {
if (LOG.isWarnEnabled()) {
LOG.warn("Could not find action or result", e);
}
}
sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
} catch (Exception e) {
if (handleException || devMode) {
sendError(request, response, context, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
} else {
throw new ServletException(e);
}
} finally {
UtilTimerStack.pop(timerKey);
}
}
最后通过Result完成页面跳转！
到此这篇关于Java struts2请求源码分析案例详解的文章就介绍到这了,更多相关Java struts2请求源码分析内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
Java框架Struts2实现图片上传功能
Struts 2 框架为处理文件上传提供了内置支持,它使用"在 HTML 中基于表单的文件上传".当上传一个文件时,它通常会被存储在一个临时目录中,而且它们应该由 Action 类进行处理或移动到一个永久的目录,用来确保数据不丢失.服务器在恰当的位置可能有一个安全策略,它会禁止你写到除了临时目录以外的目录,而且这个目录属于你的web应用应用程序. 通过预定义的名为文件上传的拦截器,Struts 的文件上传是可能的,这个拦截器在 org.apache.struts2.intercepto
-
Java struts2 package元素配置及实例解析
package 元素的所有属性及对应功能: Attribute Required Description name yes key to for other packages to reference ---包名称,用来让别的包继承时使用不能有重复 extends no inherits package behavior of the package it extends -----当前包所要继承的父包,继承之后,当前包拥有父包中所定义的任意类.拦截器等 namespace no 用于区分包中相
-
struts2简介_动力节点Java学院整理
本文为大家讲解了Struts2框架的入门知识,供大家参考,具体内容如下 1.Struts2框架介绍 Struts2框架是MVC流程框架,适合分层开发.框架应用实现不依赖于Servlet,使用大量的拦截器来处理用户请求,属于无侵入式的设计. 2.Struts2框架的流程原理 1)请求先到达Filter中央控制器 2)然后为Action创建代理类 3)将各个服务存放在拦截器中,执行完拦截器后再去执行action类行action类,action类调用service,再调用dao 4)得到结果字符串,创
-
Java框架学习Struts2复选框实例代码
复选框在Web开发中使用的非常多,现在我们通过struts2的复选框标签来实现一些在开发中经常遇到的问题. 先来看看这个标签的属性: 注:listKey相当于HTML中的value属性,这个值在和后台交互时才真正是我们在后台要使用的:listValue只是内容的显示而已. 案例1 用户选择了喜欢的课程,现在要对已经选择的课程进行修改,跳转到修改界面,然后回显已经勾选的课程. 用户已选课程界面: 点击按钮后进入课程修改界面: 注:在修改界面要对用户最初的选择进行回显. 代码实现!!!! 用户已选课
-
struts2标签总结_动力节点Java学院整理
先看一下Struts2标签的分类吧.然后分类总结一下即可. 由于控制标签用的比较多,所以放在了前边.好首先看一下控制标签吧. 一.控制标签,JSTL大家应该都使用过,其实Struts2的控制标签和那个特别像的,主要是对EL表达式满足不了的进行补充使用.这里简单看一下吧: 1. if--elseif--else,用来控制选择输出的标签: <span style="font-size:18px;"><html xmlns="http://www.w3.org/1
-
struts2数据处理_动力节点Java学院整理
Struts2框架框架使用OGNL语言和值栈技术实现数据的流转处理.值栈就相当于一个容器,用来存放数据,而OGNL是一种快速查询数据的语言. 值栈:ValueStack一种数据结构,操作数据的方式为:先进后出 OGNL : Object-GraphNavigation Language(对象图形导航语言)将多个对象的关系使用一种树形的结构展现出来,更像一个图形,那么如果需要对树形结构的节点数据进行操作,那么可以使用 对象.属性 的方式进行操作,OGNL技术底层采用反射实现. 一:数据的提交方式
-
Java中的Struts2框架拦截器之实例代码
本文实例为大家分享了Struts2框架拦截器实例的示例代码,供大家参考,具体内容如下 在看拦截器的小例子的前我们先来看看sturts2的原理 struts2自己是有拦截器的,通过拦截器可以拦截用户请求,并作出处理 拦截器作用有很多,譬如: 1.Action里面有个属性,这个属性我想在action执行之前改成别的值,可以用拦截器解决. 2.比如每个人执行action之前,我可以查看他们有没有这个权限执行这个action. 如果不设置拦截器,你要在每种action方法之前设置判定程序,非常繁琐. 拦
-
struts2拦截器_动力节点Java学院整理
如何使用struts2拦截器,或者自定义拦截器.特别注意,在使用拦截器的时候,在Action里面必须最后一定要引用struts2自带的拦截器缺省堆栈defaultStack,如下(这里我是引用了struts2自带的checkbox拦截器): <interceptor-ref name="checkbox"> <param name="uncheckedValue">0</param> </interceptor-ref>
-
Java struts2请求源码分析案例详解
Struts2是Struts社区和WebWork社区的共同成果,我们甚至可以说,Struts2是WebWork的升级版,他采用的正是WebWork的核心,所以,Struts2并不是一个不成熟的产品,相反,构建在WebWork基础之上的Struts2是一个运行稳定.性能优异.设计成熟的WEB框架. 我这里的struts2源码是从官网下载的一个最新的struts-2.3.15.1-src.zip,将其解压即可.里面的目录页文件非常的多,我们只需要定位到struts-2.3.15.1\src\core
-
Java集合框架源码分析之LinkedHashMap详解
LinkedHashMap简介 LinkedHashMap是HashMap的子类,与HashMap有着同样的存储结构,但它加入了一个双向链表的头结点,将所有put到LinkedHashmap的节点一一串成了一个双向循环链表,因此它保留了节点插入的顺序,可以使节点的输出顺序与输入顺序相同. LinkedHashMap可以用来实现LRU算法(这会在下面的源码中进行分析). LinkedHashMap同样是非线程安全的,只在单线程环境下使用. LinkedHashMap源码剖析 LinkedHashM
-
Java源码解析之详解ImmutableMap
一.案例场景 遇到过这样的场景,在定义一个static修饰的Map时,使用了大量的put()方法赋值,就类似这样-- public static final Map<String,String> dayMap= new HashMap<>(); static { dayMap.put("Monday","今天上英语课"); dayMap.put("Tuesday","今天上语文课"); dayMap.p
-
Java ThreadLocal原理解析以及应用场景分析案例详解
目录 ThreadLocal的定义 ThreadLocal的应用场景 ThreadLocal的demo TheadLocal的源码解析 ThreadLocal的set方法 ThreadLocal的get方法 ThreadLocalMap的结构 ThreadLocalMap的set方法 ThreadLocalMap的getEntry方法 ThreadLocal的内存泄露 如何避免内存泄露呢 应用实例 实际应用二 总结 ThreadLocal的定义 JDK对ThreadLocal的定义如下: The
-
Java 读写锁源码分析
前言 在实际项目中,比如我们有一个共享资源文件,我们程序会会同时并发的去读.写这个共享资源文件,那怎么能保证在高并发场景下安全.高效读写呢?OK,看了下文便知 提示:以下是本篇文章正文内容,案例仅供参考 一.技术介绍 1.ReentranReadWriteLock是什么? ReadWriteLock提供了readLock和writeLock两种锁的操作机制,一个是读锁,一个是写锁,而它的实现类就是ReentranReadWriteLock 读锁可以在没有写锁的时候被多个线程同时持有,写锁是独占的
-
Java源码解析之详解ReentrantLock
ReentrantLock ReentrantLock是一种可重入的互斥锁,它的行为和作用与关键字synchronized有些类似,在并发场景下可以让多个线程按照一定的顺序访问同一资源.相比synchronized,ReentrantLock多了可扩展的能力,比如我们可以创建一个名为MyReentrantLock的类继承ReentrantLock,并重写部分方法使其更加高效. 当一个线程调用ReentrantLock.lock()方法时,如果ReentrantLock没有被其他线程持有,且不存在
-
Java Array.sort()源码分析讲解
阅读起点: Arrays.sort(nums1); 使用ctrl+左键进入sort()方法 1.Arrays.sort() 关于sort()的方法一共有14个,就目前调用的来看是以下这种最基础的. public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0); } 2.DualPivotQuicksort DualPivotQuicksort即双轴快排,定义了七种原始类型的排序
-
Java并发LinkedBlockingQueue源码分析
目录 简介 常量 构造方法 put await isOnSyncQueue signal 简介 LinkedBlockingQueue是一个阻塞的有界队列,底层是通过一个个的Node节点形成的链表实现的,链表队列中的头节点是一个空的Node节点,在多线程下操作时会使用ReentrantLock锁来保证数据的安全性,并使用ReentrantLock下的Condition对象来阻塞以及唤醒线程. 常量 /** * 链表中的节点类 */ static class Node<E> { //节点中的元素
-
java设计模式责任链模式原理案例详解
目录 引言 责任链模式定义 类图 角色 核心 示例代码 1.对请求处理者的抽象 2.对请求处理者的抽象 3.责任链的创建 责任链实现请假案例 案例类图 可扩展性 纯与不纯的责任链模式 纯的责任链模式 不纯的责任链模式 责任链模式主要优点 职责链模式的主要缺点 适用场景 模拟实现Tomcat中的过滤器机制 运行过程如下 分析Tomcat 过滤器中的责任链模式 引言 以请假流程为例,一般公司普通员工的请假流程简化如下: 普通员工发起一个请假申请,当请假天数小于3天时只需要得到主管批准即可:当请假天数
-
ThreadPoolExecutor参数含义及源码执行流程详解
目录 背景 典型回答 考点分析 知识拓展 execute() VS submit() 线程池的拒绝策略 自定义拒绝策略 ThreadPoolExecutor 扩展 小结 背景 线程池是为了避免线程频繁的创建和销毁带来的性能消耗,而建立的一种池化技术,它是把已创建的线程放入“池”中,当有任务来临时就可以重用已有的线程,无需等待创建的过程,这样就可以有效提高程序的响应速度.但如果要说线程池的话一定离不开 ThreadPoolExecutor ,在阿里巴巴的<Java 开发手册>中是这样规定线程池的