DBUtils使用详细示例（参考）

原文链接为：http://wallimn.iteye.com/blog/1606930

用了好长一段时间JAVA，今天才知道有DBUtils这个东西。看了一下，使用方便，上手很快，是个不错的东西。 

一、使用示例 

Java代码  收藏代码
  1. package com.exam.test;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.SQLException;  
  5. import java.util.Iterator;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8. import java.util.Map.Entry;  
  9. import junit.framework.TestCase;  
  10. import org.apache.commons.dbutils.DbUtils;  
  11. import org.apache.commons.dbutils.QueryRunner;  
  12. import org.apache.commons.dbutils.handlers.ArrayHandler;  
  13. import org.apache.commons.dbutils.handlers.ArrayListHandler;  
  14. import org.apache.commons.dbutils.handlers.BeanHandler;  
  15. import org.apache.commons.dbutils.handlers.ColumnListHandler;  
  16. import org.apache.commons.dbutils.handlers.MapHandler;  
  17. import org.apache.commons.dbutils.handlers.MapListHandler;  
  18. import org.apache.commons.dbutils.handlers.ScalarHandler;  
  19. import com.exam.db.DbManager;  
  20. import com.exam.util.BasicRowProcessorEx;  
  21.   
  22. public class TestSomething extends TestCase {  
  23.     public void testDBUtilSelect() {  
  24.         Connection conn = DbManager.getInstance().getConnection();  
  25.   
  26.         QueryRunner queryRunner = new QueryRunner();  
  27.   
  28.         try {  
  29.             // 返回单行记录，使用Map  
  30.             System.out.println("使用Map处理单行记录！");  
  31.             Map<String, Object> map = queryRunner.query(conn,  
  32.                     "select * from tab where rownum=1", new MapHandler(),  
  33.                     (Object[]) null);  
  34.   
  35.             for (Iterator<Entry<String, Object>> i = map.entrySet().iterator(); i  
  36.                     .hasNext();) {  
  37.                 Entry<String, Object> e = i.next();  
  38.                 System.out.println(e.getKey() + "=" + e.getValue());  
  39.             }  
  40.   
  41.             System.out.println("处理多行记录！");  
  42.             List<Map<String, Object>> list = queryRunner.query(conn,  
  43.                     "select * from tab where rownum<=3", new MapListHandler(),  
  44.                     (Object[]) null);  
  45.   
  46.             for (Iterator<Map<String, Object>> li = list.iterator(); li  
  47.                     .hasNext();) {  
  48.                 System.out.println("--------------");  
  49.                 Map<String, Object> m = li.next();  
  50.                 for (Iterator<Entry<String, Object>> mi = m.entrySet()  
  51.                         .iterator(); mi.hasNext();) {  
  52.                     Entry<String, Object> e = mi.next();  
  53.                     System.out.println(e.getKey() + "=" + e.getValue());  
  54.                 }  
  55.             }  
  56.   
  57.             System.out.println("使用Bean处理单行记录！");  
  58.   
  59.             // com.exam.test.TestSomething.Tab  
  60.             Tab tab = queryRunner.query(conn,  
  61.                     "select tname from tab where rownum=1",  
  62.                     new BeanHandler<Tab>(Tab.class));  
  63.             System.out.println("tname=" + tab.getTname());  
  64.             System.out.println("tabtype=" + tab.getTabtype());  
  65.   
  66.             System.out.println("使用Array处理单行记录！");  
  67.             Object[] array = queryRunner.query(conn,  
  68.                     "select * from tab where rownum=1", new ArrayHandler());  
  69.   
  70.             for (int i = 0; i < array.length; i++) {  
  71.                 System.out.println(array[i]);  
  72.             }  
  73.   
  74.             System.out.println("使用Array处理多行记录！");  
  75.             List<Object[]> arraylist = queryRunner  
  76.                     .query(conn, "select * from tab where rownum<=3",  
  77.                             new ArrayListHandler());  
  78.   
  79.             for (Iterator<Object[]> itr = arraylist.iterator(); itr.hasNext();) {  
  80.                 Object[] a = itr.next();  
  81.                 System.out.println("--------------");  
  82.                 for (int i = 0; i < a.length; i++) {  
  83.                     System.out.println(a[i]);  
  84.   
  85.                 }  
  86.             }  
  87.   
  88.             System.out.println("使用ColumnListHandler处理单行记录，返回其中指定的一列！");  
  89.             List<Object> colList = queryRunner.query(conn,  
  90.                     "select * from tab where rownum=1", new ColumnListHandler(  
  91.                             "tname"));  
  92.             for (Iterator<Object> itr = colList.iterator(); itr.hasNext();) {  
  93.                 System.out.println(itr.next());  
  94.             }  
  95.   
  96.             System.out  
  97.                     .println("使用ScalarHandler处理单行记录，只返回结果集第一行中的指定字段，如未指定字段，则返回第一个字段！");  
  98.             Object scalar1 = queryRunner.query(conn, "select * from tab",  
  99.                     new ScalarHandler("tname"));  
  100.             System.out.println(scalar1);  
  101.             Object scalar2 = queryRunner.query(conn,  
  102.                     "select tname,tabtype from tab", new ScalarHandler());  
  103.             System.out.println(scalar2);  
  104.   
  105.             // 使用自定义的行处理器  
  106.             // Map中的KEY可按输入顺序输出  
  107.             System.out.println("使用Map处理单行记录(使用自定义行处理器)！");  
  108.             Map<String, Object> linkedmap = queryRunner  
  109.                     .query(  
  110.                             conn,  
  111.                             "select tabtype,tname,'wallimn' as programmer from tab where rownum=1",  
  112.                             new MapHandler(new BasicRowProcessorEx()),  
  113.                             (Object[]) null);  
  114.   
  115.             for (Iterator<Entry<String, Object>> i = linkedmap.entrySet()  
  116.                     .iterator(); i.hasNext();) {  
  117.                 Entry<String, Object> e = i.next();  
  118.                 System.out.println(e.getKey() + "=" + e.getValue());  
  119.             }  
  120.   
  121.             // 使用自定义的行处理器  
  122.             // Map中的KEY可按输入顺序输出  
  123.             System.out.println("处理多行记录(使用自定义行处理器)！");  
  124.             List<Map<String, Object>> listLinedMap = queryRunner  
  125.                     .query(  
  126.                             conn,  
  127.                             "select tabtype,tname,'wallimn' as programmer from tab where rownum<=3",  
  128.                             new MapListHandler(new BasicRowProcessorEx()),  
  129.                             (Object[]) null);  
  130.   
  131.             for (Iterator<Map<String, Object>> li = listLinedMap.iterator(); li  
  132.                     .hasNext();) {  
  133.                 System.out.println("--------------");  
  134.                 Map<String, Object> m = li.next();  
  135.                 for (Iterator<Entry<String, Object>> mi = m.entrySet()  
  136.                         .iterator(); mi.hasNext();) {  
  137.                     Entry<String, Object> e = mi.next();  
  138.                     System.out.println(e.getKey() + "=" + e.getValue());  
  139.                 }  
  140.             }  
  141.         } catch (SQLException e) {  
  142.             // TODO Auto-generated catch block  
  143.             e.printStackTrace();  
  144.         }  
  145.         DbUtils.closeQuietly(conn);  
  146.     }  
  147.   
  148.     public void testDBUtilInsertDeleteUpdateSelect() {  
  149.         // 建一个简单的测试表，建表脚本如下  
  150.         // create table T_DBUTILTEST(  
  151.         // id integer,  
  152.         // name varchar2(255)  
  153.         // );  
  154.         Connection conn = DbManager.getInstance().getConnection();  
  155.   
  156.         QueryRunner queryRunner = new QueryRunner(true);  
  157.   
  158.         try {  
  159.             queryRunner.update(conn, "delete from T_DBUTILTEST");  
  160.             // queryRunner.update(conn, "truncate table T_DBUTILTEST");  
  161.             // 插一条  
  162.             for (int i = 0; i < 10; i++) {  
  163.                 queryRunner.update(conn,  
  164.                         "insert into T_DBUTILTEST (id,name) values (?,?)", i,  
  165.                         "http://wallimn.iteye.com");  
  166.             }  
  167.   
  168.             // 再插多条  
  169.             queryRunner.batch(conn,  
  170.                     "insert into T_DBUTILTEST (id,name) values (?,?)",  
  171.                     new Object[][] { { 11, "batch:wallimn@sohu.com" },  
  172.                             { 12, "batch:wallimn@sohu.com" } });  
  173.   
  174.             // 删除示例  
  175.             queryRunner.update(conn, "delete from T_DBUTILTEST where id=1");  
  176.             queryRunner.update(conn, "delete from T_DBUTILTEST where id=?", 2);  
  177.             queryRunner.batch(conn, "delete from T_DBUTILTEST where id=?",  
  178.                     new Object[][] { { 3 }, { 4 } });  
  179.   
  180.             // 修改示例  
  181.             queryRunner.update(conn,  
  182.                     "update T_DBUTILTEST set name = ? where id=?", "修改后的新值", 5);  
  183.   
  184.             System.out.println("最终结果显示结果");  
  185.             List<Map<String, Object>> list = queryRunner.query(conn,  
  186.                     "select name,id from T_DBUTILTEST", new MapListHandler(),  
  187.                     (Object[]) null);  
  188.   
  189.             for (Iterator<Map<String, Object>> li = list.iterator(); li  
  190.                     .hasNext();) {  
  191.                 System.out.println("--------------");  
  192.                 Map<String, Object> m = li.next();  
  193.                 for (Iterator<Entry<String, Object>> mi = m.entrySet()  
  194.                         .iterator(); mi.hasNext();) {  
  195.                     Entry<String, Object> e = mi.next();  
  196.                     System.out.print(e.getValue());  
  197.                     System.out.print(",");  
  198.                 }  
  199.                 System.out.println();  
  200.             }  
  201.         } catch (SQLException e) {  
  202.             // TODO Auto-generated catch block  
  203.             e.printStackTrace();  
  204.         }  
  205.         DbUtils.closeQuietly(conn);  
  206.     }  
  207. }  



