在线制作flash的网站/网上国网推广

2012年12月29日

Struts2 第8part 使用Domain Model（域模型）接收参数

上一part讲了使用action属性来接收参数，是一种普遍的方法。但如果参数多了，这种方法就不敢苟同了。这时候，使用域模型是比较方便的，在给出实例之前，解释一下什么是域模型吧。

域模型：所谓域模型就是在我们的实体域里面，真正存在的域的概念。

我在网上看到有大牛总结的比较好，我稍微改了一下内容。如果想看原文，点击下面链接：

http://blog.sina.com.cn/s/blog_5e2c3a010100pxk9.html

实例：Struts2_DomainModelParamInput

strut.xml配置文件

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.  
6. <struts> 
7.     <package name="user" extends="struts-default" namespace="/user"> 
8.         <action name="user" class="com.wwj.struts2.user.action.UserAction"> 
9.             <result name="success">/user_add_success.jsp</result> 
10.         </action> 
11.     </package> 
12. </struts> 

这个项目里，那部分是域模型？下面建立的模型类就是这里所说的域模型：User.java

1. package com.wwj.struts2.user.model;  
2.  
3. public class User {  
4.     private String name;  
5.     private int password;  
6.     public String getName() {  
7.         return name;  
8.     }  
9.     public void setName(String name) {  
10.         this.name = name;  
11.     }  
12.     public int getPassword() {  
13.         return password;  
14.     }  
15.     public void setPassword(int password) {  
16.         this.password = password;  
17.     }  
18. }  

建立完这个域模型，怎么利用它来接收参数呢？

我们来看看Action类：UserAction.java

1. package com.wwj.struts2.user.action;  
2.  
3. import com.opensymphony.xwork2.ActionSupport;  
4. import com.wwj.struts2.user.model.User;  
5.  
6. public class UserAction extends ActionSupport {  
7.     private User user;  
8.       
9.     //private UserDTO userDTO;  
10.     public String add() {  
11.         System.out.println("name=" + user.getName());  
12.         System.out.println("age=" + user.getPassword());  
13.         return SUCCESS;  
14.     }  
15.  
16.     public User getUser() {  
17.         return user;  
18.     }  
19.  
20.     public void setUser(User user) {  
21.         this.user = user;  
22.     }  
23.       
24. }  

如果像项目跟第7part那个项目 那样，如果在域模型里面有200多个属性，那么是不是要在UserAction类里面写200多个相应的属性，还要写相应的get,set呢？

这下子就可以领会到域模型的好处了吧。

五、这样，如果想给user的属性赋值，则在IE地址栏写:

http://localhost:8080/Struts2_DomainModelParamInput/user/user!add?user.name=a&user.age=8

就是user.name= user.age=

相当于调用了setUser.setName()。setUser.setAge().这就是用域模型直接接收这个参数。

 

 

但是域模型也有不适用的时候：如何是用户登录，希望有一个用户名，一个密码，一个确认密码。可是我们的用户域模型通常只有两个属性：用户名，密码。

那么用域模型就不可以了。那么如何解决这个问题呢？

1、答：可以直接用属性接收，如果喜欢用域模型，则再建立一个user。

2、除了上面方法外，，还有一种方式，就是再定义一个DTO（data transfer object）数据传输对象。，由这个对象，再生成域对象。

 

使用DTO来解决这个方法：

创建UserDTO.java

 

1. package com.wwj.struts2.user.dto;  
2.  
3. public class UserDTO {  
4.       
5.     private String name;  
6.     private String password;  
7.     private String confirmingPasswrod;  
8.     public String getName() {  
9.         return name;  
10.     }  
11.     public void setName(String name) {  
12.         this.name = name;  
13.     }  
14.     public String getPassword() {  
15.         return password;  
16.     }  
17.     public void setPassword(String password) {  
18.         this.password = password;  
19.     }  
20.     public String getConfirmingPasswrod() {  
21.         return confirmingPasswrod;  
22.     }  
23.     public void setConfirmingPasswrod(String confirmingPasswrod) {  
24.         this.confirmingPasswrod = confirmingPasswrod;  
25.     }  
26.       
27.       
28. }  

在UserAction类中用UserDTO属性

1. package com.wwj.struts2.user.action;  
2.  
3. import com.opensymphony.xwork2.ActionSupport;  
4. import com.wwj.struts2.user.model.User;  
5.  
6. public class UserAction extends ActionSupport {  
7.     private User user;  
8.       
9.     //private UserDTO userDTO;  
10.     public String add() {  
11.         System.out.println("name=" + user.getName());  
12.         System.out.println("age=" + user.getPassword());  
13.         return SUCCESS;  
14.     }  
15.  
16.     public User getUser() {  
17.         return user;  
18.     }  
19.  
20.     public void setUser(User user) {  
21.         this.user = user;  
22.     }  
23.       
24. }  

这样前台输入进来的参数，就与UserDTO相匹配了。

然后在UserAction里面处理完之后，再根据UserDTO ，生成User对象。

方法就是从UserDTO里面拿到相应的参数，添加到User里面。

UserDTO就是把参数传递过来，在new User时，再把参数传递给User对象。

那么什么时候用DTO对象呢？只能是当前台参数传递过来时，跟我们的域模型匹配不上。

这时有两种方式，一种方式是用属性接收过来，另外一种方式，就是用DTO对象。

 

index.jsp页面的代码：

1. <?xml version="1.0" encoding="GB18030" ?> 
2. <%@ page language="java" contentType="text/html; charset=GB18030" 
3.     pageEncoding="GB18030"%> 
4.  
5. <%  
6.     String context = request.getContextPath();  
7. %> 
8.  
9. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
10. <html xmlns="http://www.w3.org/1999/xhtml"> 
11.     <head> 
12.         <meta http-equiv="Content-Type" content="text/html; charset=GB18030" /> 
13.         <title>Insert title here</title> 
14.     </head> 
15.     <body> 
16.  
17.         使用Domain Model接收参数  
18.         <a href="user/user!add?user.name=a&user.age=8">添加用户</a> 
19.         <br /> 
20.  
21.     </body> 
22. </html>