struts2各个功能详解（1）----参数自动封装和类型自动转换

2022-09-25 09:58:17

struts2里面的各个功能，现在确实都不清楚，完全属于新学！

通过前面的例子，有时就会疑问，这些jsp中的数据信息是怎么传送给action的？例如：

 <form action = "LoginAction.action" method="post">

     <p>用户名 <input type = "text" name="user.name"/></p>

     <p>密码 <input type = "text" name="user.password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

user.name是怎么传给action的？ action是怎么获取的？？这个就是下面讲解的struts2参数自动封装！

一：struts2参数自动封装

前篇文章对struts2的一个入门，重点是对struts2的架构图有一个大概的了解即可，之后的几篇文章，就是细化struts2，将struts2中的各种功能进行梳理，其实学完之后，对struts2的使用不外乎这几点，参数自动封装，拦截器的使用，数据校验，ognl表达(值栈和actionContext的讲解)，struts2的标签，struts2的国际化，struts2的文件上传下载。把这几个功能都学会了使用之后，struts2基本上就学完了。所以接下来的文章就是对这几个功能进行讲解。如何使用。而进行就对数据自动封装和数据类型自动转型进行讲解。

什么叫封装呢？其实就是把用户输入的数据获取到，然后输出或者封装到类里面去。

1.1 静态参数封装

action获取struts.xml中的参数--------是从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>

     <constant name="struts.enable.DynamicMethodInvocation" value="false" />

     <constant name="struts.devMode" value="true" />

     <package name="zxl" namespace="/" extends="struts-default">

         <action name="MyParaAction" class="action.MyParaAction" method="test01">

             <result name="success">/index.jsp</result>

             <param name="username">zhangsan</param>

             <param name="password">12345</param>

         </action>

         <action name="MyParaAction2" class="action.MyParaAction2" method="test01">

             <result name="success">/index.jsp</result>

             <param name="user.username">zhaosi</param>

             <param name="user.password">12345</param>

         </action>

     </package>

 </struts>

我们来看第一个action:MyParaAction.java

 package action;

 import com.opensymphony.xwork2.ActionSupport;

 public class MyParaAction extends ActionSupport {

     private String username;

     private String password;

     /**

      * @return the username

      */

     public String getUsername() {

         return username;

     }

     /**

      * @param username the username to set

      */

     public void setUsername(String username) {

         this.username = username;

     }

     /**

      * @return the password

      */

     public String getPassword() {

         return password;

     }

     /**

      * @param password the password to set

      */

     public void setPassword(String password) {

         this.password = password;

     }

     public String test01(){

         System.out.println("username : " + username + ", password : " + password);

         return "success";

     }

 }

加入本测试不关注的index.jsp

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"

     pageEncoding="ISO-8859-1"%>

 <!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>

 Hi, Struts2!!!

 </body>

 </html>

我们在浏览器输入：http://localhost:8080/Struts2Demo/MyParaAction

可以看到浏览器输出：Hi, Struts2!!!

而我们看控制台：username : zhangsan, password : 12345

可以看到在struts.xml中配置的参数传递到了action。

上面这种静态参数是直接定义在action里面，没有对应的实体内。下面我们看有实体内的静态参数怎么传给action:

MyParaAction2的action已经在前面struts.xml已经配置了。看具体action和JavaBean实体类：

 package login;

 public class User {

     private String username;

     private String password;

     /**

      * @return the username

      */

     public String getUsername() {

         return username;

     }

     /**

      * @param username the username to set

      */

     public void setUsername(String username) {

         this.username = username;

     }

     /**

      * @return the password

      */

     public String getPassword() {

         return password;

     }

     /**

      * @param password the password to set

      */

     public void setPassword(String password) {

         this.password = password;

     }

 }

 package action;

 import com.opensymphony.xwork2.ActionSupport;

 import login.User;

 public class MyParaAction2 extends ActionSupport {

     private User user;

     /**

      * @return the user

      */

     public User getUser() {

         return user;

     }

     /**

      * @param user the user to set

      */

     public void setUser(User user) {

         this.user = user;

     }

     public String test01(){

         System.out.println("user info:"+ user.getUsername() +" " + user.getPassword());

         return "success";

     }

 }

