标签：
Struts2
一．OGNL表达式
你还记得 EL表达式语言么？没错OGNL也是表达式语言，不过它比EL可强大太多了。OGNL的全称为Object Graphic Navigation Language（对象图导航语言）。它是Struts2的默认表达式语言！
使用OGNL需要导入OGNL的Jar包：ognl-3.0.5.jar
OGNL的功能介绍：
l EL一样的JavaBean导航；
l 调用对象方法；
l 调用类的静态方法；
l 索引数组元素；
l 操作集合；
为了可以执行OGNL表达式，所以我们必须要先学会怎么来使用Ognl类。为了更好的演示Ognl我们需要先创建一些JavaBean用来做测试。
|
public class Address { private String country; private String city; private String street; …… } |
|
public class Employee { private String name; private double salary; private Address address; …… } |
我们可以回忆一下EL的使用：${name}，它会在所有域中去查找name这个域属性。也就是说，EL表达式也需要一个查询的范围。相同的道理，OGNL也需要一个查找的范围，它查询的范围是OgnlContext。OgnlContext其实就是一个Map，你可以向其内添加N个键值对。它还可以指定多个键值中的一个为根对象（root）！
|
OgnlContext cxt = new OgnlContext(); Address add1 = new Address("中国", "北京", "大北窑"); Employee e1 = new Employee("张三", 10000, add1); Address add2 = new Address("中国", "北京", "西三旗"); Employee e2 = new Employee("李四", 12000, add2); cxt.put("emp1", e1); cxt.put("emp2", e2); cxt.setRoot(e1); |
演示OGNL表达式需要使用Ognl类，我们先从它的getValue()方法开始。这个方法需要三个参数，分别是：
l OGNL表达式；
l 上下文对象；
l 根对象。
|
String name = (String)Ognl.getValue("#emp2.name", cxt, cxt.getRoot()); System.out.println(name); |
其中“#emp2.name”是OGNL表达式，查找上下文中的元素必须以“#”开关，其中emp2对应上下文中的键，“.name”表示调用该元素的getName()方法，即JavaBean导航。如果它这个OGNL表达式翻译成Java代码，即：((Employee)cxt.get(“emp2”)).getName()。
|
String name = (String)Ognl.getValue("name", cxt, cxt.getRoot()); System.out.println(name); |
其中“name”为OGNL表达式，当没有使用“#”开始时，表达在使用根对象。所以“name”表达式可以理解为：cxt.getRoot().getName()。即输出“张三”。
|
String name = (String)Ognl.getValue("address.street", cxt, cxt.getRoot()); System.out.println(name); |
因为没有使用“#”开头，那么就是在使用根对象，即cxt.getRoot().getAddress().getStreet()，即输出“大北窑”。
OGNL也可以使用常量：
l 字符串常量：使用双引号，或单引号。如果字符串只有唯一字符时，必须使用双引号；
l 字符常量：使用单引号；
l 数值常量：与Java相同；
l boolean常量：与Java相同。
l OGNL也支持null常量。
OGNL运算符基本与Java相同，但它还有一些特殊的运算符：
l 逗号（,）：用逗号分隔多个OGNL表达式，这些表达式会依次被执行，而最后一个表达式的值为整个表达式的值；
l 大括号（{}）：用来创建列表，例如：{‘zhangSan’,’liSi’,’wangWu’}表示一个List；
l in和not in：in表示判断某个值是否在集合中，not in表达某个值是否不在集合中。
|
double s = (Double)Ognl.getValue("name,#emp2.name,salary", cxt, cxt.getRoot()); System.out.println(s); |
上面使用了逗号表达式，一共是3个OGNL表达式，它们会被依次运行，但整个整句表达式的值为最后一个OGNL表达式的值，即salary的值。
|
boolean bool = (Boolean)Ognl.getValue("name in {‘张三‘,‘李四‘}", cxt, cxt.getRoot()); System.out.println(bool); |
表达式“name in {‘张三’,’李四’}”首先需要得到name的结果，即根对象的name属性值，然后判断这个值是否在列表中存在，所以返回为true。
OGNL表达式不只是可以获取JavaBean属性值，不可以设置JavaBean属性值。但这需要使用Ognl类的setValue()方法。
|
Ognl.setValue("#emp2.address.street", cxt, cxt.getRoot(), "育新"); System.out.println(Ognl.getValue("#emp2.address.street",cxt, cxt.getRoot())); |
表达式指定的是cxt中键为emp2的对象，然后导航到它的address属性，再导航到street属性，最终给该属性设置值为“育新”。
OGNL不只可以获取JavaBean属性，还可以调用对象方法。
|
String s = (String)Ognl.getValue("‘OGNL‘.toLowerCase()", cxt, cxt.getRoot()); System.out.println(s); |
表达式“’OGNL’.toLowerCase()”表示调用字符串OGNL的toLowerCase()方法，千万要小心，在OGNL上添加单引或双引，指定其为字符串常量，不然会被误会来根对象的属性的。
当然，不只是可以调用字符串的方法，什么对象的方法都可以调用。
OGNL还可以调用类的静态方法，以及读取静态属性。操作静态方法或属性时，需要使用完整的类名称，并且需要使用两个“@”把类名称包含起来！
|
String s = (String) Ognl.getValue( "@java.lang.String@format(‘%tF %<tT‘, new java.util.Date())", cxt, cxt.getRoot()); System.out.println(s); |
上面的表达式可以翻译成：java.lang.String.format(“%tF %<tT”, new java.util.Date())
OGNL对java.lang.Math对有特殊的待遇，如果是操作Math类的静态属性或静态方法，可以不用给出类名称，但“@”不可以省略。
|
int max = (Integer)Ognl.getValue("@@max(1,2)", cxt, cxt.getRoot()); System.out.println(max); double pi = (Double)Ognl.getValue("@@PI", cxt, cxt.getRoot()); System.out.println(pi); |
OGNL可以用来操作数组，使用下标法即可：
|
String[] names = {"zhangSan", "liSi", "wangWu"}; cxt.put("ns", names); String name = (String)Ognl.getValue("#ns[0]", cxt, cxt.getRoot()); System.out.println(name); |
OGNL可以用来创建List和Map，先来创建一个List它。
|
List<String> names = (List<String>)Ognl.getValue("{‘zhangSan‘, ‘liSi‘, ‘wangWu‘}", cxt, cxt.getRoot()); System.out.println(names); |
这段代码创建一个List，类型为ArrayList。
创建Map必须以“#”开头
|
Map<String,String> map = (Map<String, String>)Ognl.getValue("#{‘a‘:‘A‘,‘b‘:‘B‘}", cxt, cxt.getRoot()); System.out.println(map); |
创建的Map默认类型为HashMap类型。还可以创建Map时指定Map的类型：
|
Map<String, String> map = (Map<String, String>) Ognl.getValue( "#@java.util.LinkedHashMap@{‘aa‘:‘AA‘,‘bb‘:‘BB‘}", cxt, cxt.getRoot()); System.out.println(map); |
获取Map的值。
|
String s = (String) Ognl.getValue( "#@java.util.LinkedHashMap@{‘aa‘:‘AA‘,‘bb‘:‘BB‘}[‘bb‘]", cxt, cxt.getRoot()); System.out.println(s); |
我们先来聊聊投影，如果有一个Employee的集合，可以通过投影获取所有的Employee的name属性值。这与数据库操作的查询指定列相似。
|
List<Employee> list = new ArrayList<Employee>(); list.add(new Employee("zhangSan", 10000)); list.add(new Employee("liSi", 11000)); list.add(new Employee("wangWu", 12000)); cxt.put("empList", list); List<String> nameList = (List<String>) Ognl.getValue("#empList.{name}", cxt, cxt.getRoot()); System.out.println(nameList); |
获取所有Employee的name属性。这相当于循环遍历list集合，然后调用每个Employee对象的getName()方法。
选择是给出一个条件，获取集合中满足条件的元素。这相当与select * from xxx where con。例如我们要获取salary > 10000的Employee对象。
|
List<Employee> list = new ArrayList<Employee>(); list.add(new Employee("zhangSan", 10000)); list.add(new Employee("liSi", 11000)); list.add(new Employee("wangWu", 12000)); cxt.put("empList", list); List<Employee> empList = (List<Employee>) Ognl.getValue( "#empList.{?salary > 10000}", cxt, cxt.getRoot()); System.out.println(empList); |
其中“{?salary > 10000}”中的“?”表示所有满足条件的元素都查询出来。还可以使用“^”或“$”，其中“^”表示查询第一个满足条件的元素，而“$”表示查询最后一个满足条件的元素。
二．值栈 ValueStack
通过几个问题来了解值栈----
问题一 ： 什么是值栈 ValueStack ?
*Struts2框架是我们ActionContext中设置的OGNL上下文，ValueStack是OGNL的根对象。（值栈是一组多个对象，但OGNL原来是一个单独的对象）。
*ValueStack 是 struts2 提供一个接口，实现类 OgnlValueStack ----值栈对象（OGNL是从值栈中获取数据的 ）
*每个Action实例都有一个ValueStack对象,一个请求对应一个ValueStack对象,保存当前Action对象和其他相关对象（值栈中是有Action引用的 ）
*Struts 框架把 ValueStack对象保存在名为“struts.valueStack”的请求属性中,request中 （值栈对象是 request一个属性）
valueStack vs = request.getAttribute("struts.valueStack");
问题二 ： 值栈的内部结构 ？
值栈由两部分组成
root (CompoundRoot): Struts 把动作和相关对象压入 ObjectStack 中--List
Context (OgnlContext): Struts 把各种各样的映射关系(一些 Map 类型的对象) 压入 ContextMap 中
Struts 会把下面这些映射压入 ContextMap 中
parameters: 该 Map 中包含当前请求的请求参数
request: 该 Map 中包含当前 request 对象中的所有属性
session: 该 Map 中包含当前 session 对象中的所有属性
application:该 Map 中包含当前 application 对象中的所有属性
attr: 该 Map 按如下顺序来检索某个属性: request, session, application
问题三 ： 值栈对象的创建 ，ValueStack 和 ActionContext 是什么关系 ？
值栈对象是请求时创建的
doFilter中 prepare.createActionContext(request, response);
* 创建ActionContext 对象过程中，创建 值栈对象ValueStack
* ActionContext对象 对 ValueStack对象 有引用的 （在程序中 通过 ActionContext 获得 值栈对象 ）
Dispatcher类 serviceAction 方法中 将值栈对象保存到 request范围
request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());(struts2源码)
获得值栈对象 有两种方法
ValueStack valueStack = (ValueStack) ServletActionContext.getRequest().getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
ValueStack valueStack2 = ActionContext.getContext().getValueStack();
关系图：
其实OgnlContext并不是ActonContext，而是ActionContext中包含了OgnlContext对象。ValueStatck也不是root对象，而是内部有root对象。其实在ActionContext中包含的OgnlContext对象，在ValueStack中也有OgnlContext的引用。
问题五：值栈应用（主要针对root）
1.存取数据，在JSP中获取值栈的数据
访问root中数据 不需要#
访问 其它对象数据 加 #
2.valueStack对象 保存在request范围， 值栈生命周期 就是 request的生命周期 ，值栈的内部结构（root、ognlContext）、获取值栈对象、向值栈保存数据、在JSP显示值栈的内容
3、 值栈在开发中应用
主流应用 ： 值栈 解决 Action 向 JSP 传递 数据问题
哪些数据默认会放入到值栈 ？
1）每次请求，访问Action对象 会被压入值栈 ------- DefaultActionInvocation 的 init方法 stack.push(action);
* Action如果想传递数据给 JSP，只有将数据保存到成员变量，并且提供get方法就可以了
2）ModelDriven 接口 有一个单独拦截器
<interceptor name="modelDriven" class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/>
在拦截器中 ，将model对象 压入了 值栈 stack.push(model);
* 如果Action 实现ModelDriven接口，值栈默认栈顶对象 就是model对象
4、 值栈的数据 通过EL访问
StrutsPreparedAndExecuteFilter的doFilter代码中 request = prepare.wrapRequest(request);
* 对Request对象进行了包装 ，StrutsRequestWrapper
* 重写request的 getAttribute
<源码分析>
Object attribute = super.getAttribute(s);
if (attribute == null) {
attribute = stack.findValue(s);
}
访问request范围的数据时，如果数据找不到，去值栈中找
* request对象 具备访问值栈数据的能力 （查找root的数据）
l 使用<s:property>标签可以执行OGNL表达式，例如：<s:property value=”name”/>；
l 当OGNL访问的是根对象时（例如OGNL表达式name），Struts2会把ValueStack中每个元素当成根对象，从栈顶依次向下查找，直到找到某个元素有name属性。
Struts2中有很多标签都支持OGNL表达式，我们也知道OGNL表达式访问的数据是在OgnlContext中。在Struts2中上下文对象就是ActionContext，其中根对象就是ValueStack。
例如<s:property value=”name”/>这个标签的value属性值name就必须是一个OGNL表达式。我们知道，没有使用“#”为前缀的OGNL表达式表示是在获取根对象的name属性值，但在Struts2中根对象是ValueStack，它不是一个对象，而是一组对象，一个栈！Struts2的根对象特殊之处是，它会在ValueStack中从栈顶开始，直接到栈尾遍历每个栈中的对象，查看是否有name属性，如果找到栈中某个对象存在name属性，那么就不会再向下去找！也就是说，如果栈顶元素就有name属性，那么就算第二个元素也有name属性，那么输出的也是栈顶元素的name属性值。
前面我们也说过了，当访问一个Action后，Struts2会把当前Action对象压入到值栈中，即栈顶位置上（当然我们也可以调用ValueStack的push()方法来向其压入对象）。然后在Action跳转的JSP页面中使用<s:property>标签来获取值栈中元素的属性值。
我们知道，还可以通过OGNL表达式访问上下文中其他的对象，但这需要以“#”为前缀。例如可以访问parameters、request、session、application、attr这些Map对象。
|
<s:property value="#parameters.password"/><br/> <s:property value="#request.hello"/><br/> |
在ActionContext中存放着很多个Map：
|
key |
value |
|
request |
Map类型，对应request中的属性，但它不是request对象本身 |
|
session |
Map类型，对应session中的属性 |
|
application |
Map类型，对应application中的属性 |
|
parameters |
Map类型，对应request中请求参数 |
|
attr |
Map类型，对应所有域对象，依次查找。 |
#request表示一个Map，而#request.hello表示获取#request这个Map中key为hello的值。当然，如果你只有request.setAttribute(“hello”, “xxx”)过，才能获取到值。
[N]语法用来获取子栈，例如[3]表示截取从下标3位置开始到栈底的一个子栈。例如[3].name表示从[3]子栈中查找每个元素是否存在name属性，如果下标3元素就存在name属性，那么直接返回即可。
例如我们向ValueStack中压入两个对象：
|
public class OgnlDemo1Action extends ActionSupport { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String execute() throws Exception { Emp emp = new Emp(); emp.setName("emp_zhangSan"); Student stu = new Student(); stu.setName("stu_liSi");
ValueStack vs = ActionContext.getContext().getValueStack(); vs.push(emp); vs.push(stu); return SUCCESS; } } |
|
<s:property value="[0].name"/><br/> <s:property value="[1].name"/><br/> <s:property value="[2].name"/><br/> |
千万注意，[1]不是表示下标1的元素，而是一个子栈。
top语法用来获取栈顶元素本身。例如还是上面的例子，值栈中从上到下依次是Student、Emp、Action三个对象，那么top表示的就是Student对象本身。而[1].top表示获取[1]子栈的栈顶元素，即Emp对象。
|
<s:property value="[0].top"/><br/> <s:property value="[1].top"/><br/> <s:property value="[2].top"/><br/> |
我们知道OGNL可以访问类的静态方法和属性，但在Struts2中默认是不允许OGNL访问静态成员的，如果想访问类的静态成员，需要设置一个常量：struts.ognl.allowStaticMethodAccess，该常量默认值为false，我们需要把它设置为true，这样就可以访问静态成员了。
|
<constant name="struts.ognl.allowStaticMethodAccess" value="true"/> |
|
<s:property value="@@min(10,20)"/><br/> |
除了使用标准的OGNL表达式访问静态属性和静态方法外，Struts2还允许你不指定完整的类名，而是通过“vs”前缀来调用保存在值栈中对象的静态属性和静态方法。
例如：@vs@hello()，表示调用栈顶元素的静态方法hello()，如果栈顶元素是MyAction类型的对象，那么@vs@hello()就表示MyAction.hello()！
还可以指定值栈中元素序号来调用静态成员，例如@vs1@hello()表示调用的是值栈中第一个元素的静态方法，其实它与@vs@hello()是相同的。因为不存在@vs0@，序号是从1开始的。@vs2@hello()表示调用值栈中第2个元素的静态方法hello()。
我们知道，Struts2会把当前Action对象压入到值栈中，所以我们在JSP页面中总是可以直接使用OGNL来访问Action元素的属性：<s:property value=”username”/>，如果我们没有自己向值栈中压入其他元素，那么Action就是栈顶元素了，所以上面的标签输出的就是当前Action的username属性值。
当Action使用模型驱动时，ModelDrivenInterceptor拦截器会把当前model对象压入值栈，这时值栈中model对象就是栈顶元素，所以<s:property value=”username”/>访问的是model对象的username属性。
让人感到奇怪的是，可以通过EL表达式访问到值栈。例如在JSP页面中使用${name}，但在域对象中没有name这个域属性，奇怪的是它会去到值栈中找到元素的name属性值。
这是因为Struts2对request对象进行了装饰，这个装饰类是StrutsRequestWrapper，它对getAttribute()方法进行了增强，它会先到域对象中查找名为name的属性值，但如果没有找到它会去到ValueStack中去找，所以EL才会有这个本事。
在Struts2的标签中，有些标签可以直接使用OGNL表达式，但有些是不能直接使用的。例如我们使用过的<s:property>标签的value属性就是默认为OGNL表达式的。但<s:url>标签的action属性默认是字符串，而不是OGNL表达式。例如<s:url action=”demo1”/>会在页面中输出/day03/damo1.action。如果你想在<s:url>标签的action属性中使用OGNL，那么需要使用%{}，这样Struts2就知道你给出的值是一个OGNL表达式了，例如：<s:url action=”%{#request.url}”/>，其中#request.url会被Struts2当做OGNL表达式来解析！
当然，你也可以在<s:property>标签的value属性中使用%{}，但对于默认就是OGNL表达式的属性而言，添加%{}是没有意义的：<s:property value=”%{name}”/>
对于OGNL表达式中的“#”，表示的是访问上下文中的非root对象时需要使用以“#”开头。这个应该没什么问题吧。
${}是在国际化资源文件中用来使用OGNL表达式用的，${}还可以在struts.xml文件用来使用OGNL表达式。
例如在res.properties文件中：msg：我的名称叫${#request.name}，然后在Action或JSP中就可以使用它了。
<s:i18n name="res">
<s:text name="msg"></s:text>
</s:i18n>
例如在struts.xml文件中使用：
<result type=”stream”>
<param name=”contentType”>${type}</param>
</result>
其中${type}表示OGNL表达式，即调用当前Action的getType()方法（因为Action在值栈的栈顶位置）。
1． 一般性数据传递
每个Action都有自己保存信息的地方，这是从ActionSupport类继承而来的！
l ActionSupport#addFieldError(“字段名”, “字段错误信息内容”)：它会把信息添加到Map<String,List>中；
l ActionSupport#addActionError(“Action错误信息内容”)：它会把信息添加到Collection<String>中；
l ActionSupport#addActionMessage(“Action通知信息内容”)：它会把信息添加到Collection<String>中。
因为Action会被压入到值栈中，所以在页面中Struts2的标签就可以来获取这些信息了。
l <s:fielderror fieldame=”字段名”/>：打印指定字段的所有错误信息；
l <s:actionerror/>：打印Action错误信息；
l <s:actioinmessage/>：打印Action通知信息。
2. 复杂数据传递
也可以把复杂类型的数据通过压入值栈来向页面传递：
valueStack.push(new User(“zhangSan”, “123”));
在页面中可以使用Struts2标签来获取值栈的内容：
<s:property value=”username”/>
<s:property value=”password”/>
Struts2为开发人员提供了一个标签：<s:debug/>，它会在页面中生成一个超链接，点击链接会在页面中显示ValueStack的内部数据。
打开struts-2.3.7\docs\WW\tag-reference.html可以看到Struts2提供的所有标签。其中分为“通用标签”和“UI标签”两大部分。我们不可能把所有标签都介绍到，我们只会介绍其中比较有用的几个标签介绍一下。
l <s:property>（重要）
<s:property>标签用来执行OGNL表达式，最为常用的方式是使用它在页面中输出ValueStack或ActionContext中的数据。
<s:property value=”#request.hello”/>，等于ActionContext.getContext().getRequest().get(“hello”)。
|
名称 |
必需 |
默认值 |
类型 |
说明 |
|
default |
否 |
无 |
String |
表示默认值。当结果为null时，输出默认值。 |
|
escape |
否 |
true |
boolean |
表示是否进行转义。该值为true时，当结果中包含<、>、”、’、&时，对其进行转义。 |
|
value |
否 |
栈顶对象 |
Object |
Ognl表达式 |
l <s:set>
<s:set>标签用来创建一个变量，保存到指定的范围内。
<s:set var=”myVar” value=”#parameters.score[0]” scope=”page”/>，创建一个变量，保存到page范围，key为myVar，值为“#parameters.score[0]”的运算结果。
|
名称 |
必需 |
默认值 |
类型 |
说明 |
|
var |
是 |
无 |
String |
变量的域名字，默认不是Ognl表达式 |
|
value |
否 |
栈顶对象 |
Object |
Ognl表达式。 |
|
scope |
否 |
Action |
String |
变量的范围。可选值为：application、session、request、page、action |
scope的可选值中的action是我们陌生的范围，它是scope的默认值。它表示保存到request和OgnlContext两个范围中。即比request范围多出了一个OgnlContext范围。
<s:set var=”myVar” value=”#parameters.score[0]” />
<s:property value=”#myVar”/>等同于ActionContext.getContext().get(“myVar”);
<s:property value=”#request.myVar”/>等同于ActionContext.getContext.getReuqest().get(“myVar”);
l <s:push>
<s:push>标签是把指定值暂时压入到值栈中，当执行完<s:push>标签后，压入到值栈中的值会被弹出。
<s:push value=”’hello’”/>等于把hello字符串压入到值栈中后，马上又弹出了，相当于什么都没做。
<s:push value=”#session.user”>把user压入到值栈中
<s:property value=”username”/>打印值栈元素的username属性
<s:property value=”password”/>打印值栈元素的password属性
</s:push>把user从值栈中弹出
l <s:url>
<s:url>标签通常用来生成action路径，它与<c:url>标签很相似。
<s:url action=”TestAction”/>在页面中打印/contextpath/TestAction.action。也就是说它与<c:url>一样会生成全路径。而且无论给出后缀“.action”！action属性的值只需要与struts.xml文件中<action>元素的name属性值相同即可。
<s:url action=”TestAction” namspace=”/” />还可以指定名称空间
<s:url action=”TestAction”>
<s:param name=”name” value=”’张三’”/>
</s:url>
页面中打印为：/ognl/TestAction.action?name=%E5%BC%A0%E4%B8%89
还可以为URL指定参数，其中参数包含中文时自动使用URL编码。
其中<s:param>是用来作为子标签的，它的作用是指定参数。它的value属性值为Ognl表达式，所以我们需要把“张三”用单引号引起来，表示Ognl表达式的字符串常量。
|
名称 |
必需 |
默认值 |
类型 |
说明 |
|
action |
否 |
无 |
String |
指定用于生成URL的action。 |
|
value |
否 |
无 |
String |
指定用于生成URL的地址值。通常只使用action或value其中一个属性。 |
|
var |
否 |
无 |
String |
如果指定了该属性，那么生成的URL不会输出到页面中，而是被保存到OgnlContext中。 |
|
method |
否 |
无 |
String |
指定调用action中的方法。如果使用的是value属性，那么该属性无效。 |
|
namespace |
否 |
无 |
String |
指定action所属的名称空间。 |
|
forceAddSchemeHostAndPort |
否 |
false |
Boolean |
当该属性为true时，生成的URL为绝对路径，而且会包含主机名及端口号。 |
l <s:a>
它用来生成超链接，与<s:url>相似！
<s:a action=”TestAction” namespace=”/”>添加用户
<s:param name=”name” value=”’张三’”/>
</s:a>
l <s:debug>
Debug标签用于调试，它在页面中生成一个“[Debug]”超链接，单击这个超链接，可以查看ValueStack和ActionContext中保存的所有对象。
控制标签很好理解，就是流程控制了。例如if、elseif等，以及iterator等。
l <s:if>、<s:elseif>、<s:else>
这种标签大家应该一看就会用了。我们直接给出个小例子看看。
|
<!— 在浏览器中输入：http://localhost:8080/tagtest/index.jsp?score=85 -->
<s:set name="score" value="#parameters.score[0]"/> <s:property value="#score"/>: <s:if test="#score > 100 || #score < 0"> <s:property value="‘输入错误‘"/> </s:if> <s:elseif test="#score >= 90"> <s:property value="‘A‘" /> </s:elseif> <s:elseif test="#score >= 80"> <s:property value="‘B‘" /> </s:elseif> <s:elseif test="#score >= 70"> <s:property value="‘C‘" /> </s:elseif> <s:elseif test="#score >= 60"> <s:property value="‘D‘" /> </s:elseif> <s:else> <s:property value="‘E‘"/> </s:else> |
l <s:iterator>
<s:iterator>标签可以用来迭代一个集合，可以迭代的集合有：Collection、Map、Enumeration、Iterator或者是数组。iterator标签在迭代过程中，会把当前对象暂时压入值栈，这样在子标签中就可以直接访问当前对象的属性（因为当前对象在栈顶），在标签体执行完毕后，位于栈顶的对象就会被删除，在循环的第二圈时，把新的当前对象再压入值栈中。
|
<s:iterator value="{‘zhangSan‘,‘liSi‘,‘wangWu‘ }"> name: <s:property/><br/> </s:iterator> |
如果为<s:iterator>标签指定了var属性，那么当前对象不只是压入到了值栈中，而且还会被添加到OgnlContext中。
|
<s:iterator value="{‘zhangSan‘,‘liSi‘,‘wangWu‘ }" var="name"> name: <s:property value="#name"/><br/> </s:iterator> |
|
名称 |
必需 |
默认值 |
类型 |
说明 |
|
var |
否 |
无 |
String |
如果指定了该属性，那么迭代的集合中的元素将被保存到OgnlContext中，可以通过该属性的值来引用集合中的元素。该属性几乎不被使用。 |
|
value |
否 |
无 |
Coolection、Map、Enumeration、Iterator 或数组 |
指定迭代的集合。如果没有指定该属性，那么iterator标签将把位于值栈栈顶的对象放入一个新创建的List中进行迭代。 |
|
status |
否 |
无 |
String |
如果指定了该属性，一个IteratorStatus实例将被放入到OgnlContext中，通过该实例可以获取迭代过程中的一些状态信息。 |
IteratorStatus类在org.apahce.struts2.views.jsp包下。下面是对该类常用方法的介绍：
l public int getCount()：得到当前已经迭代的元素的总数。
l public int getIndex()：得到当前迭代的元素的索引。
l public boolean isEven()：判断当前迭代的元素的个数是否是偶数。
l public boolean isOdd()：判断当前迭代的元素的个数是否是奇数。
l public boolean isFirest()：判断当前迭代的元素是否是第一个元素。
l public boolean isLast()：判断当前迭代的元素是否是最后一个元素。
在OGNL表达式中使用IteratorStatus类的方法时，可以直接使用：count、index、even、odd、first、last属性。
|
<s:iterator value=‘{"one", "two", "three"}‘ status="status"> <s:property value="#status.count"/>, <s:property value="#status.index"/>, <s:property value="#status.even"/>, <s:property value="#status.odd"/>, <s:property value="#status.first"/>, <s:property value="#status.last"/><br/> </s:iterator> <hr/> <s:iterator value="#{‘1‘:‘one‘,‘2‘:‘two‘,‘3‘:‘three‘,‘4‘:‘four‘}" status="st"> <s:property value="key"/>:<s:property value="value"/><br/> </s:iterator> |
Struts2的表单标签还是比较好用的，但它也存在一些败笔，例如主题这一部分就不是很灵活。所以导致开发中没有公司会使用它提供的主题。
Struts2标签的优势：
l 简化代码；
l 自动数据回显；
l 指定主题样式（说是优点，但很多人也会认为这是缺点）；
我们首先使用一个登录表单来对比一下html表单和Struts2表单的区别。
|
<form action="<c:url value=‘/user/LoginAction.action‘/>" method="post"> 用户名 <input type="text" name="username"/><br/> 密 码 <input type="password" name="password"/><br/> <input type="submit" value="登录"/> </form> <hr/> <s:form action="LoginAction" namespace="/user"> <s:textfield name="username" label="用户名" /> <s:password name="password" label="密 码" /> <s:submit value="登录" /> </s:form> |
|
|
|
<form action="/ognl/user/LoginAction.action" method="post"> 用户名 <input type="text" name="username"/><br/> 密 码 <input type="password" name="password"/><br/> <input type="submit" value="登录"/> </form>
<hr/>
<form id="LoginAction" name="LoginAction" action="/ognl/user/LoginAction.action" method="post"> <table class="wwFormTable"> <tr> <td class="tdLabel"><label for="LoginAction_username" class="label">用户名:</label></td> <td ><input type="text" name="username" value="" id="LoginAction_username"/></td> </tr>
<tr> <td class="tdLabel"><label for="LoginAction_password" class="label">密 码:</label></td> <td ><input type="password" name="password" id="LoginAction_password"/></td> </tr> <tr> <td colspan="2"><div align="right"><input type="submit" id="LoginAction_0" value="登录"/> </div></td> </tr> </table></form> |
通过上面生成的代码可以看来：
l <s:form>
l <s:textfield>
l <s:password>
l <s:submit>
我们发现，整个表单都会在<table>中生成，这也就说明无需为每个表单项添加<br/>。因为在表格中就无需再换行了。
生成在表格中是因为<s:form>标签的theme属性的默认值为xhtml，它表示一个主题样式。这个主题样式由Freemarker模板来完成。如果你不希望使用这个xhtml主题，那么有下列3种方法来修改主题：
l 在<s:textfield>的theme属性指定为simple，那么这个表单项就使用简单主题；
l 在<s:form>的theme属性指定为simple，那么整个表单都使用简单主题；
l 设置struts.ui.theme常量为simple，那么所有表单标签的默认主题都是simple。
当表单设置为theme=”simple”之后：
|
<s:form action="LoginAction" namespace="/user" theme="simple"> <s:textfield name="username" label="用户名" /> <s:password name="password" label="密 码" /> <s:submit value="登录" /> </s:form> |
|
|
<form id="LoginAction" name="LoginAction" action="/ognl/user/LoginAction.action" method="post"> <input type="text" name="username" value="" id="LoginAction_username"/> <input type="password" name="password" id="LoginAction_password"/> <input type="submit" id="LoginAction_0" value="登录"/> </form> |
这时没有表格来格式化表单，而且也不能生成<lable>，这说明样式都要自来来设定。好处是你重新获得了自由，坏处是一切都要靠自己了。
我们知道，当表单提交后，再返回到表单页面后，html标签不可能帮我们回显数据。而Struts2的表单标签可以做到这一点。原因是当前Action就在值栈顶，而表单标签会从值栈中获取数据来回显。
表单标签中简化比较大的标签可以不在需要写循环，还有就是自动回显。我们都知道在下拉列表、单选、复选中，手动回显是比较麻烦的事。但使用Struts2的表单标签就方便多了。
|
<s:radio list="#{‘male‘:‘男‘,‘female‘:‘女‘}" name="gender"/> |
|
|
list指定的是一个Map，默认key为实际值，而value为显示值。
也可以为list属性指定为list：
|
<s:radio list="{‘男‘,‘女‘}" name="gender"/> |
这时实际值和显示值是相同的。
这个东西也很好用，一下子可以显示很多复选按钮。而且自动回显！
|
<s:checkboxlist list="#{‘read‘:‘看书‘,‘netplay‘:‘上网‘,‘music‘:‘音乐‘ }" name="hobby"/> |
|
|
下拉列表与上面两个标签也一样，都是选择性的！使用它也是无需循环，无需处理循环。
|
<s:select name="city" list="#{‘bj‘:‘北京‘,‘sh‘:‘上海‘,‘gz‘:‘广州‘}"/> |
|
|
当用户提供一个表单后，然后使用浏览器后退后，再次提交表单！
表单重复提交 危害： 刷票、 重复注册、带来服务器访问压力（拒绝服务）如何重复提交：
l 转发到Action，这时地址栏中的地址是指向Action的，所以可以刷新页面来重复提交；
l 通过浏览器后退回表单页面，再次提交；
l 因为服务器很慢，在点击了提交后，页面还没有变化时，再次点击提交。
防止表单重复提交的原理就是使用令牌机制！所谓令牌机制就是在请求到达表单页面时，页面会生成令牌值（UUID），然后保存到session和表单的<input type=”hidden”>中。
然后用户提交表单后，令牌值会发送给Action。这时Action获取session中的令牌值与请求参数中的令牌值进行比较，如果相同，说明这是正常提交，Action会执行操作，然后把session中的令牌值删除。
当用户后退后，再次提交时，因为没有再次访问表单页面，那么就不会生成新的令牌值，所以参数中的令牌值还是上一次的，而session中已经没有令牌值了，所以Action会判断为重复提交。
防止重复提交需要在页面中生成令牌值，然后在表单和session中分别保存，这个任务可以使用Struts2的标签：<s:token/>来未完成。这个标签会生成令牌值，并保存到session和表单的隐藏字段中。
在Action中获取session和请求参数中的令牌值进行比较，然后在令牌值无误时，在session中删除令牌值；在令牌值不同时转发到invalid.token结果。这些任务由token拦截器来完成。
<s:token>标签和token拦截器来完成防止表单重复提交。
当token拦截器确定当前是重复提交后，会跳转到invalid.token结果，这说明我们需要在指定名为invlalid.token的结果。而且token拦截器还会在actionError中添加错误信息。
|
<s:form action="tokenTest" namespace="/"> <s:token /> <s:submit value="呵呵" /> </s:form> |
|
public class TokenAction extends ActionSupport { @Override public String execute() throws Exception { System.out.println("execute()..."); return NONE; } } |
|
<action name="tokenTest" class="cn.itcast.action.TokenAction"> <result name="invalid.token">/error.jsp</result> <interceptor-ref name="defaultStack" /> <interceptor-ref name="token" /> </action> |
|
<body> <s:actionerror/> </body> |
|
|
我们可以通过查看TokenInterceptor，知道这条错误令牌的key值是struts.messages.invalid.token，所以我们可以在国际化资源文件中覆盖这个key值。
标签：
原文地址：http://www.cnblogs.com/lulu638/p/4322003.html
