最精简实用的jdbc工具类

mex

java对JDBC的封装，操作起来更方便

IResultSetCall.java

1. import java.sql.ResultSet;
   
2. import java.sql.SQLException;
   
3. 
   
4. public interface IResultSetCall<T> {
   
5. 
   
6.     public T invoke(ResultSet rs) throws SQLException;
   
7. 
   
8. }

复制代码

DBUtil.java

1. import java.io.IOException;
   
2. import java.lang.reflect.Constructor;
   
3. import java.lang.reflect.Field;
   
4. import java.sql.CallableStatement;
   
5. import java.sql.Connection;
   
6. import java.sql.DriverManager;
   
7. import java.sql.PreparedStatement;
   
8. import java.sql.ResultSet;
   
9. import java.sql.ResultSetMetaData;
   
10. import java.sql.SQLException;
    
11. import java.sql.Statement;
    
12. import java.sql.Time;
    
13. import java.util.ArrayList;
    
14. import java.util.Date;
    
15. import java.util.HashMap;
    
16. import java.util.List;
    
17. import java.util.Map;
    
18. import java.util.Properties;
    
19. 
    
20. import oracle.jdbc.OracleTypes;
    
21. import util.db.test.DBUtilTest;
    
22. 
    
23. /**
    
24. *
    
25. * DBUtil，数据库访问工具类<br/>
    
26. * 对应测试类： {@link DBUtilTest}
    
27. * @preserve all
    
28. */
    
