一、结构介绍

高层结构图:

wrappers包:

handlers包(部分):

二、功能介绍

commons.dbutils是一个对JDBC操作进行封装的类集,其有如下几个优点:

(1)没有可能的资源泄漏,避免了繁锁的JDBC代码

(2)代码更整洁

(3)从ResultSet自动生成JavaBeans属性

(4)无其他依赖包

三、基本使用

基本用到的类有:QueryRunner、ResultSetHandler及其子类等

QueryRunner -- 执行查询的类,可以执行SELECT、INSERT、UPDATE、DELETE等语句,QueryRunner用ResultSetHandler的子类来处理ResultSet并返回结果;而包提供的ResultSetHandler子类使用RowProcessor的子类来处理ResultSet中的每一行;RowProcessor的默认实现为BasicRowProcessor;BeanProcessor不是RowProcessor,可以看作一个工具类

ResultHandler及其子类 -- 实现了Object handle(ResultSet rs) throws SQLException方法

AbstractListHandler -- 返回多行List的抽象类

ArrayHandler --  返回一行的Object[]

ArrayListHandler -- 返回List,每行是Object[]

BeanHandler -- 返回第一个Bean对象

BeanListHandler -- 返回List,每行是Bean

ColumnListHandler -- 返回一列的List

KeyedHandler -- 返回Map,具体见代码

MapHandler -- 返回单个Map

MapListHandler -- 返回List,每行是Map

ScalarHandler -- 返回列的头一个值

代码:

[java] view
plain
copy

  1. //建表语句
  2. DROP TABLE IF EXISTS `test`.`user`;
  3. CREATE TABLE  `test`.`user` (
  4. `name` varchar(10) DEFAULT NULL,
  5. `password` varchar(10) DEFAULT NULL
  6. ) ENGINE=MyISAM DEFAULT CHARSET=latin1;
  7. 表中数据
  8. 'user1', 'pwd1'
  9. 'user2', 'pwd2'
  10. //User类
  11. public class User {
  12. private String name;
  13. private String pwd;
  14. public User(){
  15. }
  16. public void setName(String val) {
  17. this.name = val;
  18. }
  19. public void setPassword(String val) {
  20. this.pwd = val;
  21. }
  22. public String getName() {
  23. return name;
  24. }
  25. public String getPassword() {
  26. return pwd;
  27. }
  28. }
