在Struts2中使用OGNL

OGNL是XWork引入的一个非常有效的数据处理的工具。我们已经了解了OGNL的基本操作和OGNL的内部结构，接下来，我们来看看XWork对OGNL做了什么样的加强，以及OGNL的体系在Struts2中如何运转。 

从例子开始 

我们先从一个例子开始，看看数据在Struts2中是如何运转的。 

Java代码  

1. /** 
2.  * @author Downpour 
3.  */  
4. public class User {  
5.       
6.     private Integer id;  
7.       
8.     private String name;  
9.       
10.     private Department department = new Department();  
11.       
12.         // setter and getters  
13. }  
14.   
15. //=========================================================================  
16.   
17. /** 
18.  * @author Downpour 
19.  */  
20. public class Department {  
21.       
22.     private Integer id;  
23.       
24.     private String name;  
25.           
26.         // setter and getters  
27. }  
28.   
29. //=========================================================================  
30.   
31. <form method="post" action="/struts-example/ognl.action">  
32.     user name: <input type="text" name="user.name" value="downpour" />  
33.     department name: <input type="text" name="department.name" value="dev" />  
34.     <input type="submit" value="submit" />  
35. </form>  
36.   
37. //=========================================================================  
38.   
39. /** 
40.  * @author Downpour 
41.  */  
42. public class OgnlAction extends ActionSupport {  
43.   
44.     private static final Log logger = LogFactory.getLog(OgnlAction.class);  
45.   
46.     private User user;  
47.       
48.     private Department department;  
49.       
50.     /* (non-Javadoc) 
51.      * @see com.opensymphony.xwork2.ActionSupport#execute() 
52.      */  
53.     @Override  
54.     public String execute() throws Exception {  
55.         logger.info("user name:" + user.getName());   // -> downpour  
56.         logger.info("department name:" + department.getName());   // -> dev  
57.         return super.execute();  
58.     }  
59.   
60.     // setter and getters  
61. }  
62.   
63. //=========================================================================  
64.   
65. user name: <s:property value="user.name" />  
66. department name: <s:property value="department.name" />  
67.   
68. //=========================================================================  

我们可以看到在JSP中，form中的元素input等，都使用OGNL的表达式作为name的值。而在form提交时，这些值都会被设置到Action中的Java对象中。而当Action转向到JSP时，Struts2的Tag又可以从Action的Java对象中，通过OGNL进行取值。 

在这里，你看不到任何的OGNL的代码级别操作，因为这些都在Struts2内部进行了封装。而这些封装，都是建立在OGNL的基本概念，也就是根对象和上下文环境之上。下面就分别就这两个方面分别进行讲解。 

ValueStack —— 对OGNL的加强 

细心的读者可能会发现，在上面的例子中，我们使用了不同的表达式，针对Action中的不同的Java对象进行设值。再结合上一讲我们所例举的OGNL的代码操作示例，我们有强烈的理由怀疑，Struts2在内部有可能执行了这样的操作，才使得页面到Action的设值工作顺利完成： 

Java代码  

1. // "user.name" as OGNL expression, action as OGNL Root object  
2. Ognl.setValue("user.name", action, "downpour");  
3. Ognl.setValue("department.name", action, "dev");  

如果这个怀疑是正确的，那么我们就能得出这样一个结论：Struts2的Action是OGNL操作的根对象。 

这个结论是我们从现象上推出来的，至于它到底正确与否，我们之后可以通过源码分析来进行验证，在这里先卖一个关子，姑且认为它是正确的。不过这个结论对我们来说非常重要，因为这个结论Struts2的Tag，JSTL和Freemarker等表示层元素获取Action中变量的值打下了坚实的基础。 

在Struts2（XWork）中，不仅把Action作为OGNL操作的根对象，作为对OGNL的扩展，它还引入了一个ValueStack的概念。这个概念代表了什么呢？还是让我们看看Struts2的Reference怎么说： 

很明显，ValueStack依照它的结构和作用，至少为我们提供两大特性： 

1. ValueStack是一个堆栈结构，堆栈中的每个元素对于OGNL操作来说，都被看作是根对象。 

2. 由于ValueStack是一个堆栈结构，所以其中的元素都是有序的，对于某个OGNL表达式来说，OGNL将自堆栈顶部开始查找，并返回第一个符合条件的对象元素。 

这里我们有必要对第二点啰嗦几句，举个具体的例子来说（这个例子同样摘自Struts2的Reference）：如果在ValueStack中有2个对象，分别是“动物”和“人”，这两个对象都具备一个属性，叫做name，而“动物”还有一个属性叫species，“人”还有个属性叫salary。其中，“动物”对象在ValueStack的栈顶，而“人”这个对象在栈底。那么看看下面的OGNL表达式将返回什么？ 

