Struts2值栈ValueStack源码阅读笔记

我们要从ActionContext开始说起，首先看StrutsPrepareAndExecuteFilter核心过滤器，也是整个程序的入口，doFilter()方法中的 ——->
prepare.createActionContext(request, response);

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);
            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);
                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);
        }
    }

进入PrepareOpreration类的createActionContext()方法。

   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();
        //如果ActionContext 不为null的话，重新new一个，在这里我们也可看到，ActionContext的数据结构，HashMap，用于查询最快的集合类。这段代码的意义在于使每一次请求，每一个action，都有其对应的ActionContext 
        if (oldContext != null) {
            // detected existing context, so we are probably in a forward
            ctx = new ActionContext(new HashMap<String, Object>(oldContext.getContextMap()));
        } else {
        //如果为null通过IoC容器ContainerImpl中的getInstance()方法创建对应实例，值栈在这里创建完成
            ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
//创建一个名字叫做extraContext的Map，里面存储了request，response，servletContext信息，并将其放入ActionContext
     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的数据结构是HashMap，那么ValueStack的数据结构是怎样的？

进入createValueStack()方法，进入OgnlValueStackFactory类，这个类继承ValueStackFactory接口

public class OgnlValueStackFactory implements ValueStackFactory 

进入ValueStackFactory 接口中发现，这个接口就是用来创建值栈的。

public interface ValueStackFactory {


    ValueStack createValueStack();


    ValueStack createValueStack(ValueStack stack);

}

回到OgnlValueStackFactory，找到createValueStack()方法.

    public ValueStack createValueStack() {
        ValueStack stack = new OgnlValueStack(xworkConverter, compoundRootAccessor, textProvider, allowStaticMethodAccess);
        container.inject(stack);
        stack.getContext().put(ActionContext.CONTAINER, container);
        return stack;
    }

进入OgnlValueStack的构造方法之中

  protected OgnlValueStack(XWorkConverter xworkConverter, CompoundRootAccessor accessor, TextProvider prov, boolean allowStaticAccess) {
        setRoot(xworkConverter, accessor, new CompoundRoot(), allowStaticAccess);
        push(prov);
    }

发现构造方法是protected 修饰符，我认为是确保了安全性，进入setRoot()方法。

  protected void setRoot(XWorkConverter xworkConverter, CompoundRootAccessor accessor, CompoundRoot compoundRoot,
                           boolean allowStaticMethodAccess) {
        //栈对象是一个CompountRoot类型的栈结构
        this.root = compoundRoot;
        //设定OGNL所需的MemeberAccess实现类
        this.securityMemberAccess = new SecurityMemberAccess(allowStaticMethodAccess);
        //创建OGNL的上下文
        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);
    }

这才是真正的OgnlValueStack的初始化过程，我们接下来进入CompoundRoot类

public class CompoundRoot extends ArrayList {

    public CompoundRoot() {
    }

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


    public CompoundRoot cutStack(int index) {
        return new CompoundRoot(subList(index, size()));
    }

    public Object peek() {
        return get(0);
    }

    public Object pop() {
        return remove(0);
    }

    public void push(Object o) {
        add(0, o);
    }
}

发现这个类继承了ArrayList类，我们发现其实OgnlValueStack的底层实际上是通过链表实现的栈结构。
接下来，我们要往回走，回到OgnlValueStackFactory的createValueStack()方法

public ValueStack createValueStack() {
        ValueStack stack = new OgnlValueStack(xworkConverter, compoundRootAccessor, textProvider, allowStaticMethodAccess);
        //将返回的值栈对象注入容器
        container.inject(stack);
        //将容器存入上下文，也就是ActionContext
        stack.getContext().put(ActionContext.CONTAINER, container);
        return stack;
    }

到这里ActionContext和值栈的初始化过程，以及他们之间的关系似乎已经弄清楚了，借用一张网上的图来说明他们之间的关系。

学习了值栈以后，引发了我的思考，xwork与ognl之间的信息是怎样交互的？他们之间的类型转换是怎样完成的？留待后续完成。