二、自定义扩展 
　　如果用户想要依照存入Map的顺序显示内容，好像不能直接支持。看了看源码，自定义了一个扩展类。用法在前的代码中有示例。 

Java代码  收藏代码
    1. package com.exam.util;  
    2.   
    3. import java.sql.ResultSet;  
    4. import java.sql.ResultSetMetaData;  
    5. import java.sql.SQLException;  
    6. import java.util.HashMap;  
    7. import java.util.LinkedHashMap;  
    8. import java.util.Map;  
    9.   
    10. import org.apache.commons.dbutils.BasicRowProcessor;  
    11.   
    12. /** 
    13.  * 用于apache的dbutil类的功能改进，当需要Map中的Key能按输入的顺序输出时，使用这个类来进行处理。简单改了一下基类。<br/> 
    14.  */  
    15. public class BasicRowProcessorEx extends BasicRowProcessor {  
    16.   
    17.     private static class CaseInsensitiveLinkedHashMap extends HashMap<String, Object> {  
    18.         private final Map<String, String> lowerCaseMap = new LinkedHashMap<String, String>();  
    19.         private static final long serialVersionUID = -2848100435296897392L;  
    20.   
    21.         /** {@inheritDoc} */  
    22.         @Override  
    23.         public boolean containsKey(Object key) {  
    24.             Object realKey = lowerCaseMap.get(key.toString().toLowerCase());  
    25.             return super.containsKey(realKey);  
    26.         }  
    27.   
    28.         /** {@inheritDoc} */  
    29.         @Override  
    30.         public Object get(Object key) {  
    31.             Object realKey = lowerCaseMap.get(key.toString().toLowerCase());  
    32.             return super.get(realKey);  
    33.         }  
    34.   
    35.         /** {@inheritDoc} */  
    36.         @Override  
    37.         public Object put(String key, Object value) {  
    38.             Object oldKey = lowerCaseMap.put(key.toLowerCase(), key);  
    39.             Object oldValue = super.remove(oldKey);  
    40.             super.put(key, value);  
    41.             return oldValue;  
    42.         }  
    43.   
    44.         /** {@inheritDoc} */  
    45.         @Override  
    46.         public void putAll(Map<? extends String, ?> m) {  
    47.             for (Map.Entry<? extends String, ?> entry : m.entrySet()) {  
    48.                 String key = entry.getKey();  
    49.                 Object value = entry.getValue();  
    50.                 this.put(key, value);  
    51.             }  
    52.         }  
    53.   
    54.         /** {@inheritDoc} */  
    55.         @Override  
    56.         public Object remove(Object key) {  
    57.             Object realKey = lowerCaseMap.remove(key.toString().toLowerCase());  
    58.             return super.remove(realKey);  
    59.         }  
    60.     }  
    61.     @Override  
    62.     public Map<String, Object> toMap(ResultSet rs) throws SQLException {  
    63.         Map<String, Object> result = new CaseInsensitiveLinkedHashMap();  
    64.         ResultSetMetaData rsmd = rs.getMetaData();  
    65.         int cols = rsmd.getColumnCount();  
    66.   
    67.         for (int i = 1; i <= cols; i++) {  
    68.             result.put(rsmd.getColumnName(i), rs.getObject(i));  
    69.         }  
    70.   
    71.         return result;  
    72.     }  
    73.   
    74. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hyqblog/p/6405945.html