Java代码  

1. species    // call to animal.getSpecies()  
2. salary     // call to person.getSalary()  
3. name       // call to animal.getName() because animal is on the top  

对于name这个属性，返回的将是“动物”的name，因为“动物”在栈顶，会被先匹配到OGNL的表达式。但是有的时候，你可能需要访问“人”的name属性，怎么办呢？你可以通过下面的方法： 

Java代码  

1. [0].name   // call to animal.getName()  
2. [1].name   // call to person.getName()  

Struts2中的OGNL上下文环境 

有了ValueStack，我们再来仔细研究一下Struts2中OGNL的上下文环境。 

也就是说，ActionContext是Struts2中OGNL的上下文环境。它维护着一个Map的结构，下面是这个结构的图示： 

 

其中，ValueStack是这个上下文环境中的根对象，而除了这个根对象以外，Struts2还在这个上下文环境中放了许多额外的变量，而这些变量多数都是被XWork封装过的Servlet对象，例如request，session，servletContext(application)等，这些对象都被封装成Map对象，随着ActionContext作用于整个Action执行的生命周期中。 

在这里，或许有些读者会提出问题来，为什么好好的Servlet对象要在这里被封装成Map对象呢？我想原因可能有以下两个： 

1. 对Struts2的Action彻底屏蔽Servlet容器，从而无需再使用底层Servlet API进行编程。你所面对的，将永远是一个又一个的Java对象。 

2. 便于各种View技术，例如JSP，Freemarker，Velocity等对ValueStack中上下文环境，尤其是Servlet对象中的数据进行读取。试想，如果在这里不将HttpServletRequest，HttpSession等Servlet对象转化成Map，那么我们将很难通过OGNL表达式，对这些Servlet对象中的值进行读取。 

Struts2中使用OGNL进行计算 

取值计算 

有了上面的这些知识，我们就能非常容易的理解在Struts2中如何使用OGNL进行取值计算。 

提问：在Struts2中，如何使用自身的Tag读取Action中的变量？ 

Struts2自身的Tag会根据value中的OGNL表达式，在ValueStack中寻找相应的对象。因为action在ValueStack的顶部，所以默认情况下，Struts2的Tag中的OGNL表达式将查找action中的变量。请注意，value中的内容直接是OGNL表达式，无需任何el的标签包装。 

例如：<s:property value="user.name" /> 

提问：在Struts2中，如何使用自身的Tag读取HttpServletRequest，HttpSession中的变量？ 

在上面的知识中，我们知道，Struts2中OGNL的上下文环境中，包含request，session，application等servlet对象的Map封装。既然这些对象都在OGNL的上下文中，那么根据OGNL的基本知识，我们可以通过在表达式前面加上#符号来对这些变量的值进行访问。 

例如：<s:property value="%{#application.myApplicationAttribute}" /> 
<s:property value="%{#session.mySessionAttribute}" /> 
<s:property value="%{#request.myRequestAttribute}" /> 
<s:property value="%{#parameters.myParameter}" /> 

在这里啰嗦一句，在Tag的value中包括%{开头和}结尾的字符串，不知道Struts2为什么要做出这样的设置，从源码上看，它似乎没有什么特别额外的作用： 

Java代码  

1. if (value == null) {  
2.     value = "top";  
3. }  
4. else if (altSyntax()) {  
5.     // the same logic as with findValue(String)  
6.     // if value start with %{ and end with }, just cut it off!  
7.     if (value.startsWith("%{") && value.endsWith("}")) {  
8.         value = value.substring(2, value.length() - 1);  
9.     }  
10. }  
11.   
12. // exception: don't call findString(), since we don't want the  
13. //            expression parsed in this one case. it really  
14. //            doesn't make sense, in fact.  
15. actualValue = (String) getStack().findValue(value, String.class);  
16.   
17. ......  

有兴趣的朋友可以研究一下，这一对符号的原理究竟是什么。 

提问：在Struts2中，如何使用JSTL来读取Action中的变量？ 

这是一个历史悠久的问题。因为事实上，很多朋友（包括我在内）是不使用Struts2自身的标签库，而是使用JSTL的，可能因为JSTL标签库比较少，简单易用的原因吧。 

