Go语言视频零基础入门到精通

javalearner

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

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

复制代码

   
     package com.hanchao.entity;
     /**
      * 实体类
      * @author hanlw
      * 2012-07-09
      */
     public class User {
      
         private int id;
         private String username;
         private String address;
         
         //getter...setter...
         public int getId() {
             return id;
         }
         public void setId(int id) {
             this.id = id;
         }
         public String getUsername() {
             return username;
         }
         public void setUsername(String username) {
             this.username = username;
         }
         public String getAddress() {
             return address;
         }
         public void setAddress(String address) {
             this.address = address;
         }
         
         
     }
      
    3.com.hanchao.dao包中是UserDao类；可以看到较上篇文章，写法简便多了！
      
   

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

复制代码

   
     package com.hanchao.test;
      
     import java.util.List;
      
     import com.hanchao.dao.UserDao;
     import com.hanchao.entity.User;
      
     /**
      * 测试类
      * @author hanlw
      * 2012-07-09
      */
     public class Test {
      
         public static void main(String[] args) {
              
             /**
              * 1.insert()
              */
     /*      UserDao userDao = new UserDao();
             User user = new User();
              
             user.setUsername("chenchen");
             user.setAddress("yancheng");
             userDao.insert(user);
     */
              
             /**
              * 2.update()
              */
     /*      UserDao userDao = new UserDao();
             User user = new User();
              
             user.setId(22);
             user.setUsername("chen");
             user.setAddress("shanghai");
             userDao.update(user);
     */
              
             /**
              * 3.delete()
              */
     //      UserDao userDao = new UserDao();
     //      userDao.delete(22);
              
             /**
              * 4.retrieve()
              */
             UserDao userDao = new UserDao();
             List<User> list = userDao.retrieve();
             for(User user : list) {
                 System.out.println(user.getUsername()+"        "+user.getAddress());
             }
              
              
             /**
              * 5.检索某一个用户
              */
             User u = userDao.retrieveById(23);
             System.out.println(u.getClass()+"
"+u.getAddress());
         }
     }
      
    出处http://hanchaohan.blog.51cto.com/2996417/926215