1.com.hanchao.util包是工具类；

1. package com.hanchao.util; 
2.  
3. import java.sql.Connection; 
4. import java.sql.DriverManager; 
5. import java.sql.PreparedStatement; 
6. import java.sql.ResultSet; 
7. import java.sql.SQLException; 
8.  
9. /** 
10.  * 简化Dao写法的工具类 
11.  * @author hanlw 
12.  * 2012-07-09 
13.  */ 
14. public class DBHelp { 
15.  
16.     /** 
17.      * 为什么要写一个工具类呢？ 
18.      *  
19.      * 因为这样可以简化我们的Dao类的写法。更何况一个实体类对应一个Dao。 
20.      * 如果每一个Dao都按照上面一篇文章写，那是很费事的啊！！ 
21.      */ 
22.      
23.     //1.下面是几个常量 
24.     private static final String DRIVER = "com.mysql.jdbc.Driver"; 
25.     private static final String URL = "jdbc:mysql://127.0.0.1:3306/mydb"; 
26.     private static final String DB_NAME = "root"; 
27.     private static final String DB_PASSWORD = "root"; 
28.      
29.     /** 
30.      * 获取数据库的连接 
31.      * @return 
32.      */ 
33.     public Connection getConnection() { 
34.         Connection con = null; 
35.          
36.         try { 
37.             Class.forName(DRIVER); 
38.             con = DriverManager.getConnection(URL,DB_NAME,DB_PASSWORD); 
39.         } catch (ClassNotFoundException e) { 
40.             e.printStackTrace(); 
41.         } catch (SQLException e) { 
42.             e.printStackTrace(); 
43.         } 
44.         return con;  
45.     } 
46.      
47.     /** 
48.      *  该方法用来执行insert,update,delete操作 
49.      * @param sql SQL语句 
50.      * @param args  不定项参数 
51.      * @return 
52.      */ 
53.     public int executeSQL(String sql,Object...args) { 
54.         Connection con = getConnection(); 
55.         PreparedStatement sta = null; 
56.         int rows = 0; 
57.          
58.         try { 
59.             sta = con.prepareStatement(sql); 
60.              
61.             //注意下面的循环语句 
62.             for (int i = 0; i < args.length; i++) { 
63.                 sta.setObject(i+1, args[i]); //为什么是i+1呢？因为你从前面的文章知道，那是从1开始的！ 
64.             } 
65.              
66.             rows = sta.executeUpdate(); 
67.             if(rows > 0) { 
68.                 System.out.println("operate successfully !"); 
69.             } else { 
70.                 System.out.println("fail!"); 
71.             } 
72.              
73.         } catch (SQLException e) { 
74.             e.printStackTrace(); 
75.         } finally { 
76.             this.close(sta, con); 
77.         } 
78.         return rows; 
79.     } 
80.      
81.     /** 
82.      * rs,sta,con的关闭 
83.      * @param rs 
84.      * @param sta 
85.      * @param con 
86.      */ 
87.     public void close(ResultSet rs, PreparedStatement sta, Connection con) { 
88.         try { 
89.             if(rs != null) { 
90.                 rs.close(); 
91.             } 
92.         } catch (SQLException e) { 
93.             e.printStackTrace(); 
94.         } finally { 
95.             try { 
96.                 if(sta != null) { 
97.                     sta.close(); 
98.                 } 
99.             } catch (SQLException e) { 
100.                 e.printStackTrace(); 
101.             } finally { 
102.                 try { 
103.                     if(con != null) { 
104.                         con.close();     
105.                     } 
106.                 } catch (SQLException e) { 
107.                     e.printStackTrace(); 
108.                 } 
109.             } 
110.         } 
111.     } 
112.     /** 
113.      * sta,con的关闭方法 
114.      * @param sta 
115.      * @param con 
116.      */ 
117.     public void close(PreparedStatement sta, Connection con) { 
118.         this.close(null, sta, con); 
119.     } 
120.      
121.     //-------------------------------------- 
122. } 

2.com.hanchao.entity包是实体类User;

1. package com.hanchao.entity; 
2. /** 
3.  * 实体类 
4.  * @author hanlw 
5.  * 2012-07-09 
6.  */ 
7. public class User { 
8.  
9.     private int id; 
10.     private String username; 
11.     private String address; 
12.      
13.     //getter...setter... 
14.     public int getId() { 
15.         return id; 
16.     } 
17.     public void setId(int id) { 
18.         this.id = id; 
19.     } 
20.     public String getUsername() { 
21.         return username; 
22.     } 
23.     public void setUsername(String username) { 
24.         this.username = username; 
25.     } 
26.     public String getAddress() { 
27.         return address; 
28.     } 
29.     public void setAddress(String address) { 
30.         this.address = address; 
31.     } 
32.      
33.      
34. } 

3.com.hanchao.dao包中是UserDao类；可以看到较上篇文章，写法简便多了！