在浏览器输入：http://localhost:8080/Struts2Demo/MyParaAction2

同样浏览器输出：Hi, Struts2!!!

控制台输出：user info:zhaosi 12345

从上面可以看出，主要是根据action中定义的情况来配置struts.xml。至于传进去的参数怎么返回给jsp等，不是这个讨论的，后面继续。

——因为在我们执行test01（）方法的前后，有很多拦截器interceptor做一些工作，其中有一个叫做staticParams的拦截器，它就是专门负责看看你struts.xml里的action里是否有定义param参数，如果有的话，拿到这个参数的name名字，然后去这个action的对应的类class里面的方法method去找setXXX方法，和setXXX中set后面的XXX比较（这里它会自动转换大小写），如果发现有匹配的，就把值复制给类class里面的变量。然后我们在执行这个方法method的时候，这个变量其实就已经有值了，我们输出到控制台的时候就能看到值了。

记住：静态参数封装就是从struts.xml中获取数据传给action.

1.2 动态参数封装

动态参数封装。核心的例子就是表单数据的提交。所以这个地方开始肯定有表单jsp

1.2.1 属性驱动

1.2.1.1 基本属性驱动： 基本属性驱动就是数据模型和动作类写在一起（即动作类中有数据模型）

我们看下面这个例子，同样以上面action为例：

 package action;

 import com.opensymphony.xwork2.ActionSupport;

 public class MyParaAction extends ActionSupport {

     private String username;

     private String password;

     /**

      * @return the username

      */

     public String getUsername() {

         return username;

     }

     /**

      * @param username the username to set

      */

     public void setUsername(String username) {

         this.username = username;

     }

     /**

      * @return the password

      */

     public String getPassword() {

         return password;

     }

     /**

      * @param password the password to set

      */

     public void setPassword(String password) {

         this.password = password;

     }

     public String test01(){

         System.out.println("username : " + username + ", password : " + password);

         return "success";

     }

 }

添加表单页面：login1.jsp

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "MyParaAction" method="post">

     <p>用户名 <input type = "text" name="username"/></p>

     <p>密码 <input type = "text" name="password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

在浏览器输入：http://localhost:8080/Struts2Demo/login1.jsp, 浏览器输出：

在输入框输入用户名和密码，然后看到控制台输出：username : zxl, password : 123

这个地方注意了，我没有修改struts.xml，也就是说里面action还是配置了静态参数的。但结果是动态参数会直接覆盖静态参数的传递。

此方式简单易懂，但是在实际开发中，用的不是很多，局限性大，并且数据模型和动作类写在一个类中，不利于解耦管理。由此出现了动态参数封装的第二种方式。

1.2.1.2 ognl表达式来封装数据： 数据模型和动作类分别写在不同类中（即数据模型建立javabean）

就按照前面第二个action，即：MyParaAction2.java, 里面User 和Action不在同一个class中。

 package action;

 import com.opensymphony.xwork2.ActionSupport;

 import login.User;

 public class MyParaAction2 extends ActionSupport {

     //动作类中只有一个javabean对象。通过set.get方法进行管理

     private User user;

     /**

      * @return the user

      */

     public User getUser() {

         return user;

     }

     /**

      * @param user the user to set

      */

     public void setUser(User user) {

         this.user = user;

     }

     public String test01(){

         System.out.println("user info:"+ user.getUsername() +" " + user.getPassword());

         return "success";

     }

 }

 //所需要的数据模型：

 package login;

 public class User {

     private String username;

     private String password;

     /**

      * @return the username

      */

     public String getUsername() {

         return username;

     }

     /**

      * @param username the username to set

      */

     public void setUsername(String username) {

         this.username = username;

     }

     /**

      * @return the password

      */

     public String getPassword() {

         return password;

     }

     /**

      * @param password the password to set

      */

     public void setPassword(String password) {

         this.password = password;

     }

 }

