JavaEE笔记（四）Struts2中的ValueStack 与 ActionContext

最新推荐文章于 2020-04-21 21:44:22 发布

原创最新推荐文章于 2020-04-21 21:44:22 发布 · 1.2k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#java ee #struts2.0 #ValueStack

JavaEE 课程笔记专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了Struts2框架中的ValueStack概念，包括其结构、创建过程、获取方法及向其中保存数据的方式。同时介绍了如何在JSP页面获取ValueStack中的数据，并讨论了ValueStack默认保存的数据。

JavaEE笔记（四）Struts2中的ValueStack 与 ActionContext

在上一篇学习笔记JavaEE笔记（三）Struts2 拦截器的最后一小节中提到了关于Struts2拦截器与过滤器的区别，其中有一条说到，拦截器可以访问ValueStack与Action上下文。我们没有展开讨论，因为关于这个话题，内容比较复杂而篇幅有限。今天的笔记将着重讨论这个话题。

1. What is ValueStack

ValueStack是Struts2框架中的一个接口类， com.opensymphony.xwork2.util.ValueStack。它的主要功能是作为一个容器将Action携带的数据反映到页面上，在页面上将通过OGNL表达式进行回显。对于ValueStack可以概括为以下4个要点，我们会在后面的内容逐一涉及解释：
1） ValueStack有一个实现类OgnlValueStack。
2）每一个Action都有一个与之对应的ValueStack，而Action也与Request一一对应，这样我们可以得出结论，一个Http请求Request对应一个Action对象，也对应一个值栈对象，ValueStack的生命周期就是Request的生命周期。
3） ValueStack中存储当前Action对象以及其他web对象（Request, Session, Application, Parameters)
4 ) Struts2框架将ValueStack以”struts.valueStack“为名存储到Request域中。

2. ValueStack的结构

之前已经提到ValueStack是接口类，而我们关心的是其实现类OgnlValueStack。查看其源代码， OgnlValueStack实际维护了2个核心对象： CompoundRoot 和 OgnlContext，前者对应Ognl的Root，而后者顾名思义即为Ognl的上下文对象。从底层分析， CompoundRoot实际是一个继承了ArrayList的集合类，OgnlContext是一个Map

public class OgnlValueStack implements Serializable, ValueStack, ClearableValueStack, MemberAccessValueStack {
    // 省略部分源码
    CompoundRoot root;
    transient Map<String, Object> context; // context对象为一个Map集合
    // ......
}

// ComoundRoot为ArryList的子类
public class CompoundRoot extends ArrayList {
    public CompoundRoot() {}

    public CompoundRoot(List list) {super(list);}
}

public class DemoAction extends ActionSupport {

    @Override
    public String execute() throws Exception {

        // 向valueStack中存储数据(root)

        ValueStack vs = ActionContext.getContext().getValueStack();

        vs.set("college", "NYU");

        vs.push("Good day NYU");

        return SUCCESS;
    }
}

利用断点以及输出页面的<s:debug />标签，我们发现List集合存储的是Action对象（以及手动入栈的数据。并且在context对象也持有对root的引用。蓝色标记框可以看到被手动压入栈的数据对象，以一个数组的形式存放。第一个元素为字符串”Good day NYU”，第二个元素为一个HashMap集合，key为”college”, value为”NYU”。蓝灰色标记的为Action对象，DemoAction (id=90)。

这里写图片描述

3. ValueStack的创建

说起ValueStack的创建，我们要回到Struts2框架的执行流程，这里不再赘述，可以参考上一篇博文，JavaEE笔记（三）Struts2 拦截器已经详细阐述了收到Request对象后框架的处理过程。这里我们直接根据之前的基础开始讨论。
在StrutsPrepareAndExecuteFilter过滤器中维护了一个预处理对象 PrepareOperations，通过调用createActionContext方法，我们将得到ActionContext对象。下面看源码：

public class StrutsPrepareAndExecuteFilter implements StrutsStatics, Filter {
    protected PrepareOperations prepare;
    protected ExecuteOperations execute;

