javaWeb开发中entityBean的习惯用法

entity bean的作用是将与数据库交互的过程封装成对象，在servelet编写的过程中，只需要会写java，不必考虑与数据库交互细节。

实体类：

基本与数据库的表相对应，表示一个实在的对象。

 

例子：User类：

成员变量：私有属性

方法实现的功能：获取属性（可自动生成）、修改属性（可自动生成）

 

 1 package entity;
 2 public class User {
 3 
 4 //定义private属性。
 5     private String username;
 6     private String password;
 7     private String  realname;
 8     private int userType;
 9     private int sex;
10     
11     public User() {
12         super();
13     }
14 
15 //user构造函数，创建一个新user对象
16     public User(String username, String password, String realname, int userType,
17             int sex) {
18         super();
19         this.username = username;
20         this.password = password;
21         this.realname = realname;
22         this.userType = userType;
23         this.sex = sex;
24     }
25 
26 //获取属性
27     public String getUsername() {
28         return username;
29     }
30 
31 //修改属性
32     public void setUsername(String usrname) {
33         this.username = usrname;
34     }
35 
36 //获取属性
37     public String getPassword() {
38         return password;
39     }
40 
41 //修改属性
42     public void setPassword(String password) {
43         this.password = password;
44     }
45 
46 //获取属性
47     public String getRealname() {
48         return realname;
49     }
50 
51 
52 //修改属性
53     public void setRealname(String realname) {
54         this.realname = realname;
55     }
56 
57 //获取属性
58     public int getUserType() {
59         return userType;
60     }
61 
62 //修改属性
63     public void setUserType(int userType) {
64         this.userType = userType;
65     }
66 
67 //获取属性
68     public int getSex() {
69         return sex;
70     }
71 
72 //修改属性
73     public void setSex(int sex) {
74         this.sex = sex;
75     }
76     
77 }

管理类：

成员变量： 主键-对象 对应的哈希表，表示一个结果集。

方法：每个方法与一个sql语句相对应

因此new一个管理类的对象，可用于得到某条查询的结果集。

 

常见方法：

查询（select）语句：

JDBC：ResultSet rset = stmt.executeQuery(sql);

1、传入查询条件，返回一个对象结果集。（如查询所有用户）

2、如果是通过主键找唯一对象，则返回对象。（如通过user_id找唯一用户）

本函数也可用来判断是否已经存在此对象。

判断：JDBC：bool result = DBBean.hasRecord(sql);

3、判断结果集是否为空，从而判断是否满足给定条件。

 

插入（insert）语句：

JDBC：bool success=DBBean.update(sql);

1、传入user对象，插入user对象的所有信息。

因为数据库中主键不能重复，因此可能插入失败。（必须为新用户）

 

更新（update）语句：

JDBC：bool success = DBBean.update(sql);

1、传入user对象，传出是否更新成功信息。

要更新记录必须在数据库有原始记录，否则会更新失败。

 

删除(delete)语句：

JDBC：bool success = DBBean.delete(sql);

1、传入删除条件，传出删除是否成功信息

 