29. public class DBUtil {
    
30. 
    
31.     private static Connection con = null;
    
32. 
    
33.     public static Connection openConnection() throws SQLException, ClassNotFoundException, IOException {
    
34.         if (null == con || con.isClosed()) {
    
35.             Properties p = new Properties();
    
36.             p.load(DBUtil.class.getResourceAsStream("/config-db.properties"));
    
37.             Class.forName(p.getProperty("db_driver"));
    
38.             con = DriverManager.getConnection(p.getProperty("db_url"), p.getProperty("db_username"),
    
39.                     p.getProperty("db_password"));
    
40.         }
    
41.         return con;
    
42.     }
    
43. 
    
44.     public static void closeConnection() throws SQLException {
    
45.         try {
    
46.             if (null != con)
    
47.                 con.close();
    
48.         } finally {
    
49.             con = null;
    
50.             System.gc();
    
51.         }
    
52.     }
    
53. 
    
54.     public static List<Map<String, Object>> queryMapList(Connection con, String sql) throws SQLException,
    
55.             InstantiationException, IllegalAccessException {
    
56.         List<Map<String, Object>> lists = new ArrayList<Map<String, Object>>();
    
57.         Statement preStmt = null;
    
58.         ResultSet rs = null;
    
59.         try {
    
60.             preStmt = con.createStatement();
    
61.             rs = preStmt.executeQuery(sql);
    
62.             ResultSetMetaData rsmd = rs.getMetaData();
    
63.             int columnCount = rsmd.getColumnCount();
    
64.             while (null != rs && rs.next()) {
    
65.                 Map<String, Object> map = new HashMap<String, Object>();
    
66.                 for (int i = 0; i < columnCount; i++) {
    
67.                     String name = rsmd.getColumnName(i + 1);
    
68.                     Object value = rs.getObject(name);
    
69.                     map.put(name, value);
    
70.                 }
    
71.                 lists.add(map);
    
72.             }
    
73.         } finally {
    
74.             if (null != rs)
    
75.                 rs.close();
    
76.             if (null != preStmt)
    
77.                 preStmt.close();
    
78.         }
    
79.         return lists;
    
80.     }
    
81. 
    
82.     public static List<Map<String, Object>> queryMapList(Connection con, String sql, Object... params)
    
83.             throws SQLException, InstantiationException, IllegalAccessException {
    
84.         List<Map<String, Object>> lists = new ArrayList<Map<String, Object>>();
    
85.         PreparedStatement preStmt = null;
    
86.         ResultSet rs = null;
    
87.         try {
    
88.             preStmt = con.prepareStatement(sql);
    
89.             for (int i = 0; i < params.length; i++)
    
90.                 preStmt.setObject(i + 1, params[i]);// 下标从1开始
    
91.             rs = preStmt.executeQuery();
    
92.             ResultSetMetaData rsmd = rs.getMetaData();
    
93.             int columnCount = rsmd.getColumnCount();
    
94.             while (null != rs && rs.next()) {
    
95.                 Map<String, Object> map = new HashMap<String, Object>();
    
96.                 for (int i = 0; i < columnCount; i++) {
    
97.                     String name = rsmd.getColumnName(i + 1);
    
98.                     Object value = rs.getObject(name);
    
99.                     map.put(name, value);
    
100.                 }
     
101.                 lists.add(map);
     
102.             }
     
103.         } finally {
     
104.             if (null != rs)
     
105.                 rs.close();
     
106.             if (null != preStmt)
     
107.                 preStmt.close();
     
108.         }
     
109.         return lists;
     
110.     }
     
111. 
     
112.     public static <T> List<T> queryBeanList(Connection con, String sql, Class<T> beanClass) throws SQLException,
     
113.             InstantiationException, IllegalAccessException {
     
114.         List<T> lists = new ArrayList<T>();
     
115.         Statement stmt = null;
     
116.         ResultSet rs = null;
     
117.         Field[] fields = null;
     
118.         try {
     
119.             stmt = con.createStatement();
     
120.             rs = stmt.executeQuery(sql);
     
121.             fields = beanClass.getDeclaredFields();
     
122.             for (Field f : fields)
     
123.                 f.setAccessible(true);
     
124.             while (null != rs && rs.next()) {
     
125.                 T t = beanClass.newInstance();
     
126.                 for (Field f : fields) {
     
127.                     String name = f.getName();
     
128.                     try {
     
129.                         Object value = rs.getObject(name);
     
130.                         setValue(t, f, value);
     
131.                     } catch (Exception e) {
     
132.                     }
     
133.                 }
     
134.                 lists.add(t);
     
135.             }
     
136.         } finally {
     
137.             if (null != rs)
     
138.                 rs.close();
     
139.             if (null != stmt)
     
140.                 stmt.close();
     
141.         }
     
142.         return lists;
     
143.     }
     
144. 
     
145.     public static <T> List<T> queryBeanList(Connection con, String sql, Class<T> beanClass, Object... params)
     
146.             throws SQLException, InstantiationException, IllegalAccessException {
     
147.         List<T> lists = new ArrayList<T>();
     
148.         PreparedStatement preStmt = null;
     
149.         ResultSet rs = null;
     
150.         Field[] fields = null;
     
151.         try {
     
152.             preStmt = con.prepareStatement(sql);
     
153.             for (int i = 0; i < params.length; i++)
     
154.                 preStmt.setObject(i + 1, params[i]);// 下标从1开始
     
155.             rs = preStmt.executeQuery();
     
156.             fields = beanClass.getDeclaredFields();
     
157.             for (Field f : fields)
     
158.                 f.setAccessible(true);
     
159.             while (null != rs && rs.next()) {
     
160.                 T t = beanClass.newInstance();
     
161.                 for (Field f : fields) {
     
162.                     String name = f.getName();
     
163.                     try {
     
164.                         Object value = rs.getObject(name);
     
165.                         setValue(t, f, value);
     
166.                     } catch (Exception e) {
     
167.                     }
     
168.                 }
     
169.                 lists.add(t);
     
170.             }
     
171.         } finally {
     
172.             if (null != rs)
     
173.                 rs.close();
     
174.             if (null != preStmt)
     
175.                 preStmt.close();
     
176.         }
     
177.         return lists;
     
178.     }
     
179. 
     
180.     public static <T> List<T> queryBeanList(Connection con, String sql, IResultSetCall<T> qdi) throws SQLException {
     
181.         List<T> lists = new ArrayList<T>();
     
182.         Statement stmt = null;
     
183.         ResultSet rs = null;
     
184.         try {
     
185.             stmt = con.createStatement();
     
186.             rs = stmt.executeQuery(sql);
     
187.             while (null != rs && rs.next())
     
188.                 lists.add(qdi.invoke(rs));
     
189.         } finally {
     
190.             if (null != rs)
     
191.                 rs.close();
     
192.             if (null != stmt)
     
193.                 stmt.close();
     
194.         }
     
195.         return lists;
     
196.     }
     
197. 
     
198.     public static <T> List<T> queryBeanList(Connection con, String sql, IResultSetCall<T> qdi, Object... params)
     
199.             throws SQLException {
     
200.         List<T> lists = new ArrayList<T>();
     
201.         PreparedStatement preStmt = null;
     
202.         ResultSet rs = null;
     
203.         try {
     
204.             preStmt = con.prepareStatement(sql);
     
205.             for (int i = 0; i < params.length; i++)
     
206.                 preStmt.setObject(i + 1, params[i]);
     
207.             rs = preStmt.executeQuery();
     
208.             while (null != rs && rs.next())
     
209.                 lists.add(qdi.invoke(rs));
     
210.         } finally {
     
211.             if (null != rs)
     
212.                 rs.close();
     
213.             if (null != preStmt)
     
214.                 preStmt.close();
     
215.         }
     
216.         return lists;
     
217.     }
     
218. 
     
219.     public static <T> T queryBean(Connection con, String sql, Class<T> beanClass) throws SQLException,
     
220.             InstantiationException, IllegalAccessException {
     
221.         List<T> lists = queryBeanList(con, sql, beanClass);
     
222.         if (lists.size() != 1)
     
223.             throw new SQLException("SqlError：期待一行返回值，却返回了太多行！");
     
224.         return lists.get(0);
     
225.     }
     
226. 
     
227.     public static <T> T queryBean(Connection con, String sql, Class<T> beanClass, Object... params)
     
228.             throws SQLException, InstantiationException, IllegalAccessException {
     
229.         List<T> lists = queryBeanList(con, sql, beanClass, params);
     
230.         if (lists.size() != 1)
     
231.             throw new SQLException("SqlError：期待一行返回值，却返回了太多行！");
     
232.         return lists.get(0);
     
233.     }
     
234. 
     
235.     public static <T> List<T> queryObjectList(Connection con, String sql, Class<T> objClass) throws SQLException,
     
236.             InstantiationException, IllegalAccessException {
     
237.         List<T> lists = new ArrayList<T>();
     
238.         Statement stmt = null;
     
239.         ResultSet rs = null;
     
240.         try {
     
241.             stmt = con.createStatement();
     
242.             rs = stmt.executeQuery(sql);
     
243.             label: while (null != rs && rs.next()) {
     
244.                 Constructor<?>[] constor = objClass.getConstructors();
     
245.                 for (Constructor<?> c : constor) {
     
246.                     Object value = rs.getObject(1);
     
247.                     try {
     
248.                         lists.add((T) c.newInstance(value));
     
249.                         continue label;
     
250.                     } catch (Exception e) {
     
251.                     }
     
252.                 }
     
253.             }
     
254.         } finally {
     
255.             if (null != rs)
     
256.                 rs.close();
     
257.             if (null != stmt)
     
258.                 stmt.close();
     
259.         }
     
260.         return lists;
     
261.     }
     
262. 
     
263.     public static <T> List<T> queryObjectList(Connection con, String sql, Class<T> objClass, Object... params)
     
264.             throws SQLException, InstantiationException, IllegalAccessException {
     
265.         List<T> lists = new ArrayList<T>();
     
266.         PreparedStatement preStmt = null;
     
267.         ResultSet rs = null;
     
268.         try {
     
269.             preStmt = con.prepareStatement(sql);
     
270.             for (int i = 0; i < params.length; i++)
     
271.                 preStmt.setObject(i + 1, params[i]);
     
272.             rs = preStmt.executeQuery();
     
273.             label: while (null != rs && rs.next()) {
     
274.                 Constructor<?>[] constor = objClass.getConstructors();
     
275.                 for (Constructor<?> c : constor) {
     
276.                     String value = rs.getObject(1).toString();
     
277.                     try {
     
278.                         T t = (T) c.newInstance(value);
     
279.                         lists.add(t);
     
280.                         continue label;
     
281.                     } catch (Exception e) {
     
282.                     }
     
283.                 }
     
284.             }
     
285.         } finally {
     
286.             if (null != rs)
     
287.                 rs.close();
     
288.             if (null != preStmt)
     
289.                 preStmt.close();
     
290.         }
     
291.         return lists;
     
292.     }
     
293. 
     
294.     public static <T> T queryObject(Connection con, String sql, Class<T> objClass) throws SQLException,
     
295.             InstantiationException, IllegalAccessException {
     
296.         List<T> lists = queryObjectList(con, sql, objClass);
     
297.         if (lists.size() != 1)
     
298.             throw new SQLException("SqlError：期待一行返回值，却返回了太多行！");
     
299.         return lists.get(0);
     
300.     }
     
301. 
     
302.     public static <T> T queryObject(Connection con, String sql, Class<T> objClass, Object... params)
     
303.             throws SQLException, InstantiationException, IllegalAccessException {
     
304.         List<T> lists = queryObjectList(con, sql, objClass, params);
     
305.         if (lists.size() != 1)
     
306.             throw new SQLException("SqlError：期待一行返回值，却返回了太多行！");
     
307.         return lists.get(0);
     
308.     }
     
309. 
     
310.     public static int execute(Connection con, String sql) throws SQLException {
     
311.         Statement stmt = null;
     
312.         try {
     
313.             stmt = con.createStatement();
     
314.             return stmt.executeUpdate(sql);
     
315.         } finally {
     
316.             if (null != stmt)
     
317.                 stmt.close();
     
318.         }
     
319.     }
     
320. 
     
321.     public static int execute(Connection con, String sql, Object... params) throws SQLException {
     
322.         PreparedStatement preStmt = null;
     
323.         try {
     
324.             preStmt = con.prepareStatement(sql);
     
325.             for (int i = 0; i < params.length; i++)
     
326.                 preStmt.setObject(i + 1, params[i]);// 下标从1开始
     
327.             return preStmt.executeUpdate();
     
328.         } finally {
     
329.             if (null != preStmt)
     
330.                 preStmt.close();
     
331.         }
     
332.     }
     
333. 
     
334.     public static int[] executeAsBatch(Connection con, List<String> sqlList) throws SQLException {
     
335.         return executeAsBatch(con, sqlList.toArray(new String[] {}));
     
336.     }
     
337. 
     
338.     public static int[] executeAsBatch(Connection con, String[] sqlArray) throws SQLException {
     
339.         Statement stmt = null;
     
340.         try {
     
341.             stmt = con.createStatement();
     
342.             for (String sql : sqlArray) {
     
343.                 stmt.addBatch(sql);
     
344.             }
     
345.             return stmt.executeBatch();
     
346.         } finally {
     
347.             if (null != stmt) {
     
348.                 stmt.close();
     
349.             }
     
350.         }
     
351.     }
     
352. 
     
353.     public static int[] executeAsBatch(Connection con, String sql, Object[][] params) throws SQLException {
     
354.         PreparedStatement preStmt = null;
     
355.         try {
     
356.             preStmt = con.prepareStatement(sql);
     
357.             for (int i = 0; i < params.length; i++) {
     
358.                 Object[] rowParams = params[i];
     
359.                 for (int k = 0; k < rowParams.length; k++) {
     
360.                     Object obj = rowParams[k];
     
361.                     preStmt.setObject(k + 1, obj);
     
362.                 }
     
363.                 preStmt.addBatch();
     
364.             }
     
365.             return preStmt.executeBatch();
     
366.         } finally {
     
367.             if (null != preStmt) {
     
368.                 preStmt.close();
     
369.             }
     
370.         }
     
371.     }
     
372. 
     
373.     private static <T> void setValue(T t, Field f, Object value) throws IllegalAccessException {
     
374.         // TODO 以数据库类型为准绳，还是以java数据类型为准绳？还是混合两种方式？
     
375.         if (null == value)
     
376.             return;
     
377.         String v = value.toString();
     
378.         String n = f.getType().getName();
     
379.         if ("java.lang.Byte".equals(n) || "byte".equals(n)) {
     
380.             f.set(t, Byte.parseByte(v));
     
381.         } else if ("java.lang.Short".equals(n) || "short".equals(n)) {
     
382.             f.set(t, Short.parseShort(v));
     
383.         } else if ("java.lang.Integer".equals(n) || "int".equals(n)) {
     
384.             f.set(t, Integer.parseInt(v));
     
385.         } else if ("java.lang.Long".equals(n) || "long".equals(n)) {
     
386.             f.set(t, Long.parseLong(v));
     
387.         } else if ("java.lang.Float".equals(n) || "float".equals(n)) {
     
388.             f.set(t, Float.parseFloat(v));
     
389.         } else if ("java.lang.Double".equals(n) || "double".equals(n)) {
     
390.             f.set(t, Double.parseDouble(v));
     
391.         } else if ("java.lang.String".equals(n)) {
     
392.             f.set(t, value.toString());
     
393.         } else if ("java.lang.Character".equals(n) || "char".equals(n)) {
     
394.             f.set(t, (Character) value);
     
395.         } else if ("java.lang.Date".equals(n)) {
     
396.             f.set(t, new Date(((java.sql.Date) value).getTime()));
     
397.         } else if ("java.lang.Timer".equals(n)) {
     
398.             f.set(t, new Time(((java.sql.Time) value).getTime()));
     
399.         } else if ("java.sql.Timestamp".equals(n)) {
     
400.             f.set(t, (java.sql.Timestamp) value);
     
401.         } else {
     
402.             System.out.println("SqlError：暂时不支持此数据类型，请使用其他类型代替此类型！");
     
403.         }
     
404.     }
     
405. 
     
406.     public static void executeProcedure(Connection con, String procedureName, Object... params) throws SQLException {
     
407.         CallableStatement proc = null;
     
408.         try {
     
409.             proc = con.prepareCall(procedureName);
     
410.             for (int i = 0; i < params.length; i++) {
     
411.                 proc.setObject(i + 1, params[i]);
     
412.             }
     
413.             proc.execute();
     
414.         } finally {
     
415.             if (null != proc)
     
416.                 proc.close();
     
417.         }
     
418.     }
     
419. 
     
420.     public static boolean executeProcedureReturnErrorMsg(Connection con, String procedureName, StringBuffer errorMsg,
     
421.             Object... params) throws SQLException {
     
422.         CallableStatement proc = null;
     
423.         try {
     
424.             proc = con.prepareCall(procedureName);
     
425.             proc.registerOutParameter(1, OracleTypes.VARCHAR);
     
426.             for (int i = 0; i < params.length; i++) {
     
427.                 proc.setObject(i + 2, params[i]);
     
428.             }
     
429.             boolean b = proc.execute();
     
430.             errorMsg.append(proc.getString(1));
     
431.             return b;
     
432.         } finally {
     
433.             if (null != proc)
     
434.                 proc.close();
     
435.         }
     
436.     }
     
437. 
     
438.     public static <T> List<T> executeProcedureReturnCursor(Connection con, String procedureName, Class<T> beanClass,
     
439.             Object... params) throws SQLException, InstantiationException, IllegalAccessException {
     
440.         List<T> lists = new ArrayList<T>();
     
441.         CallableStatement proc = null;
     
442.         ResultSet rs = null;
     
443.         try {
     
444.             proc = con.prepareCall(procedureName);
     
445.             proc.registerOutParameter(1, OracleTypes.CURSOR);
     
446.             for (int i = 0; i < params.length; i++) {
     
447.                 proc.setObject(i + 2, params[i]);
     
448.             }
     
449.             boolean b = proc.execute();
     
450.             if (b) {
     
451.                 rs = (ResultSet) proc.getObject(1);
     
452.                 while (null != rs && rs.next()) {
     
453.                     T t = beanClass.newInstance();
     
454.                     Field[] fields = beanClass.getDeclaredFields();
     
455.                     for (Field f : fields) {
     
456.                         f.setAccessible(true);
     
457.                         String name = f.getName();
     
458.                         try {
     
459.                             Object value = rs.getObject(name);
     
460.                             setValue(t, f, value);
     
461.                         } catch (Exception e) {
     
462.                         }
     
463.                     }
     
464.                     lists.add(t);
     
465.                 }
     
466.             }
     
467.         } finally {
     
468.             if (null != rs)
     
469.                 rs.close();
     
470.             if (null != proc)
     
471.                 proc.close();
     
472.         }
     
473.         return lists;
     
474.     }
     
475. 
     
476.     public static <T> List<List<T>> listLimit(List<T> lists, int pageSize) {
     
477.         List<List<T>> llists = new ArrayList<List<T>>();
     
478.         for (int i = 0; i < lists.size(); i = i + pageSize) {
     
479.             try {
     
480.                 List<T> list = lists.subList(i, i + pageSize);
     
481.                 llists.add(list);
     
482.             } catch (IndexOutOfBoundsException e) {
     
483.                 List<T> list = lists.subList(i, i + (lists.size() % pageSize));
     
484.                 llists.add(list);
     
485.             }
     
486.         }
     
487.         return llists;
     
488.     }
     
489. 
     
490. 
     
491. }