    // 初始化方法中创建了PrepareOperations对象
    public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        Dispatcher dispatcher = null;

        // 省略部分源码
        prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);
        execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);
        // ......            
    }

    // doFilter方法中prepareOperations对象生成ActionContext对象
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        try {
            // 省略部分源码
            prepare.createActionContext(request, response);
            ActionMapping mapping = prepare.findActionMapping(request, response, true);
                if (mapping == null) {
                    boolean handled = execute.executeStaticResourceRequest(request, response);
                    if (!handled) {
                        chain.doFilter(request, response);
                    }
                } else {
                    execute.executeAction(request, response, mapping);
                }
            }
        } finally {
            prepare.cleanupRequest(request);
        }
    }

下面再来看看createActionContext()方法是怎样获得ActionContext的：

public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
        ActionContext ctx;        
        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));
            ctx = new ActionContext(stack.getContext());
        }
        request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
        ActionContext.setContext(ctx);
        return ctx;
    }

首先，利用ActionContext静态方法在线程中寻找之前以后的ActionContext对象，如果有，则说明这个Request已经包含了ActionContext对象，即为转发的Request。否则，先创建一个ValueStack对象，再利用ValueStack的getContext()得到一个Map集合对象（还未封装），调用Map的putAll()方法把另一个Map集合的数据复制进之前还未封装的Map对象。因此我们将注意力放在了封装了那些数据，dispatcher类中有一个方法createContextMap()可以得到封装数据：

public Map<String,Object> createContextMap(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping, ServletContext context) {}

从中我们可以看到，最终我们封装了一些Web对象，最后在createActionContext()中，我们将再通过ValueStack.getContext()得到封装完毕的Map传入ActionContext的有参构造方法得到最终返回的ActionContext对象，当然在返回之前，我们还需要再利用静态方法setContext() 把这个得到的对象设置回这个ActionContext的线程中。值得注意的是，虽然我们是先利用了ValueStack工厂方法得到了一个ValueStack对象，但这个对象并没有任何与实际Action（Request）相关联，这也解释了为什么在执行过程中需要从ActionContext反过来获取与之相对应的ValueStack。

现在我们可以回到StrutsPrepareAndExecuteFilter的doFilter()方法了，按照接下去的流程，我们将调用ExecuteOperations.excuteAction()–>Dispatcher.serviceAction()方法来创建代理对象并执行Action，这个流程在这里也不再复述。值得注意的是在serviceAction() 方法中，在代理对象创建之前，必须要获得ValueStack对象。看源码：

public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {

        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();
            String name = mapping.getName();
            String method = mapping.getMethod();

            Configuration config = configurationManager.getConfiguration();
            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!
            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);
            }

首先要做的一件事是确定我们是否已经在这个生命周期中存有ValueStack对象。判断的依据是如果有，则Request域中必然有一对键值对，key为ServletActionContext.STRUTS_VALUESTACK_KEY，即”struts.valueStack”字符串，value为ValueStack对象。如果没有，先通过静态方法得到线程的ActionContext, 再利用ActionContext对象得到相应的ValueStack, 并且当代理对象创建完毕，也将把之前作为判断条件的键值对加入Request域，这样当这个Request转发（非重定向）后，键值对在域中被获取也就可以获取到生命周期中的ValueStack。

总结一下，简单的讲ValueStack在每一次请求时都会创建，并且在Request的生命周期中保持存在且唯一，ActionContext可以通过ValueStack的get方法得到Map映射，将Map传入构造方法得到ActionContext，ValueStack可以反过来直接通过ActionContext的get方法得到。

4. ValueStack的获取

ValueStack的获取在上一节的源码解释中已经有所提及，这里概括2个方法：

1）要获取ValueStack对象，可以先通过静态方法获取ActionContext对象，由于ActionContext持有ValueStack的引用，因此直接通过get方法调用就可以得到对应的ValueStack。

ValueStack stack = ActionContext.getContext().getValueStack();

2）在代理对象的创建过程中，我们已经将键值对存入了Request域中，因此也可以问Request域来拿到ValueStack对象。

