DBUtils学习（介绍和入门）

本文转自：http://www.cnblogs.com/CQY1183344265/p/5854418.html

Dbutils学习（介绍和入门）

---

一：Dbutils是什么？

---

当我们很难理解一个东西的官方解释的时候，就让我们记住它的作用

DBUtils： 主要是封装了JDBC的代码，简化dao层的操作。

作用： 帮助java程序员，开发Dao层代码的简单框架。

框架的作用： 帮助程序员，提高程序的开发效率。

出生： DBUtils是由Apache公司提供。

---

二：为什么需要Dbutils ？

---

在使用Dbutils 之前，我们Dao层使用的技术是JDBC。
那么分析一下JDBC的弊端：

1. 数据库链接对象、sql语句操作对象，封装结果集对象，这三大对象会重复定义
2. 封装数据的代码重复，而且操作复杂，代码量大
3. 释放资源的代码重复

结果：

1. 程序员在开发的时候，有大量的重复劳动。
2. 开发的周期长，效率低开发的周期长，效率低。

---

三：Dbutils三个核心类介绍：

---

1：DbUtils：

连接数据库对象----jdbc辅助方法的集合类，线程安全。
构造方法：DbUtils()。
作用：控制连接，控制输入，控制驱动加载额一个类。

---

2：QueryRunner：

SQL语句的操作对象，可以设置查询结果集的封装策略，线程安全。

构造方法：
（1）QueryRunner()：创建一个与数据库无关的QueryRunner对象，后期再操作数据库的会后，需要手动给一个Connection对象，它可以手动控制事务。
Connection.setAutoCommit(false);：设置手动管理事务。
Connection.commit();：提交事务。

（2）QueryRunner(DataSource ds)：创建一个与数据库关联的queryRunner对象，后期再操作数据库的时候，不需要Connection对象，自动管理事务。
DataSource：数据库连接池对象。

构造函数与增删改查方法的组合：

QueryRunner()
update(Connection conn, String sql, Object... params)
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)

QueryRunner(DataSource ds)     
update(String sql, Object... params)
query(String sql, ResultSetHandler<T> rsh, Object... params)

---

3.ResultSetHandle：

封装数据的策略对象------将封装在结果集中的数据，转换到另一个对象。

策略：封装数据到对象的方式（示例：将数据库保存在User、保存到数组、保存到集合）

方法介绍：handle(ResultSet rs)

备注：详解参考ResultSetHandle实现类。

---

四：Dbutils快速入门

使用Dbutils注意事项：

1. 需要导入的jar包：①MySql驱动 ②c3p0包 ③DbUtils包
2. 添加c3p0配置文件
3. 可以自行添加一个JDBCUtils工具类：用来获取c3p0连接池对象

c3p0-config.xml

<? xml version ="1.0" encoding= "UTF-8" ?>
< c3p0-config>
       <!-- 默认配置，c3p0框架默认加载这段默认配置 -->
       < default-config>
             <!-- 配置JDBC 四个基本属性 -->
             < property name ="driverClass" >com.mysql.jdbc.Driver</ property >
             < property name ="jdbcUrl" >jdbc:mysql:///数据库名</ property >
             <!--username ： 你的数据库用户名 -->
             < property name ="user" >username</ property >
             <!--password ： 你的数据库密码 -->
             < property name ="password" >password</ property >
       </ default-config> <!-- This app is massive! -->
</ c3p0-config>

JDBCUtils. java

package cn.utils;

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JDBCUtils {

    // 获得c3p0连接池对象
    private static ComboPooledDataSource ds = new ComboPooledDataSource();

    /**
     * 获得数据库连接对象
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 获得c3p0连接池对象
     * @return
     */
    public static DataSource getDataSource() {
        return ds;
    }
}

---

案例一：

使用queryRunner对象完成增删改操作：

1：数据表

drop database if exists jdbc;
CREATE DATABASE IF NOT EXISTS jdbc;
USE jdbc;
 
drop table if exists user ;
CREATE TABLE IF NOT EXISTS `user ` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  ` name` varchar(50) DEFAULT NULL ,
  `pwd` varchar(50) DEFAULT NULL ,
  PRIMARY KEY (`id`)
) ;
#数据初始化
insert into user values (null ,'zhangsan' ,'123456' );
insert into user values (null ,'lisi' ,'123456' );

2：演示代码

