Struts2值栈

一、前言

　　很多事儿啊，就是“成也萧何败也萧何”，细想一些事儿心中有感，当然，感慨和本文毛关系都没有~想起之前有篇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，小杜比亚-博客园

巴特西

Struts2值栈

一、前言

二、正文

三、链接

四、联系本人

最新文章

热门文章