ValueStack stack = (ValueStack) ServletActionContext.getRequest().getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);

5. 如何向ValueStack中保存数据

在1.2节中的例子我们已经看到了2中向ValueStack中保存数据的方法，set(K,V) 以及 push(Object) 并且他们默认将数据存到了Root中。我们现在来通过源码来看下原理，者及方法的实现位于ValueStack接口的实现类OgnlValueStack中。

public void push(Object o) {
    root.push(o);              // 将数据压入了CompoundRoot中
}

public void set(String key, Object o) {
    Map setMap = retrieveSetMap();
    setMap.put(key, o);
}

private Map retrieveSetMap() {
    Map setMap;
    Object topObj = peek();
    if (shouldUseOldMap(topObj)) {
        setMap = (Map) topObj;
    } else {
        setMap = new HashMap();
        setMap.put(MAP_IDENTIFIER_KEY, "");
        push(setMap);         // 将数据压入了CompoundRoot中
    }
    return setMap;
}

private boolean shouldUseOldMap(Object topObj) {
    return topObj instanceof Map && ((Map) topObj).get(MAP_IDENTIFIER_KEY) != null;
}

对于直接将对象存入alueStack的方法push()，通过源码非常明显地看到，数据被默认存到了CompoundRoot中，而CompoundRoot是ArrayList的子类，该类通过ArrayList的方法实现了栈的数据结构，由于比较简单，这里不再赘述。接下来，set()方法，底层是创建或者获取原有的HashMap集合，并将数据存入该Map, 如果是新建一个HashMap，它也将通过push()方法压入CompoundRoot的栈中。因此可以得到结论，所有的Action的数据是默认被存入root中的，并且这个root本身也是盏结构，因此给人的直观影响就是我们把数据存到了ValueStack这个栈中，而ValueStack并非真正的栈结构。

6. JSP页面获取ValueStack中保存的数据

从ValueStack中获取数据的一个基本原则： root中获取不需要加#，context中获取需要加#。
1）如果栈顶是一个Map集合，可以通过Key来获取Value

    <s:property value="key" />        //输出key对应的value

2）如果栈顶不是Map集合，可以通过序号来获取

    <s:property value="[0]" />        // 从0的位置向下查找输出所有
    <s:property value="[0].top" />    // 只输出0的位置的数据

3）想要获取Web对象中的数据，需要在context中查找，因此需要加#, 例子jsp页面将通过浏览器访问http://localhost:8080/demo.jsp?password=123456

    <%
        request.setAttribute("rname", "rvalue");
        session.setAttribute("sname", "svalue");
        application.setAttribute("aname", "avalue");
    %>

    <s:property value="#request.rname"/><br>              // output: rvalue
    <s:property value="#session.sname"/><br>              // output: svalue
    <s:property value="#application.aname"/><br>          // output: avalue 
    <s:property value="#attr.sname"/><br>                 // output: svalue
    <s:property value="#parameters.password[0]"/>         // output: 123456

attr 将以此从request，session，application搜索参数名称，匹配第一个结果输出。
parameters将携带请求参数。

4）使用<s:iterator>标签来迭代集合数据

    <!-- 迭代栈顶集合对象，迭代中的每一个元素名为 'user' -->
    <s:iterator value="[0].top" var="user"> 
    username:<s:property value="#user.username"/><br>
    password:<s:property value="#user.password"/>
    <hr>
    </s:iterator>

需要注意，虽然栈顶元素从root获取，但是迭代的每一个元素默认放入context，因此在获取时需要加#。

7. 默认保存到ValueStack中的数据

在1.2和1.5中，我们看到了手动保存在ValueStack中的数据以及方法。这一节将介绍ValueStack默认保存的数据对象。

7.1 Action对象的初始化保存

1.2中已经看到了，在手动保存数据的同时还看到了Action也被压入了栈。现在我们来根据源码来看看Action如何及何时被加载入ValueStack。根据Struts2框架的处理流程，我们必须得到Action的代理对象，ActionProxy，通过其实现类DefaultActionProxy的execute()方法执行Action，而execute()方法内实际是通过了ActionInvocation的实现类DefaultActionInvocation调用了invoke()方法来实现。这里就不贴出源码展开了，现在我们就来看看DefaultActionInvocation的初始化方法init():