//需求：向user表插入一条数据
@Test
public void test1(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "insert into user values(null,?,?)";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		int update = qr.update(sql, "狗蛋","123456");
		System.out.println(update);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
 
//需求：修改id==7的数据
@Test
public void test2(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "update user set name = ? where id = ?";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		int update = qr.update(sql, "柳岩",7);
		System.out.println(update);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
 
//需求：删除id==7的数据
@Test
public void test3(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "delete from user where id = ?";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		int update = qr.update(sql, 7);
		System.out.println(update);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

---

案例二：

QueryRunner的query方法和ResultSetHandler接口的使用

1：数据库表
同上一案例User表

drop database if exists jdbc;
CREATE DATABASE IF NOT EXISTS jdbc;
USE jdbc;
 
drop table if exists user ;
CREATE TABLE IF NOT EXISTS `user ` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  ` name` varchar(50) DEFAULT NULL ,
  `pwd` varchar(50) DEFAULT NULL ,
  PRIMARY KEY (`id`)
) ;
#数据初始化
insert into user values (null ,'zhangsan' ,'123456' );
insert into user values (null ,'lisi' ,'123456' );

2：自定义实现ResultSetHandler封装查询结果集

自定义策略：

package cn.handler;
 
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
import org.apache.commons.dbutils.ResultSetHandler;
 
import cn.itcast.domain.User;
// ResultSetHandler<T>,<T>表示封装结果的类型
//MyHandler 是自定义的ResultSetHandler封装结果集策略对象
public class MyHandler implements ResultSetHandler<List<User>>{
 
	@Override
	public List<User> handle(ResultSet rs) throws SQLException {
		// 封装数据，数据从 Resultset 中获取
		List<User> list = new ArrayList<User>();
		while(rs.next()){
			User u = new User();
			u.setId(rs.getInt( "id"));
			u.setName(rs.getString( "name"));
			u.setPwd(rs.getString( "pwd"));
			list.add(u);
		}
		return list;
	}
}

3：测试代码

//需求：获取user表中所有的数据
@Test
public void test4(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "select * from user";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		List<User> list = qr.query(sql, new MyHandler());
		System.out.println(list);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

---

案例三：

ResultSetHandler实现类介绍（由DbUtils框架提供）

备注：DbUtils给我们提供了10个ResultSetHandler实现类，分别是：

①ArrayHandler： 将查询结果的第一行数据，保存到Object数组中
②ArrayListHandler 将查询的结果，每一行先封装到Object数组中，然后将数据存入List集合
③BeanHandler 将查询结果的第一行数据，封装到user对象
④BeanListHandler 将查询结果的每一行封装到user对象，然后再存入List集合
⑤ColumnListHandler 将查询结果的指定列的数据封装到List集合中
⑥MapHandler 将查询结果的第一行数据封装到map结合（key列名，value列值）
⑦MapListHandler 将查询结果的每一行封装到map集合（key列名，value列值），再将map集合存入List集合
⑧BeanMapHandler 将查询结果的每一行数据，封装到User对象，再存入mao集合中（key = 列名，value = 列值）
⑨KeyedHandler 将查询的结果的每一行数据，封装到map1（key=列名，value=列值 ），然后将map1集合（有多个）存入map2集合（只有一个）
⑩ScalarHandler 封装类似count、avg、max、min、sum…函数的执行结果

以上10个ResultSetHandler实现类，常用的是BeanHandler、BeanListHandler和ScalarHandler，下面将对这三个实现类，写测试类

一： 测试BeanHandler策略

//需求：测试BeanHandler策略
//BeanHandler:将查询结果的第一行数据，封装到user对象
@Test
public void test7(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "select * from user";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		User user = qr.query(sql, new BeanHandler<User>(User.class));
		System.out.println(user);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

二：测试BeanListHandler策略

//需求：测试BeanListHandler策略
//BeanListHandler:将查询结果的每一行封装到user对象，然后，再存入list集合
@Test
public void test8(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "select * from user";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		List<User> list = qr.query(sql, new BeanListHandler<User>(User.class));
		System.out.println(list);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

三：测试ScalarHandler策略

//需求：测试ScalarHandler策略
//ScalarHandler:封装类似count、avg、max、min、sum。。。。函数的执行结果
@Test
public void test14(){
	//第一步：创建queryRunner对象，用来操作sql语句
	QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	//第二步：创建sql语句
	String sql = "select count(*) from user";
	//第三步：执行sql语句,params:是sql语句的参数
	//注意，给sql语句设置参数的时候，按照user表中字段的顺序
	try {
		Object object = qr.query(sql, new ScalarHandler());
		System.out.println(object);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

以上三个有测试案例的ResultSetHandler策略为常用实现类。