java 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实现类
（4）结果集：

     ①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......函数的执行结果

四：实现代码

插入。删除。更改。

        //1. insert 插入语句
		public void insert() throws SQLException {

			QueryRunner qr = new QueryRunner();

			String sql = "insert into tb_student(username, password) values (?, ?)";

			Object[] params = { "hello", 123 };

			qr.execute(conn, sql, params);

			DbUtils.close(conn);
		}

	
	//2. update 更新语句
		public void update() throws SQLException {

			QueryRunner qr = new QueryRunner();

			String sql = "update tb_student set username = ?, password = ? where id = ?";

			Object[] params = { "温老板", 250, 3};

			int i = qr.execute(conn, sql, params);

			System.out.println(i);

			DbUtils.close(conn);
		}


	//3. delete 删除语句
		public void delete() throws SQLException {

			QueryRunner qr = new QueryRunner();

			String sql = "delete from tb_student where id = ?";

			int i = qr.execute(conn, sql, 5);

			DbUtils.close(conn);
		}

package com.hello.dbutils.resultSetHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.junit.Test;

import com.hello.dbutils.pojo.Student;
import com.hello.dbutils.utils.DataBaseUtils;

public class Demo {

	private static Connection conn = DataBaseUtils.getDataBaseConnection();

	@Test
	public void run() throws SQLException {
		// arrayHandler();
		// arrayListHandler();
		// BeanHandler();
		// BeanListHandler();
		// columnListHandler();
		// scalarHandler();
		// mapHandler();
		mapListHandler();
	}
	
	/**
	 * MapListHandler：将获取的结果中的每一条记录封装到一个 Map 集合中，主要是使用 key 键和 value 值来存储数据。最终，将所有的值，放在 List 集合中进行存储。
	 * @throws SQLException
	 */
	public void mapListHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		List<Map<String, Object>> mapList = qr.query(conn, sql, new MapListHandler());

		// 4. 处理结果
		for (Map<String, Object> map : mapList) {
			
			for (String key : map.keySet()) {
				
				System.out.print(map.get(key) + "  ");
			}
			
			// 换行
			System.out.println();
		}
		
		// 5. 释放资源
		DbUtils.close(conn);
	}
	
	/**
	 * MapHandler 将获取的结果中的第一条记录封装到一个 Map 集合中，主要是使用 key 键和 value 值来存储数据。
	 * @throws SQLException
	 */
	public void mapHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		Map<String, Object> map = qr.query(conn, sql, new MapHandler());

		// 4. 处理结果
		for (String key : map.keySet()) {
			
			System.out.print(map.get(key) + "  ");
		}
	
		// 5. 释放资源
		DbUtils.close(conn);
	}
	
	/**
	 * ScalarHandler：主要是用于聚合函数，比如 count(*)、sum(*)，用于处理单数据的。
	 * @throws SQLException
	 */
	public void scalarHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select count(*) from tb_student";

		// 3. 执行 SQL 并获取结果
		Long count = qr.query(conn, sql, new ScalarHandler<Long>());

		// 4. 处理结果
		System.out.println(count);
	
		// 5. 释放资源
		DbUtils.close(conn);
	}
	
	/**
	 * ColumnListHandler：将获取的结果中的列所对应的字段值，封装到一个 List 集合中存储。
	 * @throws SQLException
	 */
	public void columnListHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		List<Object> list = qr.query(conn, sql, new ColumnListHandler<Object>("username"));

		// 4. 处理结果
		for (Object obj : list) {
			
			System.out.println(obj);
		}

		// 5. 释放资源
		DbUtils.close(conn);
	}
	
	/**
	 * BeanListHandler：将获取的结果中的每一条记录封装到指定的 JavaBean 中，然后将这些 JavaBean 放到一个集合中存储。
	 * @throws SQLException
	 */
	public void BeanListHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		List<Student> stuList = qr.query(conn, sql, new BeanListHandler<Student>(Student.class));

		// 4. 处理结果
		for (Student stu : stuList) {
			
			System.out.println(stu);
		}
		
		// 5. 释放资源
		DbUtils.close(conn);
	}

	/**
	 * BeanHandler：将获取的结果中的第一条记录封装到指定的一个 JavaBean 中。比如，封装到 Student。
	 * @throws SQLException
	 */
	public void BeanHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		Student stu = qr.query(conn, sql, new BeanHandler<Student>(Student.class));

		// 4. 处理结果
		System.out.println(stu);

		// 5. 释放资源
		DbUtils.close(conn);
	}
	
	/**
	 * ArrayListHandler：将获取的结果中的每一条记录封装到一个 Object[] 数组中，数组中的每个元素就是记录中的每一个字段的值。
	 * @throws SQLException
	 */
	public void arrayListHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		List<Object[]> result = qr.query(conn, sql, new ArrayListHandler());

		// 4. 处理结果
		for (Object[] objs : result) {
			for (Object obj : objs) {
				System.out.print(obj + "\t");
			}

			// 换行
			System.out.println();
		}

		// 5. 释放资源
		DbUtils.close(conn);
	}

	/**
	 * ArrayHandler：将获取的结果中的第一条记录封装到一个 Object[] 数组中，数组中的元素就是记录中的每一个字段的值。
	 * 
	 * @throws SQLException
	 */
	public void arrayHandler() throws SQLException {

		// 1. 获取 QueryRunner 对象
		QueryRunner qr = new QueryRunner();

		// 2. 准备 SQL 语句
		String sql = "select * from tb_student";

		// 3. 执行 SQL 并获取结果
		Object[] result = qr.query(conn, sql, new ArrayHandler());

		// 4. 处理结果
		for (Object obj : result) {
			System.out.println(obj);
		}

		// 5. 释放资源
		DbUtils.close(conn);
	}

}