1. package com.hanchao.dao; 
2.  
3. import java.sql.Connection; 
4. import java.sql.PreparedStatement; 
5. import java.sql.ResultSet; 
6. import java.sql.SQLException; 
7. import java.util.ArrayList; 
8. import java.util.List; 
9.  
10. import com.hanchao.entity.User; 
11. import com.hanchao.util.DBHelp; 
12.  
13. /** 
14.  * 实体类对应的Dao类 
15.  * @author hanlw 
16.  * 2012-07-09 
17.  */ 
18. public class UserDao { 
19.  
20.     /** 
21.      * 说明：通过DBHelp类，我们可以简化dao中的insert,update,delete操作 
22.      *  
23.      * 以后有机会的话，咱们也可以简化对retrieve的操作！ 
24.      */ 
25.      
26.     private DBHelp db = new DBHelp(); 
27.      
28.     /** 
29.      * 对t_user的插入操作 
30.      * @param user 
31.      * @return 
32.      */ 
33.     public int insert(User user) { 
34.         String sql = "insert t_user(username,address) values(?,?)"; 
35.         return db.executeSQL(sql, user.getUsername(),user.getAddress()); 
36.     } 
37.      
38.     /** 
39.      * 对t_user的更新操作 
40.      * @param user 
41.      * @return 
42.      */ 
43.     public int update(User user) { 
44.         String sql = "update t_user set username=?,address=? where id=?"; 
45.         return db.executeSQL(sql, user.getUsername(),user.getAddress(),user.getId()); 
46.     } 
47.      
48.     /** 
49.      * 对t_user的删除操作 
50.      * @param id 
51.      * @return 
52.      */ 
53.     public int delete(int id) { 
54.         String sql = "delete from t_user where id=?"; 
55.         return db.executeSQL(sql, id); 
56.     } 
57.      
58.     /** 
59.      * 对t_user的全检索 
60.      * @return 
61.      */ 
62.     public List<User> retrieve() { 
63.         List<User> list = new ArrayList<User>(); 
64.         Connection con = db.getConnection(); 
65.         PreparedStatement sta = null; 
66.         ResultSet rs = null; 
67.          
68.         try { 
69.             String sql = "select id,username,address from t_user"; 
70.             sta = con.prepareStatement(sql); 
71.             rs = sta.executeQuery(); 
72.              
73.             while(rs.next()) { 
74.                 User user = new User(); 
75.                 user.setId(rs.getInt("id")); 
76.                 user.setUsername(rs.getString("username")); 
77.                 user.setAddress(rs.getString("address")); 
78.                 list.add(user); 
79.             } 
80.         } catch (SQLException e) { 
81.             // TODO Auto-generated catch block 
82.             e.printStackTrace(); 
83.         } finally { 
84.             db.close(rs,sta, con); 
85.         } 
86.         return list; 
87.     } 
88.      
89.     /** 
90.      * 跟id进行检索 
91.      * @param id 用户的id号 
92.      * @return 
93.      */ 
94.     public User retrieveById(int id) { 
95.         Connection con = db.getConnection(); 
96.         PreparedStatement sta = null; 
97.         ResultSet rs = null; 
98.         User user = null; 
99.          
100.         try { 
101.             String sql = "select id,username,address from t_user where id=?"; 
102.             sta = con.prepareStatement(sql); 
103.             sta.setInt(1, id); 
104.             rs = sta.executeQuery(); 
105.             if(rs.next()) { 
106.                 user = new User(); 
107.                 user.setId(rs.getInt("id")); 
108.                 user.setUsername(rs.getString("username")); 
109.                 user.setAddress("address"); 
110.             } 
111.              
112.         } catch (SQLException e) { 
113.             e.printStackTrace(); 
114.         } finally { 
115.             db.close(rs,sta, con); 
116.         } 
117.         return user; 
118.     } 
119.      
120.     //------------------------------------------- 
121. } 

4.com.hanchao.test包是测试类Test;

1. package com.hanchao.test; 
2.  
3. import java.util.List; 
4.  
5. import com.hanchao.dao.UserDao; 
6. import com.hanchao.entity.User; 
7.  
8. /** 
9.  * 测试类 
10.  * @author hanlw 
11.  * 2012-07-09 
12.  */ 
13. public class Test { 
14.  
15.     public static void main(String[] args) { 
16.          
17.         /** 
18.          * 1.insert() 
19.          */ 
20. /*      UserDao userDao = new UserDao(); 
21.         User user = new User(); 
22.          
23.         user.setUsername("chenchen"); 
24.         user.setAddress("yancheng"); 
25.         userDao.insert(user); 
26. */ 
27.          
28.         /** 
29.          * 2.update() 
30.          */ 
31. /*      UserDao userDao = new UserDao(); 
32.         User user = new User(); 
33.          
34.         user.setId(22); 
35.         user.setUsername("chen"); 
36.         user.setAddress("shanghai"); 
37.         userDao.update(user); 
38. */ 
39.          
40.         /** 
41.          * 3.delete() 
42.          */ 
43. //      UserDao userDao = new UserDao(); 
44. //      userDao.delete(22); 
45.          
46.         /** 
47.          * 4.retrieve() 
48.          */ 
49.         UserDao userDao = new UserDao(); 
50.         List<User> list = userDao.retrieve(); 
51.         for(User user : list) { 
52.             System.out.println(user.getUsername()+"\t"+user.getAddress()); 
53.         } 
54.          
55.          
56.         /** 
57.          * 5.检索某一个用户 
58.          */ 
59.         User u = userDao.retrieveById(23); 
60.         System.out.println(u.getClass()+"\n"+u.getAddress()); 
61.     } 
62. }