在Spring中使用DButils

 1 <!-- 定义数据源Bean--> 
 2 <bean id="dataSource" 
 3     class="org.apache.commons.dbcp.BasicDataSource" 
 4     destroy-method="close"> 
 5     <property name="driverClassName" 
 6         value="${jdbc.driverClassName}" /> 
 7     <property name="url" value="${jdbc.url}" /> 
 8     <property name="username" value="${jdbc.username}" /> 
 9     <property name="password" value="${jdbc.password}" /> 
10 </bean> 
11 <!-- 下面定义了DbUtils的一个模板操作Bean --> 
12 <bean id="dbUtilsTemplate" class="com.company.project.dao.template.DbUtilsTemplate"> 
13         <property name="dataSource" ref="dataSource" /> 
14 </bean> 

  1 package com.company.project.dao.template; 
  2 
  3 import java.sql.SQLException; 
  4 import java.util.ArrayList; 
  5 import java.util.List; 
  6 import java.util.Map; 
  7 
  8 import javax.sql.DataSource; 
  9 
 10 import org.apache.commons.dbcp.BasicDataSource; 
 11 import org.apache.commons.dbutils.QueryRunner; 
 12 import org.apache.commons.dbutils.handlers.BeanHandler; 
 13 import org.apache.commons.dbutils.handlers.BeanListHandler; 
 14 import org.apache.commons.dbutils.handlers.MapHandler; 
 15 import org.apache.commons.dbutils.handlers.MapListHandler; 
 16 import org.apache.commons.dbutils.handlers.ScalarHandler; 
 17 import org.apache.commons.logging.Log; 
 18 import org.apache.commons.logging.LogFactory; 
 19 
 20 /** 
 21 * 调用Apache Commons DBUtil组件的数据库操作类 
 22 * 采用DBCP作为数据源，数据源在Spring中已经配置好 
 23 * 本类已经在Spring中配置好，在需要的地方，set注入后即可调用 
 24 * <code> 
 25 * private DbUtilsTemplate dbUtilsTemplate; 
 26 * public void setDbUtilsTemplate(DbUtilsTemplate dbUtilsTemplate) { 
 27 *     this.dbUtilsTemplate = dbUtilsTemplate; 
 28 * } 
 29 * </code> 
 30 * @author Sunshine 
 31 * @version 1.0 2009-07-29 
 32 */ 
 33 public class DbUtilsTemplate { 
 34 
 35     private DataSource dataSource; 
 36     private QueryRunner queryRunner; 
 37     private static final Log LOG = LogFactory.getLog(DbUtilsTemplate.class); 
 38 
 39     public void setDataSource(BasicDataSource dataSource) { 
 40         this.dataSource = dataSource; 
 41     } 
 42 
 43     /** 
 44      * 执行sql语句 
 45      * @param sql sql语句 
 46      * @return 受影响的行数 
 47      */ 
 48     public int update(String sql) { 
 49         return update(sql, null); 
 50     } 
 51       
 52     /** 
 53      * 执行sql语句 
 54      * <code> 
 55      * executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty"); 
 56      * </code> 
 57      * @param sql sql语句 
 58      * @param param 参数 
 59      * @return 受影响的行数 
 60      */ 
 61     public int update(String sql, Object param) { 
 62         return update(sql, new Object[] { param }); 
 63     } 
 64       
 65     /** 
 66      * 执行sql语句 
 67      * @param sql sql语句 
 68      * @param params 参数数组 
 69      * @return 受影响的行数 
 70      */ 
 71     public int update(String sql, Object[] params) { 
 72         queryRunner = new QueryRunner(dataSource); 
 73         int affectedRows = 0; 
 74         try { 
 75             if (params == null) { 
 76                 affectedRows = queryRunner.update(sql); 
 77             } else { 
 78                 affectedRows = queryRunner.update(sql, params); 
 79             } 
 80         } catch (SQLException e) { 
 81             LOG.error("Error occured while attempting to update data", e); 
 82         } 
 83         return affectedRows; 
 84     } 
 85       
 86     /** 
 87      * 执行批量sql语句 
 88      * @param sql sql语句 
 89      * @param params 二维参数数组 
 90      * @return 受影响的行数的数组 
 91      */ 
 92     public int[] batchUpdate(String sql, Object[][] params) { 
 93         queryRunner = new QueryRunner(dataSource); 
 94         int[] affectedRows = new int[0]; 
 95         try { 
 96             affectedRows = queryRunner.batch(sql, params); 
 97         } catch (SQLException e) { 
 98             LOG.error("Error occured while attempting to batch update data", e); 
 99         } 
100         return affectedRows; 
101     }     
102 
103     /** 
104      * 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中 
105      * @param sql sql语句 
106      * @return 查询结果 
107      */ 
108     public List<Map<String, Object>> find(String sql) { 
109         return find(sql, null); 
110     } 
111       
112     /** 
113      * 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中 
114      * @param sql sql语句 
115      * @param param 参数 
116      * @return 查询结果 
117      */ 
118     public List<Map<String, Object>> find(String sql, Object param) { 
119         return find(sql, new Object[] {param}); 
120     } 
121       
122     /** 
123      * 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中 
124      * @param sql sql语句 
125      * @param params 参数数组 
126      * @return 查询结果 
127      */ 
128     @SuppressWarnings("unchecked") 
129     public List<Map<String, Object>> find(String sql, Object[] params) { 
130         queryRunner = new QueryRunner(dataSource); 
131         List<Map<String, Object>> list = new ArrayList<Map<String,Object>>(); 
132         try { 
133             if (params == null) { 
134                 list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler()); 
135             } else { 
136                 list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler(), params); 
137             } 
138         } catch (SQLException e) { 
139             LOG.error("Error occured while attempting to query data", e); 
140         } 
141         return list; 
142     } 
143       
144     /** 
145      * 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中 
146      * @param entityClass 类名 
147      * @param sql sql语句 
148      * @return 查询结果 
149      */ 
150     public <T> List<T> find(Class<T> entityClass, String sql) { 
151         return find(entityClass, sql, null); 
152     } 
153       
154     /** 
155      * 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中 
156      * @param entityClass 类名 
157      * @param sql sql语句 
158      * @param param 参数 
159      * @return 查询结果 
160      */ 
161     public <T> List<T> find(Class<T> entityClass, String sql, Object param) { 
162         return find(entityClass, sql, new Object[] { param }); 
163     } 
164       
165     /** 
166      * 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中 
167      * @param entityClass 类名 
168      * @param sql sql语句 
169      * @param params 参数数组 
170      * @return 查询结果 
171      */ 
172     @SuppressWarnings("unchecked") 
173     public <T> List<T> find(Class<T> entityClass, String sql, Object[] params) { 
174         queryRunner = new QueryRunner(dataSource); 
175         List<T> list = new ArrayList<T>(); 
176         try { 
177             if (params == null) { 
178                 list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass)); 
179             } else { 
180                 list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass), params); 
181             } 
182         } catch (SQLException e) { 
183             LOG.error("Error occured while attempting to query data", e); 
184         } 
185         return list; 
186     } 
187       
188     /** 
189      * 查询出结果集中的第一条记录，并封装成对象 
190      * @param entityClass 类名 
191      * @param sql sql语句 
192      * @return 对象 
193      */ 
194     public <T> T findFirst(Class<T> entityClass, String sql) { 
195         return findFirst(entityClass, sql, null); 
196     } 
197       
198     /** 
199      * 查询出结果集中的第一条记录，并封装成对象 
200      * @param entityClass 类名 
201      * @param sql sql语句 
202      * @param param 参数 
203      * @return 对象 
204      */ 
205     public <T> T findFirst(Class<T> entityClass, String sql, Object param) { 
206         return findFirst(entityClass, sql, new Object[] { param }); 
207     } 
208       
209     /** 
210      * 查询出结果集中的第一条记录，并封装成对象 
211      * @param entityClass 类名 
212      * @param sql sql语句 
213      * @param params 参数数组 
214      * @return 对象 
215      */ 
216     @SuppressWarnings("unchecked") 
217     public <T> T findFirst(Class<T> entityClass, String sql, Object[] params) { 
218         queryRunner = new QueryRunner(dataSource); 
219         Object object = null; 
220         try { 
221             if (params == null) { 
222                 object = queryRunner.query(sql, new BeanHandler(entityClass)); 
223             } else { 
224                 object = queryRunner.query(sql, new BeanHandler(entityClass), params); 
225             } 
226         } catch (SQLException e) { 
227             LOG.error("Error occured while attempting to query data", e); 
228         } 
229         return (T) object; 
230     } 
231       
232     /** 
233      * 查询出结果集中的第一条记录，并封装成Map对象 
234      * @param sql sql语句 
235      * @return 封装为Map的对象 
236      */ 
237     public Map<String, Object> findFirst(String sql) { 
238         return findFirst(sql, null); 
239     } 
240       
241     /** 
242      * 查询出结果集中的第一条记录，并封装成Map对象 
243      * @param sql sql语句 
244      * @param param 参数 
245      * @return 封装为Map的对象 
246      */ 
247     public Map<String, Object> findFirst(String sql, Object param) { 
248         return findFirst(sql, new Object[] { param }); 
249     } 
250       
251     /** 
252      * 查询出结果集中的第一条记录，并封装成Map对象 
253      * @param sql sql语句 
254      * @param params 参数数组 
255      * @return 封装为Map的对象 
256      */ 
257     @SuppressWarnings("unchecked") 
258     public Map<String, Object> findFirst(String sql, Object[] params) { 
259         queryRunner = new QueryRunner(dataSource); 
260         Map<String, Object> map = null; 
261         try { 
262             if (params == null) { 
263                 map = (Map<String, Object>) queryRunner.query(sql, new MapHandler()); 
264             } else { 
265                 map = (Map<String, Object>) queryRunner.query(sql, new MapHandler(), params); 
266             } 
267         } catch (SQLException e) { 
268             LOG.error("Error occured while attempting to query data", e); 
269         } 
270         return map; 
271     } 
272       
273     /** 
274      * 查询某一条记录，并将指定列的数据转换为Object 
275      * @param sql sql语句 
276      * @param columnName 列名 
277      * @return 结果对象 
278      */ 
279     public Object findBy(String sql, String columnName) { 
280         return findBy(sql, columnName, null); 
281     } 
282       
283     /** 
284      * 查询某一条记录，并将指定列的数据转换为Object 
285      * @param sql sql语句 
286      * @param columnName 列名 
287      * @param param 参数 
288      * @return 结果对象 
289      */ 
290     public Object findBy(String sql, String columnName, Object param) { 
291         return findBy(sql, columnName, new Object[] { param }); 
292     } 
293       
294     /** 
295      * 查询某一条记录，并将指定列的数据转换为Object 
296      * @param sql sql语句 
297      * @param columnName 列名 
298      * @param params 参数数组 
299      * @return 结果对象 
300      */ 
301     public Object findBy(String sql, String columnName, Object[] params) { 
302         queryRunner = new QueryRunner(dataSource); 
303         Object object = null; 
304         try { 
305             if (params == null) { 
306                 object = queryRunner.query(sql, new ScalarHandler(columnName)); 
307             } else { 
308                 object = queryRunner.query(sql, new ScalarHandler(columnName), params); 
309             } 
310         } catch (SQLException e) { 
311             LOG.error("Error occured while attempting to query data", e); 
312         } 
313         return object; 
314     } 
315       
316     /** 
317      * 查询某一条记录，并将指定列的数据转换为Object 
318      * @param sql sql语句 
319      * @param columnIndex 列索引 
320      * @return 结果对象 
321      */ 
322     public Object findBy(String sql, int columnIndex) { 
323         return findBy(sql, columnIndex, null); 
324     } 
325       
326     /** 
327      * 查询某一条记录，并将指定列的数据转换为Object 
328      * @param sql sql语句 
329      * @param columnIndex 列索引 
330      * @param param 参数 
331      * @return 结果对象 
332      */ 
333     public Object findBy(String sql, int columnIndex, Object param) { 
334         return findBy(sql, columnIndex, new Object[] { param }); 
335     } 
336       
337     /** 
338      * 查询某一条记录，并将指定列的数据转换为Object 
339      * @param sql sql语句 
340      * @param columnIndex 列索引 
341      * @param params 参数数组 
342      * @return 结果对象 
343      */ 
344     public Object findBy(String sql, int columnIndex, Object[] params) { 
345         queryRunner = new QueryRunner(dataSource); 
346         Object object = null; 
347         try { 
348             if (params == null) { 
349                 object = queryRunner.query(sql, new ScalarHandler(columnIndex)); 
350             } else { 
351                 object = queryRunner.query(sql, new ScalarHandler(columnIndex), params); 
352             } 
353         } catch (SQLException e) { 
354             LOG.error("Error occured while attempting to query data", e); 
355         } 
356         return object; 
357     } 
358 }