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 }
