一、前言
很多事儿啊，就是“成也萧何败也萧何”，细想一些事儿心中有感，当然，感慨和本文毛关系都没有~想起之前有篇Struts2中值栈的博客还未完工，就着心中的波澜，狂咽一把~
二、正文
博文基于：struts-core-2.5.2.jar，ognl-3.1.10.jar
和值栈的邂逅还是大学学习Struts2的时候，老师当时在台上津津有味，我却在底下晕头转向~很长时间都没有去理清这个值栈到底是什么，实现原理是什么，偶然的际遇，让我又遇到了它，所以我决定以我现有的知识储备再次去追根溯源~
那从概念上，我们要怎么去理解值栈呢？你可以将它理解为一个容器（就像装水的杯子，只不过它里面“装”的不是水，而是java对象），这边“装”的意思是“引用”了其他类或者对象，我想这样说应该能理解吧~其实呢，作为开发人员，再精准的文字描述也很难让自己理解到技术的精华，所以看源码是进阶的必经之路~源码的精妙有些时候会让人如痴如醉，编程，就应该是一门艺术~
在Struts2中，值栈和ActionContext是同步创建的，这个创建过程可以在Struts2的核心过滤器：org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter中，doFilter方法中查看，源码如下：
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
try {
String uri = RequestUtils.getUri(request);
if (excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
LOG.trace("Request {} is excluded from handling by Struts, passing request to other filters", uri);
chain.doFilter(request, response);
} else {
LOG.trace("Checking if {} is a static resource", uri);
boolean handled = execute.executeStaticResourceRequest(request, response);
if (!handled) {
LOG.trace("Assuming uri {} as a normal action", uri);
prepare.setEncodingAndLocale(request, response);
prepare.createActionContext(request, response);
prepare.assignDispatcherToThread();
request = prepare.wrapRequest(request);
ActionMapping mapping = prepare.findActionMapping(request, response, true);
if (mapping == null) {
LOG.trace("Cannot find mapping for {}, passing to other filters", uri);
chain.doFilter(request, response);
} else {
LOG.trace("Found mapping {} for {}", mapping, uri);
execute.executeAction(request, response, mapping);
}
}
}
} finally {
prepare.cleanupRequest(request);
}
}在上面的代码中，我们可以看到17行“prepare.createActionContext(request, response);”就是创建ActionContext的代码，其具体实现的源码如下：
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;
}
ActionContext oldContext = ActionContext.getContext();
if (oldContext != null) {
// detected existing context, so we are probably in a forward
ctx = new ActionContext(new HashMap<>(oldContext.getContextMap()));
} else {
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
stack.getContext().putAll(dispatcher.createContextMap(request, response, null));
ctx = new ActionContext(stack.getContext());
}
request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
ActionContext.setContext(ctx);
return ctx;
}进入14行中的createValueStack方法内部可以知道值栈的实现者为：OgnlValueStack
//class OgnlValueStackFactory
public ValueStack createValueStack() {
ValueStack stack = new OgnlValueStack(xworkConverter, compoundRootAccessor, textProvider, allowStaticMethodAccess);
container.inject(stack);
stack.getContext().put(ActionContext.CONTAINER, container);
return stack;
}
值栈OgnlValueStack中包含两个重要的成员变量，CompoundRoot root(这其实是一个ArrayList)和context.(我们通常称为contextMap)：
CompoundRoot root;
transient Map<String, Object> context; //其中CompoundRoot的声明如下
public class CompoundRoot extends CopyOnWriteArrayList<Object>
再进入OgnlValueStack的构造函数和setRoot方法：
protected OgnlValueStack(ValueStack vs, XWorkConverter xworkConverter, CompoundRootAccessor accessor, boolean allowStaticAccess) {
setRoot(xworkConverter, accessor, new CompoundRoot(vs.getRoot()), allowStaticAccess);
}
protected void setRoot(XWorkConverter xworkConverter, CompoundRootAccessor accessor, CompoundRoot compoundRoot,
boolean allowStaticMethodAccess) {
this.root = compoundRoot;
this.securityMemberAccess = new SecurityMemberAccess(allowStaticMethodAccess);
this.context = Ognl.createDefaultContext(this.root, accessor, new OgnlTypeConverterWrapper(xworkConverter), securityMemberAccess);
context.put(VALUE_STACK, this);
Ognl.setClassResolver(context, accessor);
((OgnlContext) context).setTraceEvaluations(false);
((OgnlContext) context).setKeepLastEvaluation(false);
}从第11行我们可以看出，OgnlValueStack中的context有包含了对自身的引用，我们回头再来看看第10行Ognl.createDefaultContext方法内部的实现：
//class Ognl.java
public static Map createDefaultContext(Object root, ClassResolver classResolver,TypeConverter converter, MemberAccess memberAccess)
{
return addDefaultContext(root, classResolver, converter, memberAccess, new OgnlContext());
} public static Map addDefaultContext(Object root, ClassResolver classResolver,TypeConverter converter, MemberAccess memberAccess, Map context)
{
OgnlContext result; if (!(context instanceof OgnlContext)) {
result = new OgnlContext();
result.setValues(context);
} else {
result = (OgnlContext) context;
}
if (classResolver != null) {
result.setClassResolver(classResolver);
}
if (converter != null) {
result.setTypeConverter(converter);
}
if (memberAccess != null) {
result.setMemberAccess(memberAccess);
} result.setRoot(root);
return result;
}
从方法addDefaultContext可以得知，OnglValueStack中的context是OnglContext对象。第27行可以看出，这个context还包含了对OgnlValueStack中“CompoundRoot root”的引用。
接下来，我们回到PrepareOperation.java类中的“createActionContext”方法（StrutsPrepareAndExecuteFilter.java中doFilter中调用这个方法，正文最开始已经贴出了源码）：
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;
}
ActionContext oldContext = ActionContext.getContext();
if (oldContext != null) {
// detected existing context, so we are probably in a forward
ctx = new ActionContext(new HashMap<>(oldContext.getContextMap()));
} else {
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
stack.getContext().putAll(dispatcher.createContextMap(request, response, null));
ctx = new ActionContext(stack.getContext());
}
request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
ActionContext.setContext(ctx);
return ctx;
}从之前的源码分析，我们知道，14行的ValueStack存储的是OgnlValueStack对象，这个对象的getContext方法获取成员变量context（Map类型，具体实现类为OgnlContext）。我们再来看看15行dispatcher.createContextMap的源码：
// class Dispacher.java public Map<String,Object> createContextMap(HttpServletRequest request, HttpServletResponse response,
ActionMapping mapping) { // 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(servletContext); Map<String,Object> extraContext = createContextMap(requestMap, params, session, application, request, response); if (mapping != null) {
extraContext.put(ServletActionContext.ACTION_MAPPING, mapping);
}
return extraContext;
}
看着上面Map类型的requestMap、params等变量，是不是觉得很熟悉？我们在使用ActionContext的时候是不是经常有如下用法，这些值就在这边设置的：
ActionContext.getContext().getParameters();
ActionContext.getContext().get("request");
ActionContext.getContext().getSession();
等等，是不是又有读者要问了，我值栈ValueStack中的context怎么又和ActionContext扯上关系了？有迷惑的读者，请往前两段代码看下createActionContext的第16行：
再看下类ActionContext的声明和构造函数：
.........................................................................................
public class ActionContext implements Serializable { static ThreadLocal<ActionContext> actionContext = new ThreadLocal<>();
private Map<String, Object> context; public ActionContext(Map<String, Object> context) {
this.context = context;
}
public static void setContext(ActionContext context) {
actionContext.set(context);
}
public static ActionContext getContext() {
return actionContext.get();
}
........................................................................
}
OgnlValueStack将成员变量context传递给ActionContext对象的context成员变量，之前在OgnlValueStack设置的值便都能在ActionContext的对象中获取~当然这边还有一个非常关键的一步：
这一步将ActionContext实例变量设置到ThreadLocal变量中，这个就使得ActionContext实例变量可以在同一个线程中的不同类间传递，对于ThreadLocal使用不太清晰的读者，请参考我之前的博文：ThreadLocal 验明正身。
至此，已经从源码的角度将Struts2中的“值栈”说清楚了~下面附张图，可以更好的帮助读者去理解本文内容~（别人画的，本文参考链接中有贴出原链接 ）
（本图用来说明OnglValueStack中context和ActionContext中context的关系）
总结：
当初会去深究Struts2中的值栈，起因是在使用Ognl表达式时，获取“值栈”中某些值，有些表达式要加“#”有些不要，然后就有了去深究的冲动~
“值栈”由两部分组成：
1）ObjectStack (保存为root属性，类型CompoundRoot) ----- ArrayList 2）ContextMap(保存为context属性， 类型 ) ------ Map
Struts2 会把下面这些映射压入 ContextMap 中：
parameters: 该 Map 中包含当前请求的请求参数
request: 该 Map 中包含当前 request 对象中的所有属性
session: 该 Map 中包含当前 session 对象中的所有属性
application:该 Map 中包含当前 application 对象中的所有属性
attr: 该 Map 按如下顺序来检索某个属性: request, session, application
注：CompoucdRoot继承了ArrayList，实际上就是一个集合，用于存储元素的数据，OgnlContext实现了Map， 其中持有CompoucdRoot对象的引用，其key为_root
在JSP页面内，通过 <s:property>等标签去访问值栈的数据，访问root中数据，不需要“#”，访问 Context中数据必须以“#”开始。
当Struts2接受一个请求时，会迅速创建ActionContext，ValueStack，action ，然后把action存放进ValueStack，所以action的实例变量可以被OGNL访问。
Action对象会被保存root 对象栈中，Action所有成员变量属性，都位于root中 ，访问root中数据不需要“#”。
再附一张图，图中“ValueStack（值栈，根对象）”指的是OgnlValueStack类中的CompoundRoot root成员变量：
三、链接
http://blog.csdn.net/javaliuzhiyue/article/details/9357337
http://www.cnblogs.com/x_wukong/p/3887737.html
http://blog.csdn.net/elvis12345678/article/details/7909936
http://www.cnblogs.com/hlhdidi/p/6185836.html
四、联系本人
为方便没有博客园账号的读者交流，特意建立一个企鹅群（纯公益，非利益相关），读者如果有对博文不明之处，欢迎加群交流：261746360，小杜比亚-博客园