public void init(ActionProxy proxy) {
        this.proxy = proxy;
        Map<String, Object> contextMap = createContextMap();

        // 首先得到线程的ActionContext对象
        ActionContext actionContext = ActionContext.getContext(); 

        // 将这个ActionInvocation对象存入ActionContext
        if (actionContext != null) {
            actionContext.setActionInvocation(this);
        }
        // 得到Action对象，Action对象在类中声明为成员变量
        createAction(contextMap);

        // 将Action对象存入ValueStack
        if (pushAction) {
            stack.push(action);
            contextMap.put("action", action);
        }        
        // ......省略部分代码

我们需要了解的2点：
1） Action是由Action的代理对象ActionProxy负责存入ValueStack;
2） Action存入栈的时机是在ActionProxy对象的初始化过程中。
3）存入栈中的Action中会默认保存getXXX()方法返回的对象。（详见下一节）

7.2 模型驱动对象的默认加载

模型驱动封装数据指的是利用Strut2框架提供的内置拦截器interceptor.ModelDrivenInterceptor来自动进行封装。Action类需要实现ModelDriven<T>接口并指明泛型类型。类似于自定义数据封装，我们仍然需要维护一个私有的需要封装的成员变量并初始化，不同于自定义数据封装，我们并不需要提供set(), get()方法，但需要重写接口getModel()方法，方法中直接返回我们需要默认加载入ValueStack的对象，也就是私有化的成员变量即可。完成这些操作后，即使我们在Action的execute()方法中不进行人为的手动加载，这个私有化对象也会被默认加载进ValueStack。有一点需要注意的是，这种方法的加载由于是由拦截器完成的，因此它的加载时机晚于Action本身的加载。换一种讲法，我们会看到如果利用这种加载方式，它的加载对象将处在栈顶。

首先我们来看下拦截器的源码来验证下加载原理：

public class ModelDrivenInterceptor extends AbstractInterceptor {

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        Object action = invocation.getAction(); // 获取Action对象

        if (action instanceof ModelDriven) { //判断Action是否实现了ModelDriven接口
            ModelDriven modelDriven = (ModelDriven) action; // 强转
            ValueStack stack = invocation.getStack();       // 获得ValueStack对象
            Object model = modelDriven.getModel();      // 调用getModel()方法获得需要加载的对象
            if (model !=  null) {
                stack.push(model);            // 压入ValueStack
            }            
        }
        return invocation.invoke();
    }

这段源码的结构和逻辑还是比较清楚的，不再这里赘述了。接下来，我们看一个例子：

public class ModelActionDemo extends ActionSupport implements ModelDriven<Student> {

    private Student student = new Student("xx101", "Jack", 784721, "CSE");

    public Student getModel() {
        return student;
    }

    public String getHello() {
        return "hello world";
    }

    @Override
    public String execute() throws Exception {

        student = new Student("xx202", "Ken", 597357, "ECE");

        return SUCCESS;
    }
}

我们通过JSP页面的<s:debug/>标签来观察一下Root里的元素，清楚地看到栈顶是一个初始化了得Student对象即getModel()返回的对象，特别注意到，Action对象中也有名为model值是一个Student对象，还有一个名为Hello，值为”hello world“的字符串对象。这边是之前提到的，只要Action中含有getXXX()方法，在Action被默认加载如StackValue的时候，会默认以XXX为名，以该方法的返回对象为值存入Action对象中。因此我们也就看到了在Action中也含有getModel()的返回Student对象。
这里写图片描述

现在的问题就是，Action中的Student对象和栈顶的Student对象是否指向同一个内存地址，答案是否定的。
首先，我们先要明确这几个对象的加载顺序，从前到后依次为Action初始化–>拦截器调用–>Action被执行。前一节已经讨论了Action和Model对象的加载时机，因此这也就是为什么Model返回对象位于栈顶。接下来，来看看程序里的2个Student对象是如何加载的。Action初始化相当于也初始化了一个Student对象并连同Action一起存入ValueStack，假设其内存地址为Student@12345678，接着ModelDriven拦截器被调用，并调用getModel()返回了刚才初始化的对象，因次栈顶对象指向Student@12345678。随后Action被调用，也就是执行Action类中execute()方法，这个方法中，我们又开辟了新的一个内存地址由图可见为Student@438a3a1d，并且让student指向新的地址。然而Model返回对象由于是引用的赋值，不会因此而指向新的地址，因此仍然指向Student@12345678。至此，当JSP页面用<s:debug/>输出Action视图时，其底层实际会利用Action中的getXXX()方法得到最后的引用并显示，因此，最后在Action中看到的model指向的是新的地址。

8. EL表达式访问ValueStack数据

我们首先拿第2节中的Action作为例子，JSP页面如下，来看一个效果：

<body>  
    ognl获取:<s:property value="college"/><br>
    el获取:${username}
</body>

输出：

ognl获取:NYU
el获取:NYU

我们都知道，OGNL可以从ValueStack中获取数据，EL则是从域对象中获取数据，在这里，我们的Action中也没有在任何域对象中存放数据，但EL表达式却从ValueStack中获取到了同样的内容，这是怎么实现的？
依旧，我们还是要回到源码中寻找答案，StrutsPreparedAndExecuteFilter中的doFilter()方法中，在得到Action映射以及最后调用executeAction()之前，对Request进行了处理：

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) res;
    // ......
    request = prepare.wrapRequest(request); // 处理request对象
    ActionMapping mapping = prepare.findActionMapping(request, response, true);
    // ......

