DBUtils使用详细示例

字体大小: 中小 标准 ->行高大小: 标准 中 大
　用了好长一段时间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.  * 编码：wallimn　时间：2012-7-25　上午11:07:06<br/>  
  15.  * 版本：V1.0<br/>  
  16.  */  
  17. public class BasicRowProcessorEx extends BasicRowProcessor {   
  18.   
  19.     private static class CaseInsensitiveLinkedHashMap extends HashMap<String, Object> {   
  20.         private final Map<String, String> lowerCaseMap = new LinkedHashMap<String, String>();   
  21.         private static final long serialVersionUID = -2848100435296897392L;   
  22.   
  23.         /** {@inheritDoc} */  
  24.         @Override  
  25.         public boolean containsKey(Object key) {   
  26.             Object realKey = lowerCaseMap.get(key.toString().toLowerCase());   
  27.             return super.containsKey(realKey);   
  28.         }   
  29.   
  30.         /** {@inheritDoc} */  
  31.         @Override  
  32.         public Object get(Object key) {   
  33.             Object realKey = lowerCaseMap.get(key.toString().toLowerCase());   
  34.             return super.get(realKey);   
  35.         }   
  36.   
  37.         /** {@inheritDoc} */  
  38.         @Override  
  39.         public Object put(String key, Object value) {   
  40.             Object oldKey = lowerCaseMap.put(key.toLowerCase(), key);   
  41.             Object oldValue = super.remove(oldKey);   
  42.             super.put(key, value);   
  43.             return oldValue;   
  44.         }   
  45.   
  46.         /** {@inheritDoc} */  
  47.         @Override  
  48.         public void putAll(Map<? extends String, ?> m) {   
  49.             for (Map.Entry<? extends String, ?> entry : m.entrySet()) {   
  50.                 String key = entry.getKey();   
  51.                 Object value = entry.getValue();   
  52.                 this.put(key, value);   
  53.             }   
  54.         }   
  55.   
  56.         /** {@inheritDoc} */  
  57.         @Override  
  58.         public Object remove(Object key) {   
  59.             Object realKey = lowerCaseMap.remove(key.toString().toLowerCase());   
  60.             return super.remove(realKey);   
  61.         }   
  62.     }   
  63.     @Override  
  64.     public Map<String, Object> toMap(ResultSet rs) throws SQLException {   
  65.         Map<String, Object> result = new CaseInsensitiveLinkedHashMap();   
  66.         ResultSetMetaData rsmd = rs.getMetaData();   
  67.         int cols = rsmd.getColumnCount();   
  68.   
  69.         for (int i = 1; i <= cols; i++) {   
  70.             result.put(rsmd.getColumnName(i), rs.getObject(i));   
  71.         }   
  72.   
  73.         return result;   
  74.     }   
  75.   
  76. }  

此文章由 http://www.ositren.com 收集整理 ,地址为: http://www.ositren.com/htmls/70224.html