然后看我们的表单页面：login2.jsp

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "MyParaAction2" method="post">

     <p>用户名 <input type = "text" name="user.username"/></p>

     <p>密码 <input type = "text" name="user.password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

同样在浏览器输入：http://localhost:8080/Struts2Demo/login2.jsp 在输入框输入信息：

控制台输出：user info:qwert 1234567。

同样可以看出，也没有修改struts.xml 里面同样还是配置了静态参数，但是动态参数依然会覆盖掉静态参数。

表单中的name属性值必须是javabean的对象的属性，不是简单的username了，变成了user.username。

还有动作类中set.get方法的执行顺序：

get方法：struts2先调用get方法，判断对象是否存在，如果不存在，使用反射创建一个对象。
set方法：不存在的时候，创建一个对象，把它set进去
get方法：再调用get方法得到对象，调用set方法得到对象的各种属性，为属性赋值。

在jsp页面中的user.name和user.age其实就是ognl表达式，代表着往根(root，值栈valueStack)中存放值，而值栈中的栈顶元素也就是为当前action，我们在action中设置user的get、set属性，即可以让存进来的值匹配到，进而将对应属性赋值成功。

上面这种参数封装属于OGNL中的封装对象。

下面看一下封装列表和map

下面先看OGNL封装List 例子：

 package action;

 import java.util.List;

 import com.opensymphony.xwork2.ActionSupport;

 import login.User;

 public class MyParaAction2 extends ActionSupport {

     //创建用户对象，在JSP中用OGNL封装对象来获取参数

     private User user;

     //创建List对象，在JSP中用OGNL封装列表list来获取参数

     private List<User> users;

     /**

      * @return the user

      */

     public User getUser() {

         return user;

     }

     /**

      * @param user the user to set

      */

     public void setUser(User user) {

         this.user = user;

     }        

     /**

      * @return the users

      */

     public List<User> getUsers() {

         return users;

     }

     /**

      * @param users the users to set

      */

     public void setUsers(List<User> users) {

         this.users = users;

     }

     public String test01(){

         System.out.println("user info:"+ user.getUsername() +" " + user.getPassword());

         return "success";

     }

     public String test03(){

         System.out.println("test03");

         System.out.println("user1 info:"+ users.get(0).getUsername() +" " + users.get(0).getPassword());

         System.out.println("user2 info:"+ users.get(1).getUsername() +" " + users.get(1).getPassword());

         return "success";

     }

     public String test04(){

         System.out.println("test04");

         System.out.println("user1 info:"+ users.get(0).getUsername() +" " + users.get(0).getPassword());

         System.out.println("user2 info:"+ users.get(1).getUsername() +" " + users.get(1).getPassword());

         return "success";

     }

 }

然后我们来看一下表单页面：login3.jsp

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "Login3!test03" method="post">

     <p>用户名1 <input type = "text" name="users[0].username"/></p>

     <p>密码 <input type = "text" name="users[0].password"/></p>

     <p>用户名2 <input type = "text" name="users[1].username"/></p>

     <p>密码 <input type = "text" name="users[1].password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

这个表单页面是不是和前面有点不一样了：

首先，后面传递的参数users[0].username，users[0].password，users[1].username，users[1].password就是用OGNL对List进行的封装。

　　这个地方的list必须与动作类中定义的list完全对应。

其次action处是：Login3!test03，看到这个要想到这个是动态函数调用。和struts.xml配合使用。