一路跟随源码，最后发现Request对象被当作参数传入了Dispather中的wrapRequest()方法，这个方法返回一个StrutsRequestWrapper对象，这个对象的类又是HttpServletRequestWrapper的子类，到这里我们可以确定，对request对象的处理其实就是对其进行了包装，在包装类中重写了getAttribute()方法，让我们能够找到ValueStack中的参数。

// Dispatcher
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();
    // 上传操作请求
    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;
}

再来看下getAttribute()方法是怎么样被增强的：

public Object getAttribute(String key) {
    // 省略部分代码
    // 用父类方法先查找
    ActionContext ctx = ActionContext.getContext();
    Object attribute = super.getAttribute(key);

    // ActionContext不为空，但没有找到相应参数名
    if (ctx != null && attribute == null) {
        boolean alreadyIn = isTrue((Boolean) ctx.get(REQUEST_WRAPPER_GET_ATTRIBUTE));

        if (!alreadyIn && !key.contains("#")) {
            try {
                // If not found, then try the ValueStack
                ctx.put(REQUEST_WRAPPER_GET_ATTRIBUTE, Boolean.TRUE);
                ValueStack stack = ctx.getValueStack();
                if (stack != null) {
                    attribute = stack.findValue(key); // 到ValueStack中去寻找
                }
            } finally {
                ctx.put(REQUEST_WRAPPER_GET_ATTRIBUTE, Boolean.FALSE);
            }
        }
    }
    return attribute;
}

getAttribute()被增强，先调用父类方法查询参数名，如果没有找到则通过ValueStack对象调用findValue(key)方法查找。findValue(key)即为查找Key对应的值对象。

/**
     * Find a value by evaluating the given expression against the stack in the default search order.
     *
     * @param expr the expression giving the path of properties to navigate to find the property value to return
     * @return the result of evaluating the expression
     */
    public abstract Object findValue(String expr);

总结

ValueStack是Struts2框架中的一个重要概念，为了理解ValueStack的结构的创建，理解框架的处理流程是一个必要的前提。本篇笔记主要介绍了ValueStack的主要功能以及结构和原理。依靠ValueStack的手动加载以及默认自动加载的特性，我们可以不再依靠Web对象（域对象）来进行数据的传递，框架本身也包装了这些Web对象，让我们可以随时取用。

以上