jdbc框架 commons-dbutils的使用

　commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。

　　commons-dbutilsAPI介绍：

• org.apache.commons.dbutils.QueryRunner
• org.apache.commons.dbutils.ResultSetHandler

　　工具类

• org.apache.commons.dbutils.DbUtils

 

直接上代码:

1.先建立一个jdbc的连接相关类:

  1 package com.ming.core.db;
  2 
  3 import java.io.InputStream;
  4 import java.io.PrintWriter;
  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 import java.sql.SQLFeatureNotSupportedException;
 11 import java.sql.Statement;
 12 import java.util.Properties;
 13 import java.util.logging.Logger;
 14 
 15 import javax.sql.DataSource;
 16 
 17 import org.apache.commons.dbutils.ResultSetHandler;
 18 
 19 public class JdbcUtils {
 20 
 21     private static String driver = "com.mysql.jdbc.Driver";
 22     private static String url = "jdbc:mysql://localhost:3306/test";
 23     private static String username = "root";
 24     private static String password = "root";
 25     static {
 26         try {
 27             // 加载数据库驱动
 28             Class.forName(driver);
 29         } catch (Exception e) {
 30             throw new ExceptionInInitializerError(e);
 31         }
 32     }
 33 
 34     /**
 35      * @Method: getConnection
 36      * @Description: 获取数据库连接对象
 37      * @Anthor:孤傲苍狼
 38      *
 39      * @return Connection数据库连接对象
 40      * @throws SQLException
 41      */
 42     public static Connection getConnection() throws SQLException {
 43         return DriverManager.getConnection(url, username, password);
 44     }
 45 
 46     /**
 47      * @Method: release
 48      * @Description: 释放资源， 要释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，
 49      *               存储查询结果的ResultSet对象
 50      * @Anthor:孤傲苍狼
 51      *
 52      * @param conn
 53      * @param st
 54      * @param rs
 55      */
 56     public static void release(Connection conn, Statement st, ResultSet rs) {
 57         if (rs != null) {
 58             try {
 59                 // 关闭存储查询结果的ResultSet对象
 60                 rs.close();
 61             } catch (Exception e) {
 62                 e.printStackTrace();
 63             }
 64             rs = null;
 65         }
 66         if (st != null) {
 67             try {
 68                 // 关闭负责执行SQL命令的Statement对象
 69                 st.close();
 70             } catch (Exception e) {
 71                 e.printStackTrace();
 72             }
 73         }
 74 
 75         if (conn != null) {
 76             try {
 77                 // 关闭Connection数据库连接对象
 78                 conn.close();
 79             } catch (Exception e) {
 80                 e.printStackTrace();
 81             }
 82         }
 83     }
 84 
 85     /**
 86      * @Method: update
 87      * @Description: 万能更新 所有实体的CUD操作代码基本相同，仅仅发送给数据库的SQL语句不同而已，
 88      *               因此可以把CUD操作的所有相同代码抽取到工具类的一个update方法中，并定义参数接收变化的SQL语句
 89      * @Anthor:孤傲苍狼
 90      * @param sql
 91      *            要执行的SQL
 92      * @param params
 93      *            执行SQL时使用的参数
 94      * @throws SQLException
 95      */
 96     public static void update(String sql, Object params[]) throws SQLException {
 97         Connection conn = null;
 98         PreparedStatement st = null;
 99         ResultSet rs = null;
100         try {
101             conn = getConnection();
102             st = conn.prepareStatement(sql);
103             for (int i = 0; i < params.length; i++) {
104                 st.setObject(i + 1, params[i]);
105             }
106             st.executeUpdate();
107 
108         } finally {
109             release(conn, st, rs);
110         }
111     }
112 
113     /**
114      * @Method: query
115      * @Description:万能查询 实体的R操作，除SQL语句不同之外，根据操作的实体不同，对ResultSet的映射也各不相同，
116      *                   因此可义一个query方法，除以参数形式接收变化的SQL语句外，
117      *                   可以使用策略模式由qurey方法的调用者决定如何把ResultSet中的数据映射到实体对象中。
118      * @Anthor:孤傲苍狼
119      *
120      * @param sql
121      *            要执行的SQL
122      * @param params
123      *            执行SQL时使用的参数
124      * @param rsh
125      *            查询返回的结果集处理器
126      * @return
127      * @throws SQLException
128      */
129     public static Object query(String sql, Object params[], ResultSetHandler rsh) throws SQLException {
130 
131         Connection conn = null;
132         PreparedStatement st = null;
133         ResultSet rs = null;
134 
135         try {
136             conn = getConnection();
137             st = conn.prepareStatement(sql);
138             for (int i = 0; i < params.length; i++) {
139                 st.setObject(i + 1, params[i]);
140             }
141             rs = st.executeQuery();
142             /**
143              * 对于查询返回的结果集处理使用到了策略模式，
144              * 在设计query方法时，query方法事先是无法知道用户对返回的查询结果集如何进行处理的，即不知道结果集的处理策略，
145              * 那么这个结果集的处理策略就让用户自己提供，query方法内部就调用用户提交的结果集处理策略进行处理
146              * 为了能够让用户提供结果集的处理策略，需要对用户暴露出一个结果集处理接口ResultSetHandler
147              * 用户只要实现了ResultSetHandler接口，那么query方法内部就知道用户要如何处理结果集了
148              */
149             return rsh.handle(rs);
150 
151         } finally {
152             release(conn, st, rs);
153         }
154     }
155     
156     public static DataSource getDataSource(){
157         return new DataSource() {
158             
159             
160             @Override
161             public Connection getConnection(String username, String password) throws SQLException {
162                 
163                 return null;
164             }
165             
166             @Override
167             public Connection getConnection() throws SQLException {
168                 
169                 return JdbcUtils.getConnection();
170             }
171 
172             @Override
173             public PrintWriter getLogWriter() throws SQLException {
174                 
175                 return null;
176             }
177 
178             @Override
179             public int getLoginTimeout() throws SQLException {
180                 
181                 return 0;
182             }
183 
184             @Override
185             public Logger getParentLogger() throws SQLFeatureNotSupportedException {
186                 
187                 return null;
188             }
189 
190             @Override
191             public void setLogWriter(PrintWriter out) throws SQLException {
192                 
193                 
194             }
195 
196             @Override
197             public void setLoginTimeout(int seconds) throws SQLException {
198                 
199                 
200             }
201 
202             @Override
203             public boolean isWrapperFor(Class iface) throws SQLException {
204                 
205                 return false;
206             }
207 
208             @Override
209             public  T unwrap(Class iface) throws SQLException {
210                 
211                 return null;
212             }
213         };
214     }
215 }