我们看一下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>

    <constant name="struts.enable.DynamicMethodInvocation" value="true" />

    <constant name="struts.devMode" value="false" />

    <package name="zxl" namespace="/" extends="struts-default">

        <action name="MyParaAction" class="action.MyParaAction" method="test01">

            <result name="success">/index.jsp</result>

            <param name="username">zhangsan</param>

            <param name="password">12345</param>

        </action>

        <action name="Login3" class="action.MyParaAction2" >

            <result name="success">/index.jsp</result>

        </action>

        <action name="Login4_*" class="action.MyParaAction2" method="{1}">

            <result name="success">/index.jsp</result>

        </action>

    </package>

    <include file="example.xml"/>

    <include file="struts-constant.xml"/>

    <include file="struts-dynamic.xml"/>

    <include file="struts-actionsupport.xml"/>

    <!-- Add packages here -->

</struts>

此处看到了OGNL封装List. 在此添加一个知识点：动态函数调用

动态函数调用主要有三种方式：

方式一：我们很常见，在struts.xml中显示的指示出来method。

         <action name="MyParaAction2" class="action.MyParaAction" method="test01">

             <result name="success">/index.jsp</result>

             <param name="username">zhangsan</param>

             <param name="password">12345</param>

         </action>

也就是说通过在struts.xml文件中通过配置action标签的method属性来设置即可。
但是这个方法有一个缺陷，当一个action中有很多方法的时候就需要为每个方法配置一遍action，同时通过分配不同的name属性来指定到对应的method，因此这种方法很麻烦

方式二：感叹号方式（需要在struts.xml中配置常量，启动动态方法调用）

前面的例子就是通过这种方式来动态调用test03的。

表单页面：需要在调用的时候在action名字加上感叹号加上你要调用的方法名即可。

 <form action = "Login3!test03" method="post">

在struts2.xml配置文件中需要添加常量指明可以动态调用方法才可以。

<constant name="struts.enable.DynamicMethodInvocation" value="true" />

在配置action的地方就不用写method参数了。这样test03()就会运行了。

上面那个常量属性在哪儿呢？

方式三：通配符方法调用

也就是说name属性中的占位符*可以用来指定你想指定的值。第一个通配符匹配的就是属性值为{1}的，第二个通配符就是指定属性值为{2}的值。
看下面表单定义：在action后面加上“_”+函数名
表单login4.jsp

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "Login4_test04" method="post">

     <p>用户名1 <input type = "text" name="users[0].username"/></p>

     <p>密码 <input type = "text" name="users[0].password"/></p>

     <p>用户名2 <input type = "text" name="users[1].username"/></p>

     <p>密码 <input type = "text" name="users[1].password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

然后在struts.xml中进行匹配：

         <action name="Login4_*" class="action.MyParaAction2" method="{1}">

             <result name="success">/index.jsp</result>

         </action>

运行效果同上。

OGNL封装MAP

给出例子如下：

 package action;

 import java.util.List;

 import java.util.Map;

 import com.opensymphony.xwork2.ActionSupport;

 import login.User;

 public class MyParaAction2 extends ActionSupport {

     //创建用户对象，在JSP中用OGNL封装对象来获取参数

     private User user;

     //创建List对象，在JSP中用OGNL封装列表list来获取参数

     private List<User> users;

     //创建Map对象，在JSP中用OGNL封装Map来获取参数

     private Map<String, User> userMap;

     /**

      * @return the user

      */

     public User getUser() {

         return user;

     }

     /**

      * @param user the user to set

      */

     public void setUser(User user) {

         this.user = user;

     }        

     /**

      * @return the users

      */

     public List<User> getUsers() {

         return users;

     }

     /**

      * @param users the users to set

      */

     public void setUsers(List<User> users) {

         this.users = users;

     }

     /**

      * @return the userMap

      */

     public Map<String, User> getUserMap() {

         return userMap;

     }

     /**

      * @param userMap the userMap to set

      */

     public void setUserMap(Map<String, User> userMap) {

         this.userMap = userMap;

     }

     public String test01(){

         System.out.println("user info:"+ user.getUsername() +" " + user.getPassword());

         return "success";

     }

     public String test03(){

         System.out.println("test03");

         System.out.println("user1 info:"+ users.get(0).getUsername() +" " + users.get(0).getPassword());

         System.out.println("user2 info:"+ users.get(1).getUsername() +" " + users.get(1).getPassword());

         return "success";

     }

     public String test04(){

         System.out.println("test04");

         System.out.println("user1 info:"+ users.get(0).getUsername() +" " + users.get(0).getPassword());

         System.out.println("user2 info:"+ users.get(1).getUsername() +" " + users.get(1).getPassword());

         return "success";

     }

     public String test05(){

         System.out.println("test05");

         System.out.println("user1 info:"+ userMap.get("china").getUsername() +" " + userMap.get("china").getPassword());

         System.out.println("user2 info:"+ userMap.get("Japan").getUsername() +" " + userMap.get("Japan").getPassword());

         return "success";

     }

 }

