struts2 Advanced Learning
catalog
0. 引言 1. struts2的类型转换 2. struts2的输入校验 3. struts2的拦截器机制 4. 使用struts2的Ajax支持 5. struts2 OGNL表达式 6. struts2的文件上传 7. Struts2标签库
0. 引言
1. 与所有MVC框架类似，struts2也提供了类型转换和输入校验支持 2. struts2提供了非常强大的类型转换支持，它既提供了大量内建类型转换器，用以满足常规的Web开发，也允许开发者实现自己的类型转换器 3. struts提供了非常强大的输入检验功能，开发者既可以通过XML文件来配置校验规则，也可以通过重写validate()方法来进行更复杂的校验 4. struts2拦截器机制是struts2框架的灵魂，拦截器完成了struts2框架的绝大部分功能 5. struts2致力于成为一个完备的MVC框架，因此整合了Dojo库 6. struts2框架提供了简单、易用的上传、下载支持
0x1: Action
HelloWorld.jsp
<%-- Created by IntelliJ IDEA. User: zhenghan.zh Date: 2016/3/18 Time: 16:44 To change this template use File | Settings | File Templates. --%> <%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@ taglib prefix="s" uri="/struts-tags" %> <html> <head> <title></title> </head> <body> <h2><s:property value ="message" /> </body> </html>
classes/tutorial/HelloWorld.java
/** * Created by zhenghan.zh on 2016/3/18. */ package tutorial; import java.text.DateFormat; import java.util.Date; import com.opensymphony.xwork2.ActionSupport; public class HelloWorld extends ActionSupport { private String message; public String getMessage() { return message; } @Override public String execute() { message = " Hello World, Now is " + DateFormat.getInstance().format( new Date()); return SUCCESS; } }
classes/struts.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <package name="ActionDemo" extends ="struts-default" > <action name ="HelloWorld" class ="tutorial.HelloWorld" > <result name="success">/HelloWorld.jsp</result> </action> </package> </struts>
http://localhost:8080/s2-029/HelloWorld.action?
strut2是一种MVC的WEB架构，通过浏览器访问时指定的是C(control层)的映射，strut2在C层中进行逻辑处理后，将结果传递到View层进行展示(并返回处理结果状态码)
Relevant Link:
《轻量级Java_EE企业应用实战_struts2+Spring3+Hibernate整合开发》 http://blog.chinaunix.net/uid-7602921-id-2048554.html http://blog.csdn.net/gaopu12345/article/details/47024555 http://blog.csdn.net/ldl420783321/article/details/7546607
1. struts2的类型转换
所有的MVC框架，都需要负责解析HTTP请求参数，并将请求参数传给控制器组件，但是HTTP请求参数都是字符串类型，但java是强类型语言，因此MVC框架必须将这些字符串参数转换成相应的数据类型
struts2提供了非常强大的类型转换机制，struts2的类型转换可以基于OGNL表达式，只要我们把HTTP参数(表单元素、GET/POST参数)命名为合法的OGNL表达式，就可以充分利用struts2的类型转换机制
除此之外，struts2提供了很好的扩展性，开发者可以开发自己的类型转换器，完成字符串和自定义复合类型之间的转换(例如完成字符串到Person实例的转换)，如果类型转换中出现未知异常，类型转换器开发者无须关心异常处理逻辑，struts2的conversionError拦截器会自动处理该异常，并且哎页面上生成提示信息。struts2的类型转换器提供了非常强大的表现层数据处理机制，开发者可以利用struts2的类型转换机制来完成任意的类型转换
表现层另一个数据处理是数据校验，数据校验可以分为客户端校验和服务端校验两种
1. 客户端校验: 进行基本校验，如检验非空字段是否为空，数字格式是否正确等等，客户端校验主要用来过滤用户的误操作 2. 服务端校验: 防止非法数据进入程序，导致程序异常、底层数据库异常，保证程序有效运行及数据完整性的手段
0x1: struts2内建的类型转换器
对于大部分的常用类型，struts2可以完成大多数常用的类型转换，这些常用的类型转换是通过struts2内建的类型转换器完成的
1. boolean/Boolean: 字符串和布尔值之间的转换 2. char/Character: 字符串和字符之间的转换 3. int/Integer: 字符串和整型值之间的转换 4. long/Long: 字符串和长整型之间的转换 5. double/Double: 字符串和双精度浮点值之间的转换 6. Date: 字符串和日期之间的转换 7. 数组: 在默认情况下，数组元素是字符串，如果用户提供了自定义类型转换器，也可以是其他复合类型的数组 8. 集合: 在默认情况下，假定集合元素类型为String，并创建一个新的ArrayList封装所有的字符串 //对于数组的类型转换将按照数组元素的类型来单独转换每一个元素，但如果数组元素的类型转换本身无法完成，系统将出现类型转换错误
0x2: 基于OGNL的类型转换
借助于内置的类型转换器，struts2可以完成字符串和基本类型之间的类型转换，除此之外，借助于OGNL表达式的支持，struts2允许以另一种简单方式将请求参数转换成复合类型
package crazyit; import com.opensymphony.xwork2.ActionSupport; public class LoginAction extends ActionSupport { private User user; //user属性的setter和getter方法 public void setUser(User user) { this.user = user; } public User getUser() { return (this.user); } public String execute() throws Exception { if(getUser().getName().equalsIgnoreCase("LittleHann" ) && getUser().getPassword().equalsIgnoreCase("111") ) { return SUCCESS; } else { return ERROR; } } }
User.java
package crazyit; public class User { private String name; private String password; public void setName(String name) { this.name = name; } public String getName() { return this.name; } public void setPassword(String password) { this.password = password; } public String getPassword() { return this.password; } }
该Action里包含了一个User类型的属性，这个属性需要进行类型转换，struts2框架接收到HTTP请求参数后，需要将这些请求参数封装成User对象
但struts2提供的OGNL表达式允许开发者无须任何特殊处理，只需在定义表单域时使用OGNL表达式来定义表单域的name属性，struts2会在底层完成复合类型的映射
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h1>Hello World From Struts2</h1> <form action="login"> <s:textfield name="user.name" label="username"/> <s:textfield name="user.password" label="password"/> <tr> <td colspan="2"> <s:submit value="transfer" theme="simple"/> <s:reset value="reset" theme="simple"/> </td> </tr> </form> </body> </html>
表单中的文本框对应两个请求参数: user.name、user.password，这就是OGNL表达式的形式，struts2会自动对OGNL请求参数作逐级切分，赋值对应对象的属性
通过这种方式，struts2可以将普通请求参数转换成复合类型对象，但有几点需要注意
1. 因为struts2将通过反射来创建一个复合类(User类)的实例，因此系统必须为该复合类提供无参数的构造器 2. 如果希望使用user.name请求参数的形式为Action实例的user属性的user属性赋值，则必须为user属性对应的复合类(User类)提供setName()方法，因为struts2是通过调用该方法来为该属性赋值的
更进一步，我们甚至可以直接生成Collection，或者Map实例
package crazyit; import java.util.Map; import com.opensymphony.xwork2.Action; import com.opensymphony.xwork2.ActionSupport; public class LoginAction implements Action { //Action类里包含一个Map类型的参数 //Map的value类型为User类型 private Map<String, User> users; //user属性的setter和getter方法 public void setUsers(Map<String, User> users) { this.users = users; } public Map<String, User> getUsers() { return this.users; } public String execute() throws Exception { System.out.println(getUsers()); if(getUsers().get("one").getName().equalsIgnoreCase("LittleHann" ) && getUsers().get("one").getPassword().equalsIgnoreCase("111") ) { return SUCCESS; } else { return ERROR; } } }
上面的Action中定义了一个users属性，该属性的类型为Map<String, User>，只要在定义表单域的name属性时使用OGNL表达式语法，struts2一样可以将请求参数直接封装成这种user属性
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h1>Hello World From Struts2</h1> <form action="login"> <s:textfield name="users['one'].name" label="the one user usrename"/> <s:textfield name="users['one'].password" label="the one user password"/> <s:textfield name="users['two'].name" label="the two user usrename"/> <s:textfield name="users['two'].password" label="the two user password"/> <tr> <td colspan="2"> <s:submit value="transfer" theme="simple"/> <s:reset value="reset" theme="simple"/> </td> </tr> </form> </body> </html>
通过这种方式，struts2可以将HTTP请求转换成Map属性
类似地，如果我们需要访问Action的Map类型的属性，也可以使用OGNL表达式
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> the one user usrename: <s:property value="users['one'].name"/><br/> the one user password: <s:property value="users['one'].password"/><br/> the two user usrename: <s:property value="users['two'].name"/><br/> the two user password: <s:property value="users['two'].password"/><br/> </body> </html>
如果把LoginAction中的user属性改为List<User>，也就是需要struts2将用户请求封装成List属性，同样可以利用OGNL表达式实现，我们通过索引来指定要将请求转换成List的哪个元素
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h1>Hello World From Struts2</h1> <form action="login"> <s:textfield name="users[0].name" label="the one user usrename"/> <s:textfield name="users[0].password" label="the one user password"/> <s:textfield name="users[1].name" label="the two user usrename"/> <s:textfield name="users[1].password" label="the two user password"/> <tr> <td colspan="2"> <s:submit value="transfer" theme="simple"/> <s:reset value="reset" theme="simple"/> </td> </tr> </form> </body> </html>
0x3: 指定集合元素的类型
前面我们使用集合时使用了泛型，这种泛型可以让struts2了解集合元素的类型，struts2就可以通过反射来创建对应类的对象，并将这些对象添加到List中
但是如果不使用泛型，struts2就不知道使用类型转换器来处理该users属性，因此，开发者需要通过"局部类型转换文件"来指定集合元素的类型，类型转换文件就是一个普通的Properties(*.properties)文件，类型转换文件里提供了类型转换的相关配置信息
package crazyit; import java.util.List; import java.util.Map; import com.opensymphony.xwork2.Action; import com.opensymphony.xwork2.ActionSupport; public class LoginAction implements Action { private List users; //user属性的setter和getter方法 public void setUsers(List users) { this.users = users; } public List getUsers() { return this.users; } public String execute() throws Exception { System.out.println(getUsers()); //因为没有使用泛型，所以要进行强制类型转换 User firstUser = (User)getUsers().get(0); if(firstUser.getName().equalsIgnoreCase("LittleHann" ) && firstUser.getPassword().equalsIgnoreCase("111") ) { return SUCCESS; } else { return ERROR; } } }
如果仅仅通过上面Action类的代码，struts2无法知道该Action的users属性里集合元素的类型，所以我们要通过局部类型文件来指定集合元素的类型
文件名为ActionName-conversion.properties形式，类型转换文件应该放在和Action类文件相同的位置
为了指定List集合里元素的数据类型，需要指定两个部分
1. List集合属性的名称 2. List集合里元素的类型
通过在局部类型转换文件中指定如下key-value对即可
Element_<ListPropName>=<ElementType> //ListPropName替换成List集合属性的名称、ElementType替换成集合元素的类型即可，例如 Element_users=crazyit.User
增加上面的局部类型转换文件后，系统将可以识别到users集合属性的集合元素是crazyit.User类型，因此struts2的类型转换器可以正常工作
总结一下，为了能让struts2能了解集合属性中元素的类型，可以使用如下两种方式
1. 通过为集合属性指定泛型 2. 通过在Actino的局部类型转换文件中指定集合元素类型
0x4: 自定义类型转换器
大部分时候，我们使用struts2提供的类型转换器，以及基于OGNL的类型转换机制，就能满足大部分类型转换需求，但是在有些特殊的情况下，例如需要把一个字符串转换成一个复合对象时，这就需要使用自定义类型转换器
package crazyit; import java.util.List; import com.opensymphony.xwork2.Action; public class LoginAction implements Action { private User user; //user属性的setter和getter方法 public void setUser(User user) { this.user = user; } public User getUser() { return this.user; } public String execute() throws Exception { if(getUser().getName().equalsIgnoreCase("LittleHann" ) && getUser().getPassword().equalsIgnoreCase("111") ) { return SUCCESS; } else { return ERROR; } } }
从上面的代码中可以看出，该Action的user属性是User类型，而对应表单页发送的user请求参数则只能是字符串类型，struts2不知道如何完成字符串和User对象之间的转换，这种转换需要"自定义类型转换器"来完成
User类就似乎一个普通的JavaBean类
struts2的类型转换实际上依然是基于OGNL框架的，在OGNL项目中有一个TypeConverter接口，这个接口就是自定义类型转换器必须实现的接口
//OGNL提供的类型转换器接口 public interface TypeConverter { public Object converterValue(Map context, Object target, Member member, String propertyName, Object value, Class toType); }
实现类型转换器必须实现上面的TypeConverter，但是因为接口里的方法太过复杂，所以OGNL项目还为该接口提供了一个实现类: DefaultTypeConverter，通常都采用扩展该类来实现自定义类型转换器，实现自定义类型转换器需要重写DefaultTypeConverter类的convertValue方法
package crazyit; import java.util.Map; import ognl.DefaultTypeConverter; public class UserConverter extends DefaultTypeConverter { //类型转换器必须重写convertValue方法，该方法需要完成双向转换 public Object convertValue(Map context, Object value, Class toType) { //当需要将字符串向User类型转换时 if(toType == User.class) { String[] params = (String[])value; User user = new User(); String[] userValues = params[0].split(","); user.setName(userValues[0]); user.setPassword(userValues[1]); return user; } else if(toType == String.class) { User user = (User)value; return "<" + user.getName() + "," + user.getPassword() + ">"; } return null; } }
关于上面的类型转换器，有几点需要注意
1. convertValue方法的作用 convertValue方法的作用最简单，该方法负责完成类型的转换，同时这种转换是双向的，为了让该方法实现双向转换，我们通过判断toType的类型即可判断转换的方向 2. convertValue方法参数和返回值的意义 该方法有如下三个参数 1) context: 类型转换环境的上下文 2) value: 需要转换的参数，随着转换方向的不同，value参数值也是不一样的 3) toType: 转换后的目标类型 3. 浏览器发送的HTTP参数是一个字符串数组
可以认为DefaultTypeConverter是通过HttpServletRequest的getParameter Values(name)方法来获取请求参数值的，因此它获取的请求参数总是字符串数组，如果请求参数只包含一个单个的值，则该请求参数的值是一个长度为1的字符串数组
0x5: 注册类型转换器
仅仅为该应用提供类型转换器还不够，因为struts2依然不知道何时使用这些类型转换器，所以我么必须将类型转换器注册在WEB应用中，struts2框架才可以正常使用该类型转换
1. 注册局部类型转换器: 局部类型转换器仅仅对某个Action的属性起作用 2. 注册全局类型转换器: 全局类型转换器对所有Action的特定类型的属性都起作用 3. 使用JDK1.5的注释来注册类型转换器: 通过注释方式来注册类型转换器
1. 局部类型转换器
注册局部类型转换器使用局部类型转换文件指定，只要在局部类型转换文件中增加如下一行即可
<propName>=<ConverterClass> //propName: 指定需要进行类型转换的属性、ConverterClass: 指定类型转换器的实现类
LoginAction-conversion.properties
user=crazyit.UserConverterfdg
index.jsp
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h1>Hello World From Struts2</h1> <form action="login"> <s:textfield name="user" label="the one user usrename"/> <s:textfield name="user" label="the one user password"/> <tr> <td colspan="2"> <s:submit value="transfer" theme="simple"/> <s:reset value="reset" theme="simple"/> </td> </tr> </form> </body> </html>
LoginAction.java
package crazyit; import java.util.List; import com.opensymphony.xwork2.Action; public class LoginAction implements Action { private User user; //user属性的setter和getter方法 public void setUser(User user) { this.user = user; } public User getUser() { return this.user; } public String execute() throws Exception { return SUCCESS; } }
Loginsucc.jsp
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> user info: ${user} </body> </html>
因为已经实现了自定义转换器并进行了局部注册，因此这里可以直接使用user来输出内容
2. 全局类型转换器
局部类型转换器的局限性很明显，它只能对指定Action、指定属性起作用，但如果应用中有多个Action都包含了User类型的属性，或者一个Action中包含了多个User类型的属性，使用全局类型转换器将更合适
全局类型转换器不是对指定Action的指定属性起作用，而是对指定类型起作用，例如对所有crazyit.User类型的属性起作用
注册全局类型转换器需要提供一个xwork-conversion.properties文件，该文件也是Properties文件，直接放在WEB应用的WEB-INF/classes路径下即可
<proType>=<ConvertClass> //proType替换成需要进行类型转换的类型、ConvertClass替换成类型转换器的实现类
例如
crazyit.User=crazyit.UserConvertert
一旦注册了上面的全局类型转换，该全局类型转换器就会对所有类型为crazyit.User类型的属性起作用
1. 局部类型转换器对指定Action的指定属性生效，一个属性只调用convertValue()方法一次 2. 全局类型转换器对指定类型的全部属性起作用，因此可能对一个属性多次调用convertValue()方法进行转换，当该属性是一个数组或集合时，该数组或集合中包含几个该类型的元素，那么就会调用convertValue()方法多次
3. 使用JDK1.5的注释来注册类型转换器
0x6: 基于struts2的自定义类型转换器
我们之前讨论的都是类型转换器都是基于DefaultTypeConverter类实现的，基于该类实现类型转换器时，将字符串转换成复合类型以及反转要通过convertValue方法实现，因此我们必须先通过toType参数来判断转换的方向，然后分别实现不同转换方向的转换逻辑
为了简化类型转换器的实现，struts2提供了一个StrutsTypeConverter抽象类，这个抽象类是DefaultTypeConverter类的子类，StrutsTypeConverter类简化了类型转换器的实现，该类已经实现了DefaulTypeConverter的convertValue方法，实现该方法时，它将两个不同转换方向替换成不同方法
0x7: 处理set集合
Action中的Set集合属性处于无序状态，所以struts2不能准确得将请求参数转换成Set元素，不仅如此，由于Set集合里元素的无序性，所以struts2也不能准确读取Set集合里的元素，除非Set集合里的元素有一个标识属性，这个标识属性可以唯一地表示集合元素，原理上类似于很多编程语言中提供的存储数据结构可以重写一些"比较器"以此来实现排序、索引等目的
puublic class LoginAction extends ActionSupport { private Set users; public void setUsers(Set users) { this.users = users; } public Set getUsers() { return this.users; } }
为了让struts2能够将参数转换成Set集合对象，我们需要提供类型转换器，除此之外，为了让struts2能够准确地存取Set集合元素，我们还必须让struts2识别Set集合元素的标识属性，指定struts2根据该标识属性来存取Set集合元素
public class User { private String name; //省略name的setter、geter方法 public boolean equals(Object obj) { //如果将比较的两个对象是同一个对象，则直接返回true if(this == obj) { return true; } //只有当obj是User对象 if(obj != null && obj.getClass() == User.class) { User user = (User)obj; if(this.getName().equals(user.getName())) { return true; } } return false; } //根据name属性来计算hashCode public int hashCode() { return name.hashCode(); } }
上面的代码重写了equals、hashCode方法，该User类的标识属性是name，当两个User的name属性相等时即可认为它们相等
struts2允许通过局部类型转换文件来指定Set集合元素的标识属性，在局部类型转换文件中增加如下
KeyProperty_<SetPropName>=<keyPropName> //SetPropName替换为集合属性名、keyPropName替换成集合元素的标识属性
一旦指定了集合元素的索引属性后，struts2就可以通过该索引属性来存取Set集合元素了
<!-- 访问user集合属性里索引属性值为LittleHann的元素的name属性 --> <s:property value="users('LittleHann').name"
注意到访问Set元素用额是圆括号，而不是方括号，但对于数组、List、Map属性，则通过方括号来访问指定集合元素
0x8: 类型转换中的错误处理
实际上，表现层数据涉及的两个处理: 数据校验和类型转换是紧密相关的
1. 类型转换: 只有当输入数据是有效数据时，系统才可以进行有效的类型转换 2. 数据校验: 只有当数据完成了有效的类型转换后，下一步才去做数据校验
struts2提供了一个conversionError拦截器，这个拦截器被注册在默认的拦截器栈中
struts-default.xml
<interceptor-stack name="defaultStack"> .. <interceptor-ref name="conversionError"/> <interceptor-ref name="validation"> <param name="excludeMethods">input,back,cancel,browse</param> </interceptor-ref> .. </interceptor-stack>
默认拦截器栈中包含了conversionError拦截器的引用，如果struts2的类型转换器执行类型转换时出现错误，该拦截器将负责将对应错误封装成"单域错误(FieldError)"，并将这些错误信息放入ActionContext中
显然，conversionError拦截器实际上是AOP中的Throws处理，Throws处理当系统抛出异常时启动，负责处理异常，通过这种方式，struts2的类型转换器中只完成类型转换逻辑，而无需关注异常处理逻辑
为了让struts2框架处理类型转换错误，以及使用后面的数据校验机制，系统的Action类都应该通过继承ActionSupport类来实现，ActionSupport类为完成类型转换错误处理、数据校验实现了许多基础工作
1. 处理类型转换错误
当类型转换出现异常时，conversionError拦截器会处理该异常，然后转入名为input的逻辑视图，因此需要为该Action增加名为input的逻辑视图定义
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="crazyit" extends="struts-default"> <action name="login" class="crazyit.LoginAction" method="execute"> <result name="success">/Loginsucc.jsp</result> <result name="input">/input.jsp</result> </action> </package> </struts>
如果用户输入不能成功转换成User对象，系统将转入input.jsp页面，等待用户再次输入
同时，struts2会负责将错误封装成FieldError，并将其放入ActionContext中，这样就可以在对应视图中输出转换错误，在页面中使用<s:fielderror/>标签即可输出类型转换错误信息
2. 处理集合属性的转换错误
如果Action里包含一个集合属性，只要struts2能检测到集合里元素的类型(可以通过局部类型转换文件指定、也可以通过泛型方式指定)，类型转换器就可以正常起作用，当类型转换器在执行类型转换过程中出现异常时，系统的conversionError拦截器就会处理该异常，处理结束后返回名为input的逻辑视图
2. struts2的输入校验
输入校验也是所有WEB应用必须处理的问题，异常的输入，轻则导致系统非正常中断，重则导致系统崩溃，应用程序必须能正常处理表现层接收的各种数据，通常的做法是遇到异常输入时应用程序直接返回，提示浏览器必须重新输入，也就是将那些异常输入过滤掉，对异常输入的过滤，就是输入校验，也称为数据校验
struts2提供了强大的类型转换机制，也提供了强大的输入校验功能，struts2的输入校验既包括服务端校验，也包括客户端校验
0x1: 编写校验规则文件
struts2提供了基于验证框架的输入校验，在这种校验方式下，所有的输入校验只需要编写简单的配置文件，struts2的验证框架将会负责进行服务器校验和客户端校验，struts2在底层会自动将配置文件转换为Servlet形式的输入验证判断
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h3>请输入您的注册信息</h3> <s:fielderror/> <form method="post" action="regist.action"> name: <input type="text" name="name"><br /> pass: <input type="text" name="pass"><br /> age: <input type="text" name="age"><br /> birth: <input type="text" name="birth"><br /> <input type="submit" value="注册"> </form> </body> </html>
假设本应用要求这4个请求参数满足如下规则
1. name、pass只能是字母和数组，且长度在4~25之间 2. 年龄必须是1~150之间的整数 3. 生日必须在1900-01-01~2050-02-21之间
RegistAction.java
package crazyit; import java.util.Date; import com.opensymphony.xwork2.ActionSupport; public class RegistAction extends ActionSupport { private String name; private String pass; private int age; private Date birth; //name public String getName() { return this.name; } public void setName(String name) { this.name = name; } //pass public String getPass() { return this.pass; } public void setPass(String pass) { this.pass = pass; } //age public int getAge() { return this.age; } public void setAge(int age) { this.age = age; } //birth public Date getBirth() { return this.birth; } public void setBirth(Date birth) { this.birth = birth; } public String execute() throws Exception { return SUCCESS; } }
通过为该Action指定一个校验规则文件后，即可利用struts2的输入校验功能对该Action进行校验
<?xml version="1.0" encoding="GBK"?> <!-- 指定校验配置文件的DTD信息 --> <!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.3//EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.3.dtd"> <!-- 校验文件的根元素 --> <validators> <!-- 校验Action的name属性 --> <field name="name"> <!-- 指定name属性必须满足必填规则 --> <field-validator type="requiredstring"> <param name="trim">true</param> <message>必须输入名字</message> </field-validator> <!-- 指定name属性必须匹配正则表达式 --> <field-validator type="regex"> <param name="expression"><![CDATA[(\w{4,25})]]></param> <message>您输入的用户名只能是字母和数字 ，且长度必须在4到25之间</message> </field-validator> </field> <!-- 校验Action的pass属性 --> <field name="pass"> <!-- 指定pass属性必须满足必填规则 --> <field-validator type="requiredstring"> <param name="trim">true</param> <message>必须输入密码</message> </field-validator> <!-- 指定pass属性必须满足匹配指定的正则表达式 --> <field-validator type="regex"> <param name="expression"><![CDATA[(\w{4,25})]]></param> <message>您输入的密码只能是字母和数字 ，且长度必须在4到25之间</message> </field-validator> </field> <!-- 指定age属性必须在指定范围内--> <field name="age"> <field-validator type="int"> <param name="min">1</param> <param name="max">150</param> <message>年龄必须在1到150之间</message> </field-validator> </field> <!-- 指定birth属性必须在指定范围内--> <field name="birth"> <field-validator type="date"> <!-- 下面指定日期字符串时，必须使用本Locale的日期格式 --> <param name="min">1900-01-01</param> <param name="max">2050-02-21</param> <message>生日必须在${min}到${max}之间</message> </field-validator> </field> </validators>
struts2中每个Action都有一个校验文件，因此该文件的文件名遵守如下规则
<Action name>-validation.xml //<Action name>可变，且该文件应该被保存在与Action class文件相同的路径下
与类型转换失败类似，当输入校验失败后，struts2也是自动返回名为"input"的Result，即使类型转换失败，系统并不是直接返回 input 逻辑视图，依然会调用 Struts 2 的输入校验机制进行输入校验
需要注意的是，RegistAction-validation.xml的文件头对struts2来说很重要，它规约了当前配置文件的文法规范，如果这些配置信息错误，将会导致struts2加载失败，进而输入验证器失败 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE validators PUBLIC "-//Apache Struts//XWork Validator 1.0.2//EN" "http://struts.apache.org/dtds/xwork-validator-1.0.2.dtd">
0x2: 国际化提示信息
0x3: 使用客户端校验
struts2应用中使用客户端校验很简单
1. 将输入页面的表单元素改为使用struts2标签来生成表单 2. 为该<s:form../>元素增加validate="true"属性
register.jsp
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h3>请输入您的注册信息</h3> <s:fielderror/> <s:form action="regist" validate="true"> <s:textfield name="name" label="name"/> <s:textfield name="pass" label="pass"/> <s:textfield name="age" label="age"/> <s:textfield name="birth" label="birth"/> <s:submit value="reigst"/> </s:form> </body> </html>
需要注意的是，如果我们希望struts2的客户端校验能发生作用，那么进入jsp页面之前必须先经过struts2的核心Filter，在纯粹的MVC思想中，JSP页面只是简单的视图，用户请求不应该直接向视图页面发送请求，而是应该向控制器发送请求，由控制器来调用视图页面向浏览者呈现数据
为了避免这种情况，我们把应用中所有JSP页面都移到WEB-INF/content目录下，这样就可以避免浏览者直接向指定页面发送请求(这是MVC框架保证的)
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="crazyit" extends="struts-default"> <action name="*"> <result>/WEB-INF/content/{1}.jsp</result> </action> <action name="regist" class="crazyit.RegistAction"> <result name="input">/register.jsp</result> </action> </package> </struts>
增加了上面的配置后，浏览者不应该直接向register.jsp页面发送请求，而是应该向regist Action发送请求，这个请求会先经过StrutsPrepareAndExecuteFilter，然后再由该Filter forward到/WEB-INF/content/register.jsp页面
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <h3>请输入您的注册信息</h3> <s:fielderror/> <s:form action="register" validate="true"> <s:textfield name="name" label="name"/> <s:textfield name="pass" label="pass"/> <s:textfield name="age" label="age"/> <s:textfield name="birth" label="birth"/> <s:submit value="reigst"/> </s:form> </body> </html>
客户端校验依然是基于JavaScript完成的，因为JavaScript本身的限制，有些服务端校验不能转换成客户端校验，客户端校验仅仅支持如下几种校验器
1. required validator: 必填校验器 2. requiredstring validator: 必填字符串校验器 3. stringlength validator: 字符串长度校验器 4. regex validator: 表达式校验器 5. email validator: 邮件校验器 6. url validator: 网址校验器 7. int validator: 整数校验器 8. double validator: 双精度数校验器
客户端校验有三个值得注意的地方
1. struts2的<s:form../>元素有一个theme属性，不要将该属性指定为simple 2. 浏览者不能直接访问启动客户端校验的表单页，这样会引发异常，我们可以把启用客户端校验的表单页放到WEB-INF路径下去，让浏览者访问的所有资源之前都先经过它的核心Filter 3. 启用客户端校验的表单页面的action和namespace要分开写，例如我们向namespace为/lee，name为regisPro的Action请求，应写成<s:form action="registPro" namespace="/lee">，而不应该写成<s:form action="lee/registPro">
0x4: 字段校验器配置风格
struts2提供了两种方式来配置校验规则
1. 字段校验器风格: 字段优先 采用字段校验器配置风格时，校验文件里以<field../>元素为基本元素 2. 非字段校验器风格: 校验器优先 以<validator../>元素为基本元素 //并没有本质的不同，只是组织校验规则的方式不同
0x5: 非字段校验器配置风格
对于非字段校验器配置风格，这是一种以校验器优先的配置方式，在这种配置方式下，校验规则文件的根元素下包含多个<validator../>元素，每个<validator../>元素定义了一个校验规则
对于采用非字段校验器配置风格的校验规则文件，<validator../>元素下有多个<validator../>元素，每个<validator../>元素都有如下格式
<validator type="校验器名"> <param name="fieldName">需要被校验的字段</param> <param name="参数名">参数值</param> .. <message key="I18Nkey">校验失败后的提示信息</message> </validator>
RegistAction-validation.xml
<?xml version="1.0" encoding="GBK"?> <!-- 指定Struts2数据校验的规则文件的DTD信息 --> <!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.3//EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.3.dtd"> <!-- Struts2校验文件的根元素 --> <validators> <!-- 配置指定必填字符串的校验器 --> <validator type="requiredstring"> <!-- 使用该校验器校验name属性 --> <param name="fieldName">name</param> <param name="trim">true</param> <!-- 指定校验失败后输出name.required对应的国际化信息 --> <message>${getText("name.requried")}</message> </validator> <!-- 配置指定正则表达式的校验器 --> <validator type="regex"> <!-- 使用该校验器校验name属性 --> <param name="fieldName">name</param> <param name="trim">true</param> <param name="expression"><![CDATA[(\w{4,25})]]></param> <!-- 指定校验失败后输出name.required对应的国际化信息 --> <message>${getText("name.regex")}</message> </validator> <!-- 配置指定必填字符串的校验器 --> <validator type="requiredstring"> <!-- 使用该校验器校验pass属性 --> <param name="fieldName">pass</param> <param name="trim">true</param> <!-- 指定校验失败后输出pass.required对应的国际化信息 --> <message>${getText("pass.requried")}</message> </validator> <!-- 配置指定正则表达式的校验器 --> <validator type="regex"> <!-- 使用该校验器校验pass属性 --> <param name="fieldName">pass</param> <param name="trim">true</param> <param name="expression"><![CDATA[(\w{4,25})]]></param> <!-- 指定校验失败后输出pass.required对应的国际化信息 --> <message>${getText("pass.regex")}</message> </validator> <!-- 配置指定整数校验器 --> <validator type="int"> <!-- 使用该校验器校验age属性 --> <param name="fieldName">age</param> <!-- 指定整数校验器的范围--> <param name="min">1</param> <param name="max">150</param> <!-- 指定校验失败后输出age.range对应的国际化信息 --> <message>${getText("age.range")}</message> </validator> <!-- 配置指定日期校验器 --> <validator type="date"> <!-- 使用该校验器校验birth属性 --> <param name="fieldName">birth</param> <!-- 指定日期校验器的范围--> <param name="min">1900-01-01</param> <param name="max">2050-02-21</param> <!-- 指定校验失败后输出birth.range对应的国际化信息 --> <message>${getText("birth.range")}</message> </validator> </validators>
0x6: 短路校验器
为了实现短路校验器，我们只需要在<validator../>元素或<field-validator../>元素中增加short-circuit="true"即可，则当第一次校验失败的时候，之后的校验失败将不会再显示
0x7: 校验文件的搜索规则
struts2的一个Action中可能包含了多个处理逻辑，当一个Action类中包含多个类似于execute的方法时，每个方法都是一个处理逻辑，不同的处理逻辑可能需要不同的校验规则，struts2允许为不同控制逻辑制定不同校验规则的支持
为了能精确控制每个校验逻辑，struts2允许通过为校验规则文件增加名为Action别名来指定具体需要校验的处理逻辑
<ActionClassName>-<ActionAliasName>-validation.xml //ActionClassName是Action处理类的类名，ActionAliasName是在struts.xml中配置该Action时所指定的name属性
假设系统有两个Action: BaseAction、ResigtAction，则系统搜索规则文件顺序如下
1. BaseAction-validation.xml 2. BaseAction-ActionAliasName-validation.xml 3. RegistAction-validation.xml 4. RegistAction--ActionAliasName-validation.xml //即使找到第一条规则，系统还会继续搜索，并将规则全部汇总，取并集，如果两个校验文件中指定的校验规则冲突，则后面文件中的校验规则取胜
0x8: 检验顺序和短路
校验器增加了短路的特性后，校验器的执行顺序就变得非常重要了，因为前面执行的校验器可能阻止后面校验器的执行
1. 所有非字段风格的校验器优先于字段风格的校验器 2. 所有非字段风格的校验器中，排在前面的先执行 3. 所有字段风格的校验器中，排在前面的先执行
校验器短路的原则是
//在短路模式下 1. 所有非字段校验器是最优先执行，如果某个非字段校验器校验失败了，则该字段上所有字段校验器都不会获得校验的机会 2. 非字段校验器的校验失败，不会组织其他非字段校验器的执行 3. 如果一个字段校验器校验失败后，则该字段下且排在该校验失败的校验器之后的其他字段校验器都不会获得校验的机会 4. 字段校验器永远不会阻止非字段校验器的执行
0x9: 内建校验器
struts2提供了大量的内建校验器，这些内建的校验器可以满足大部分应用的校验需求
xwork-core-2.3.24.jar\com\opensymphony\xwork2\validator\validators\default.xml
<validators>
<validator name="required" class="com.opensymphony.xwork2.validator.validators.RequiredFieldValidator"/>
<validator name="requiredstring" class="com.opensymphony.xwork2.validator.validators.RequiredStringValidator"/>
<validator name="int" class="com.opensymphony.xwork2.validator.validators.IntRangeFieldValidator"/>
<validator name="long" class="com.opensymphony.xwork2.validator.validators.LongRangeFieldValidator"/>
<validator name="short" class="com.opensymphony.xwork2.validator.validators.ShortRangeFieldValidator"/>
<validator name="double" class="com.opensymphony.xwork2.validator.validators.DoubleRangeFieldValidator"/>
<validator name="date" class="com.opensymphony.xwork2.validator.validators.DateRangeFieldValidator"/>
<validator name="expression" class="com.opensymphony.xwork2.validator.validators.ExpressionValidator"/>
<validator name="fieldexpression" class="com.opensymphony.xwork2.validator.validators.FieldExpressionValidator"/>
<validator name="email" class="com.opensymphony.xwork2.validator.validators.EmailValidator"/>
<validator name="url" class="com.opensymphony.xwork2.validator.validators.URLValidator"/>
<validator name="visitor" class="com.opensymphony.xwork2.validator.validators.VisitorFieldValidator"/>
<validator name="conversion" class="com.opensymphony.xwork2.validator.validators.ConversionErrorFieldValidator"/>
<validator name="stringlength" class="com.opensymphony.xwork2.validator.validators.StringLengthFieldValidator"/>
<validator name="regex" class="com.opensymphony.xwork2.validator.validators.RegexFieldValidator"/>
<validator name="conditionalvisitor" class="com.opensymphony.xwork2.validator.validators.ConditionalVisitorFieldValidator"/>
</validators>
如果开发者自己开发了一个自己开发的校验器，则可以通过添加一个validators.xml文件(放在WEB-INF/classes路径下)来注册一个校验器，validators.xml文件的内容也是由多个<validator../>组成的，每个<validator../>元素注册一个校验器
如果struts2在WEB-INF/classes路径下找到一个validators.xml文件，则不会再加载系统默认的default.xml文件，因此如果开发者提供了自己的校验器注册文件(validators.xml)，一定要把default.xml文件里的全部内容复制到validators.xml文件中
0x10: 基于annotation的输入校验
基于Annotation的输入校验实质上也属于struts2零配置特性的一部分，它允许使用Annotation来定义每个字段应该满足的规则
为了在Action类通过Annotation指定验证规则，经过如下配置即可
1. 使用验证器Annotation修饰Action里各属性对应的setter方法
0x11: 手动完成输入校验
基于struts2校验器的校验可以完成绝大部分输入校验，但这些校验器都具有固定的校验逻辑，无法满足一些特殊的校验规则，对于一些特殊的校验要求，可能需要在struts2中进行手动校验，struts2提供了良好的可扩展性，从而允许通过手动方式完成自定义校验
1. 重写validate()方法
package crazyit; import java.util.Date; import com.opensymphony.xwork2.ActionSupport; public class RegistAction extends ActionSupport { //封装用户请求参数的四个属性 private String name; private String pass; private int age; private Date birth; //name属性的setter和getter方法 public void setName(String name) { this.name = name; } public String getName() { return this.name; } //pass属性的setter和getter方法 public void setPass(String pass) { this.pass = pass; } public String getPass() { return this.pass; } //age属性的setter和getter方法 public void setAge(int age) { this.age = age; } public int getAge() { return this.age; } //birth属性的setter和getter方法 public void setBirth(Date birth) { this.birth = birth; } public Date getBirth() { return this.birth; } public void validate() { System.out.println("进入validate方法进行校验" + name); if(!name.contains("LittleHann")) { addFieldError("user", "您的用户名必须包含LittleHann"); } } }
在validate方法中，一旦发现校验失败，就把校验失败提示通过addFieldError方法添加进系统的FieldError中，这与类型转换失败后的处理是完全一样的，如果struts2发现系统的FieldError不为空，将会自动跳转到input逻辑视图
2. 重写validateXxx()方法
我们知道，struts2的Action类里可以包含多个处理逻辑，不同的处理逻辑对应不同的方法，即struts2的Action类里定义了几个类似于execute的方法，只是方法名不是execute，如果我们的输入校验只想校验某个处理逻辑，struts2的Action允许提供一个validateXxx()方法，其中Xxx即是Action对应的处理逻辑方法
总结一下，struts2的输入校验需要经过如下几个步骤
1. 类型转换器负责对字符串的请求参数执行类型转换，并将这些值设置成Action的属性值 2. 在执行类型转换过程中可能出现异常，如果出现异常，将异常信息保存到ActionContext中，conversionError拦截器负责将其封装到FieldError里，然后执行第3步，如果转换过程中没有异常信息，则直接进入第3步 3. 使用struts2应用中所配置的校验器进行输入校验 4. 通过反射调用validateXxx()方法，其中Xxx是即将处理用户请求的处理逻辑所对应的方法 5. 调用Action类里的validate()方法 6. 如果经过上面5步没有出现FieldError，将调用Action里处理用户请求的处理方法，如果出现了FieldError，系统将转入input逻辑视图所指定的视图资源
Relevant Link:
http://terryjs.iteye.com/blog/796277 http://terryjs.iteye.com/blog/812265
3. struts2的拦截器机制
拦截器体系是struts2框架的重要组成部分，我们可以把struts2理解成一个空容器，而大量的内建拦截器完成了该框架的大部分操作，比如，params拦截器负责解析HTTP请求的参数，并设置Action的属性
1. servlet-config拦截器直接将HTTP请求中的HttpServletRequest实例和HttpServletResponse实例传给Action 2. fileUpload拦截器则负责解析请求参数中的文件域，并将一个文件域设置成Action的3个属性 //这些操作都是通过struts2的内建拦截器完成的
struts2拦截器是可插拔式的设计
1. 如果我们需要使用某个拦截器，只需要在配置文件中应用该拦截器即可 2. 如果不需要使用该拦截器，只需要在配置文件中取消应用该拦截器，不管是否应用某个拦截器，对于struts2框架不会有任何影响 3. struts2拦截器由struts-default.xml、struts.xml等配置文件进行管理，开发者很容易扩展自己的拦截器
0x1: 拦截器在struts2中的作用
对于任何MVC框架来说，都会完成一些通用的控制逻辑，例如解析请求参数、类型转换、将请求参数封装成DTO(Dsta Transfer Object)、执行输入校验、解析文件上传表单中的文件域、防止表单多次提交
struts2把大部分核心控制器需要完成的工作按功能分开定义，每个拦截器完成一个功能，而这些拦截器可以自由选择、灵活组合
struts2框架的绝大部分功能都是通过拦截器完成的，当StrutsPrepareAndExecuteFilter拦截到用户请求之后，大量拦截器将会对用户请求进行处理，然后才会调用用户开发的Action实例的方法来处理请求
0x2: struts2内建的拦截器
从struts2框架来看，拦截器几乎完成了struts2框架70%的工作，包括解析请求参数、将请求参数赋值给Action属性、执行数据校验、文件上传，struts2设计的灵巧性，更大程度地得益于拦截器设计，当需要扩展struts2功能时，只需要提供对应拦截器，并将它配置在struts2容器中即可；如果不需要该功能，也只需要取消该拦截器的配置即可，是一种可插拔的设计
struts2内建了大量的拦截器，这些拦截器以name-class对的形式配置在struts-default.xml文件中
1. name: 拦截器的名字，以后使用该拦截器的唯一标识 2. class: 指定了该拦截器的实现类，如果我们定义的package继承了struts2的默认struts-default包，则可以自由使用下面定义的拦截器
struts2内建拦截器的简要介绍
1. alias: 实现在不同请求中相似参数别名的转换 2. autowiring: 这是个自动装配的拦截器，主要用于当struts2和spring整合时，struts2可以使用自动装配的方式来访问spring容器中的bean 3. chain: 构建一个Action链，使当前Action可以访问前一个Action的属性，一般和<result="chain"../>一起使用 4. conversionError: 这是一个负责处理类型转换错误的拦截器，它负责将类型转换错误从ActionContext中取出，并转换成Action的FieldError错误 5. createSession: 该拦截器负责创建一个HttpSession对象，主要用于那些需要有HttpSession对象才能正常工作的拦截器中 6. debugging: 当使用struts2的开发模式时，这个拦截器会提供更多的调试信息 7. execAndWait: 后台执行Action，负责将等待画面发送给用户 8. exception: 这个拦截器负责处理异常，它将异常映射为结果 9. fileUpload: 这个拦截器主要用于文件上传，它负责解析表单中文件域的内容 10. i18n: 这是支持国际化的拦截器，它负责把所选的语言、区域放入用户Session中 11. logger: 这个一个负责日志记录的拦截器，主要是输出Action的名字 12. model-driven: 这是一个用于模型驱动的拦截器，当某个Action类实现了ModelDriven接口时，它负责把getModel()方法的结果堆入ValueStack中 13. scoped-model-driven: 如果一个Action实现了一个ScopedModelDriven接口，该拦截器负责从指定生存范围中找出指定的Model，并将通过setModel方法将该Model传给Action实例 14. params: 这是最基本的拦截器，它负责解析HTTP请求中的参数，并将参数值设置成Action对应的属性值 15. prepare: 如果Action实现了Preparable接口，将会调用该拦截器的prepare()方法 16. static-params: 这个拦截器负责将xml中<action>标签下<param>标签中的参数传入action 17. scope: 这是范围转换拦截器，它可以将Action状态信息保存到HttpSession范围，或者保存到ServletContext范围内 18. servlet-config: 如果某个Action需要直接访问Servlet API，就是通过这个拦截器实现的 //尽量避免在Action中直接访问Servlet API，这样会导致Action与Servlet的高耦合 19. roles: 这是一个JAAS(Java Authentication and Authorization Service Java授权和认证服务)拦截器，只有当浏览者取得合适的授权后，才可以调用被该拦截器拦截的Action 20. timer: 这个拦截器负责输出Action的执行时间，这个拦截器在分析该Action的性能瓶颈时比较有用 21. token: 这个拦截器主要用于阻止重复提交，它检查传到Action中的token，从而防止多次提交 22. token-session: 这个拦截器的作用与token基本类似，只是它把token保存在HttpSession中 23. validation: 通过执行在xxxAction-validation.xml中定义的校验器，从而完成数据校验 24: workflow: 这个拦截器负责调用Action类中的validate方法，如果校验失败，则返回input的逻辑视图
大部分时候，开发者无须手动控制这些拦截器，因为struts-default.xml文件中已经配置了这些拦截器，只要我们定义的包继承了系统的struts-default包，就可以直接使用这些拦截器
0x3: 配置拦截器
struts.xml文件中可以定义拦截器、也可以定义拦截器栈
1. 拦截器 <interceptor name="拦截器名" class="拦截器实现类"/> 2. 拦截器栈: 相当于一个拦截器整体 <interceptor-stack name="拦截器栈名"> <interceptor-ref name="拦截器1"/> <interceptor-ref name="拦截器2"/> .. <interceptor name="拦截器n"/> </interceptor-stack>
一旦配置成为拦截器栈之后，就可以完全像使用普通拦截器一样使用拦截器占，因为拦截器和拦截器栈的功能是完全统一的，甚至有可能出现拦截器栈里包含拦截器栈
系统为拦截器指定参数有如下两个时机
1. 定义拦截器时指定参数值: 这种参数值讲作为拦截器参数的默认参数值，通过<intercepter../>元素来定义拦截器 2. 使用拦截器时指定参数值: 在配置Action时为拦截器参数指定值。通过<interceptor-ref../>元素使用拦截器，这种方式用于覆盖拦截器的默认参数值(就近原则)
0x4: 使用拦截器
一旦定义了拦截器和拦截器栈后，就可以使用这个拦截器或拦截器栈来拦截Action了，拦截器(包括拦截器栈)的拦截行为将会在Action的execute方法执行之前被执行
通过<interceptor-ref../>元素可以在Action内使用拦截器
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="crazyit" extends="struts-default"> <interceptors> <interceptor name="mysimple" class="crazyit.SimpleInterceptor"/> <interceptor name="later" class="crazyit.LaterInterceptor"> <param name="name">第二个拦截器</param> </interceptor> </interceptors> <action name="register" class="crazyit.RegistAction"> <result name="input">/register.jsp</result> <interceptor-ref name="defaultStack"/> <interceptor-ref name="mysimple"/> <interceptor-ref name="later"> <param name="name">动态餐胡</param> </interceptor> </action> </package> </struts>
在执行LoginAction之前，这3个拦截器都会起作用
0x5: 配置默认拦截器
当配置一个包时，可以为其指定默认拦截器，一旦为某个包指定了默认的拦截器，如果该包中的Action没有显式指定拦截器，则默认的拦截器将会起作用
配置默认拦截器使用<default-interceptor../>元素，该元素作为<package../>元素的子元素使用，为该包下的所有Action配置默认的拦截器
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="crazyit" extends="struts-default"> <interceptors> <interceptor name="mysimple" class="crazyit.SimpleInterceptor"/> <interceptor name="later" class="crazyit.LaterInterceptor"> <param name="name">第二个拦截器</param> </interceptor> </interceptors> <defaul-interceptor-ref naem="拦截器名或拦截器栈名"/> <action name="register" class="crazyit.RegistAction"> <result name="input">/register.jsp</result> <interceptor-ref name="defaultStack"/> <interceptor-ref name="mysimple"/> <interceptor-ref name="later"> <param name="name">动态餐胡</param> </interceptor> </action> </package> </struts>
每个包只能指定一个默认拦截器，如果我们需要指定多个拦截器共同作为默认拦截器，则应该讲这些拦截器定义成拦截器栈，然后把这个拦截器栈配置成默认拦截器即可
默认情况下，所有Action都无须配置defaultStack拦截器栈，因为在struts2的struts-default.xml文件中有如下配置
<package name="struts-default" abstract="true"> ... default-interceptor-ref name="defaultStack"/> .. </package>
我们定义的struts2应用中的包，都是struts-default包的子包，当我们定义的包继承struts-default包时，也继承了它的默认拦截器栈: defaultStack
拦截器的工作原理如上图，每一个Action请求都包装在一系列的拦截器的内部。拦截器可以在Action执行直线做相似的操作也可以在Action执行直后做回收操作
每一个Action既可以将操作转交给下面的拦截器，Action也可以直接退出操作返回客户既定的画面
0x6: 实现拦截器类
如果用户要开发自己的拦截器类，应该实现com.opensymphony.xwork2.interceptor.Interceptor接口
public interface Interceptor extends Serializable { //在拦截器实例被销毁之前，系统讲回调该拦截器的destroy方法，该方法用于销毁在init()方法里打开的资源 void destroy(); //在该拦截器被实例化之后，在该拦截器执行拦截之前，系统将回调该方法，对于每个拦截器而言，其init()方法只执行一次 void init(); /* 该方法是用户需要实现的拦截动作，就像Action的execute一样，intercept方法会返回一个字符串字符串作为逻辑视图 该方法的ActionInvocation参数包含了被拦截的Action的引用，可以通过调用该参数的invoke方法，讲控制权转给下一个拦截器，或者转给Action的execute方法 */ String intercept(ActionInvocation invocation)throws Exception; }
下面实现了一个简单的拦截器
package crazyit; import java.util.Date; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.AbstractInterceptor; public class SimpleInterceptor extends AbstractInterceptor { //简单拦截器名字 private String name; public void setName(String name) { this.name = name; } public String intercept(ActionInvocation invocation) throws Exception { //取得被拦截的Action实例 RegistAction action = (RegistAction)invocation.getAction(); System.out.println(name + " 拦截器的动作---" + "开始执行登录Action的时间为: " + new Date()); long start = System.currentTimeMillis(); String result = invocation.invoke(); System.out.println(name + " 拦截器的动作---" + "执行完登录Action的时间为: " + new Date()); long end = System.currentTimeMillis(); System.out.println(name + " 拦截器的动作---" + "执行完该Action的事件为: " + (end - start) + "毫秒"); return result; } }
当我们实现intercept(ActionInvocation invocation)方法时，可以获得ActionInvocation参数，这个参数又可以获得被拦截的Action实例，一旦取得了Action实例，几乎获得了全部的控制权
1. 可以实现讲HTTP请求中的参数解析出来，设置成Action的属性(这个系统params拦截器完成的事情，防御S2-005也是通过这个拦截器的升级实现的) 2. 可以直接讲HTTP请求中的HttpServletRequest实例和HttpServletResponse实例传给Action(这是servlet-config拦截器完成的事情)
struts.xml
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="crazyit" extends="struts-default"> <interceptors> <interceptor name="mysimple" class="crazyit.SimpleInterceptor"> <param name="name">第二个拦截器</param> </interceptor> </interceptors> <action name="register" class="crazyit.RegistAction"> <result name="input">/register.jsp</result> <result name="success">/register.jsp</result> <interceptor-ref name="defaultStack"/> <interceptor-ref name="mysimple"> <param name="name">动态参数</param> </interceptor-ref> </action> </package> </struts>
0x7: 使用拦截器
如果为Action指定了一个拦截器，则系统默认的拦截器栈将会失去作用，为了继续使用默认拦截器，我们在配置文件中应该显式地应用默认拦截器
struts2拦截器的功能非常强大，它既可以在Action的execute方法之前插入执行代码，也可以在execute方法之后插入执行代码，这种方式的实质就是AOP(面向切面编程)的思想
0x8: 拦截方法的拦截器
在默认情况下，如果我们为某个Action定义了拦截器，则这个拦截会拦截该Action内的所有方法，但在某些情况下，我们需要拦截指定方法，此时就需要使用struts2拦截器的方法过滤特性
为了实现方法过滤的特性，struts2提供了一个MethodFilterInterceptor类，该类是AbstractInterceptor类的子类，如果用户需要自己实现的拦截器支持方法过滤特性，则应该继承MethodFilterInterceptor
MethodFilterInterceptor类重写了AbstractInterceptor类的intercept(ActionInvocation invocation)方法，但提供了一个doIntercept(ActionInvocation invocation)抽象方法，从这种设计可以看出，MethodFilterInterceptor类的intercept已经实现了对Action的拦截行为(只是实现了方法过滤的框架逻辑)，但真正的拦截逻辑还需要开发者通过重写提供，也就是通过回调doIntercept方法实现
package crazyit; import java.util.Date; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor; public class SimpleInterceptor extends MethodFilterInterceptor { //简单拦截器名字 private String name; public void setName(String name) { this.name = name; } public String doIntercept(ActionInvocation invocation) throws Exception { //取得被拦截的Action实例 RegistAction action = (RegistAction)invocation.getAction(); System.out.println(name + " 拦截器的动作---" + "开始执行登录Action的时间为: " + new Date()); long start = System.currentTimeMillis(); String result = invocation.invoke(); System.out.println(name + " 拦截器的动作---" + "执行完登录Action的时间为: " + new Date()); long end = System.currentTimeMillis(); System.out.println(name + " 拦截器的动作---" + "执行完该Action的事件为: " + (end - start) + "毫秒"); return result; } }
实际上，方法过滤拦截器和普通拦截器没有本质区别，后者是基于前者实现的
1. 实现方法过滤拦截器需要继承MethodFilterInterceptor抽象类，并且重写doIntercept方法，定义对Action的拦截逻辑 2. 在MethodFilterInterceptor类的方法中，增加了如下两个方法 1) public void serExcludeMethod(String excludeMethods); 排除需要过滤的方法，相当于设置黑名单 2) public void setIncludeMethod(String includeMethods); 设置需要过滤的方法，相当于设置白名单 //如果一个方法同时出现在excludeMethods、includeMethods中，则该方法会被拦截
0x9: 拦截器的执行顺序
随着系统中配置拦截器的顺序的不同，系统执行拦截器的顺序也不一样
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="crazyit" extends="struts-default"> <interceptors> <interceptor name="mysimple" class="crazyit.SimpleInterceptor"> <param name="name">第二个拦截器</param> </interceptor> </interceptors> <action name="register" class="crazyit.RegistAction"> <result name="input">/register.jsp</result> <result name="success">/register.jsp</result> <interceptor-ref name="defaultStack"/> <interceptor-ref name="mysimple"> <param name="name">第一个</param> </interceptor-ref> <interceptor-ref name="mysimple"> <param name="name">第二个</param> </interceptor-ref> </action> </package> </struts>
从结果上可以看出
1. 对于在execute方法之前的动作，配置在前面的拦截器先起作用 2. 在execute方法之后的动作，配置在后面的拦截器先起作用 //在Action的控制方法执行之前，位于拦截器链前面的拦截器讲先发生作用，在Action的控制方法执行之后，位于拦截器链后面的拦截器讲先发生作用
这实际上是因为拦截器栈采用了"后进先出LIFO"的堆结构
0x10: 拦截结果的监听器
为了精确定义在execute方法执行结束后，在物理资源转向之前的动作，struts2提供了用于拦截结果的监听器
我们之前介绍的"拦截结果的监听器接口: PreResultListener"它只能在Action中注册该监听器，则该监听器只对指定Action有效，把PreResultListener注册在拦截器中，这样可以只要该拦截器起作用的地方，这个拦截接口的监听器都会被触发
虽然在beforeResult方法中再对ActionInvocation方法进行处理已经没有太大的作用了，但了解Action已经执行完毕，而处理物理资源转向还没有开始执行的时间点也非常重要，可以让开发者精确地控制Action处理的结果，并且对处理结果做有针对性的处理
0x11: 覆盖拦截器栈里特定拦截器的参数
如果需要在使用拦截器栈时直接覆盖栈内某个拦截器的属性值，则在指定需要被覆盖的属性时，不能只指定属性名，必须加上该属性属于的拦截名，即
<拦截器名>.<属性名>
0x12: 使用拦截器完成权限控制
Relevant Link:
http://www.blogjava.net/i369/articles/162407.html
4. 使用struts2的Ajax支持
5. struts2 OGNL表达式
0x1: OGNL简介
OGNL是Object-Graph Navigation Language的缩写，全称为对象图导航语言，是一种功能强大的表达式语言，它通过简单一致的语法，可以任意存取对象的属性或者调用对象的方法，能够遍历整个对象的结构图，实现对象属性类型的转换等功能
1. OGNL表达式的计算是围绕OGNL上下文进行的 OGNL上下文实际上就是一个Map对象，由ognl.OgnlContext类表示。它里面可以存放很多个JavaBean对象。它有一个上下文根对象 上下文中的根对象可以直接使用名来访问或直接使用它的属性名访问它的属性值。否则要加前缀"#key" 2. Struts2的标签库都是使用OGNL表达式来访问ActionContext中的对象数据的。如: <s:propertyvalue="xxx"/> 3. Struts2将ActionContext设置为OGNL上下文，并将值栈(ValueStack)作为OGNL的根对象放置到ActionContext中，使得可以通过OGNL表达式访问到ValueStack，进而获得Action的访问能力 4. 值栈(ValueStack) 可以在值栈中放入、删除、查询对象。访问值栈中的对象不用"#"，因为值栈(ValueStack)位于ActionContext的顶端 Struts2总是把当前Action实例放置在栈顶(即值栈(ValueStack)中)。所以在OGNL中引用Action中的属性也可以省略"#" 5. 调用ActionContext的put(key,value)放入的数据，需要使用#访问
0x2: OGNL中重要的3个符号：#、%、$
1．#符号 #符号的用途一般有三种 1) 访问非根对象属性，例如#session.msg表达式，由于Struts 2中值栈被视为根对象，所以访问其他非根对象时，需要加#前缀。实际上，#相当于ActionContext. getContext()，#session.msg表达式相当于ActionContext.getContext().getSession(). getAttribute("msg") 2) 用于过滤和投影(projecting)集合，如persons.{?#this.age>25}，persons.{?#this.name=='pla1'}.{age}[0] 3) 用来构造Map，例如示例中的#{'foo1':'bar1', 'foo2':'bar2'} 2．%符号 %符号的用途是在标志的属性为字符串类型时，计算OGNL表达式的值，这个类似js中的eval 3．$符号 $符号主要有两个方面的用途 1) 在国际化资源文件中，引用OGNL表达式，例如国际化资源文件中的代码：reg.agerange=国际化资源信息：年龄必须在${min}同${max}之间 2) 在Struts 2框架的配置文件中引用OGNL表达式
0x3: OGNL的使用方法
1. 访问属性 名字属性获取: <s:property value="user.username"/> 地址属性获取: <s:property value="user.address.addr"/> 2. 访问方法 调用值栈中对象的普通方法: <s:property value="user.get()"/> 3. 访问静态属性和方法 调用Action中的静态方法: <s:property value="@struts.action.LoginAction@get()"/> 调用JDK中的类的静态方法: <s:property value="@java.lang.Math@floor(44.56)"/> 调用JDK中的类的静态方法(同上): <s:property value="@@floor(44.56)"/> 调用JDK中的类的静态方法: <s:property value="@java.util.Calendar@getInstance()"/> 调用普通类中的静态属性: <s:property value="@struts.vo.Address@TIPS"/> 4. 访问构造方法 调用普通类的构造方法: <s:property value="new struts.vo.Student('李晓红' , '美女' , 3 , 25).username"/> 5. 访问数组 获取List:<s:property value="testList"/> 获取List中的某一个元素(可以使用类似于数组中的下标获取List中的内容): <s:property value="testList[0]"/> 获取Set: <s:property value="testSet"/> 获取Set中的某一个元素(Set由于没有顺序，所以不能使用下标获取数据): <s:property value="testSet[0]"/> 获取Map: <s:property value="testMap"/> 获取Map中所有的键: <s:property value="testMap.keys"/> 获取Map中所有的值: <s:property value="testMap.values"/> 获取Map中的某一个元素(可以使用类似于数组中的下标获取List中的内容): <s:property value="testMap['m1']"/> 获取List的大小: <s:property value="testSet.size"/> 6. 访问集合 – 投影、选择(? ^ $) 利用选择获取List中成绩及格的对象: <s:property value="stus.{?#this.grade>=60}"/> 利用选择获取List中成绩及格的对象的username: <s:property value="stus.{?#this.grade>=60}.{username}"/> 利用选择获取List中成绩及格的第一个对象的username: <s:property value="stus.{?#this.grade>=60}.{username}[0]"/> 利用选择获取List中成绩及格的第一个对象的username: <s:property value="stus.{^#this.grade>=60}.{username}"/> 利用选择获取List中成绩及格的最后一个对象的username: <s:property value="stus.{$#this.grade>=60}.{username}"/> 利用选择获取List中成绩及格的第一个对象然后求大小: <s:property value="stus.{^#this.grade>=600}.{username}.size"/> 7. 集合的伪属性 OGNL能够引用集合的一些特殊的属性,这些属性并不是JavaBeans模式，例如size()、length()等等. 当表达式引用这些属性时，OGNL会调用相应的方法,这就是伪属性集合 8. Lambda: […] 格式：:[…] 使用Lambda表达式计算阶乘: <s:property value="#f = :[#this==1?1:#this*#f(#this-1)] , #f(4)"/><br> 9. OGNL中#的使用 #可以取出堆栈上下文中的存放的对象 1. parameters: 包含当前HTTP请求参数的Map: parameters.id[0]作用相当于request.getParameter("id") 2. request: 包含当前HttpServletRequest的属性(attribute)的Map: #request.userName相当于request.getAttribute("userName") 3. session: 包含当前HttpSession的属性(attribute)的Map: #session.userName相当于session.getAttribute("userName") 4. application: 包含当前应用的ServletContext的属性(attribute)的Map: #application.userName相当于application.getAttribute("userName") 5. attr: 用于按request > session > application顺序访问其属性(attribute): 获取Paraments对象的属性: <s:property value="#parameters.username"/> 10. OGNL中%的使用 用%{}可以取出存在值堆栈中的Action对象,直接调用它的方法. 例如你的Action如果继承了ActionSupport .那么在页面标签中，用%{getText('key')}的方式可以拿出国际化信息. 11. OGNL中$的使用 12. "$"有两个主要的用途 1) 用于在国际化资源文件中，引用OGNL表达式 2) 在Struts 2配置文件中，引用OGNL表达式
Relevant Link:
http://blog.csdn.net/tjcyjd/article/details/6850203 https://struts.apache.org/docs/ognl-basics.html https://struts.apache.org/docs/ognl.html
6. struts2的文件上传
为了能上传文件，我们必须将表单的method设置为POST，将enctype设置为multipart/form-data，只有在这种情况下，浏览器才会把用户选择文件的二进制数据发送给服务器，Servlet3.0规范的HttpServletRequest已经提供了方法来处理文件上传，但这种上传需要在Servlet中完成，而struts2则提供了更简单的"封装"
需要注意的是，struts2的文件上传还没有使用Servlet3.0 API，因此struts2的文件上传还需要依赖于Common-FileUpload、COS等文件上传组件
0x1: struts2的文件上传
struts2并未提供自己的请求解析器，即struts2不会自己去处理multipart/form-data的请求，它需要调用其他上传框架来解析二进制请求数据，但struts2在原有的上传解析器基础上做了进一步的封装，更进一步简化了文件上传
在struts2的struts.properties配置文件中，我们可以看到如下代码，它们主要用于配置struts2上传文件时的上传解析器
# 指定使用COS的文件上传解析器 struts.multipart.parser=cos # 指定使用Pell的文件上传解析器 struts.multipart.parser=pell # struts2默认使用Jakarta的Common-FileUpload的文件上传解析器 struts.multipart.parser=jakarta
struts2的封装隔离了底层文件上传组件的区别，开发者只要在此处配置文件上传所使用的解析器，就可以在不同的文件上传框架之间切换
struts2默认使用的是Jakarta的Common-FileUpload的文件上传框架，因此需要在Web应用中增加两个JAR文件，即将commons-io-xxx.jar、commons-fileupload-xx.jar复制到Web应用下的WEB-INF/lib路径下
0x2: 实现文件上传的Action
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>simple file upload</title> </head> <body> <s:form action="uploadPro" enctype="multipart/form-data"> <s:textfield name="title" label="file title"/><br /> <s:file name="upload" label="select file"/><br /> <s:submit value="upload"/> </s:form> </body> </html>
struts2的Action无须负责处理HttpServletRequest请求，因为struts2的Action已经完全与Servlet API彻底分离了，struts2框架负责解析HttpServletRequest请求中的参数，包括文件域，struts2使用File类型来封装文件域
package S2_XX; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import org.apache.struts2.ServletActionContext; import com.opensymphony.xwork2.ActionSupport; public class UploadAction extends ActionSupport { //封装文件标题请求参数的属性 private String title; //封装上传文件域的属性 private File upload; //封装上传文件类型的属性 private String uploadContentType; //封装上传文件名的属性 private String uploadFileName; //直接在struts.xml文件中配置的属性 private String savaPath; //接受struts.xml文件配置值方法 public void setSavePath(String value) { this.savaPath = value; } //返回上传文件的保存位置 private String getSavePath() throws Exception { return ServletActionContext.getServletContext().getRealPath("/WEB-INF/" + savaPath); } //文件标题的setter、getter方法 public void setTitle(String title) { this.title = title; } public String getTitle() { return this.title; } //上传文件对应文件内容的setter、getter方法 public void setUpload(File upload) { this.upload = upload; } public File getUpload() { return this.upload; } //上传文件的文件类型的setter。getter方法 public void setUploadContentType(String uploadContentType) { this.uploadContentType = uploadContentType; } public String getUploadContentType() { return this.uploadContentType; } //上传文件的文件名的setter、getter方法 public void setUploadFileName(String uploadFileName) { this.uploadFileName = uploadFileName; } public String getUploadFileName() { return this.uploadFileName; } @Override
public String execute() throws Exception
{
String newPath = getSavePath();
String newName = getUploadFileName();
File file = new File(newPath);
if (!file .exists() && !file .isDirectory())
{
file.mkdir();
}
else
{
FileOutputStream fos = new FileOutputStream(newPath + "\\" + newName);
FileInputStream fis = new FileInputStream(getUpload());
byte[] buffer = new byte[1024];
int len = 0;
while((len = fis.read(buffer)) > 0)
{
fos.write(buffer, 0, len);
}
fos.close();
fis.close();
}
return SUCCESS;
} }
我们知道，struts2使用Actoin属性对上传参数进行了封装，同样，struts2通过Action类直接通过File类型属性封装了上传文件的文件内容，但这个File属性无法获取上传文件的文件名和文件类型，所以struts2直接讲文件域中包含的上传文件名和文件类型的信息封装到uploadFileName、uploadContentType属性中，可以认为，如果表单中包含一个name属性为XXX的文件域，则对应Action需要使用3个属性来封装该文件域的信息
1. 类型为File的xxx属性: 封装了该文件域对应的文件内容 2. 类型为String的xxxFileName属性: 封装了该文件域对应的文件的文件名 3. 类型为String的xxxContentType属性: 封装了该文件域对应的文件类型
struts2的Action中的属性，除了可以用于封装HTTP请求参数外，也可以封装Action的处理结果，还可以通过在struts.xml配置文件中进行配置，接收struts2框架的注入，允许在配置文件中为该属性动态指定值
0x3: 配置文件上传的Action
配置struts2文件上传的Action与配置普通Action基本类似，唯一存在的区别是，该Action还配置了一个<param../>元素，该元素用于为该Action的属性动态分配属性值
<?xml version="1.0" encoding="GBK"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="S2_XX" extends="struts-default"> <action name="uploadPro" class="S2_XX.UploadAction"> <param name="savePath">/upload</param> <result name="success">/succ.jsp</result> </action> </package> </struts>
succ.jsp
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib prefix="s" uri="/struts-tags" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>上传成功</title> </head> <body> 上传成功! <br/> 文件标题: <s:property value=" + title"/><br/> 文件为: <img src="<s:property value="'uploadFiles/' + uploadFileName"/>"/><br/> </body> </html>
只要我们讲文件域与Action中的一个类型为File的属性关联，就可以访问到上传文件的文件内容，至于struts2使用何种Multipart解析器，对开发者完全透明的
0x4: 手动实现文件过滤
如果需要手工实现文件过滤，需要按如下步骤进行
1. 在Action中定义一个专门用于进行文件过滤的方法，名字是任意的，例如filterTypes() 2. 在filterTypes()中实现过滤判断逻辑 3. 为了让应用程序可以动态配置允许上传的文件列表，为该Action增加了一个allowTypes属性，该属性的值列出了所有允许上传的文件类型，为了可以在struts.xml文件中配置allowTypes属性的值，必须在Action类中提供setter、getter方法 4. 利用struts2的输入校验来判断用户输入的文件是否符合要求，如果不符合要求，则讲错误添加到FieldError中，该Action需要增加validate()方法，并调用filterTypes()方法 //validate()会在execute方法之前被执行
可以看到，这本质上是一个输入校验过程，只是数据来源是上传文件相关的
0x5: 拦截器实现文件过滤
使用手动实现文件过滤的方式虽然简单，但需要写大量的过滤代码，不利于程序的高层次解耦，而且开发复杂，struts2提供了一个文件上传的拦截器，通过配置该拦截器可以更轻松地实现文件过滤，struts2中文件上传的拦截器是fileUpload，为了让该拦截器起作用，只需要在该Action中配置该拦截器引用即可，本质上来说，手动的validate()也是拦截器，只是struts2提供了自动化、框架化的方式来实现这个过程
配置fileUpload拦截器时，可以为其指定两个参数
1. allowedTypes: 该参数指定允许上传的文件类型，多个文件类型之间以英文逗号","隔开 2. maximumSize: 该参数指定允许上传的文件大小，单位是字节
通过配置fileUpload的拦截器，可以很容易实现文件过滤，当文件过滤失败后，系统自动转入input逻辑视图，因此需要为该Action配置名为input的逻辑视图，除此之外，还需要显示地为该Action配置defaultStack的拦截器引用
必须显式配置引用struts2默认的拦截器栈: defaultStack，而且fileUpload拦截器必须配置在defaultStack拦截器之前
0x6: 输出错误提示
开发者可以使用<s:fielderror/>来显式输出上传失败的校验信息
0x7: 文件上传的常量配置
Relevant Link:
http://www.java3z.com/cwbwebhome/article/article2/2923.html?id=1613 https://struts.apache.org/docs/strutsproperties.html
7. Struts2标签库
Struts2的标签库使用OGNL表达式来访问ActionContext中的对象数据。为了能够访问到ActionContext中的变量，Struts2将ActionContext设置为OGNL的上下文，并将OGNL的跟对象加入ActionContext中
<p>parameters: <s:property value="#parameters.msg" /></p>
Copyright (c) 2015 Little5ann All rights reserved
