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，小杜比亚-博客园