2.建立一个与数据相关的实体类

 1 package com.ming.user.entity;
 2 
 3 public class User {
 4 
 5     private int id;
 6     
 7     private String account;
 8     
 9     private int user_id;
10 
11     public int getId() {
12         return id;
13     }
14 
15     public void setId(int id) {
16         this.id = id;
17     }
18 
19     public String getAccount() {
20         return account;
21     }
22 
23     public void setAccount(String account) {
24         this.account = account;
25     }
26 
27     public int getUser_id() {
28         return user_id;
29     }
30 
31     public void setUser_id(int user_id) {
32         this.user_id = user_id;
33     }
34     
35     
36 }

3.数据库操作类及测试方法

 1 package com.ming.core.db;
 2 
 3 import java.sql.SQLException;
 4 import java.util.List;
 5 
 6 
 7 import org.apache.commons.dbutils.QueryRunner;
 8 import org.apache.commons.dbutils.handlers.BeanHandler;
 9 import org.apache.commons.dbutils.handlers.BeanListHandler;
10 
11 import com.ming.user.entity.User;
12 
13 public class QueryRunnerCRUDTest {
14 
15     /*
16      *测试表
17     CREATE TABLE `users` (
18         `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
19         `account` VARCHAR(50) NULL DEFAULT NULL,
20         `user_id` BIGINT(20) NOT NULL,
21         PRIMARY KEY (`id`)
22     )
23     COMMENT='user表'
24     COLLATE='latin1_swedish_ci'
25     ENGINE=InnoDB
26     ;
27      */
28     
29     
30     public void add() throws SQLException {
31         //将数据源传递给QueryRunner，QueryRunner内部通过数据源获取数据库连接
32         QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
33         String sql = "INSERT INTO `test`.`users` (`account`, `user_id`) VALUES (?, ?);";
34         Object params[] = {"hello world",2323};
35   
36         qr.update(sql, params);
37     }
38     
39    
40     
41     public void delete() throws SQLException {
42         QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
43         String sql = "delete from users where id=?";
44         qr.update(sql, 1);
45 
46     }
47 
48     
49     public void update() throws SQLException {
50         QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
51         String sql = "update users set account=? where id=?";
52         Object params[] = { "ddd", 2};
53         qr.update(sql, params);
54     }
55 
56     
57     public void find() throws SQLException {
58         QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
59         String sql = "select * from users where id=?";
60         Object params[] = {2};
61         User user = (User) qr.query(sql, params, new BeanHandler(User.class));
62        System.out.println(user.getId());
63     }
64 
65     
66     public void getAll() throws SQLException {
67         QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
68         String sql = "select * from users";
69         List list = (List) qr.query(sql, new BeanListHandler(User.class));
70         for(User u : list){
71              System.out.println(u.getUser_id());
72         }
73        
74     }
75     
76     public void testBatch() throws SQLException {
77         QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
78         String sql = "INSERT INTO `test`.`users` (`account`, `user_id`) VALUES (?, ?)";
79         Object params[][] = new Object[10][];
80         for (int i = 0; i < 10; i++) {
81             params[i] = new Object[] {"123"+i, i};
82         }
83         qr.batch(sql, params);
84     }
85     
86     public static void main(String[] args) throws Exception {
87         QueryRunnerCRUDTest t=new QueryRunnerCRUDTest();
88         t.add();
89         t.find();
90         t.delete();
91     }
92     
93 
94 }

 

以上代码都测试通了。

 

该博客参考:http://www.cnblogs.com/xdp-gacl/p/4007225.html

 

源码下载:http://pan.baidu.com/s/1mhDtMti

转载于:https://www.cnblogs.com/huzi007/p/5788223.html