[java] view
plain
copy

  1. package dbutiltest;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.util.List;
  6. import java.util.Map;
  7. import org.apache.commons.dbutils.DbUtils;
  8. import org.apache.commons.dbutils.QueryRunner;
  9. import org.apache.commons.dbutils.ResultSetHandler;
  10. import org.apache.commons.dbutils.handlers.ArrayHandler;
  11. import org.apache.commons.dbutils.handlers.ArrayListHandler;
  12. import org.apache.commons.dbutils.handlers.BeanHandler;
  13. import org.apache.commons.dbutils.handlers.BeanListHandler;
  14. import org.apache.commons.dbutils.handlers.ColumnListHandler;
  15. import org.apache.commons.dbutils.handlers.KeyedHandler;
  16. import org.apache.commons.dbutils.handlers.MapListHandler;
  17. public class TestDbUtils {
  18. static {
  19. try {
  20. Class.forName("org.gjt.mm.mysql.Driver");
  21. } catch (ClassNotFoundException e) {
  22. e.printStackTrace();
  23. System.exit(1);
  24. }
  25. }
  26. public Connection getConnection() {
  27. Connection conn = null;
  28. try {
  29. conn = DriverManager.getConnection(
  30. "jdbc:mysql://localhost:3306/test", "root", "pwd");
  31. } catch (SQLException e) {
  32. e.printStackTrace();
  33. }
  34. return conn;
  35. }
  36. public static void main(String[] args) {
  37. TestDbUtils u = new TestDbUtils();
  38. u.testArrayHandler();
  39. u.testArrayListHandler();
  40. u.testBeanListHandler();
  41. u.testMapListHandler();
  42. u.testColumnListHandler();
  43. u.testNonQuery();
  44. }
  45. public void testArrayHandler() {
  46. System.out.println("----testArrayHandler----");
  47. String sql = "select * from user";
  48. ResultSetHandler handler = new ArrayHandler();
  49. QueryRunner query = new QueryRunner();
  50. Connection conn = null;
  51. try {
  52. conn = getConnection();
  53. Object[] arr = (Object[])query.query(conn, sql, handler);
  54. for (int i = 0; i < arr.length; i++) {
  55. System.out.println(arr[i].toString());
  56. }
  57. } catch (SQLException e) {
  58. e.printStackTrace();
  59. } finally {
  60. try {
  61. DbUtils.close(conn);
  62. } catch (SQLException e) {
  63. // ignore
  64. }
  65. }
  66. }
  67. public void testArrayListHandler() {
  68. System.out.println("----testArrayListHandler----");
  69. String sql = "select * from user";
  70. ResultSetHandler handler = new ArrayListHandler();
  71. QueryRunner query = new QueryRunner();
  72. Connection conn = null;
  73. try {
  74. conn = getConnection();
  75. List list = (List)query.query(conn, sql, handler);
  76. for (int i = 0; i < list.size(); i++) {
  77. Object[] arr = (Object[])list.get(i);
  78. for (int j = 0; j < arr.length; j++) {
  79. System.out.print(arr[j] + "  ");
  80. }
  81. System.out.println();
  82. }
  83. } catch (SQLException e) {
  84. e.printStackTrace();
  85. } finally {
  86. try {
  87. DbUtils.close(conn);
  88. } catch (SQLException e) {
  89. // ignore
  90. }
  91. }
  92. }
  93. public void testBeanListHandler() {
  94. System.out.println("----testBeanListHandler----");
  95. String sql = "select * from user where name=?";
  96. Object[] params = new Object[]{"user1"};
  97. ResultSetHandler handler = new BeanListHandler(User.class);
  98. QueryRunner query = new QueryRunner();
  99. Connection conn = null;
  100. try {
  101. conn = getConnection();
  102. List list = (List)query.query(conn, sql, params, handler);
  103. for (int i = 0; i < list.size(); i++) {
  104. User user = (User)list.get(i);
  105. System.out.println(user.getName() + "  " + user.getPassword());
  106. }
  107. } catch (SQLException e) {
  108. e.printStackTrace();
  109. } finally {
  110. try {
  111. DbUtils.close(conn);
  112. } catch (SQLException e) {
  113. // ignore
  114. }
  115. }
  116. }
  117. public void testMapListHandler() {
  118. System.out.println("----testMapListHandler----");
  119. String sql = "select * from user where name=?";
  120. Object[] params = new Object[]{"user1"};
  121. ResultSetHandler handler = new MapListHandler();
  122. QueryRunner query = new QueryRunner();
  123. Connection conn = null;
  124. try {
  125. conn = getConnection();
  126. List list = (List)query.query(conn, sql, params, handler);
  127. for (int i = 0; i < list.size(); i++) {
  128. Map user = (Map)list.get(i);
  129. System.out.println(user.get("name") + "  " + user.get("password"));
  130. }
  131. } catch (SQLException e) {
  132. e.printStackTrace();
  133. } finally {
  134. try {
  135. DbUtils.close(conn);
  136. } catch (SQLException e) {
  137. // ignore
  138. }
  139. }
  140. }
  141. public void testColumnListHandler() {
  142. System.out.println("----testColumnListHandler----");
  143. String sql = "select * from user";
  144. ResultSetHandler handler = new ColumnListHandler("name");
  145. QueryRunner query = new QueryRunner();
  146. Connection conn = null;
  147. try {
  148. conn = getConnection();
  149. List list = (List)query.query(conn, sql, handler);
  150. for (int i = 0; i < list.size(); i++) {
  151. System.out.println(list.get(i));
  152. }
  153. } catch (SQLException e) {
  154. e.printStackTrace();
  155. } finally {
  156. try {
  157. DbUtils.close(conn);
  158. } catch (SQLException e) {
  159. // ignore
  160. }
  161. }
  162. }
  163. public void testKeyedHandler() {
  164. System.out.println("----testKeyedHandler----");
  165. String sql = "select * from user";
  166. ResultSetHandler handler = new KeyedHandler("name");
  167. QueryRunner query = new QueryRunner();
  168. Connection conn = null;
  169. try {
  170. conn = getConnection();
  171. Map map = (Map)query.query(conn, sql, handler);
  172. Map user = (Map)map.get("user2");
  173. System.out.println(user.get("password"));
  174. } catch (SQLException e) {
  175. e.printStackTrace();
  176. } finally {
  177. try {
  178. DbUtils.close(conn);
  179. } catch (SQLException e) {
  180. // ignore
  181. }
  182. }
  183. }
  184. public void testNonQuery() {
  185. System.out.println("----testNonQuery----");
  186. String sql = "insert into `user` values('user_test','pwd_test')";
  187. QueryRunner query = new QueryRunner();
  188. Connection conn = null;
  189. try {
  190. conn = getConnection();
  191. query.update(conn, sql);
  192. } catch (SQLException e) {
  193. e.printStackTrace();
  194. } finally {
  195. try {
  196. DbUtils.close(conn);
  197. } catch (SQLException e) {
  198. // ignore
  199. }
  200. }
  201. }
  202. }

关于wrappers包:

在新建 QueryRunner时,覆盖父类的方法wrap

[java] view
plain
copy

  1. QueryRunner query = new QueryRunner() {
  2. protected ResultSet wrap(ResultSet rs) {
  3. return StringTrimmedResultSet.wrap(rs);
  4. }
  5. };

四、扩展

1.RowProcessor接口

2.ResultSetHandler接口