复制代码

config-db.properties

1. db_url=jdbc:oracle:thin:@localhost:1521:orcl
   
2. db_driver=oracle.jdbc.driver.OracleDriver
   
3. db_username=hr
   
4. db_password=

复制代码

DBUtilTest.java

1. import static org.junit.Assert.fail;
   
2. import static util.db.DBUtil.executeAsBatch;
   
3. import static util.db.DBUtil.executeProcedure;
   
4. import static util.db.DBUtil.openConnection;
   
5. 
   
6. import java.sql.Connection;
   
7. import java.sql.ResultSet;
   
8. import java.sql.SQLException;
   
9. import java.util.ArrayList;
   
10. import java.util.List;
    
11. import java.util.Map;
    
12. import java.util.Set;
    
13. 
    
14. import org.junit.After;
    
15. import org.junit.Assert;
    
16. import org.junit.Before;
    
17. import org.junit.Test;
    
18. 
    
19. import util.db.DBUtil;
    
20. import util.db.IResultSetCall;
    
21. 
    
22. /**
    
23. * 注意： 可以替换Employess1为Employess2,看看查询结果有什么区别。。
    
24. */
    
25. public class DBUtilTest {
    
26. 
    
27.     private Connection con = null;
    
28. 
    
29.     @Before
    
30.     public void setUp() throws Exception {
    
31.         try {
    
32.             con = DBUtil.openConnection();
    
33.         } catch (SQLException e) {
    
34.             fail(e.getMessage());
    
35.         }
    
36.     }
    
37. 
    
38.     @After
    
39.     public void tearDown() throws Exception {
    
40.         try {
    
41.             DBUtil.closeConnection();
    
42.         } catch (SQLException e) {
    
43.             fail(e.getMessage());
    
44.         }
    
45.     }
    
46. 
    
47.     @Test
    
48.     public void testQueryBeanListConnectionStringClassOfT() {
    
49.         String sql = "SELECT * FROM employees";
    
50.         try {
    
51.             List<Employees1> emList = DBUtil.queryBeanList(con, sql, Employees1.class);
    
52.             print(emList);
    
53.         } catch (Exception e) {
    
54.             fail(e.getMessage());
    
55.         }
    
56.     }
    
57. 
    
58.     @Test
    
59.     public void testQueryBeanListConnectionStringClassOfTObjectArray() {
    
60.         String sql = "SELECT * FROM employees t WHERE t.salary > ? and T.JOB_ID = ?";
    
61.         try {
    
62.             List<Employees1> emList = DBUtil.queryBeanList(con, sql, Employees1.class, 5000, "ST_MAN");
    
63.             print(emList);
    
64.         } catch (Exception e) {
    
65.             fail(e.getMessage());
    
66.         }
    
67.     }
    
68. 
    
69.     @Test
    
70.     public void testQueryBeanListConnectionStringIResultSetCallOfTObjectArray() {
    
71.         String sql = "SELECT first_name, last_name, salary FROM employees t WHERE t.salary > ? and T.JOB_ID = ?";
    
72.         try {
    
73.             List<Employees1> emList = DBUtil.queryBeanList(con, sql, new IResultSetCall<Employees1>() {
    
74.                 public Employees1 invoke(ResultSet rs) throws SQLException {
    
75.                     Employees1 e = new Employees1();
    
76.                     e.setFirst_name(rs.getString("first_name"));
    
77.                     e.setLast_name(rs.getString("last_name"));
    
78.                     e.setSalary(rs.getDouble("salary"));
    
79.                     return e;
    
80.                 }
    
81.             }, 5000, "ST_MAN");
    
82.             print(emList);
    
83.         } catch (Exception e) {
    
84.             e.printStackTrace();
    
85.             fail(e.getMessage());
    
86.         }
    
87.     }
    
88. 
    
89.     @Test
    
90.     public void testQueryObjectListConnectionStringClassOfT() {
    
91.         String sql = "SELECT email FROM employees t";
    
92.         try {
    
93.             List<String> lists = DBUtil.queryObjectList(con, sql, String.class);
    
94.             print(lists);
    
95.         } catch (Exception e) {
    
96.             fail(e.getMessage());
    
97.         }
    
98.     }
    
99. 
    
100.     @Test
     
101.     public void testQueryObjectListConnectionStringClassOfTObjectArray() {
     
102.         String sql = "SELECT salary FROM employees t WHERE t.salary > ? and T.JOB_ID = ?";
     
103.         try {
     
104.             List<Double> lists = DBUtil.queryObjectList(con, sql, Double.class, 2000, "ST_MAN");
     
105.             print(lists);
     
106.         } catch (Exception e) {
     
107.             fail(e.getMessage());
     
108.             e.printStackTrace();
     
109.         }
     
110.     }
     
111. 
     
112.     @Test
     
113.     public void testQueryBeanConnectionStringClassOfT() {
     
114.         String sql = "SELECT * FROM employees t WHERE t.employee_id in (120)";
     
115.         try {
     
116.             Employees1 emp = DBUtil.queryBean(con, sql, Employees1.class);
     
117.             print(emp);
     
118.         } catch (Exception e) {
     
119.             fail(e.getMessage());
     
120.         }
     
121.     }
     
122. 
     
123.     @Test
     
124.     public void testQueryBeanConnectionStringClassOfTObjectArray() {
     
125.         String sql = "SELECT * FROM employees t WHERE t.employee_id = ?";
     
126.         try {
     
127.             Employees1 emp = DBUtil.queryBean(con, sql, Employees1.class, 120);
     
128.             print(emp);
     
129.         } catch (Exception e) {
     
130.             fail(e.getMessage());
     
131.         }
     
132.     }
     
133. 
     
134.     @Test
     
135.     public void testQueryObjectConnectionStringClassOfT() {
     
136.         String sql = "SELECT email FROM employees t WHERE t.employee_id in (120)";
     
137.         try {
     
138.             String s = DBUtil.queryObject(con, sql, String.class);
     
139.             print(s);
     
140.         } catch (Exception e) {
     
141.             fail(e.getMessage());
     
142.         }
     
143.     }
     
144. 
     
145.     @Test
     
146.     public void testQueryObjectConnectionStringClassOfTObjectArray() {
     
147.         String sql = "SELECT salary FROM employees t WHERE t.employee_id in (?)";
     
148.         try {
     
149.             Double d = DBUtil.queryObject(con, sql, Double.class, 12);
     
150.             print(d);
     
151.         } catch (Exception e) {
     
152.             fail(e.getMessage());
     
153.             e.printStackTrace();
     
154.         }
     
155.     }
     
156. 
     
157.     @Test
     
158.     public void testExecuteConnectionStringObjectArray() {
     
159.         String sql = "UPDATE employees t SET t.salary =? WHERE t.employee_id =?";
     
160.         try {
     
161.             con.setAutoCommit(false);
     
162.             int count = DBUtil.execute(con, sql, 20000, 120);
     
163.             Assert.assertTrue(count == 1);
     
164.             sql = "SELECT t.salary FROM employees t WHERE t.employee_id =?";
     
165.             Double d = DBUtil.queryObject(con, sql, Double.class, 120);
     
166.             Assert.assertTrue(d - 20000 == 0);
     
167.         } catch (Exception e) {
     
168.             e.printStackTrace();
     
169.             fail(e.getMessage());
     
170.         } finally {
     
171.             try {
     
172.                 con.rollback();
     
173.                 con.setAutoCommit(true);
     
174.             } catch (SQLException e) {
     
175.                 e.printStackTrace();
     
176.             }
     
177.         }
     
178.     }
     
179. 
     
180.     @Test
     
181.     public void testQueryMapList() {
     
182.         String sql = "SELECT first_name, last_name, salary FROM employees t WHERE t.salary > ? and T.JOB_ID = ?";
     
183.         try {
     
184.             List<Map<String, Object>> lists = DBUtil.queryMapList(con, sql, 3000, "ST_MAN");
     
185.             print(lists);
     
186.         } catch (Exception e) {
     
187.             e.printStackTrace();
     
188.             fail(e.getMessage());
     
189.         }
     
190.     }
     
191. 
     
192.     @Test
     
193.     public void testExecuteProcedure() {
     
194.         try {
     
195.             executeProcedure(openConnection(), "{CALL prc_updatedata_for_daochong(?,?,?,?)}", "3000000993447731",
     
196.                     "060000019213", "50", "0010701848");
     
197.             System.out.println("执行存储过程更新采购订单表上的数据成功");
     
198.         } catch (Exception e) {
     
199.             e.printStackTrace();
     
200.             fail(e.getMessage());
     
201.         }
     
202.     }
     
203. 
     
204.     @Test
     
205.     public void testExecuteAsBatch() {
     
206.         try {
     
207.             List<String> sqlList = new ArrayList<String>();
     
208.             sqlList.add("UPDATE sm_user t SET t.password = 'ok' WHERE t.row_id = '232s43' ");
     
209.             sqlList.add("UPDATE sm_user t SET t.password = 'ok' WHERE t.row_id = '232f42' ");
     
210.             sqlList.add("UPDATE sm_user t SET t.password = 'ok' WHERE t.row_id = '23g2423' ");
     
211.             sqlList.add("UPDATE sm_user t SET t.password = 'ok' WHERE t.row_id = '232434s' ");
     
212.             executeAsBatch(openConnection(), sqlList);
     
213.         } catch (Exception e) {
     
214.             e.printStackTrace();
     
215.             fail(e.getMessage());
     
216.         }
     
217.     }
     
218. 
     
219.     @Test
     
220.     public void testExecuteAsBatchForPre() {
     
221.         try {
     
222.             executeAsBatch(con, "UPDATE employees t SET t.first_name = ? WHERE t.last_name = ? ", new Object[][] {
     
223.                     { "ok", "235jklsd" }, { "no", "jg4ti324" }, { "no1", "111" }, { "no2", "32423" } });
     
224.         } catch (Exception e) {
     
225.             e.printStackTrace();
     
226.             fail(e.getMessage());
     
227.         }
     
228.     }
     
229. 
     
230.     private void print(Object obj) {
     
231.         if (obj instanceof List) {
     
232.             List list = (List) obj;
     
233.             for (Object o : list) {
     
234.                 if (o instanceof Map) {
     
235.                     Map<String, Object> map = (Map<String, Object>) o;
     
236.                     Set<String> set = map.keySet();
     
237.                     for (String key : set) {
     
238.                         Object value = map.get(key);
     
239.                         System.out.print(key + ":" + value + "\t");
     
240.                     }
     
241.                     System.out.println();
     
242.                 } else {
     
243.                     System.out.println(o);
     
244.                 }
     
245.             }
     
246.             System.out.println("总共查询出数据数量是：" + list.size());
     
247.         } else {
     
248.             System.out.println(obj);
     
249.         }
     
250.     }
     
251. 
     
252. }

复制代码