看表单login5.jsp

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "Login5_test05" method="post">

     <p>用户名1 <input type = "text" name="userMap['china'].username"/></p>

     <p>密码 <input type = "text" name="userMap['china'].password"/></p>

     <p>用户名2 <input type = "text" name="userMap['Japan'].username"/></p>

     <p>密码 <input type = "text" name="userMap['Japan'].password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

userMap['china'].username来匹配动作类中的map
map集合和上面的list集合类似，只不过在编写ognl表达式有些不同，userMap['china'].username、userMap['china'].password，userMap['china']代表的是map中key为China的value，也就找到了key为China的User对象，然后在进行封装数据即可。看struts.xml配置：同样采用模式匹配来进行动态函数调用。

         <action name="Login5_*" class="action.MyParaAction2" method="{1}">

             <result name="success">/index.jsp</result>

         </action>

在浏览器输入：http://localhost:8080/Struts2Demo/login5.jsp

在控制台输出：test05
user1 info:qaz edc
user2 info:rfv tgb。

到此属性驱动的参数封装结束。下面看模型驱动的参数封装：

1.2.1 模型驱动

使用模型驱动进行参数封装时，数据模型必须和动作类方法不在同一个类中。

使用步骤如下：
1. 动作类实现ModelDriven的接口
2. 实现接口中的抽象方法getModel
3. 使用模型驱动时，数据模型必须由我们自己实例化。即
private User user = new User();
此时在form表单中可以直接使用username进行参数传递了~
先看下动作类：MyParaAction3.java

 package action;

 import com.opensymphony.xwork2.ActionSupport;

 import com.opensymphony.xwork2.ModelDriven;

 import login.User;

 public class MyParaAction3 extends ActionSupport implements ModelDriven<User> {//动作类实现ModelDriven的接口

     //使用模型驱动时，数据模型必须由我们自己实例化

     private User user = new User();

     //实现接口中的抽象方法getModel

     @Override

     public User getModel() {

         return user;

     }

     public String test01(){

         System.out.println("user info:" + user.getUsername() +" , " + user.getPassword());

         return "success";

     }

 }

看表单数据login6.jsp：

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "Login6_test01" method="post">

     <p>用户名1 <input type = "text" name="username"/></p>

     <p>密码 <input type = "text" name="password"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

上面是动态参数传递。下面看struts.xml配置：

         <action name="Login6_*" class="action.MyParaAction3" method="{1}">

             <result name="success">/index.jsp</result>

         </action>

在浏览器输入：http://localhost:8080/Struts2Demo/login6.jsp

控制台输出：user info:zxl , 123。

这个地方有个主意：如果在jsp中不直接写username, 而是写user.username, 发现action 得不到参数。参数传递失败。

模型驱动方式通过JavaBean模型进行数据传递。只要是普通的JavaBean，就可以充当模型部分。采用这种方式，JavaBean所封装的属性与表单的属性一一对应，JavaBean将成为数据传递的载体。

记住：通过模型驱动时，在表单页面中必须直接按照JavaBean中数据模型来填写参数！

