struts2简介

Posted 2020-08-20 一天一个知识点

1. MVC框架。不过有一点需要注意的是：struts2和struts2虽然名字很相似，但是在两者在代码编写风格上几乎是不一样的。那么既然有了struts1，为什么还要推出struts2。主要的原因是struts2有以下优点：

   1.在软件设计上struts2没有像struts1那样跟servlet API和struts API有着紧密的耦合，struts2的应用可以不依赖于servlet API和struts API。struts2的这种设计属于无侵入式设计，而struts1却属于侵入式设计。

   2.struts2提供了拦截器，利用拦截器可以进行AOP编程，实现如权限拦截等功能。

   3.struts2提供了类型转换器，可以把特殊的请求参数转化成需要的类型。在struts1中，如果我们要实现同样的功能，就必须向struts1的底层实现BeanUtil注册类型转换器才行。

   4.struts2提供支持多种表现层技术，如：jsp、freemarker、velocity等。

   5.struts2的输入校验可以对指定的方法进行校验，解决了struts1长久之痛。

   6.提供了全局范围、包范围和Action范围的国际化资源文件实现。

    

   struts2开发环境搭建

   搭建struts2（这里使用的是2.1.8版的）的开发环境的时，一般都会按如下的步骤：

   1.引入struts2需要的jar文件

   （一般需要commons-fileupload-1.2.1.jar、

   commons-logging-1.0.4.jar、

   freemarker-2.3.15.jar、

   ognl-2.7.3.jar、struts2-core-2.1.8.1.jar和xwork-core-2.1.6.jar这6个jar文件，可以从struts2自带的示例项目中拷贝，粘贴到WebRoot/WEB-INF/lib下面）

   2.编写struts2的配置文件（可以从struts2自带的示例项目中拷贝struts.xml，粘贴到src目录下，然后在这个基础上按照自己的需要来更改）

   3.在web.xml中加入struts2框架启动配置，具体的方法是在web.xml中加入如下的代码：

   [html] view plain copy

   1. <filter>  
   2.     <filter-name>struts2</filter-name>  
   3.     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
   4. </filter>  
   5.       
   6. <filter-mapping>  
   7.     <filter-name>struts2</filter-name>  
   8.     <url-pattern>/*</url-pattern>  
   9. </filter-mapping>  

   从上面可以看出，struts2框架是通过filter启动的。在StrutsPrepareAndExecuteFilter的init()方法中读取类路径下默认的配置文件struts.xml完成初始化操作。

   注意：struts2读取到struts.xml中的内容后，以javabean的形式保存在内存中，以后struts2对用户的每次请求处理将使用内存中的数据，而不是每次都读取struts.xml文件。

    

   struts2配置中的包介绍

   [html] view plain copy

   1. <package name="upload" namespace="/upload" extends="struts-default">  
   2.     <action name="upload" class="zhchljr.action.HelloWorldAction" method="upload">  
   3.         <result name="success">/success.jsp</result>  
   4.     </action>  
   5. </package>  

   
   struts2中使用包来管理action。包的作用和java中类包是非常类似的，它主要用于管理一组业务功能相关的action。在实际应用中，应该把一组业务功能相关的action放在同一个包下面。

   配置包是必须指定name属性，该name可以随意取名，但是必须唯一，它不对应Java的类包，如果其他类要继承该包，必须使用该属性进行使用。包的namespace属性用于定义包的命名空间，命名空间作为该action路径的一部分，如访问上面的例子中的action的路径为：/upload/upload.action。namespace属性可以不用配置，如果不指定该属性，默认的命名空间为  “”（空字符串）。

   通常每个包都必须继承struts-default包，因为struts很多核心的功能都是在这个包中定义的拦截器实现的，如：从请求中把请求参数封装到action、文件上传和数据验证等功能搜是通过拦截器实现的。struts-default包中定义了这些拦截器和result类型。换句话说，当包继承了strtus-default包才能使用struts提供的核心功能。struts-default包是在struts2-core-2.x.x.x.jar文件中的struts-default.xml中定义的。struts-default.xml是struts2的默认配置文件，struts2每次都会自动加载struts-default.xml文件。

   包还可以通过abstract=“true”定义为抽象包，抽象包中不能包含action。

   注意，在配置文件struts.xml中没有提示的解决办法：window->preference->xml catalog中添加struts-2.0.dtd文件，key type为URI，key为http://struts.apache.org/dtds/struts-2.0.dtd。

    

   action名称的搜索顺序

   1.获得请求的URI，例如uri是:http://server/struts2/path1/path2/path3/test.action

   2.首先寻找namesp为/path1/path2/path3的package，如果不存在这个package，就转第三步，如果存在这个package，则在这个package中寻找名字为test的action，当在该package中找不到action时就到默认namespace的package中寻找（默认package的命名空间为空字符串“”），如果在默认的package中还找不到该action，页面提示找不到action。

   3.寻找namespace为/path1/path2的package，如果不存在这个package，则转第四步，如果存在这个package，则在这个package中寻找名字为test的action，当在该package中找不到action时就到默认namespace的package中寻找（默认package的命名空间为空字符串“”），如果在默认的package中还找不到该action，页面提示找不到action。

   4.寻找namespace为/path1的package，如果不存在这个package，则转第五步，如果存在这个package，则在这个package中寻找名字为test的action，当在该package中找不到action时就到默认namespace的package中寻找（默认package的命名空间为空字符串“”），如果在默认的package中还找不到该action，页面提示找不到action。

   5.寻找namespace为/的package，如果存在这个package，则在这个package中寻找名字为test的action，当在该package中找不到action或不存在这个package时就到默认namespace的package中寻找（默认package的命名空间为空字符串“”），如果在默认的package中还找不到该action，页面提示找不到action。

    

   action配置中的默认值

   [html] view plain copy

   1. <package name="department" namespace="/department" extends="struts-default">  
   2.     <action name="helloworld" class="zhchljr.action.HelloWorldAction" method="execute">  
   3.         <param name="savepath">department</param>  
   4.         <result name="success">/employeeAdd.jsp?username=${username}</result>  
   5.     </action>  
   6. </package>  

   
   1.如果没有为action指定class，默认的class是ActionSupport。

   2.如果没有为action指定method，默认执行action中的execute方法。

   3.如果没有为result指定name属性，默认值为success。

    

   action中result的各种转发类型

   result配置类似于struts1中的forward，但struts2提供了多种结果类型，常用的类型有dispatcher（默认值）、redirect、redirectAction、plainText。

   result中还可以使用${属性名}表达式来访问action中的属性，表达式中的属性名为action中的属性名，如下：

   [html] view plain copy

   1. <result type="redirect">/employeeAdd.jsp?id=4{id}</result>  

   
   下面是结果类型为redirectAction的例子：

   重定向到同一个包中的action：

   [html] view plain copy

   1. <result type="redirectAction">add</result>  

   重定向到别的namespace中的action：

   [html] view plain copy

   1. <result type="redirectAction">  
   2.     <param name="actionName">xxx</param>  
   3.     <param name="namespace">/redirectAction</param>  
   4. </result>  

   
   plainText：显示原始文件内容，例如：当需要原样显示jsp文件源代码的时候，就可以使用此类型。

   [html] view plain copy

   1. <action name="source">  
   2.     <result type="plainText">  
   3.         <param name="location">/index.jsp</param>  
   4.         <param name="charSet">UTF-8</param> <!--指定读取文件的编码方式-->   
   5.     </result>  
   6. </action>  

   
   为action的属性注入值

   struts2为action的属性提供了依赖注入功能，在struts2的配置文件中，可以很方便的为action中的属性值注入值。注意，属性必须有setter方法。

   [html] view plain copy

   1. <action name="helloworld_*" class="zhchljr.action.HelloWorldAction" method="{1}">  
   2.     <param name="savepath">/upload</param>  
   3.     <result name="success">/employeeAdd.jsp?username=${username}</result>  
   4. </action>  

   上面就是通过<param>节点为action中的savePath注入"/upload"。

    

   常用的常量介绍

   default.properties文件中定义了很多常量，下面就说说通常使用到的几个。

   struts.i18n.encoding 指定默认编码集

   struts.action.extension struts2处理的默认后缀，如果需要定义多个后缀，则用逗号“,"隔开

   struts.serve.static.browserCache 设置浏览器是否缓存静态内容，默认为true（生产环境下使用），开发阶段最好关闭

   struts.configuration.xml.reload 当struts的配置文件修改后，系统是否自动重新加载该文件，默认值为false（生产环境下），开发阶段最好打开。

   struts.devMode 是否为开发模式，默认为false，（生产环境下），开发阶段最好打开，以便打印出更详细的信息

   struts.ui.theme 视图主题，一般用simple

   struts.objectFactory  于spring集成时，指定由spring负责action对象的创建

   struts.enable.DynamicMethodInvocation 是否支持动态方法调用，action!methodname，默认为true

   struts.multipart.maxSize 上传文件的大小

    

   struts处理流程

   

   StrutsPrepareAndExecuteFilter是struts2框架的核心控制器，它负责拦截由<url-pattern>/*</url-pattern>指定的所有用户请求，当用户请求到达时，该Filter会过滤用户请求。默认情况下，如果用户请求的路径不带后缀或是后缀是action，这时请求将被struts2框架处理，否则struts2将略过该请求。当请求转入struts2处理时会先经过一些列的拦截器，然后到action。与struts1不同，struts2对用户的每一个请求都会创建一个action，所以struts2是线程安全的。

    

   为应用指定多个struts配置文件

   在大部分应用里，随着应用规模的增加，系统中action的数量也会大量增加，导致struts.xml配置文件变的非常臃肿。为避免struts.xml文件过于庞大、臃肿，提高struts.xml文件的可读性，可以将一个struts.xml文件分解成过个配置文件，然后在struts.xml文件中包含其他的配置文件。下面的struts.xml文件通过include元素指定多个配置文件：

   [html] view plain copy

   1. <?xml version="1.0" encoding="UTF-8"?>  
   2. <!DOCTYPE struts PUBLIC  
   3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
   4.     "http://struts.apache.org/dtds/struts-2.0.dtd">  
   5. <struts>  
   6.     <include file="department.xml"></include>  
   7.     <include file="employee.xml"></include>  
   8.     <include file="upload.xml"></include>  
   9.     <include file="interceptor.xml"></include>  
   10. </struts>  

   通过这种方式，可以将struts中的action按模块添加在多个配置文件中。

    

   动态方法调用

   在配置文件的action中不指定method，而是在访问的时候通过actionname!methodname这种方式来访问，前提是struts.enable.DynamicMethodInvocation要设置为true。

   例如：

   [html] view plain copy

   1. <package name="employee" namespace="/employee" extends="struts-default">  
   2.     <action name="helloworld" class="zhchljr.action.HelloWorldAction">  
   3.         <result name="success">/employeeAdd.jsp?username=${username}</result>  
   4.     </action>  
   5. </package>  

   
   假设zhchljr.action.HelloWorldAction类中有add()和update()两个方法，可以使用"/employee/helloworld!add"来访问add()方法。
   

    

   使用通配符的定义action

   使用通配符*定义action，可以有效的减小配置文件的规模。下面就是一个简单的例子，和上面动态方法调用中的配置文件类似：

   [html] view plain copy

   1. <package name="employee" namespace="/employee" extends="struts-default">  
   2.     <action name="helloworld_*" class="zhchljr.action.HelloWorldAction" method="{1}">  
   3.         <param name="savepath">employee</param>  
   4.         <result name="success">/employeeAdd.jsp?username=${username}</result>  
   5.     </action>  
   6. </package>  

   假设zhchljr.action.HelloWorldAction类中有add()和update()两个方法,这样定义后，就可以使用”/employee/helloworld_add“来访问add()方法。

    

   接收请求参数

   1.采用基本类型接收参数(get/post)

   在action类中定义与请求参数同名的属性，并且该属性有set和get方法，struts2就能自动接收请求参数并赋予同名属性。

   请求路径：http://localhost:8080/struts2/product/view.action?id=1

   [java] view plain copy

   1. public class ProductAction {  
   2.     private int id;  
   3.     public int getId() {  
   4.         return id;  
   5.     }  
   6.     public void setId(int id) {//通过反射技术调用与与请求参数同名的属性的setter方法来为该属性设置值  
   7.         this.id=id;  
   8.     }  
   9. }  

   
   2.采用复合类型接收参数

   请求路径：http://localhost:8080/struts2/product/view.action?product.id=1

   [java] view plain copy

   1. public class ProductAction {  
   2.     private Product product;  
   3.     public Product getProduct() {  
   4.         return product;  
   5.     }  
   6.     public void setProduct(Product product) {  
   7.         this.product=product;  
   8.     }  
   9. }  

   struts2首先通过反射技术调用Product的默认构造器创建product对象，然后再通过反射技术调用product中与请求参数同名的属性的setter方法来设置请求参数值。

   struts2.1.6接收中文请求参数乱码的问题是个bug，原因是在获取并使用了请求参数后才调用HttpServletRequest的setCharacterEncoding()方法进行编码设置，导致应用使用的就是乱码参数。这个bug在struts2.1.8中已经被解决，如果使用的是struts2.1.6，要解决这个问题，可以采用下面的方法：

   新建一个filter，把这个filter放在struts2的filter前面，然后在doFilter()方法里添加如下的代码：

   1. public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws java.io.IOException,ServletException {  
   2.     HttpServletRequest req = (HttpServletRequest)request;  
   3.     req.setCharacterEncoding("UTF-8");//根据实际使用的编码替换  
   4.     chain.doFilter(request,response);  
   5. }  

   
   自定义类型转换器

   1.定义类

   [java] view plain copy

   1. public class DateTypeConverter extends DefaultTypeConverter {  
   2.   
   3.     @Override  
   4.     public Object convertValue(Map<String, Object> context, Object value,Class toType) {  
   5.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");  
   6.         try {  
   7.             if(toType == Date.class) {//字符串向date类型转换  
   8.                 String[] params = (String[])value;  
   9.                 return sdf.parse(params[0]);  
   10.             } else if(toType == String.class) {//date转换成string类型  
   11.                 Date date = (Date)value;  
   12.                 return sdf.format(date);  
   13.             }  
   14.         } catch (ParseException e) {  
   15.             e.printStackTrace();  
   16.         }  
   17.         return null;  
   18.     }  
   19.       
   20. }  

   2.将上面的类注册为局部类型转换器

   在action所在的包下放置ActionClassName-conversion.properties文件，ActionClassName是action的类名，后面的-conversion.properties是固定写法，在本例中，文件名为HelloWorldAction-conversion.properties。该文件的内容为：

   属性名称=类型转换器的全类名

   就本例而言，HelloWorldAction-conversion.properties文件中的内容为：

   [html] view plain copy

   1. birthday=zhchljr.type.converter.DateTypeConverter  

   
   3.将上面的类注册为全局类型转换器

   在WEB-INF/classes下放置xwork-conversion.properties文件。该文件中的内容为：

   待转换的类型=类型转换器的类全名

   对于本例而言，xwork-conversion.properties文件中的内容为：

   [html] view plain copy

   1. java.util.Date=zhchljr.type.converter.DateTypeConverter  

   
   访问或添加request/session/application属性
   
   1.如果只是添加或访问request/session/application中的属性，就可以用ActionContext类来实现。如下代码所示：
   

   [java] view plain copy

   1. ActionContext ctx = ActionContext.getContext();  
   2. ctx.getApplication().put("app", "应用范围");//相当于往ServletContext中放入app  
   3. ctx.getSession().put("ses", "session应用范围");//相当于往session中加入ses  
   4. ctx.put("req", "request应用范围");//相当于往request中加入req   
   5. ctx.put("names", Arrays.asList("刘明","茫茫大海"));  

   
   2.获取HttpServletRequest/HttpSession/ServletContext/HttpServletResponse对象，可以有两种方法实现：
   （1）通过ServletActionContext直接获取：
   

   [java] view plain copy

   1. HttpServletRequest request = ServletActionContext.getRequest();  
   2. ServletContext context = ServletActionContext.getServletContext();  
   3. request.setAttribute("req", "请求范围属性");  
   4. request.getSession().setAttribute("ses", "会话范围属性");  
   5. context.setAttribute("app", "应用范围属性");  

   
   （2）实现指定接口，由struts2框架运行时注入：
   

   [java] view plain copy

   1. public class TestAction implements ServletRequestAware, ServletResponseAware,   ServletContextAware {  
   2.     private HttpServletRequest request;  
   3.     private HttpServletResponse response;  
   4.     private ServletContext servletContext;  
   5.       
   6.     public void setServletRequest(HttpServletRequest request) {  
   7.         this.request = request;  
   8.     }  
   9.   
   10.     public void setServletResponse(HttpServletResponse response) {  
   11.         this.response = response;  
   12.     }  
   13.   
   14.     public void setServletContext(ServletContext context) {  
   15.         this.servletContext = context;  
   16.     }  
   17.   
   18. }  

   
   文件上传
   
   文件上传在项目中经常会用到，下面就来说说struts2中怎么上传文件的：
   1.引入相应的jar包（commons-fileupload-1.2.1.jar和commons-io-1.3.2.jar）
   2.把form的enctype设置为"multipart/form-data"，如下所示：
   

   [html] view plain copy

   1. <form action="<%=basePath%>upload/upload.action" method="post" name="form" enctype="multipart/form-data">  
   2.     文件1:<input type="file" name="upload"/><br/>  
   3.     <input type="submit" value="上传" />  
   4. </form>  

   3.在action类中添加如下代码中注释的几个属性。
   

   [java] view plain copy

   1. public class HelloWorldAction {  
   2.     private File upload;//得到上传的文件  
   3.     private String uploadContentType;//得到上传文件的扩展名  
   4.     private String uploadFileName;//得到上传文件的名称  
   5.               
   6.     public File getUpload() {  
   7.         return upload;  
   8.     }  
   9.   
   10.     public void setUpload(File upload) {  
   11.         this.upload = upload;  
   12.     }  
   13.   
   14.     public String getUploadContentType() {  
   15.         return uploadContentType;  
   16.     }  
   17.   
   18.     public void setUploadContentType(String uploadContentType) {  
   19.         this.uploadContentType = uploadContentType;  
   20.     }  
   21.   
   22.     public String getUploadFileName() {  
   23.         return uploadFileName;  
   24.     }  
   25.   
   26.     public void setUploadFileName(String uploadFileName) {  
   27.         this.uploadFileName = uploadFileName;  
   28.     }  
   29.       
   30.     public String upload() throws IOException {  
   31.         String realpath = ServletActionContext.getServletContext().getRealPath("/upload");  
   32.         if(upload != null) {  
   33.             File savefile = new File(realpath,uploadFileName);  
   34.             if(!savefile.getParentFile().exists()) {  
   35.                 savefile.getParentFile().mkdirs();  
   36.             }  
   37.             FileUtils.copyFile(upload, savefile);  
   38.             ActionContext.getContext().put("msg", "文件上传成功！");  
   39.         }  
   40.         return "success";  
   41.     }  
   42. }  

   
   注意，如果在上传的过程中文件的大小超过了struts2默认的文件大小的话，就会上传失败，这时候，可以根据具体的情况设置struts.multipart.maxSize的值来满足上传的需求。
   
   多文件上传
   
   在实际的项目中，有时候可能会要求上传多个文件的情况，下面就来说说上传多个文件的情况。
   1.同上。
   2.form如下所示：

   [html] view plain copy

   1. <form action="<%=basePath%>upload/upload" method="post" name="form" enctype="multipart/form-data">  
   2.     文件1:<input type="file" name="upload"/><br/>  
   3.     文件2:<input type="file" name="upload"/><br/>  
   4.     文件3:<input type="file" name="upload"/><br/>  
   5.     <input type="submit" value="上传" />  
   6. </form>  

   3.action中添加的几个属性都是数组形式的。

   [java] view plain copy

   1. public class HelloWorldAction {  
   2.     private File[] upload;//得到上传的文件  
   3.     private String[] uploadContentType;//得到上传文件的扩展名  
   4.     private String[] uploadFileName;//得到上传文件的名称  
   5.               
   6.     public File[] getUpload() {  
   7.         return upload;  
   8.     }  
   9.   
   10.     public void setUpload(File[] upload) {  
   11.         this.upload = upload;  
   12.     }  
   13.   
   14.     public String[] getUploadContentType() {  
   15.         return uploadContentType;  
   16.     }  
   17.   
   18.     public void setUploadContentType(String[] uploadContentType) {  
   19.         this.uploadContentType = uploadContentType;  
   20.     }  
   21.   
   22.     public String[] getUploadFileName() {  
   23.         return uploadFileName;  
   24.     }  
   25.   
   26.     public void setUploadFileName(String[] uploadFileName) {  
   27.         this.uploadFileName = uploadFileName;  
   28.     }  
   29.       
   30.     public String upload() throws IOException {  
   31.         String realpath = ServletActionContext.getServletContext().getRealPath("/upload");  
   32.         if(upload != null) {  
   33.             for(int i=0; i<upload.length; i++) {  
   34.                 File savefile = new File(realpath,uploadFileName[i]);  
   35.                 if(!savefile.getParentFile().exists()) {  
   36.                     savefile.getParentFile().mkdirs();  
   37.                 }  
   38.                 FileUtils.copyFile(upload[i], savefile);  
   39.             }  
   40.             ActionContext.getContext().put("msg", "文件上传成功！");  
   41.         }  
   42.         return "success";  
   43.     }  
   44. }  

   
   自定义拦截器
   
   自定义拦截器要实现com.opensymphony.xwork2.interceptor.Interceptor接口。下面是一个自定义拦截器的例子：
   

   [java] view plain copy

   1. public class PermissionInterceptor implements Interceptor {  
   2.   
   3.     public void destroy() {  
   4.           
   5.     }  
   6.   
   7.     public void init() {  
   8.   
   9.     }  
   10.   
   11.     public String intercept(ActionInvocation invocation) throws Exception {  
   12.         Object user = ActionContext.getContext().getSession().get("user");  
   13.         if(user != null) {  
   14.             return invocation.invoke();  
   15.         } else {  
   16.             ActionContext.getContext().put("message", "你没有执行权限！");  
   17.         }  
   18.         return "success";  
   19.     }  
   20.   
   21. }  

   
   接下来，就要在配置文件中注册拦截器，具体的做法是：
   
   

   [html] view plain copy

   1. <interceptors>  
   2.     <interceptor name="permission" class="zhchljr.interceptor.PermissionInterceptor"></interceptor>  
   3. </interceptors>  

   
   为action指定拦截器，具体的做法是：
   

   [html] view plain copy

   1. <action name="interceptor" class="zhchljr.action.HelloWorldAction" method="interceptor">  
   2.     <interceptor-ref name="permission"></interceptor-ref>  
   3. </action>  

   
   但是这样做了以后，就会出现一个问题，struts2中为一个action指定拦截器后，默认的defaultStack中的拦截器就不起作用了，也就是说struts2的众多核心功能都使用不了了（struts2的许多核心功能都是通过拦截器实现的），为了解决这个问题，引入拦截器栈，先使用系统默认的拦截器，然后再来使用自定义的拦截器，具体的做法是：
   

   [html] view plain copy

   1. <interceptors>  
   2.     <interceptor name="permission" class="zhchljr.interceptor.PermissionInterceptor"></interceptor>  
   3.     <interceptor-stack name="permissionStack">  
   4.         <interceptor-ref name="defaultStack"></interceptor-ref>  
   5.         <interceptor-ref name="permission"></interceptor-ref>  
   6.     </interceptor-stack>  
   7. </interceptors>  

   如果希望包下的所有action都使用自定义的拦截器，可以把拦截器设置为默认拦截器，具体的实现方式是：
   

   [html] view plain copy

   1. <default-interceptor-ref name="permissionStack"></default-interceptor-ref>  

   
   注意：每个包中只能有一个默认的拦截器；一旦为包中的某个action指定了拦截器，则默认的拦截器就不起作用了。
   
   
   输入校验
   
   struts2中可以实现对action中的所有方法进行校验，也可以实现对指定的方法进行校验。可以用如下两种方式来实现输入校验。
   
   1.采用手工编写代码实现：
   <1>手工编写代码实现对action中的所有方法进行校验：通过编写validate()方法实现，validate()会校验action中所有与execute方法签名相同的方法。当某个数据校验失败时，应该采用addFieldError()方法往系统的filedErrors添加校验失败信息（为了使用该方法，action可以继承ActionSupport），如果系统的filedErrors包含失败信息，struts2会将请求发到名为input的result，在input视图中可以通过<s:fielderror/>显示失败信息。具体的参见下面的例子：
   

   [html] view plain copy

   1. <s:fielderror></s:fielderror>  
   2. <form method="post" action="<%=basePath%>person/manage_save.action">  
   3.        用户名:<input type="text" name="username"/>不能为空<br/>  
   4.        手机号:<input type="text" name="mobile"/>不能为空，并且要符合手机号的格式，1，3/5/8，后面是9个数字<br/>  
   5.        <input type="submit" value="提交"/>  
   6. </form>  

   
   页面中使用<s:fielderror></s:fielderror>来显示失败信息。
   

   [java] view plain copy

   1. public void validate() {//会对action中的所有方法进行校验  
   2.     if(this.username == null || this.username.trim().equals("")) {  
   3.         this.addFieldError("username", "用户名不能为空！");  
   4.     }  
   5.           
   6.     if(this.mobile == null || this.mobile.trim().equals("")) {  
   7.         this.addFieldError("mobile", "手机号不能为空！");  
   8.     } else {  
   9.         if(!Pattern.compile("^1[358]\\d{9}{1}quot;).matcher(this.mobile).matches()) {  
   10.             this.addFieldError("mobile", "手机号格式不正确！");  
   11.         }  
   12.     }  
   13. }  

   
   <2>手工编写代码实现对action中的指定方法进行校验：通过编写validateXxx()方法实现，validateXxx()会校验action中方法名为xxx的方法。当某个数据校验失败时，应该采用addFieldError()方法往系统的filedErrors添加校验失败信息（为了使用该方法，action可以继承ActionSupport），如果系统的filedErrors包含失败信息，struts2会将请求发到名为input的result，在input视图中可以通过<s:fielderror/>显示失败信息。该校验方法示例如下：
   

   [java] view plain copy

   1. public void validateUpdate() {//会对action中的update方法进行校验  
   2.     if(this.username == null || this.username.trim().equals("")) {  
   3.         this.addFieldError("username", "用户名不能为空！");  
   4.     }  
   5.           
   6.     if(this.mobile == null || this.mobile.trim().equals("")) {  
   7.         this.addFieldError("mobile", "手机号不能为空！");  
   8.     } else {  
   9.         if(!Pattern.compile("^1[358]\\d{9}{1}quot;).matcher(this.mobile).matches()) {  
   10.             this.addFieldError("mobile", "手机号格式不正确！");  
   11.         }  
   12.     }  
   13. }  

   
   *.输入校验的流程：
   （1）类型转换器对请求参数进行执行类型转换，并把转换后的值赋给action中的属性。
   （2）如果在执行转换的过程中出现异常，系统会将异常信息保存到ActionContext中，conversionError拦截器将异常信息封装到fieldErrors中。不管类型转换是否异常，都会转入第3步。
   （3）系统通过放射技术先调用action中的validateXxx()方法，xxx为方法名。
   （4）再调用action的validate()方法。
   （5）经过上面四步，如果系统中的fieldErrors存在错误信息（即存放错误信息的集合的size大于0），系统会将请求转发至名为input的视图。如果系统中的filedErrors中没有错误信息，系统将执行action中的处理方法。
   
   2.基于xml配置方式来实现：
   <1>基于xml配置方式实现对action中的所有方法进行校验：Action要继承ActionSupport，并且提供校验文件，校验文件和action类在同一个包下，文件的命名规则是：ActionClassName-validation.xml，其中的ActionClassName为action的简单类名，-validation为固定写法。下面是一个校验文件（PersonAction-validation.xml）的例子：
   

   [html] view plain copy

   1. <?xml version="1.0" encoding="UTF-8"?>  
   2. <!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.3//EN"  
   3.        "http://www.opensymphony.com/xwork/xwork-validator-1.0.3.dtd">  
   4. <validators>  
   5.     <field name="username">  
   6.         <field-validator type="requiredstring">  
   7.             <param name="trim">true</param><!-- 默认为true -->  
   8.             <message>用户名不能为空！</message>  
   9.         </field-validator>  
   10.     </field>  
   11.     <field name="mobile">  
   12.         <field-validator type="requiredstring">  
   13.             <param name="trim">true</param><!-- 默认为true -->  
   14.             <message>手机号不能为空！</message>  
   15.         </field-validator>  
   16.         <field-validator type="regex">  
   17.              <param name="expression"><![CDATA[^1[358]\d{9}$]]></param>  
   18.             <message>手机格式不正确！</message>  
   19.         </field-validator>  
   20.     </field>  
   21. </validators>  

   
   说明：<field>指定action中要校验的属性，<field-validator>指定校验器，上面指定的requiredstring校验器是由系统提供的，系统提供了能满足大部分验证需求的校验器，这些校验器可以在文件xwork-core-2.X.X.jar中的com.opensymphony.xwork2.validator.validators下的default.xml中找到。<message>为校验失败后的提示信息，如果需要国际化，可以为message指定key属性，key的值为资源文件中的key。在这个配置文件中，对action中字符串类型的username属性进行验证，首先要求调用trim()去掉空格，然后判断用户名是否为空。对string类型的mobile字段的校验使用了regex这个校验器。
   
   <2>基于xml配置方式实现对action中指定的方法进行校验：当校验文件名为ActionClassName-validation.xml时，会对action中的所有方法进行校验。如果要对action中的某一个方法进行校验，那么校验文件的名称为：ActionClassName-ActionName-validation.xml。其中ActionName为struts.xml中的action的名称。配置文件如下：
   

   [html] view plain copy

   1. <package name="person" namespace="/person" extends="struts-default">  
   2.     <action name="manage_*" class="zhchljr.action.PersonAction" method="{1}">  
   3.         <result name="message">/WEB-INF/page/message.jsp</result>  
   4.         <result name="input">/index.jsp</result>  
   5.     </action>  
   6. </package>  

   
   假设PersonAction中有save()和update()两个方法。对save方法进行校验的文件名为PersonAction-manage_save-validation.xml，对update方法进行校验的文件名位PersonAction-manage_update-validation.xml。
   
   *.基于xml校验的一些特点：
   当为某个action提供了ActionClassName-validation.xml和ActionClassName-ActionName-validation.xml两种规则的校验文件时，系统按下面的顺序寻找校验文件：
   （1）ActionClassName-validation.xml
   （2）ActionclassName-ActionName-validation.xml
   系统搜索到第一个校验文件时，还会继续搜索后面的校验文件，当搜索到所有校验文件时，会把校验文件里的所有校验规则汇总，然后全部应用于action方法的校验。如果两个文件指定的校验规则冲突，则只使用后面文件中的校验规则。
   
   当action继承了另一个action时，父类action的校验文件会被先搜索到。还是按照上面的顺序，校验规则为四个文件的总和。
   
   
   国际化
   
   1.准备资源文件，资源文件的命名格式是：
   baseName_language_country.properties
   其中baseName为资源文件的基本名，可以自定义。但language和country必须是java支持的语言和国家。如：
   中国大陆：baseName_zh_CN.properties
   美国：baseName_en_US.properties
   
   现在为应用添加两个资源文件：
   第一个存放中文：welcome_zh_CN.properties
   内容为：welcome=欢迎来到中国
   第二个存放英文：welcome_en_US.properties
   内容为：welcome=welcome to china
   
   对于中文的属性文件，编写好后，应该使用jdk自带的native2ascii命令把文件转成unicode编码的文件，命令的使用方式如下：
   native2ascii src.properties dest.properties
   
   2.配置全局资源文件
   准备好资源文件后， 可以在struts.xml中通过struts.custom.i18n.resources把资源文件定义为全局资源文件，如下所示：
   

   [html] view plain copy

   1. <constant name="struts.custom.i18n.resources" value="welcome"></constant>  

   
   3.输出国际化信息
   （1）在jsp页面中使用<s:text name=""/>标签输出国际化信息，如：<s:text name="welcome"/>，name为资源文件中的key
   （2）在action类中，可以继承ActionSupport，使用getText()方法得到国际化信息，该方法的第一个参数用于指定资源文件中的key
   （3）在表单标签中，通过key属性指定资源文件中的key，如：<s:textfield name="realname" key="welcome"/>
   
   *.输出带占位符的国际化信息
   资源文件中的内容为：welcome=package:{0}，欢迎来到传智播客{1}
   
   在jsp页面输出带占位符的国际化信息
   

   [html] view plain copy

   1. <s:text name="welcome">  
   2.     <s:param>liuming</s:param>  
   3.     <s:param>study</s:param>  
   4. </s:text>  

   
   在action类中获取带占位符的国际化信息，可以使用getText(String key,String[] args)或getText(String key,List args)。
   
   4.包范围的资源文件
   在一个大型应用中，整个应用有大量的内容需要实现国际化，如果把国际化的内容都放置在全局资源文件属性中，会导致资源文件过于庞大、臃肿，不便于维护，这个时候可以针对不同模块，使用包范围来组织国际化文件。具体的做法如下：
   
   在java的包下放置package_language_country.properties资源文件，package为固定写法，处于该包及子包下的action都可以访问该资源。当查找指定key的消息时，系统会先从package资源文件中查找，当找不到对应的key时，才会从全局资源文件中找。
   
   5.action范围的资源文件
   可以为某个action单独指定资源文件，方法如下：
   在action类所在的路径，放置ActionClassName_language_country.properties资源文件，ActionClassName为action类的简单名称。
   
   当查找指定key的消息时，系统会先从ActionClassName_language_country.properties资源文件中查找，如果没有找到对应的key，然后沿着当前包向上查找基本名为package的资源文件，一直找到最顶层包。如果还没有找到指定的key，最后会从全局资源文件中查找。
   
   6.jsp中直接访问某个资源文件
   struts2提供了<s:i18n>标签，使用该标签可以在类路径下直接从某个资源文件中获取国际化数据，而无需任何配置。
   

   [html] view plain copy

   1. <s:i18n name="welcome">  
   2.     <s:text name="welcome"/>  
   3. </s:i18n>  

   
   如果要访问的资源在类路径的某个包下，可以这样访问：
   

   [html] view plain copy

   1. <s:i18n name="zhchljr/action/package">  
   2.     <s:text name="welcome"/>  
   3. </s:i18n>  

   访问包zhchljr.action包下基本名为package的资源文件。
   
   还可以访问action范围的资源文件:
   

   [html] view plain copy

   1. <s:i18n name="zhchljr/action/PersonManageAction">  
   2.     <s:text name="welcome">  
   3.        <s:param>liuming</s:param>  
   4.        <s:param>study</s:param>  
   5.     </s:text>  
   6. </s:i18n>  

   
   
   OGNL表达式语言
   
   OGNL是Object Graphic Navigation Language（对象导航图语言）的缩写，它是一个开源项目。Struts2框架使用OGNL作为默认的表达式语言。
   
   相对于EL表达式，它提供了一些平时需要的功能。
   （1）支持对象方法调用，如xxx.save()
   （2）支持类静态方法调用和值访问，表达式的格式为@全类名（包括包路径）@方法名(参数)，如：@[email protected](‘foo%s‘,‘bar‘)或@[email protected]
   （3）操作集合对象
   
   Ognl有一个上下文（Context）概念，说白了上下文就是一个Map结构，它实现了java.util.Map接口，在struts2中context的实现为ActionContext，下面是它的结构示意图：
   
   
   当struts2接受一个请求时，会迅速创建出ActionContext，ValueStack，action，然后把action存放进ValueStack，所以action的实例变量可以被ognl访问。
   
   访问上下文中的对象需要使用#标注命名空间，如#application，#session等。
   
   ognl有一个根对象（root对象），在struts2中根对象就是ValueStack，如果要访问根对象中对象的属性，则可以省略#命名空间，直接访问该对象的属性即可。
   
   在struts2中，根对象ValueStack的实现为OgnlValueStack,该对象不是只存放单个值，而是存放一组对象。在OgnlValueStack中有一个List类型的root变量，就是使用它存放一组对象。
   
   在root变量中处于第一位的对象叫做栈顶对象。通常在OGNL表达式里面直接写上属性的名称即可访问root变量里对象的属性，搜索顺序是从栈顶对象开始，依次往下搜索，直到找到为止。
   
   需要注意的一点是，struts2中ognl表达式要配合struts标签才可以使用。如：<s:property value="name"/>
   
   由于ValueStack是Struts2中的ognl的根对象，如果用户需要访问ValueStack中的对象，在jsp页面可以通过下面的EL表达式访问ValueStack中对象的属性。
   
   ${foo}//获得ValueStack中某个对象的foo属性
   
   如果访问Context中的别的对象，由于它们不是根对象，所以在访问是需要添加#前缀。
   （1）application对象：用于访问ServletContext，例如#application.userName或#application[‘userName‘]，相当于调用session的getAttribute("userName")
   （2）session对象：用于访问HttpSession，例如#session.userName或#session[‘userName‘]，相当于调用ServletContext的getAttribute("userName")
   （3）request对象：用于访问HttpServletRequest对象，例如#request.userName或#request[‘userName‘]，相当于调用request的getAttribute("userName")
   （4）parameters对象：用于访问Http的请求参数，例如#parameters.userName或#parameters[‘userName‘]，相当于调用request的getParameter("userName")
   （5)attr对象：用于按page->request->session->application的顺序访问其属性。
   
   采用ognl表达式创建List/Map集合对象：如果需要一个集合元素的时候（例如list或map），可以使用ognl中通集合相关的表达式，使用如下代码可以直接生成一个list对象：
   

   [html] view plain copy

   1. <s:set var="list" value="{‘第一个‘,‘第二个‘,‘第三个‘}"></s:set><!-- 默认放在OGNL context中 -->  
   2. <!--s:iterator中有一个特点，会把当前迭代的对象放在栈顶中  -->  
   3. <s:iterator value="#list">  
   4.     <s:property/><br/>  
   5. </s:iterator>  

   
   set标签用于将某个值放入某个范围。
   scope指定变量被放置的范围，该属性可以接受application、session、request、page和action。如果没有该属性，则默认放在OGNL context中。
   value赋给变量的值，如果没有该属性，则将ValueStack栈顶的值放入赋给变量。
   
   生成一个map对象：
   

   [html] view plain copy

   1. <s:set var="maps" value="#{‘key1‘:90,‘key2‘:35,‘key3‘:12}"></s:set>  
   2. <s:iterator value="#maps">  
   3.     <s:property value="key"/>=<s:property value="value"/><br/>  
   4. </s:iterator>  

   
   采用ognl表达式判断对象是否在集合中：对于集合类型，ognl表达式可以使用in和not in两个符号，其中in表示指定的元素是否在集合中，而not in表示指定的元素是否不再集合中。如下所示：
   

   [html] view plain copy

   1. <s:if test="‘foo‘ not in {‘xxx‘,‘foo1‘,‘foo2‘}">  
   2.     不在  
   3. </s:if>  
   4. <s:else>  
   5.     在  
   6. </s:else>  

   
   OGNL表达式的投影功能：
   除了in和not in外，ognl还允许使用某个规则获得集合对象的子集，常用的有以下三个操作符：
   ?：获得所有符合逻辑的元素
   ^：获得符合逻辑的第一个元素
   $：获得符合逻辑的最后一个元素
   例如：
   

   [html] view plain copy

   1. <s:iterator value="books.{?#this.price>60}">  
   2.     <s:property value="name"/>，价格:<s:property value="price"/><br/>  
   3. </s:iterator>  

   在上面的代码中，直接在集合后跟.{}运算符表明用于取出该集合的子集，{}内的表达式用于获取符合条件的元素，this表示为了从大集合books中筛选数据到小集合，需要对大集合books进行迭代，this代表当前迭代的元素。本例中用与获取集合中价格大于60的书的集合。
   
   
   struts2中的标签
   
   struts2中标签分为通用标签和UI标签，通用标签包含控制标签和数据标签，如下图所示：
   
   
   UI标签包含form标签，非form标签和Ajax标签，如下图所示：
   
   
   这里有很多的标签，掌握一些常用的，然后在用到的时候查struts2帮助文档。
   
   
   使用<s:token/>标签防止重复提交
   
   使用<s:token/>标签可以防止重复提交，具体的用户如下：
   
   1.在表单中加入<s:token/>，例如：
   

   [html] view plain copy

   1. <s:form action="token" namespace="/test" method="post">  
   2.     姓名：<s:textfield name="name" label="姓名"></s:textfield>  
   3.     <s:token></s:token>  
   4.     <s:submit label="提交"></s:submit>  
   5. </s:form>  

   2.在action中配置token拦截器，如下所示：

   [html] view plain copy

   1. <action name="token" class="zhchljr.action.PersonAction">  
   2.     <interceptor-ref name="defaultStack"></interceptor-ref>  
   3.     <interceptor-ref name="token"></interceptor-ref>  
   4.     <result name="success">/WEB-INF/page/message.jsp</result>  
   5.     <result name="invalid.token">/index.jsp</result>  
   6. </action>  

   

   上面加入了token拦截器和invalid.token result，因为token拦截器在会话状态的token与请求状态的token不一致时，直接返回invalid.token result。
   
   以上就是这两天在看传智播客黎活明老师的sturs2视频时做的一些学习笔记，通过这两天的学习可以说是入门了，后面在具体使用的过程中可以继续深入学习。

    

   顶

   6

   踩

   0

    

    

   • 上一篇struts2关于A web application created a ThreadLocal with key of type 异常解决办法
   • 下一篇Hibernate学习笔记

    
    

   参考知识库

   

   Java EE知识库

   1120关注|581收录

   

   Java SE知识库

   9391关注|454收录

   

   Java Web知识库

   9681关注|1017收录