commons.dbutils1.2介绍及使用的更多相关文章

  1. Apache Commons 工具类介绍及简单使用

    转自:http://www.cnblogs.com/younggun/p/3247261.html Apache Commons包含了很多开源的工具,用于解决平时编程经常会遇到的问题,减少重复劳动.下 ...

  2. Apache Commons 工具集介绍

    Apache Commons包含了很多开源的工具,用于解决平时编程经常会遇到的问题,减少重复劳动.下面是我这几年做开发过程中自己用过的工具类做简单介绍. 组件 功能介绍 BeanUtils 提供了对于 ...

  3. Apache Commons 工具类介绍及简单使用(转载)

    原文链接 http://www.cnblogs.com/younggun/p/3247261.html Apache Commons包含了很多开源的工具,用于解决平时编程经常会遇到的问题,减少重复劳动 ...

  4. Java:Apache Commons 工具类介绍及简单使用

    Apache Commons包含了很多开源的工具,用于解决平时编程经常会遇到的问题,减少重复劳动.下面是我这几年做开发过程中自己用过的工具类做简单介绍. Commons简介 组件 功能介绍 commo ...

  5. apache commons lang架包介绍

    commons lang组件介绍和学习 介绍 Java语言开发时有一个隐患,那就是java支持null值,这就导致很多时候操作可能会出异常. 因此很多第三方组件都会提供安全null safe 操作(即 ...

  6. java中常用的工具类(三)

    继续分享java中常用的一些工具类.前两篇的文章中有人评论使用Apache 的lang包和IO包,或者Google的Guava库.后续的我会加上的!谢谢支持IT江湖 一.连接数据库的综合类       ...

  7. java:工具类

    Google guava工具类的介绍和使用:https://blog.csdn.net/wwwdc1012/article/details/82228458 Apache Commons 工具类介绍及 ...

  8. java常用工具类(三)

    一.连接数据库的综合类 package com.itjh.javaUtil; import java.sql.Connection; import java.sql.DriverManager; im ...

  9. Java常用开源库

    Java的经久不衰,很大程度上得益于Java的生态好.在日常开发中,我们也会经常使用到各种开源库和工具类,为了避免重复造轮子,本文将贴出工作及学习中会用到的部分开源库和工具类.Java的生态实在太大, ...

  10. Apache Commons介绍(转载)

    一.Commons BeanUtils说明:针对Bean的一个工具集.由于Bean往往是有一堆get和set组成,所以BeanUtils也是在此基础上进行一些包装. 二.Commons CLI说明:这 ...

随机推荐

  1. docker高级篇:实战-自己开发的微服务怎么在docker上面运行?

    通过前面的一系列学习,我们已经知道怎么制作dockerfile了.那么,本篇文章,咱们就把自己写的spring boot的demo项目,部署在docker上面. 案例目标: 我们自己开发的微服务怎么在 ...

  2. SpringMVC:SpringMVC执行流程

    目录 SpringMVC常用组件 DispatcherServlet初始化过程 ①初始化WebApplicationContext ②创建WebApplicationContext ③Dispatch ...

  3. vue打包项目版本号自加

    原因 项目每次打包后都需要改动项目版本号,这个改动每次都需要在package.json中修改version,比较麻烦,到底有没有一种打包后版本号自加的办法. 方案 版本号自加其实可以使用fs修改文件来 ...

  4. 6.2 XXE和XML利用

    pikaqu靶场xml数据传输测试-有回显,玩法,协议,引入 1.构造payload 写文件 <?xml version="1.0" encoding="UTF-8 ...

  5. 【论文解读】RLAIF基于人工智能反馈的强化学习

    [论文解读]RLAIF基于人工智能反馈的强化学习 一.简要介绍 人类反馈强化学习(RLHF)可以有效地将大型语言模型(LLM)与人类偏好对齐,但收集高质量的人类偏好标签是一个关键瓶颈.论文进行了一场R ...

  6. C# – Record, Class, Struct

    前言 之前在 C# – 10.0 已经有介绍过 Record 了. 但之前还没怎么用到, 最近有用到了, 所以特别写多一篇. Class vs Struct 参考: C#详解struct和class的 ...

  7. 2024.7.5-2024.7.20 HA省学会集训游记(焦作一中)

    这是一篇长篇小说 DAY1 除了DAY4-DAY5个别内容以外,这些都是补的,但是全写完有太多了qwq,挑题写了 树状数组和线段树基础 很多都是一些模板题,太模板的题不再做太多解释 题目: P4062 ...

  8. Android复习(三)清单文件中的元素——>path-permission、permission、permission-group、permission-tree

    <path-permission> 语法: <path-permission android:path="string" android:pathPrefix=& ...

  9. Android复习(二)应用资源 --> 动画

    没什么好总结的 复制自 https://developer.android.google.cn/guide/topics/resources/animation-resource 有需要的可以查看官方 ...

  10. Redis实现幂等、防抖、限流等功能

    本文章主要讲述如何使用Redis实现幂等.防抖.限流等功能. 幂等组件 import lombok.RequiredArgsConstructor; import org.springframewor ...