时间：2017-1-12 12:02
——OGNL
1、OGNL表达式是什么
OGNL的全称是Object-Graph Navigation Language的缩写，中文名是对象图导航语言，它是一种功能强大的表达式语言。
比EL表达式功能强大。
Struts2将OGNL表达式语言集成到Struts2框架中，作为它的默认表达式语言。
2、OGNL表达式的功能
1）支持对象方法调用，如：xxx.doSomeMethod()
2）支持类静态的方法调用和值访问。
3）访问OGNL上下文（OGNL Context）和ActionContext：（重点，操作ValueStack）
4）支持赋值操作和表达式串联。
5）操作集合对象。
3、OGNL中“根”与“非根”的区别
root：只能有一个根，用于存储Action相关数据
contextMap：用于存储Web相关数据
4、示例代码
在Java代码中使用ognl表达式。
根中数据不需要使用#获取。
非根中数据需要使用#获取。
OGNL叫做对象图导航语言。
Person.java
public class Person {
private String name;
private Dog dog;
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Dog.java
public class Dog {
private String name;
private Person p;
public Person getP() {
return p;
}
public void setP(Person p) {
this.p = p;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
----------------------------------------------------------------------------------------------------------------------------
OgnlDemo1.java
import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;
public class OgnlDemo1 {
public static void main(String[] args) throws OgnlException{
// ognl可以通过对象调用方法
System.out.println("aaa".length());
/*
* 使用ognl来实现上面操作
* 1、创建一个ognl上下文对象
* 2、调用getValue()方法
*/
OgnlContext context = new OgnlContext();
Object o1 = Ognl.getValue("'aaa'.length()", context.getRoot());
System.out.println(o1);
// 调用Math的静态方法和静态成员
System.out.println(Math.max(10, 20));
System.out.println(Math.PI);
/*
* 在ognl表达式中调用静态方法
*/
Object o2 = Ognl.getValue("@java.lang.Math@max(10, 20)", context.getRoot());
System.out.println(o2);
Object o3 = Ognl.getValue("@java.lang.Math@PI", context.getRoot());
System.out.println(o3);
}
}
OgnlDemo2.java
import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;
public class OgnlDemo2 {
public static void main(String[] args) throws OgnlException {
/*
* 创建一个ognl上下文 OgnlContext是一个Map集合
* public class ognl.OnglContext implements java.util.Map
*/
OgnlContext context = new OgnlContext();
Person p = new Person();
p.setName("张三");
Dog dog = new Dog();
dog.setName("王五");
p.setDog(dog);
// 设置根
context.setRoot(p);
Dog d = new Dog();
d.setName("李四");
Person p2 = new Person();
p2.setName("赵六");
d.setP(p2);
// 设置属性（非根）
context.put("dog", d);
// 使用ognl来获取根中数据
// 获取根中数据，不需要加#
Object o1 = Ognl.getValue("name", context, context.getRoot());
System.out.println(o1);
// 使用ognl来获取非根中的数据
// 获取非根中数据，需要使用#
Object o2 = Ognl.getValue("#dog.name", context, context.getRoot());
System.out.println(o2);
// 获取p中的dog对象
// p表示根，所以可以省略p
Object o3 = Ognl.getValue("dog.name", context, context.getRoot());
System.out.println(o3);
// 获取dog中的person
Object o4 = Ognl.getValue("#dog.p.name", context, context.getRoot());
System.out.println(o4);
}
}
需要结合Struts2的标签使用：<s:property value="" />
* value：
书写ognl表达式
* default：
默认值
* escapeHtml
是否解析HTML
* escapeJavaScript
是否解析JS
* escapeXml
是否解析XML
注意：在Struts的JSP页面中访问静态成员时，必须设置一个常量值：
struts.ognl.allowStaticMethodAccess=false
示例代码：
<h1>使用ognl通过对象来调用方法</h1>
<s:property value="'aaa'.length()"/>
<hr />
<!-- 在Struts2中使用静态成员，必须设置一个常量 -->
<s:property value="@java.lang.Math@max(10,20)"/>
——ValueStack
1、ValueStack是什么
从技术角度来讲，ValueStack是一个接口（com.opensymphony.xwork2.util.ValueStack）。
从实用角度来讲，ValueStack是一个容器，用于将数据携带到action数据页面，然后在页面通过ognl表达式来获取。
ValueStack是Struts2提供的一个接口，实现类是OgnlValueStack。
OGNL表达式是从ValueStack中获取数据的。
每个Action实例都有一个ValueStack对象（一个请求对应一个ValueStack对象）
ValueStack中保存当前Action对象和其他常用Web对象，例如request, session, application, parameters（值栈中是有Action引用的）
Struts2框架把ValueStack对象保存在key为“struts.valueStack”的request域中（request中值栈对象是request的一个属性）
一个request一个Action，一个Action一个ValueStack，request - Action - ValueStack是一一对应的。
ValueStack生命周期就是一个request的生命周期。
流程（源码分析）：
从第一个请求开始，被StrutsPrepareAndExecuteFilter拦截后执行doFilter()中的execute.executeAction(request, response, mapping);方法，然后一直调用，进入到Dispatcher中的serviceAction()方法，在该方法中通过request获取ValueStack对象：ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);如果是第一次获取，则ValueStack对象为null，然后创建一个新的ValueStack，因为每次请求都是一个新的请求，所以每次请求都会创建一个新的ValueStack。当请求结束后，ValueStack就被释放了，所以ValueStack的生命周期等同于request的生命周期。
然后通过Dispatcher类中的serviceAction()方法中的：request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());来获取一个新的ValueStack对象，并保存到request域中，保存的key为：ServletActionContext.STRUTS_VALUESTACK_KEY，在ServletActionContext中可以查看，该常量的值为：struts.valueStack。
2、ValueStack的内部结构
查看ValueStack接口，可以看到两个方法：
* public abstract Map<String, Object> getContext();
* public abstract CompoundRoot getRoot();
> public class CompoundRoot extends ArrayList
> CompoundRoot类继承了ArrayList，提供了peek() pop() push()方法，相当于栈。
ValueStack接口中声明了root属性（CompoundRoot）、context属性（OgnlContext）：
* CompoundRoot就是ArrayList。
* OgnlContext就是Map
值栈由两部分组成：
ObjcetStack：Struts2把Action和相关对象压入ObjectStack中，用一个List保存
保存Action相关信息。
ContextMap：Struts2把各种各样的映射关系（一些Map类型的对象）压入ContextMap中。
比较常见的映射关系就是常见Web对象。
Struts2会把下面这些映射压入ContextMap中：
* parameters：该Map中包含当前请求的请求参数
* request：该Map中包含当前request对象的所有属性
* session：该Map中包含当前session对象的所有属性
* application：该Map中包含当前application对象的所有属性。
* attr：该Map按如下顺序来检索某个属性：request、session、application，相当于全域查找
* 对象引用
通过断点可以发现：
其中root在ContextMap中也有一个映射关系：
ValueStack中包含ContextMap和Root，而在ContextMap中又持有了Root的引用。
可以在断点调试中发现：
OGNL表达式访问root（List）中数据时，不需要使用#访问。
访问（Map）request、session、application、attr、parameters、对象引用时，必须写#。
操作ValueStack时，默认是指操作root元素。
其实ContextMap就是一个OgnlContext，可以查看ValutStack接口的实现类：OgnlValueStack
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);
}
结论：
ValueStack有两个部分，一个是List，一个是Map。
在Struts2中List就是Root，Map就是OgnlContext。
在Struts2中，默认情况下（不加#）从ValueStack中的Root获取数据。
3、ValueStack对象的创建，ValueStack和ActionContext是什么关系？
当请求发出时，会被doFilter()拦截然后调用Dispatcher类中的serviceAction()方法，方法中可以创建ValueStack对象：
// 刚开始会到request域中获取
ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
// 如果获取不到ValueStack对象
// 如果获取不到ValueStack对象
boolean nullStack = stack == null;
if (nullStack) {
// 会到ActionContext中获取
// 会到ActionContext中获取
ActionContext ctx = ActionContext.getContext();
if (ctx != null) {
stack = ctx.getValueStack();
}
}
ValueStack和ActionContext的关系：
ActionContext中持有了ValueStack的引用。
4、如何获取ValueStack对象
有两种方式可以获取ValueStack对象：
1）通过request获取
2）通过ActionContext获取
ValueStack和ActionContext的关系：
ActionContext中持有了ValueStack的引用。
4、如何获取ValueStack对象
有两种方式可以获取ValueStack对象：
1）通过request获取
2）通过ActionContext获取
public class OgnlDemo1Action extends ActionSupport {
@Override
public String execute() throws Exception {
/*
* 获取ValueStack
*/
// 1、通过request获取
ValueStack stack1 = (ValueStack) ServletActionContext.getRequest().getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
System.out.println(stack1);
// 2、通过ActionContext获取（推荐）
ValueStack stack2 = ActionContext.getContext().getValueStack();
System.out.println(stack2);
return null;
}
}
5、向ValueStack中保存数据（主要针对root）
在ValueStack接口中有两个方法：
有两种方式：
* push(Object obj)
* set(String key, Object obj)
1）push(Object obj)
在ValueStack接口的实现类OgnlValueStack中，重写了此方法：
public void push(Object obj) {
root.push(obj);
}
底层调用的是：root.add(0, obj);
所以push方法会将对象压入栈顶。
如果当前位置存在元素，那么当前元素会先后移，然后再在栈顶压入元素。
底层调用的是：root.add(0, obj);
所以push方法会将对象压入栈顶。
如果当前位置存在元素，那么当前元素会先后移，然后再在栈顶压入元素。
2）set(String key, Object obj)
在ValueStack接口的实现类OgnlValueStack中，重写了此方法：
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();
// 将数据封装到一个新的HashMap中
// 将数据封装到一个新的HashMap中
setMap.put(MAP_IDENTIFIER_KEY, "");
// 将Map集合压入栈顶
// 将Map集合压入栈顶
push(setMap);
}
return setMap;
}
底层是将数据封装到HashMap中，再将这个HashMap压入栈顶，保存到List集合中。
底层是将数据封装到HashMap中，再将这个HashMap压入栈顶，保存到List集合中。
示例代码：
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
stack.push("1");
stack.push("2");
stack.push("3");
stack.set("username", "张三");
stack.set("username", "张三");
List list = stack.getRoot();
System.out.println(list);
return null;
}
输出结果：[3, 2, 1, com.wyc.action.OgnlDemo2Action@320859ec, com.opensymphony.xwork2.DefaultTextProvider@5c1958e7]
6、在JSP页面中使用<s:debug />标签查看ValueStack中的数据
<body>
<h1>使用debug标签查看ValueStack数据</h1>
<!-- 通过debug标签查看ValueStack中存储的数据 -->
<s:debug />
</body>
7、在JSP页面中获取ValueStack数据
获取Root中数据不需要#
获取ContextMap中数据需要#
获取Root中的数据：
1）如果栈顶是一个Map集合，那么获取时可以直接通过Map集合的key来获取value。
<s:property value="username"/>
如果只写属性名，那么即使栈顶不是Map集合，也会从栈顶开始依次往下查找。
2）如果栈顶元素不是Map，不能通过key来获取，可以使用下标来获取元素：
<s:property value="[0] />
从0位置开始向下查找所有数据。
<s:property value="[0].top" />
只查找0位置上的数据。
JSP页面示例代码：
1、获取栈顶的Map
<br />
<s:property value="username" />
<hr />
2、获取栈顶非Map集合数据
<br />
<!-- 如果只写[0]，表示从0位置开始检索元素 -->
<s:property value="[0]" />
<hr />
<!-- [0].top表示获取栈的顶部元素 -->
<s:property value="[0].top" />
<hr />
<!-- 如果只写[1]，表示从1位置开始检索全部元素 -->
<s:property value="[1]" />
<hr />
<!-- [1].top表示获取栈的第二个位置的元素 -->
<s:property value="[1].top" />
<hr />
获取OgnlContext中的数据：
1）request数据
request.setAttribute()
2）session数据
session.setAttribute()
3）application数据
application.setAttribute()
4）attr
依次从request, session, application域中查找。
相当于pageContext的全域查找。
5）parameters数据
获取请求参数。
JSP页面代码：
3、获取OgnlContext中的数据
<%
request.setAttribute("rname", "rvalue");
session.setAttribute("sname", "svalue");
application.setAttribute("aname", "avalue");
%>
<s:property value="#request.rname"/><br />
<s:property value="#session.sname"/><br />
<s:property value="#application.aname"/><br />
<s:property value="#attr.sname"/><br />
<!-- 获取到的是参数的Map集合 -->
<s:property value="#parameters"/><br />
<!-- 获取指定参数 -->
<!-- 当存在checkbox这种一键多值的情况时，#parameters.username会打印一个数组 -->
<s:property value="#parameters.username"/><br />
<!-- 获取数组中的第一个元素 -->
<s:property value="#parameters.username[0]" />
8、ValueStack有什么作用
使用ValueStack最大的作用就是将Action相关的数据以及Web相关的对象，传递到页面上。
简单来讲，在Struts2中通过ValueStack将Action中的数据携带到页面上进行展示。
1）Action向JSP携带的数据都是什么类型的数据？
* 普通文本（字符串）
> fieldError：校验数据错误信息提示（常用于表单校验），this.addFieldError("msg", "字段错误信息")
> actionError：关于逻辑操作时的错误信息（普通错误信息，例如登录失败），this.addActionError("Action全局错误信息")
> message：通用信息，this.addActionMessage("Action普通消息信息")
在JSP中使用Struts2标签显示错误信息：
* <s: fielderror fieldName="msg" />
* <s:actionerror />
* <s:actionmessage />
* 复杂数据
可以使用ValueStack存储：
Action中存储数据：
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
List<User> users = new ArrayList<User>();
users.add(new User("zhangsan", "111", 20, "男"));
users.add(new User("lisi", "222", 30, "女"));
users.add(new User("wangwu", "333", 40, "男"));
// stack.push(users);
stack.set("users", users);
return SUCCESS;
}
JSP中获取数据：
<body>
<h1>使用ognl表达式来获取ValueStack中复杂数据</h1>
1、使用push()存储时获取数据（保存到OgnlContext中，是一个Map集合）
<s:property value="[0].top" />
<hr />
<s:iterator value="[0].top" var="user">
username:<s:property value="#user.username" /><br/>
password:<s:property value="#user.password" /><br/>
sex:<s:property value="#user.sex" /><br/>
age:<s:property value="#user.age" /><hr/>
</s:iterator>
<!-- 如果不为当前元素起别名，则默认使用当前元素 -->
<!-- 可以不写user，因为ContextMap中是有“user”的 -->
<s:iterator value="[0].top">
username:<s:property value="username" /><br/>
password:<s:property value="password" /><br/>
sex:<s:property value="sex" /><br/>
age:<s:property value="age" /><hr/>
</s:iterator>
<hr />
2、使用set存储数据（保存到List集合中）
<s:property value="users"/>
<hr />
<s:iterator value="users" var="user">
username:<s:property value="#user.username" /><br/>
password:<s:property value="#user.password" /><br/>
sex:<s:property value="#user.sex" /><br/>
age:<s:property value="#user.age" /><hr/>
</s:iterator>
</body>
9、关于默认压入到ValueStack中的数据分析
当前的Action会被默认压入ValueStack
1）属性驱动
每次请求访问Action对象，Action对象都会被压入ValueStack，在DefaultActioninvocation的init()方法中：
stack.push(action);
DefaultActioninvocation源码：
public void init(ActionProxy proxy) {
this.proxy = proxy;
Map<String, Object> contextMap = createContextMap();
// Setting this so that other classes, like object factories, can use the ActionProxy and other
// contextual information to operate
ActionContext actionContext = ActionContext.getContext();
if (actionContext != null) {
actionContext.setActionInvocation(this);
}
createAction(contextMap);
if (pushAction) {
stack.push(action);
contextMap.put("action", action);
}
......
}
......
}
在拦截器被调用之前就压入ValueStack了。
作用：
当Action被压入ValueStack之后，Action如果向传递数据给JSP，只要将数据保存为成员变量，并且提供get()方法就可以了。
当Action中声明了一个getXxx()方法后，ValueStack会将get之后的JavaBean的名称放到ValueStack的key中，然后在页面中可以直接使用JavaBean对象的key值来获取value值。
示例代码：
public class OgnlDemo4Action extends ActionSupport {
private List<User> users;
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
@Override
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
users = new ArrayList<User>();
users.add(new User("zhangsan", "111", 20, "男"));
users.add(new User("lisi", "222", 30, "女"));
users.add(new User("wangwu", "333", 40, "男"));
return SUCCESS;
}
}
JSP代码：
<s:iterator value="users" var="user">
JSP代码：
<s:iterator value="users" var="user">
<s:property value="#user.username"/>
</s:iterator>
2）模型驱动
ModelDriven接口有一个单独的拦截器
<interceptor name="modelDriven" class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor" />
在拦截器中，将Model对象压入了ValueStack：stack.push(model);
如果Action实现了ModelDriven接口，ValueStack默认栈顶对象就是Model对象。
因为Action对象在拦截器执行前就已经压入，而Model对象在ModelDrivenInterceptor拦截器执行时才会压入。
ModelDrivenInterceptor源码：
public String intercept(ActionInvocation invocation) throws Exception {
Object action = invocation.getAction();
// 将实现了ModelDriven接口的Action中的getModel()方法的返回值也就是内部封装的JavaBean对象压入到了ValueStack
if (action instanceof ModelDriven) {
ModelDriven modelDriven = (ModelDriven) action;
ValueStack stack = invocation.getStack();
Object model = modelDriven.getModel();
if (model != null) {
stack.push(model);
}
if (refreshModelBeforeResult) {
invocation.addPreResultListener(new RefreshModelBeforeResult(modelDriven, model));
}
}
return invocation.invoke();
}
在同一个请求中，Action中声明的private User user = new User();和getModel()方法中返回的User是相同的，也就是说在JSP页面中通过ValueStack获取到的User对象是同一个对象。但是，如果在execute()方法中对user重新赋值，那么push到ValueStack中的Action所包含的User就是后赋值的user对象，因为这个User对象是通过getXxx()方法获得的。而Model依然是private User user = new User();对象，因为Model是在execute()方法执行之前被压入的，所以在获取值时需要注意，这是两个对象。（new了两次，是两个对象。）
ModelDriven中保存的是初始化时压入的对象。
Action中保存的是execute()方法中赋值的对象。
示例代码：
public class OgnlDemo4Action extends ActionSupport implements ModelDriven {
private User user = new User();
@Override
public String execute() throws Exception {
return SUCCESS;
}
public Object getModel() {
return this.user;
}
}
10、为什么EL表达式可以访问ValueStack中的数据
Action中：
stack.set("username", "张三");
JSP中：
ognl获取：<s:property value="username" /><br />
EL获取：${username }
Struts2框架中所使用的request对象，是增强后的request对象，重写了getAttribute()方法。
StrutsPreparedAndExecuteFilter的doFilter()方法中：
request = prepare.wrapRequest(request)
* 对Request对象进行了包装，包装类：StrutsRequestWrapper
* 重写了request的getAttribute()方法
Object attribute = super.getAttribute(key)
if(attribute == null) {
attribute = stack.findValue(key);
}
增强后的request，会首先在request范围查找，如果查找不到，会到ValueStack中查找。
——OGNL表达式的常见使用
1、#
1）#相当于ActionContext.getContext()上下文
<s:property value="#request.name" />
相当于：ActionContext.getContext().getRequest().get("name");
2）不写#默认在ValueStack的Root中进行查找
3）进行投影映射以及过滤操作（结合复杂对象遍历）
映射：
<s:property value="ps" /><br />
1、使用iterator进行遍历<br />
<s:iterator value="ps" var="p">
<s:property value="#p.name" /><br />
<s:property value="#p.price" /><br />
<s:property value="#p.count" /><br />
</s:iterator>
<hr/>
2、对集合进行投影，只得到指定的属性<br />
<!-- 只迭代name -->
<s:iterator value="ps.{name}" var="name">
<s:property value="#name" />
</s:iterator>
过滤：
过滤：
3、对集合进行过滤操作<br />
<!-- 得到商品价格大于2000的对象 -->
<s:iterator value="ps.{?#this.price>1999}" var="p">
名称：<s:property value="#p.name" /><br />
价格：<s:property value="#p.price" /><br />
数量：<s:property value="#p.count" /><br />
</s:iterator>
<hr />
4、对集合进行过滤操作<br />
<!-- 得到商品价格大于2000的商品的名称 -->
<s:iterator value="ps.{?#this.price>1999}.{name}" var="pname">
名称：<s:property value="#pname" /><br />
</s:iterator>
4）使用#构造Map集合
经常结合Struts2标签用来生成select、checkbox、radio
示例代码：
1、使用#构造一个Map集合<br/>
2、%4）使用#构造Map集合
经常结合Struts2标签用来生成select、checkbox、radio
示例代码：
1、使用#构造一个Map集合<br/>
<s:iterator value="#{'name':'tom','age':20 }" var="entry">
<s:property value="#entry.key" /> --- <s:property value="#entry.value"/><br />
</s:iterator>
<hr/>
2、构造一个List集合<br/>
<s:iterator value="{'aa', 'bb', 'cc'}" var="list">
<s:property value="list" /><br/>
</s:iterator>
<hr/>
3、手动创建一个集合，在Struts2中结合表单标签使用<br/>
<s:form>
<!-- 用List集合创建radio表单标签 -->
<s:radio list="{'男', '女'}" name="sex"/><br/>
<!-- 用Map集合创建radio表单标签 -->
<s:radio list="#{'male':'男', 'female':'女' }" name="sex2"/><br/>
<!-- 使用List集合创建select -->
<s:select list="{'a', 'b', 'c'}" name="select" />
</s:form>
作用是用来设定当前字符串是否要解析为ognl表达式。
<h1>演示%用法</h1>
<%
request.setAttribute("username", "tom");
%>
<s:property value="#request.username" default="null"/><br />
<!-- 当前表达式会被作为ognl表达式解析 -->
<s:property value="%{#request.username}"/><br/>
<!-- 当前表达式不会被作为ognl表达式解析 -->
<s:property value="%{'#request.username'}"/><br/>
<!-- 如果不解析，则默认显示字符串 -->
<s:textfield name="username" value="#request.username"/><br/>
<s:textfield name="username" value="%{#request.username}"/><br/>
3、$
作用是在配置文件中写ognl表达式来获取ValueStack中的数据。
1）struts.xml
<result type="stream">
<param name="contentType">${contentType}</param>
</result>
2）在校验文件中使用
<param min="${min}"></param>
<param min="${max}"></param>
<param min="${maxLength}"></param>
校验文件会引入校验器，校验器会被加载，所以数据也会保存到ValueStack中。
3）在国际化文件中使用
在properties文件中：
username=${#request.username}
在JSP页面：
<%
request.setAttribute("username", "李四");
%>
<s:i18n name="com.wyc.resources.my">
<s:text name="username" />
</s:i18n>
在properties文件中也可以使用%获取值：
username=%{request.username}
在properties文件中也可以使用%获取值：
username=%{request.username}
——总结
1、ognl介绍
2、ValueStack介绍
3、什么是ValueStack
4、ValueStack内部结构
5、ValueStack创建以及ActionContext关系
6、如何获取ValueStack
7、如何向ValueStack存储数据（Root）
8、JSP页面中如何获取ValueStack数据
9、关于ValueStack携带数据分析
* 携带数据类型
* 如何在页面上获取复杂数据
* ValueStack默认压入数据
* #
* %
* $