二：struts2参数自动类型转换

上面我们知道了struts2的方便之处，不用我们自己手动来获取请求参数了，struts2中的某些拦截器已经帮我们全部解决好了，我们只需要写get、set方法即可，真是非常方便。不知道大家发现了没有，从表单元素提交过来的都是String类型的，而我们在servlet中获取到表单元素后，得到的是Object类型，也就是需要我们自己手动转型。但是在struts2中，我们却不需要，是因为有这么一个机制，参数类型自动转型，获取过来的参数都是String类型的，但是如果我们需要int型，double型等，都会帮我们自己转换。

下面我们看一个例子：首先给出动作类：定义了不同的数据类型

 package action;

 import java.util.Date;

 import com.opensymphony.xwork2.ActionSupport;

 public class MyParaAction4 extends ActionSupport {

     private int age;

     private String name;

     private float money;

     private boolean married;

     private char sex;

     private Date date;

     /**

      * @return the date

      */

     public Date getDate() {

         return date;

     }

     /**

      * @param date the date to set

      */

     public void setDate(Date date) {

         this.date = date;

     }

     /**

      * @return the age

      */

     public int getAge() {

         return age;

     }

     /**

      * @param age the age to set

      */

     public void setAge(int age) {

         this.age = age;

     }

     /**

      * @return the name

      */

     public String getName() {

         return name;

     }

     /**

      * @param name the name to set

      */

     public void setName(String name) {

         this.name = name;

     }

     /**

      * @return the money

      */

     public float getMoney() {

         return money;

     }

     /**

      * @param money the money to set

      */

     public void setMoney(float money) {

         this.money = money;

     }

     /**

      * @return the married

      */

     public boolean isMarried() {

         return married;

     }

     /**

      * @param married the married to set

      */

     public void setMarried(boolean married) {

         this.married = married;

     }

     /**

      * @return the sex

      */

     public char getSex() {

         return sex;

     }

     /**

      * @param sex the sex to set

      */

     public void setSex(char sex) {

         this.sex = sex;

     }

     public String test01(){

         System.out.println("user info:" + name +","+ age +","+ money +","+ sex +","+ married +","+ date);

         return "success";

     }

 }

下面给出表单页面login7.jsp

 <%@ page language="java" contentType="text/html; charset=UTF-8"

     pageEncoding="UTF-8"%>

 <!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=UTF-8">

 <title>登录实例</title>

 </head>

 <body>

 <form action = "Login7_test01" method="post">

     <p>int <input type = "text" name="age"/></p>

     <p>String <input type = "text" name="name"/></p>

     <p>float <input type = "text" name="money"/></p>

     <p>boolean <input type = "radio" name="married" value=true checked="checked"/>是

                <input type = "radio" name="married" value=false />否</p>

     <p>char <input type = "radio" name="sex" value="男" checked="checked"/>男

                <input type = "radio" name="sex" value="女" />女</p>

     <p>日期 <input type = "text" name="date"/></p>

     <input type = "submit" value = "登录"/>

 </form>

 </body>

 </html>

struts配置就不贴出来。在浏览器输入：http://localhost:8080/Struts2Demo/login7.jsp

点击登陆，

在浏览器页面输出：Hi, Struts2!!!

在控制台输出：user info:zhangsan,30,100000.0,男,true,Thu Sep 13 00:00:00 CST 2018.

这个地方注意了：上面输入日期的格式必须是：2018-09-13。也就是说，必须是：年-月-日。如果我们按照下面格式输入：

点击登录：会报错。

看上面例子，全部都自动转型了，这里需要注意一点，在使用struts2中的日期自动转型时，表单中的日期字符串的格式是固定的，也就是说按照上面那样编程，日期格式必须是那样，没法进行自动转换。但是如果给客户使用，客户就是没按照那种格式来书写，怎么办？

struts2能够让我们自定义类型转换器，格式让我们自己来决定。自定义日期转换器：

