Jdbc Template详解

Jdbc Template详解

1. /**
2. * Copyright: Copyright (c) 2005-2005
3. * Company: JavaResearch(http://www.javaresearch.org)
4. */
5. package org.javaresearch.jerch;
9. import java.lang.reflect.Method;
10. import java.sql.Connection;
11. import java.sql.PreparedStatement;
12. import java.sql.ResultSet;
13. import java.sql.ResultSetMetaData;
14. import java.sql.SQLException;
15. import java.util.ArrayList;
16. import java.util.List;
18. import javax.sql.DataSource;
20. /**
21. * JDBC的模板定义，包含所有支持的方法。
22. * 这个类是这个类库的核心，所有的实际功能差不多都是这个定义并完成的。
23. * 最后更新日期:2005年5月7日
24. * @author cherami
25. */
26. public class JDBCTemplate {
27.   /**
28.    * 数据源。
29.    */
30.   privateDataSource datasource;
31.   /**
32.    * 构造一个空的JDBCTemplate。
33.    */
34.   protectedJDBCTemplate() {
36.   }
37.   /**
38.    * 以指定的数据源构造一个JDBCTemplate。
39.    * @param datasource 数据源
40.    */
41.   protectedJDBCTemplate(DataSource datasource) {
42.     this.datasource = datasource;
43.   }
44.  
45.  
46.   /**
47.    * 设置当前JDBCTemplate的数据源。
48.    * @param datasource 数据源
49.    */
50.   protectedvoid setDataSource(DataSource datasource) {
51.     this.datasource = datasource;
52.   }
53.   /**
54.    * 得到当前JDBCTemplate的数据源。
55.    * @return 当前JDBCTemplate的数据源
56.    */
57.   protectedDataSource getDataSource() {
58.     return datasource;
59.   }
60.   /**
61.    * 使用psc创建PreparedStatement并使用pss设置相关的参数最后调用action执行。
62.    * @param psc PreparedStatement的创建器
63.    * @param pss PreparedStatement的参数设置器
64.    * @param action PreparedStatement执行的回掉实现
65.    * @return 执行后的结果
66.    */
67.   publicObject execute(PreparedStatementCreator psc,
68.       PreparedStatementSetter pss, PreparedStatementCallback action) {
69.     Connection con = Utils.getConnection(datasource);
70.     PreparedStatement ps = null;
71.     try {
72.       ps = psc.createPreparedStatement(con);
73.       pss.setValues(ps);
74.       Object result = action.doInPreparedStatement(ps);
75.       return result;
76.     }
77.     catch (SQLException ex) {
78.       Utils.error("JDBCTemplate.EXECUTE_ERROR", ex);
79.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",ex);
80.     } finally {
81.       Utils.closeStatement(ps);
82.       Utils.closeConnection(con);
83.     }
84.   }
85.   /**
86.    * 执行指定的sql并返回更新的记录数。
87.    * @param sql SQL语句
88.    * @return 更新的记录数
89.    */
90.   publicint update(String sql) {
91.     return update(sql, nullPSS);
92.   }
93.   /**
94.    * 执行指定的sql并返回更新的记录数。
95.    * @param sql SQL语句
96.    * @param args 参数中的值
97.    * @return 更新的记录数
98.    */
99.   publicint update(String sql, Object[] args) {
100.     return update(sql, new ArgPreparedStatementSetter(args));
101.   }
102.   /**
103.    * 执行指定的sql并返回更新的记录数。
104.    * @param sql SQL语句
105.    * @param args 参数中的值
106.    * @param types 参数类型
107.    * @return 更新的记录数
108.    */
109.   publicint update(String sql, Object[] args, int[] types) {
110.     return update(sql, new ArgTypePreparedStatementSetter(args, types));
111.   }
112.   /**
113.    * 执行指定的sql并返回更新的记录数。
114.    * @param sql SQL语句
115.    * @param pss PreparedStatement的参数设置器
116.    * @return 更新的记录数
117.    */
118.   publicint update(String sql, PreparedStatementSetter pss) {
119.     Integer result = (Integer) execute(new SimplePreparedStatementCreator(sql),
120.         pss, newPreparedStatementCallback() {
121.           publicObject doInPreparedStatement(PreparedStatement stmt)
122.               throwsSQLException {
123.             returnnewInteger(stmt.executeUpdate());
124.           }
125.         });
126.     return result.intValue();
127.   }
128.   /**
129.    * 批量执行更新并返回每次的更新记录数
130.    * @param sql SQL语句
131.    * @param args 每次执行时的参数值
132.    * @return 每次执行更新的记录数数组
133.    */
134.   publicint[] batchUpdate(String sql, Object[][] args) {
135.     return batchUpdate(sql, new ArgBatchPreparedStatementSetter(args));
136.   }
138.   /**
139.    * 批量执行更新并返回每次的更新记录数
140.    * @param sql SQL语句
141.    * @param args 每次执行时的参数值
142.    * @param types 参数类型
143.    * @return 每次执行更新的记录数数组
144.    */
145.   publicint[] batchUpdate(String sql, Object[][] args, int[] types) {
146.     return batchUpdate(sql,
147.         new ArgTypeBatchPreparedStatementSetter(args, types));
148.   }
150.   /**
151.    * 批量执行更新并返回每次的更新记录数
152.    * @param sql SQL语句
153.    * @param bpss PreparedStatement的批量参数设置器
154.    * @return 每次执行更新的记录数数组
155.    */
156.   publicint[] batchUpdate(String sql, BatchPreparedStatementSetter bpss) {
157.     return batchUpdate(sql, new BatchPreparedStatementSetterConverter(bpss));
158.   }
160.   /**
161.    * 批量执行更新并返回每次的更新记录数
162.    * @param sql SQL语句
163.    * @param pss PreparedStatement的参数设置器
164.    * @return 每次执行更新的记录数数组
165.    */
166.   publicint[] batchUpdate(String sql, PreparedStatementSetter pss) {
167.     return (int[]) execute(new SimplePreparedStatementCreator(sql), pss,
168.         newPreparedStatementCallback() {
169.           publicObject doInPreparedStatement(PreparedStatement stmt)
170.               throwsSQLException {
171.             return stmt.executeBatch();
172.           }
173.         });
174.   }
176.   /**
177.    * 查询一个整型结果。
178.    * @param sql SQL语句
179.    * @return 查询的第一行的第一个字段的整型值。
180.    */
181.   publicint queryForInt(String sql) {
182.     return queryForInt(sql, nullPSS);
183.   }
184.   /**
185.    * 查询一个整型结果。
186.    * @param sql SQL语句
187.    * @param args 参数中的值
188.    * @return 查询的第一行的第一个字段的整型值。
189.    */
190.   publicint queryForInt(String sql, Object[] args) {
191.     return queryForInt(sql, new ArgPreparedStatementSetter(args));
192.   }
193.   /**
194.    * 查询一个整型结果。
195.    * @param sql SQL语句
196.    * @param args 参数中的值
197.    * @param types 参数类型
198.    * @return 查询的第一行的第一个字段的整型值。
199.    */
200.   publicint queryForInt(String sql, Object[] args, int[] types) {
201.     return queryForInt(sql, new ArgTypePreparedStatementSetter(args, types));
202.   }
203.   /**
204.    *  查询一个整型结果。
205.    * @param sql SQL语句
206.    * @param pss PreparedStatement的参数设置器
207.    * @return 查询的第一行的第一个字段的整型值。
208.    */
209.   publicint queryForInt(String sql, PreparedStatementSetter pss) {
210.     Number result = (Number) queryObject(sql, pss,
211.         new ObjectResultRowExtractor());
212.     if (result==null) {
213.       return 0;
214.     }
215.     return result.intValue();
216.   }
218.   /**
219.    * 查询一个长整型结果。
220.    * @param sql SQL语句
221.    * @return 查询的第一行的第一个字段的长整型值。
222.    */
223.   publiclong queryForLong(String sql) {
224.     return queryForLong(sql, nullPSS);
225.   }
227.   /**
228.    * 查询一个长整型结果。
229.    * @param sql SQL语句
230.    * @param args 参数中的值
231.    * @return 查询的第一行的第一个字段的长整型值。
232.    */
233.   publiclong queryForLong(String sql, Object[] args) {
234.     return queryForLong(sql, new ArgPreparedStatementSetter(args));
235.   }
237.   /**
238.    * 查询一个长整型结果。
239.    * @param sql SQL语句
240.    * @param args 参数中的值
241.    * @param types 参数类型
242.    * @return 查询的第一行的第一个字段的长整型值。
243.    */
244.   publiclong queryForLong(String sql, Object[] args, int[] types) {
245.     return queryForLong(sql, new ArgTypePreparedStatementSetter(args, types));
246.   }
248.   /**
249.    *  查询一个长整型结果。
250.    * @param sql SQL语句
251.    * @param pss PreparedStatement的参数设置器
252.    * @return 查询的第一行的第一个字段的长整型值。
253.    */
254.   publiclong queryForLong(String sql, PreparedStatementSetter pss) {
255.     Number result = (Number) queryObject(sql, pss,
256.         new ObjectResultRowExtractor());
257.     if (result==null) {
258.       return 0;
259.     }
260.     return result.longValue();
261.   }
263.   /**
264.    * 查询一个字符串结果。
265.    * @param sql SQL语句
266.    * @return 查询的第一行的第一个字段的字符串值。
267.    */
268.   publicString queryString(String sql) {
269.     return queryString(sql, nullPSS);
270.   }
272.   /**
273.    * 查询一个字符串结果。
274.    * @param sql SQL语句
275.    * @param args 参数中的值
276.    * @return 查询的第一行的第一个字段的字符串值。
277.    */
278.   publicString queryString(String sql, Object[] args) {
279.     return queryString(sql, new ArgPreparedStatementSetter(args));
280.   }
282.   /**
283.    * 查询一个字符串结果。
284.    * @param sql SQL语句
285.    * @param args 参数中的值
286.    * @param types 参数类型
287.    * @return 查询的第一行的第一个字段的字符串值。
288.    */
289.   publicString queryString(String sql, Object[] args, int[] types) {
290.     return queryString(sql, new ArgTypePreparedStatementSetter(args, types));
291.   }
293.   /**
294.    *  查询一个字符串结果。
295.    * @param sql SQL语句
296.    * @param pss PreparedStatement的参数设置器
297.    * @return 查询的第一行的第一个字段的字符串值。
298.    */
299.   publicString queryString(String sql, PreparedStatementSetter pss) {
300.     return (String) queryObject(sql, pss, new StringResultRowExtractor());
301.   }
303.   /**
304.    * 查询一个对象结果。
305.    * @param sql SQL语句
306.    * @param rre 单行结果提取器
307.    * @return 查询的第一行的结果并使用rre转换为结果对象。
308.    */
309.   publicObject queryObject(String sql, ResultRowExtractor rre) {
310.     return queryObject(sql, nullPSS, rre);
311.   }
313.   /**
314.    * 查询一个对象结果。
315.    * @param sql SQL语句
316.    * @param args 参数中的值
317.    * @param rre 单行结果提取器
318.    * @return 查询的第一行的结果并使用rre转换为结果对象。
319.    */
320.   publicObject queryObject(String sql, Object[] args, ResultRowExtractor rre) {
321.     return queryObject(sql, new ArgPreparedStatementSetter(args), rre);
322.   }
324.   /**
325.    * 查询一个对象结果。
326.    * @param sql SQL语句
327.    * @param args 参数中的值
328.    * @param types 参数类型
329.    * @param rre 单行结果提取器
330.    * @return 查询的第一行的结果并使用rre转换为结果对象。
331.    */
332.   publicObject queryObject(String sql, Object[] args, int[] types,
333.       ResultRowExtractor rre) {
334.     return queryObject(sql, new ArgTypePreparedStatementSetter(args, types),
335.         rre);
336.   }
338.   /**
339.    * 查询一个对象结果。
340.    * @param sql SQL语句
341.    * @param pss PreparedStatement的参数设置器
342.    * @param rre 单行结果提取器
343.    * @return 查询的第一行的结果并使用rre转换为结果对象。
344.    */
345.   publicObject queryObject(String sql, PreparedStatementSetter pss,
346.       finalResultRowExtractor rre) {
347.     Object result = (Object) execute(new SimplePreparedStatementCreator(sql),
348.         pss, newPreparedStatementCallback() {
349.           publicObject doInPreparedStatement(PreparedStatement ps)
350.               throwsSQLException {
351.             ResultSet rs = null;
352.             try {
353.               rs = ps.executeQuery();
354.               if (rs.next()) {
355.                 return rre.extractRow(rs);
356.               } else {
357.                 returnnull;
358.               }
359.             }
360.             catch (SQLException e) {
361.               Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
362.               thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
363.             } finally {
364.               Utils.closeResultSet(rs);
365.             }
366.           }
367.         });
368.     return result;
369.   }
371.   /**
372.    * 查询一个对象列表结果。
373.    * @param sql SQL语句
374.    * @param rre 单行结果提取器
375.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
376.    */
377.   publicList query(String sql, ResultRowExtractor rre) {
378.     return (List) execute(new SimplePreparedStatementCreator(sql), nullPSS,
379.         new ResultRowListPreparedStatementCallback(rre));
380.   }
381.   /**
382.    * 查询结果。
383.    * @param sql SQL语句
384.    * @param rse 全部结果提取器。
385.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
386.    */
387.   publicObject query(String sql, finalResultSetExtractor rse) {
388.     return (Object) execute(new SimplePreparedStatementCreator(sql), nullPSS,
389.         new ResultSetPreparedStatementCallback(rse));
390.   }
392.   /**
393.    * 查询一个对象列表结果。
394.    * @param sql SQL语句
395.    * @param args 参数中的值
396.    * @param types 参数类型
397.    * @param rre 单行结果提取器
398.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
399.    */
400.   publicList query(String sql, Object[] args, int[] types, ResultRowExtractor rre) {
401.     return (List) execute(new SimplePreparedStatementCreator(sql),
402.         new ArgTypePreparedStatementSetter(args,types),
403.         new ResultRowListPreparedStatementCallback(rre));
404.   }
406.   /**
407.    * 查询结果。
408.    * @param sql SQL语句
409.    * @param args 参数中的值
410.    * @param types 参数类型
411.    * @param rse 全部结果提取器。
412.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
413.    */
414.   publicObject query(String sql, Object[] args, int[] types, ResultSetExtractor rse) {
415.     return (Object) execute(new SimplePreparedStatementCreator(sql),
416.         new ArgTypePreparedStatementSetter(args,types),
417.         new ResultSetPreparedStatementCallback(rse));
418.   }
420.   /**
421.    * 查询一个对象列表结果。
422.    * @param sql SQL语句
423.    * @param args 参数中的值
424.    * @param rre 单行结果提取器
425.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
426.    */
427.   publicList query(String sql, Object[] args, ResultRowExtractor rre) {
428.     return (List) execute(new SimplePreparedStatementCreator(sql),
429.         new ArgPreparedStatementSetter(args),
430.         new ResultRowListPreparedStatementCallback(rre));
431.   }
433.   /**
434.    * 查询结果。
435.    * @param sql SQL语句
436.    * @param args 参数中的值
437.    * @param rse 全部结果提取器。
438.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
439.    */
440.   publicObject query(String sql, Object[] args, ResultSetExtractor rse) {
441.     return (Object) execute(new SimplePreparedStatementCreator(sql),
442.         new ArgPreparedStatementSetter(args),
443.         new ResultSetPreparedStatementCallback(rse));
444.   }
446.   /**
447.    * 查询一个对象列表结果。
448.    * @param sql SQL语句
449.    * @param pss PreparedStatement的参数设置器
450.    * @param rre 单行结果提取器
451.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
452.    */
453.   publicList query(String sql, PreparedStatementSetter pss,
454.       ResultRowExtractor rre) {
455.     return (List) execute(new SimplePreparedStatementCreator(sql), pss,
456.         new ResultRowListPreparedStatementCallback(rre));
457.   }
459.   /**
460.    * 查询结果。
461.    * @param sql SQL语句
462.    * @param pss PreparedStatement的参数设置器
463.    * @param rse 全部结果提取器。
464.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
465.    */
466.   publicObject query(String sql, PreparedStatementSetter pss,
467.       ResultSetExtractor rse) {
468.     return (Object) execute(new SimplePreparedStatementCreator(sql), pss,
469.         new ResultSetPreparedStatementCallback(rse));
470.   }
471.   /**
472.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
473.    * @param sql SQL语句
474.    * @param bean 结果Bean的类型
475.    * @return 第一行的结果并转换为Bean实例。
476.    */
477.   publicObject queryForBean(String sql, Class bean) {
478.     try {
479.       Object obj = bean.newInstance();
480.       if (obj instanceofMappable) {
481.         return queryObject(sql, nullPSS, new MappableResultRowExtractor(obj,
482.             (Mappable) obj));
483.       } else {
484.         return queryObject(sql, nullPSS, new MappableResultRowExtractor(obj,
485.             newNameMatchMappable()));
486.       }
487.     }
488.     catch (Exception e) {
489.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
490.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
491.     }
492.   }
494.   /**
495.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
496.    * @param sql SQL语句
497.    * @param args 参数中的值
498.    * @param bean 结果Bean的类型
499.    * @return 第一行的结果并转换为Bean实例。
500.    */
501.   publicObject queryForBean(String sql, Object[] args, Class bean) {
502.     try {
503.       Object obj = bean.newInstance();
504.       if (obj instanceofMappable) {
505.         return queryObject(sql, new ArgPreparedStatementSetter(args),
506.             new MappableResultRowExtractor(obj, (Mappable) obj));
507.       } else {
508.         return queryObject(sql, new ArgPreparedStatementSetter(args),
509.             new MappableResultRowExtractor(obj, newNameMatchMappable()));
510.       }
511.     }
512.     catch (Exception e) {
513.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
514.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
515.     }
516.   }
518.   /**
519.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
520.    * @param sql SQL语句
521.    * @param args 参数中的值
522.    * @param types 参数类型
523.    * @param bean 结果Bean的类型
524.    * @return 第一行的结果并转换为Bean实例。
525.    */
526.   publicObject queryForBean(String sql, Object[] args, int[] types, Class bean) {
527.     try {
528.       Object obj = bean.newInstance();
529.       if (obj instanceofMappable) {
530.         return queryObject(sql, new ArgTypePreparedStatementSetter(args,types),
531.             new MappableResultRowExtractor(obj, (Mappable) obj));
532.       } else {
533.         return queryObject(sql, new ArgTypePreparedStatementSetter(args,types),
534.             new MappableResultRowExtractor(obj, newNameMatchMappable()));
535.       }
536.     }
537.     catch (Exception e) {
538.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
539.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
540.     }
541.   }
543.   /**
544.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
545.    * @param sql SQL语句
546.    * @param pss PreparedStatement的参数设置器
547.    * @param bean 结果Bean的类型
548.    * @return 第一行的结果并转换为Bean实例。
549.    */
550.   publicObject queryForBean(String sql, PreparedStatementSetter pss, Class bean) {
551.     try {
552.       Object obj = bean.newInstance();
553.       if (obj instanceofMappable) {
554.         return queryObject(sql, pss,
555.             new MappableResultRowExtractor(obj, (Mappable) obj));
556.       } else {
557.         return queryObject(sql, pss,
558.             new MappableResultRowExtractor(obj, newNameMatchMappable()));
559.       }
560.     }
561.     catch (Exception e) {
562.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
563.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
564.     }
565.   }
567.   /**
568.    * 查询并返回第一行的结果并使用m将其转换为bean。
569.    * @param sql SQL语句
570.    * @param bean 结果Bean的类型
571.    * @param m 字段－属性映射器
572.    * @return 第一行的结果并使用m将其转换为Bean实例。
573.    */
574.   publicObject queryForBean(String sql, Class bean, Mappable m) {
575.     try {
576.       return queryObject(sql, nullPSS, new MappableResultRowExtractor(bean
577.           .newInstance(), m));
578.     }
579.     catch (Exception e) {
580.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
581.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
582.     }
583.   }
585.   /**
586.    * 查询并返回第一行的结果并使用m将其转换为bean。
587.    * @param sql SQL语句
588.    * @param args 参数中的值
589.    * @param bean 结果Bean的类型
590.    * @param m 字段－属性映射器
591.    * @return 第一行的结果并使用m将其转换为Bean实例。
592.    */
593.   publicObject queryForBean(String sql, Object[] args, Class bean, Mappable m) {
594.     try {
595.       return queryObject(sql, new ArgPreparedStatementSetter(args),
596.           new MappableResultRowExtractor(bean.newInstance(), m));
597.     }
598.     catch (Exception e) {
599.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
600.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
601.     }
602.   }
604.   /**
605.    * 查询并返回第一行的结果并使用m将其转换为bean。
606.    * @param sql SQL语句
607.    * @param args 参数中的值
608.    * @param types 参数类型
609.    * @param bean 结果Bean的类型
610.    * @param m 字段－属性映射器
611.    * @return 第一行的结果并使用m将其转换为Bean实例。
612.    */
613.   publicObject queryForBean(String sql, Object[] args, int[] types, Class bean, Mappable m) {
614.     try {
615.       return queryObject(sql, new ArgTypePreparedStatementSetter(args,types),
616.           new MappableResultRowExtractor(bean.newInstance(), m));
617.     }
618.     catch (Exception e) {
619.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
620.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
621.     }
622.   }
624.   /**
625.    * 查询并返回第一行的结果并使用m将其转换为bean。
626.    * @param sql SQL语句
627.    * @param pss PreparedStatement的参数设置器
628.    * @param bean 结果Bean的类型
629.    * @param m 字段－属性映射器
630.    * @return 第一行的结果并使用m将其转换为Bean实例。
631.    */
632.   publicObject queryForBean(String sql, PreparedStatementSetter pss,
633.       Class bean, Mappable m) {
634.     try {
635.       return queryObject(sql, pss, new MappableResultRowExtractor(bean
636.           .newInstance(), m));
637.     }
638.     catch (Exception e) {
639.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
640.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
641.     }
642.   }
643.   /**
644.    * 无任何参数的PreparedStatement设置器实例。
645.    */
646.   privatestaticfinalPreparedStatementSetter nullPSS = newPreparedStatementSetter() {
647.     publicvoid setValues(PreparedStatement ps) {
648.     }
649.   };
651.   /**
652.    * 将参数数组转换为PreparedStatement的设置器的简单适配器。
653.    */
654.   privatestaticclass ArgPreparedStatementSetter implements
655.       PreparedStatementSetter {
657.     privatefinalObject[] args;
659.     public ArgPreparedStatementSetter(Object[] args) {
660.       this.args = args;
661.     }
663.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
664.       if (this.args != null) {
665.         for (int i = 0; i < this.args.length; i++) {
666.           ps.setObject(i + 1, this.args[i]);
667.         }
668.       }
669.     }
670.   }
672.   /**
673.    * 将参数数组和其类型转换为PreparedStatement的设置器的简单适配器。
674.    */
675.   privatestaticclass ArgTypePreparedStatementSetter implements
676.       PreparedStatementSetter {
678.     privatefinalObject[] args;
680.     privatefinalint[] types;
682.     public ArgTypePreparedStatementSetter(Object[] args, int[] types) {
683.       if ((args != null && types == null)
684.           || (args == null && types != null)
685.           || (args != null && args.length != types.length)) {
686.         thrownewJerchException("ArgTypePreparedStatementSetter.ARG_NOT_MATCH");
687.       }
688.       this.args = args;
689.       this.types = types;
690.     }
692.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
693.       if (this.args != null) {
694.         for (int i = 0; i < this.args.length; i++) {
695.           ps.setObject(i + 1, this.args[i], this.types[i]);
696.         }
697.       }
698.     }
699.   }
701.   /**
702.    * 将sql语句转换为PreparedStatement的创建器的简单适配器。
703.    */
704.   privatestaticclass SimplePreparedStatementCreator implements
705.       PreparedStatementCreator {
707.     privatefinalString sql;
709.     public SimplePreparedStatementCreator(String sql) {
710.       this.sql = sql;
711.     }
713.     publicPreparedStatement createPreparedStatement(Connection con)
714.         throwsSQLException {
715.       return con.prepareStatement(this.sql);
716.     }
717.   }
719.   /**
720.    * 将第一个字段作为String类型提取的单行结果提取器。
721.    */
722.   privatestaticclass StringResultRowExtractor implementsResultRowExtractor {
723.     publicObject extractRow(java.sql.ResultSet rs) throwsSQLException {
724.       return rs.getString(1);
725.     }
726.   }
728.   /**
729.    * 将第一个字段作为Object类型提取的单行结果提取器。
730.    */
731.   privatestaticclass ObjectResultRowExtractor implementsResultRowExtractor {
732.     publicObject extractRow(java.sql.ResultSet rs) throwsSQLException {
733.       return rs.getObject(1);
734.     }
735.   }
737.   /**
738.    * 将BatchPreparedStatement设置其转换为PreparedStatement设置器的适配器。
739.    */
740.   privatestaticclass BatchPreparedStatementSetterConverter implements
741.       PreparedStatementSetter {
742.     BatchPreparedStatementSetter bpss;
744.     public BatchPreparedStatementSetterConverter(
745.         BatchPreparedStatementSetter bpss) {
746.       this.bpss = bpss;
747.     }
749.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
750.       for (int i = 0; i < bpss.getBatchSize(); i++) {
751.         bpss.setValues(ps, i);
752.         ps.addBatch();
753.       }
754.     }
755.   }
757.   /**
758.    * 将批量参数数组转换为PreparedStatement设置器的适配器。
759.    */
760.   privatestaticclass ArgBatchPreparedStatementSetter implements
761.       PreparedStatementSetter {
763.     privatefinalObject[][] args;
765.     public ArgBatchPreparedStatementSetter(Object[][] args) {
766.       this.args = args;
767.     }
769.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
770.       if (this.args != null) {
771.         for (int i = 0; i < this.args.length; i++) {
772.           Object[] arg = args[i];
773.           for (int j = 0; j < arg.length; j++) {
774.             ps.setObject(j + 1, arg[j]);
775.           }
776.           ps.addBatch();
777.         }
778.       }
779.     }
780.   }
782.   /**
783.    * 将批量参数数组和对应类型转换为PreparedStatement设置器的适配器。
784.    */
785.   privatestaticclass ArgTypeBatchPreparedStatementSetter implements
786.       PreparedStatementSetter {
788.     privatefinalObject[][] args;
790.     privatefinalint[] types;
792.     public ArgTypeBatchPreparedStatementSetter(Object[][] args, int[] types) {
793.       if ((args != null && types == null)
794.           || (args == null && types != null)
795.           || (args != null && args.length != types.length)) {
796.         thrownewJerchException("ArgTypePreparedStatementSetter.ARG_NOT_MATCH");
797.       }
798.       this.args = args;
799.       this.types = types;
800.     }
802.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
803.       if (this.args != null) {
804.         for (int i = 0; i < this.args.length; i++) {
805.           Object[] arg = args[i];
806.           for (int j = 0; j < arg.length; j++) {
807.             ps.setObject(j + 1, arg[j], types[j]);
808.           }
809.           ps.addBatch();
810.         }
811.       }
812.     }
813.   }
815.   /**
816.    * 使用ResultRowExtractor提取单行结果并将全部结果添加到List的PreparedStatement回调实现。
817.    */
818.   privatestaticclass ResultRowListPreparedStatementCallback implements
819.       PreparedStatementCallback {
820.     ResultRowExtractor rre;
822.     public ResultRowListPreparedStatementCallback(ResultRowExtractor rre) {
823.       this.rre = rre;
824.     }
826.     publicObject doInPreparedStatement(PreparedStatement ps)
827.         throwsSQLException {
828.       ResultSet rs = null;
829.       List result = newArrayList();
830.       try {
831.         rs = ps.executeQuery();
832.         while (rs.next()) {
833.           result.add(rre.extractRow(rs));
834.         }
835.       }
836.       catch (SQLException e) {
837.         Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
838.         thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
839.       } finally {
840.         Utils.closeResultSet(rs);
841.       }
842.       return result;
843.     }
844.   }
846.   /**
847.    * 使用ResultSetExtractor提取全部结果的PreparedStatement回调实现。
848.    */
849.   privatestaticclass ResultSetPreparedStatementCallback implements
850.       PreparedStatementCallback {
851.     ResultSetExtractor rse;
853.     public ResultSetPreparedStatementCallback(ResultSetExtractor rse) {
854.       this.rse = rse;
855.     }
857.     publicObject doInPreparedStatement(PreparedStatement ps)
858.         throwsSQLException {
859.       ResultSet rs = null;
860.       try {
861.         rs = ps.executeQuery();
862.         return rse.extractSet(rs);
863.       }
864.       catch (SQLException e) {
865.         Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
866.         thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
867.       } finally {
868.         Utils.closeResultSet(rs);
869.       }
870.     }
871.   }
873.   /**
874.    * 使用Mappable将单行结果转换为对象实例的ResultRow提取器实现。
875.    */
876.   privatestaticclass MappableResultRowExtractor implementsResultRowExtractor {
877.     privateMappable map;
879.     privateObject obj;
881.     public MappableResultRowExtractor(Object obj, Mappable map) {
882.       this.obj = obj;
883.       this.map = map;
884.     }
886.     publicObject extractRow(ResultSet rs) throwsSQLException {
887.       Class c = obj.getClass();
888.       ResultSetMetaData metaData = rs.getMetaData();
889.       int count = metaData.getColumnCount();
890.       try {
891.         for (int i = 0; i < count; i++) {
892.           String fieldName = metaData.getColumnName(i + 1);
893.           int type = metaData.getColumnType(i + 1);
894.           Class[] types = { map.getMethodParameterType(fieldName, type) };
895.           Method m = c.getMethod(map.getMapMethod(fieldName), types);
896.           Object[] args = { ValueConverterFactory.convert(rs
897.               .getObject(fieldName), types[0]) };
898.           m.invoke(obj, args);
899.         }
900.       }
901.       catch (Exception e) {
902.         Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
903.         thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
904.       }
905.       return obj;
906.     }
907.   }
908. }