例子：UserMgr类

  1 package entity;
  2 
  3 import java.sql.Connection;
  4 import java.sql.ResultSet;
  5 import java.sql.SQLException;
  6 import java.sql.Statement;
  7 import java.util.HashMap;
  8 
  9 import db.DBBean;
 10 
 11 public class UserMgr {
 12     
 13     private HashMap<String, User> userList;
 14     
 15     public UserMgr() {
 16         super();
 17     }
 18     
 19     /**
 20      * 得到所有用户的列表
 21      * 
 22      * @return
 23      */
 24     
 25 
 26 //查询：传入查询条件，返回一个对象结果集。（如查询所有用户）
 27     public HashMap getUserList() {
 28         HashMap userList = new HashMap();
 29         Connection conn = null;
 30         Statement stmt = null;
 31         ResultSet rset = null;
 32         User user = null;
 33         try {
 34             conn = DBBean.getConnection();
 35             String sql = "select * from Table_user";
 36             stmt = conn.createStatement();
 37             rset = stmt.executeQuery(sql);
 38             while (rset.next()) {
 39                 user = new User(rset.getString("username"), "888888",
 40                         rset.getString("realname"), rset.getInt("userType"),
 41                         rset.getInt("sex"));
 42 
 43                 userList.put(rset.getString("username"), user);
 44             }
 45 
 46         } catch (SQLException e) {
 47             // TODO Auto-generated catch block
 48             e.printStackTrace();
 49 
 50         } finally {
 51             try {
 52                 rset.close();
 53                 stmt.close();
 54                 conn.close();
 55             } catch (Exception e) {
 56                 e.printStackTrace();
 57             }
 58         }
 59         return userList;
 60     }
 61 
 62     
 63     
 64 
 65 
 66 //插入：传入user对象，插入user对象的所有信息。
 67 //因为数据库中主键不能重复，因此可能插入失败。（必须为新用户）
 68     public int addUser(User newUser) {
 69         int result = 0; //
 70         if (findUser(newUser)) {
 71             result = 1; //
 72         } else {
 73             String sql = "insert into Table_user(username,password,realname,userType,sex)values('"
 74                     + newUser.getUsername()
 75                     + "','"
 76                     + newUser.getPassword()
 77                     + "','"
 78                     + newUser.getRealname()
 79                     + "','"
 80                     + newUser.getUserType() + "','" + newUser.getSex() + "')";
 81 
 82             if (DBBean.update(sql)) {
 83                 result = 2; //
 84             }
 85         }
 86         return result;
 87     }
 88 
 89     
 90 
 91     public boolean findUser(User user) {
 92         boolean result = false;
 93         String sql = "select * from Table_user where username=('"
 94                 + user.getUsername() + "')";
 95         result = DBBean.hasRecord(sql);
 96         return result;
 97     }
 98 
 99 
100 //删除：传入删除条件，传出删除是否成功信息
101     public boolean deleteUser(String username) {
102         boolean result = false;
103         String sql = "delete from Table_user where username=('" + username
104                 + "')";
105         result = DBBean.delete(sql);
106         System.out.println("delete user:" + sql);
107         return result;
108     }
109 
110 
111 //查询：如果是通过主键找唯一对象，则返回对象。（如通过user_id找唯一用户）
112 //判断：本函数也可用来判断是否已经存在此对象。
113     public User getUser(String username) {
114         String sql = "select * from Table_user where username=('" + username
115                 + "')";
116         User user = null;
117         Connection conn = null;
118         Statement stmt = null;
119         ResultSet rset = null;
120 
121         try {
122             conn = DBBean.getConnection();
123             stmt = conn.createStatement();
124             rset = stmt.executeQuery(sql);
125             int i = 0;
126             while (rset.next()) {
127                 user = new User(rset.getString("username"),
128                         rset.getString("password"), rset.getString("realname"),
129                         rset.getInt("userType"), rset.getInt("sex"));
130 
131             }
132 
133         } catch (SQLException e) {
134             e.printStackTrace();
135 
136         } finally {
137             DBBean.clean(conn, stmt, rset);
138         }
139         return user;
140     }
141 
142 
143 
144 
145     public int editUser(User user) {
146         int result = 1;
147         String sql = "update Table_user set username ='" + user.getUsername()
148                 + "',realname='" + user.getRealname() + "',userType='"
149                 + user.getUserType() + "' " + "where username=('"
150                 + user.getUsername() + "')";
151         //System.out.println("edit user:" + sql);
152         if (DBBean.update(sql)) {
153             result = 2; 
154         }
155         return result;
156     }
157 
158 
159 //判断:结果集是否为空，从而判断是否满足给定条件。
160     public int verifyUser(String username, String password) {
161         Connection conn = null;
162         Statement stmt = null;
163         ResultSet rset = null;
164         int result = -1;// 用户名密码不对
165         try {
166             conn = DBBean.getConnection();
167             String sql = "select * from table_user where username='" + username
168                     + "' and password='" + password + "'";
169             stmt = conn.createStatement();
170             rset = stmt.executeQuery(sql);
171             if (rset.next()) {
172                 result = rset.getInt("userType");
173                 System.out.println("user type: " + result);
174             }
175         } catch (SQLException e) {
176             System.out.println("SQLException inside verify user");
177             e.printStackTrace();
178 
179         } finally {
180             try {
181                 rset.close();
182                 stmt.close();
183                 conn.close();
184             } catch (Exception e) {
185                 e.printStackTrace();
186             }
187         }
188         return result;
189     }
190 
191 }