我们知道，JSTL默认是从page，request，session，application这四个Scope逐次查找相应的EL表达式所对应的对象的值。那么如果要使用JSTL来读取Action中的变量，就需要把Action中的变量，放到request域中才行。所以，早在Webwork2.1.X的年代，我们会编写一个拦截器来做这个事情的。大致的原理是：在Action执行完返回之前，依次读取Action中的所有的变量，并依次调用request.setAttribute()来进行设置。具体的整合方式，请参考以下这篇文档：http://wiki.opensymphony.com/display/WW/Using+WebWork+and+XWork+with+JSP+2.0+and+JSTL+1.1 

不过随着时代的发展，上面的这种方式，已经不再被推荐使用了。（虽然如此，我们依然可以学习它的一个解决问题的思路）目前来说，自从Webwork2.2以后，包括Struts2，都使用另外一种整合方式：对HttpServletRequest进行装饰。让我们来看一下源码： 

Java代码  

1. public class StrutsRequestWrapper extends HttpServletRequestWrapper {  
2.   
3.     /** 
4.      * The constructor 
5.      * @param req The request 
6.      */  
7.     public StrutsRequestWrapper(HttpServletRequest req) {  
8.         super(req);  
9.     }  
10.   
11.     /** 
12.      * Gets the object, looking in the value stack if not found 
13.      * 
14.      * @param s The attribute key 
15.      */  
16.     public Object getAttribute(String s) {  
17.         if (s != null && s.startsWith("javax.servlet")) {  
18.             // don't bother with the standard javax.servlet attributes, we can short-circuit this  
19.             // see WW-953 and the forums post linked in that issue for more info  
20.             return super.getAttribute(s);  
21.         }  
22.   
23.         ActionContext ctx = ActionContext.getContext();  
24.         Object attribute = super.getAttribute(s);  
25.   
26.         boolean alreadyIn = false;  
27.         Boolean b = (Boolean) ctx.get("__requestWrapper.getAttribute");  
28.         if (b != null) {  
29.             alreadyIn = b.booleanValue();  
30.         }  
31.   
32.         // note: we don't let # come through or else a request for  
33.         // #attr.foo or #request.foo could cause an endless loop  
34.         if (!alreadyIn && attribute == null && s.indexOf("#") == -1) {  
35.             try {  
36.                 // If not found, then try the ValueStack  
37.                 ctx.put("__requestWrapper.getAttribute", Boolean.TRUE);  
38.                 ValueStack stack = ctx.getValueStack();  
39.                 if (stack != null) {  
40.                     attribute = stack.findValue(s);  
41.                 }  
42.             } finally {  
43.                 ctx.put("__requestWrapper.getAttribute", Boolean.FALSE);  
44.             }  
45.         }  
46.         return attribute;  
47.     }  
48. }  

看到了嘛？这个类会在Struts2初始化的时候，替换HttpServletRequest，运行于整个Struts2的运行过程中，当我们试图调用request.getAttribute()的时候，就会执行上面的这个方法。（这是一个典型的装饰器模式）在执行上面的方法时，会首先调用HttpServletRequest中原本的request.getAttribute()，如果没有找到，它会继续到ValueStack中去查找，而action在ValueStack中，所以action中的变量通过OGNL表达式，就能找到对应的值了。 

在这里，在el表达式广泛使用的今天，JSTL1.1以后，也支持直接使用el表达式。注意与直接使用struts2的tag的区别，这里需要使用el的表示符号：${} 

例如：${user.name}, <c:out value="${department.name}" /> 

提问：在Struts2中，如何使用Freemarker等模板来读取Action中的变量以及HttpServletRequest和HttpSession中的变量？ 

Freemarker等模板在Struts2中有对应的Result，而在这些Result中，Freemarker等模板会根据ValueStack和ActionContext中的内容，构造这些模板可识别的Model，从而使得模板可以以他们各自的语法对ValueStack和ActionContext中的内容进行读取。 

有关Freemarker对于变量的读取，可以参考Struts2的官方文档，非常详细：http://struts.apache.org/2.0.14/docs/freemarker.html 

设值计算 

Struts2中使用OGNL进行设值计算，就是指View层传递数据到Control层，并且能够设置到相应的Java对象中。这个过程从逻辑上说需要分成两步来完成： 

1. 对于每个请求，都建立一个与相应Action对应的ActionContext作为OGNL的上下文环境和ValueStack，并且把Action压入ValueStack 

2. 在请求进入Action代码前，通过某种通用的机制，搜集页面上传递过来的参数，并调用OGNL相关的代码，对Action进行设值。 

上面的第一个步骤，在处理URL请求时完成，而第二个步骤，则涉及到另外一个XWork的核心知识：拦截器。所以有关Struts2使用OGNL进行设值计算的详细分析，将会在拦截器章节具体给出。 

原文链接：[http://wely.iteye.com/blog/2295298]