只需要两步即可完成：1、继承DefaultTypeConverter类，重写convertValue方法　

　　　　　　　　　　2、注册转换器。也就是该转换器的作用范围。局部配置和全局配置。

下面给出例子：动作类还是上面那个，只是输入日期可以有好多个格式：

自定义转换器：MyConvert.java

 package util;

 import java.text.DateFormat;

 import java.text.ParseException;

 import java.text.SimpleDateFormat;

 import java.util.Date;

 import com.opensymphony.xwork2.conversion.TypeConversionException;

 import com.opensymphony.xwork2.conversion.impl.DefaultTypeConverter;

 public class MyConvert extends DefaultTypeConverter {

     //支持转换的多种日期格式，可增加时间格式

     private final DateFormat[] dfs={

             new SimpleDateFormat("yyyy年MM月dd日"),

             new SimpleDateFormat("yyyy-MM-dd"),

             new SimpleDateFormat("MM/dd/yy"),

             new SimpleDateFormat("yyyy.MM.dd"),

             new SimpleDateFormat("yy.MM.dd"),

             new SimpleDateFormat("yyyy/MM/dd")

         };

     /* (non-Javadoc)

      * @see com.opensymphony.xwork2.conversion.impl.DefaultTypeConverter#convertValue(java.lang.Object, java.lang.Class)

      */

     @Override

     public Object convertValue(Object value, Class toType) {

         //用特定格式转换，也就是说输入格式必须是2018/09/13,也即是说字符串的格式只能是这个才可以转换

         SimpleDateFormat sf = new SimpleDateFormat("yyyy-mm-dd");

         if(toType == java.util.Date.class){

             //获得数据

             String[] param = (String[])value;//获取日期的字符串

             for(int i=0; i < dfs.length ; i++){//遍历日期支持格式，进行转换

                 try {

                     return dfs[i].parse(param[0]);//转化为特定格式的date类型

                 } catch (ParseException e) {

                         continue;

                 }

             }

             //如果遍历完毕后仍没有转换成功，表示出现转换异常

             throw new TypeConversionException();

         }

         //将日期转换为指定的字符串格式

         if(toType == String.class){

             java.util.Date date = (Date) value;

             return sf.format(date);        //输出格式是yyyy-MM-dd

         }    

         return null;

     }

 }

然后注册转换器：分两种情况：一种是局部注册，一种是全局注册

局部注册：

位置：action类同包

名称：actionClass-conversion.properties

actionClass:action类的类名

conversion.properties：固定名

内容：属性=转换器类的全限定类名

date=util.MyConvert

这样一来，我们自定义的转换器就只能在Demo01Action中属性名为date身上使用了，超过了该范围，就会使用struts2默认的转换器。

全局注册：

位置：src

名称：xwork-conversion.properties

内容：需要转换得类=转换器

全局配置后，所有在struts2中使用Date型的都会用我们写的转换器进行转换。

本测试中用的是局部注册，然后我们在访问浏览器：http://localhost:8080/Struts2Demo/login7.jsp

在日期那一行就可以输入各种自定义的日期格式了。

到此关于struts的参数封装和自动转换学习完了。有个疑问就是struts在动作类中的参数又是怎么回显到表单的呢？这个是在哪个模块呢？struts标签？？？？

主要参考的帖子有：在此感谢！！！

https://www.cnblogs.com/jingpeipei/p/5945724.html-----日期转换

https://www.cnblogs.com/whgk/category/964133.html------各个功能介绍

https://blog.csdn.net/wjw0130/article/category/2503465-----各个功能介绍

https://blog.csdn.net/q547550831/article/category/6532892-----各个功能介绍

https://blog.csdn.net/xtayfjpk/article/details/14133589-----专门介绍拦截器

码农公寓

一：struts2参数自动封装

方式二：感叹号方式（需要在struts.xml中配置常量，启动动态方法调用）

方式三：通配符方法调用

二：struts2参数自动类型转换

相关文章