apache提供的dbutils工具包中的QueryRunner、DbUtils类使用

package dbutils;

import Bean.T;
import TTest.JDBCUtilsNew;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

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

/**
 * @className: QueryRunnerTest
 * @description: QueryRunner是apache提供的封装数据库操作的工具包dbutils中的一个类,封装了针对数据库的增删改查操作
 * @author: CCQ
 * @date: 2021/10/2
 **/
public class QueryRunnerTest {

    //测试插入操作
    @Test
    public void testInsert() {
        Connection connection = null;
        try {
            //利用这个类可以对数据库进行增删改查操作
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="insert into t values(?,?,?,?,?,?)";
            //更新操作，里面封装了sql语句预编译以及执行操作
            int updatecount = runner.update(connection, sql, 10, "黑鱼", "男", "2021-10-02", "高级教师", "数科院");
            System.out.println("添加了"+updatecount+"条记录");
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }

    //测试查询操作（返回一条记录的情况,以对象的形式）
    //BeanHandler:是ResultSetHandler接口的一个实现类，用于封装表中的一条数据
    @Test
    public void testQuery1(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select * from t where id =?";
            //利用QueryRunner进行查询操作的时候需要传入返回结果集的形式，就是结果集处理器，比如这个BeanHandler就是返回一条数据的处理器
            BeanHandler<T> handler = new BeanHandler<T>(T.class);
//第三个参数是传入结果集处理器，形参是ResultSetHandler接口，BeanHandler是ResultSetHandler的一个实现类，不同的结果集处理器有不同的实现类
            T t = runner.query(connection, sql, handler, 10);
            System.out.println(t.toString());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }


    //测试查询操作（返回多条记录的情况，以对象的集合形式）
    //BeanListHandler：是ResultSetHandler接口的一个实现类，用于封装表中的多条数据构成的集合
    @Test
    public void testQuery2(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select * from t where id <= ?";
            //利用QueryRunner进行查询操作的时候需要传入返回结果集的形式，就是结果集处理器，比如这个BeanListHandler就是返回多条数据的处理器
            BeanListHandler<T> handler = new BeanListHandler<T>(T.class);
//第三个参数是传入结果集处理器，形参是ResultSetHandler接口，BeanHandler是ResultSetHandler的一个实现类，不同的结果集处理器有不同的实现类
            List<T> list = runner.query(connection, sql, handler, 10);
            list.forEach(System.out::println);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }


    //测试查询操作（返回一条记录的情况，以map的形式）
    //MapHandler:是ResultSetHandler接口的一个实现类，对应表中的一条数据,将字段以及字段的值作为map中的key和value
    @Test
    public void testQuery3(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select * from t where id =?";
            MapHandler handler = new MapHandler();
            Map<String, Object> map = runner.query(connection, sql, handler, 10);
            System.out.println(map);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }


    //测试查询操作（返回多条记录的情况，以map的集合形式）
    //MapListHandler:是ResultSetHandler接口的一个实现类，对应表中的多条数据,将字段以及字段的值作为map中的key和value
    @Test
    public void testQuery4(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select * from t where id <?";
            MapListHandler handler = new MapListHandler();
            List<Map<String, Object>> maplist = runner.query(connection, sql, handler, 10);
            maplist.forEach(System.out::println);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }



    //测试查询操作（查询特殊值,计算记录总数）
    //ScalarHandler:是ResultSetHandler接口的一个实现类，用于查询特殊值
    @Test
    public void testQuery5(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select count(*) from t";
            ScalarHandler<Long> handler = new ScalarHandler<>();
            Long count = runner.query(connection, sql, handler);
            System.out.println(count);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }


    //测试查询操作（查询特殊值，计算出生最晚的）
    //ScalarHandler:是ResultSetHandler接口的一个实现类，用于查询特殊值
    @Test
    public void testQuery6(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select Max(birthday) from t";
            ScalarHandler<String> handler = new ScalarHandler<>();
            String MaxBirthday = runner.query(connection, sql, handler);
            System.out.println(MaxBirthday);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }


    //自定义ResultSetHandler实现类
    @Test
    public void testQuery7(){
        Connection connection = null;
        try {
            QueryRunner runner = new QueryRunner();
            connection = JDBCUtilsNew.getConnection2();
            String sql ="select * from t where id =?";
            ResultSetHandler<T> handler =new ResultSetHandler<T>() {
                @Override
                public T handle(ResultSet resultSet) throws SQLException {
                    if (resultSet.next()){
                        int id = resultSet.getInt("id");
                        String name = resultSet.getString("NAME");
                        String sex = resultSet.getString("sex");
                        String birthday = resultSet.getString("birthday");
                        String zhicheng = resultSet.getString("zhicheng");
                        String yuanxi = resultSet.getString("yuanxi");
                        T t = new T(id,name,sex,birthday,zhicheng,yuanxi);
                        return t;
                    }
                    return null;
                }
            };

            T t = runner.query(connection, sql, handler, 9);
            System.out.println(t);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtilsNew.closeConnection(connection,null);
        }
    }

    //使用dbutils包中的DbUtils工具类，实现资源的关闭
    public void closeResoutce1(Connection connection, Statement statement,ResultSet resultSet){
//        try {
//            DbUtils.close(connection);
//        } catch (SQLException throwables) {
//            throwables.printStackTrace();
//        }
//        try {
//            DbUtils.close(statement);
//        } catch (SQLException throwables) {
//            throwables.printStackTrace();
//        }
//        try {
//            DbUtils.close(resultSet);
//        } catch (SQLException throwables) {
//            throwables.printStackTrace();
//        }
        DbUtils.closeQuietly(connection);
        DbUtils.closeQuietly(statement);
        DbUtils.closeQuietly(resultSet);
    }
}