一、Dbutils如何使用,操作步骤

1、创建执行对象
(1)>QueryRunner(Datasource ds) :是自动提交

>update(String sql,Object...params) ;参数2:可变参数 ---不知道参数多少个(数组)

>针对DQL语句 ?query(String sql,ResultSetHandler<T>(Class<T> type))

>query(String sql,ResultSetHandler<T>(Class<T> type),Object...params)

(2)>QueryRunner():手动提交 ? ??
> update(Connection conn,String sql,Object...params)
> query(Connection conn,String sql,,ResultSetHandler<T>(Class<T> type))

????????QueryRunner qr = new QrueryRunner(DruidJdbcUtiils.getDataSource()) ; //封装工具类获取数据源

2、准备好sql语句

????????String sql ?= "insert into 表名 values(?,?,?,?)" ;
>通用的方法:针对DML语句 ?update(String sql,Object...params) ;;参数2:可变参数 ---不知道参数多少个(数组)
>针对DQL语句 ?query(String sql,ResultSetHandler<T>(Class<T> type))
>query(String sql,ResultSetHandler<T>(Class<T> type),Object...params)
3、ResultSetHandler 接口结果集的处理
? （1）子类 ? BeanListHandler<T>:将查询的多条记录封装到List集合中
? （2）BeanHandler<T>:将查询的某一条记录封装到实体类中(JavaBean)
? （3）sclarHandler:将单行单列的数据封装到实体类中Object(---转换成需要基本类型)
? （4）MapHanler:将查询的多条记录封装到Map集合中
? （5）ArrayHandler:将查询的多条记录封装到对象数组中...

4、qr.update(sql,实际参数列表) ;----//int 影响的行数?

二、ResultSetHandler 接口结果集的处理

? （1）子类 ? BeanListHandler<T>:将查询的多条记录封装到List集合中
? （2）BeanHandler<T>:将查询的某一条记录封装到实体类中(JavaBean)
? （3）sclarHandler:将单行单列的数据封装到实体类中Object(---转换成需要基本类型)
? （4）MapHanler:将查询的多条记录封装到Map集合中
? （5）ArrayHandler:将查询的多条记录封装到对象数组中...

三、练习

1、创建jdbc.properties属性列表

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb_01?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000

2、创建工具类

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @author Kuke
 * @date 2021/8/18
 * 工具类---->DataSource----->获取数据库的连接对象 Connection以及后期管理事务
 *
 * 获取连接对象----静态方法
 * 关闭资源-----静态方法
 */
public class DruidJdbcUtils {

    //成员变量位置
    private  static DataSource ds ;
    //为了保证线程安全:每一线程使用自己的Connection (张三/李四)
    private static ThreadLocal<Connection>  t1 = new ThreadLocal<>() ; //提供线程的局部变量保存连接对象



    //构造方法私有化
    private DruidJdbcUtils(){}

    //静态代码块
    static{
        try {
            //读取数据库连接池的配置文件----->通过DruidDataSourceFactory工厂类创建DataSource
            //创建一个属性集合列表
            Properties prop = new Properties() ;
            //读取druid.properties
            InputStream inputStream = DruidJdbcUtils.class.getClassLoader().
                    getResourceAsStream("jdbc.properties");

            //将资源文件所在的输入流加载列表中
            prop.load(inputStream);
            ds = DruidDataSourceFactory.createDataSource(prop); //底层子实现类:DruidDataSource
            //System.out.println("数据源获取成功");

        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //提供静态方法:单独获取数据源
    public static DataSource getDataSource(){
        return ds ;
    }


    //获取连接对象Connection静态功能

    public static Connection getConnection(){
        //从ThreadLocal中获取局部变量的副本:Connection
        /**
         *   public T get()  :从线程中获取局部变量的副本!
         */
        Connection conn =  null ;
        try {
            conn  =  t1.get();
            if(conn==null){
                //如果空,需要从数据库的连接池中获取连接对象
                 conn  = ds.getConnection();
                //获取到之后,每一线程执行自己的Connection
                //将获取到的连接对象 绑定到当前线程中
                t1.set(conn);
            }
            //如果不为空,说明ThreadLocal线程中已经存在Connection
            return conn ; //
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null ;

    }

    //关闭(释放资源)资源
    public static void close(ResultSet rs, Statement stmt,Connection conn)  {
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
                //关闭之后,归还到连接池中,需要从当前线程中解绑
                t1.remove();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close( Statement stmt,Connection conn)  {
        close(null,stmt,conn);
    }

    //事务管理代码 --- 加入

    //定义开启事务的方法
    //定义回滚的方法
    public static void rollback() throws SQLException {
        Connection connection = DruidJdbcUtils.getConnection();
        //调用回滚方法
        connection.rollback();
        //使用完毕,归还连接池中
        connection.close();
        //从当前线程中解绑
        t1.remove();

    }
    //定义提交的方法---->需要将当前线程中绑定的Connetion remove掉

    public static void main(String[] args) {
       // DataSource ds = DruidJdbcUtils.getDataSource();
        //System.out.println(ds);


        Connection connection = DruidJdbcUtils.getConnection();
        System.out.println(connection);
    }
}

3、Admin类

import java.io.Serializable;

/**
 * @author Kuke
 * @date 2021/8/19
 * 管理员类
 *
 * JavaBean是一种规范:
 *     1)当前类是具体类
 *     2)当前类中字段(成员变量)私有化
 *     3)需要通过公共setXXX()/getXXX()方法
 *     4)当前类可以实现序列化接口
 */
public class Admin  implements Serializable {

    private int id ;
    private String username ;
    private String gender ;
    private int age ;
    private String address ;
    private String phone ;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() { //getXXX()  get()去掉 username 称为 当前类bean属性
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Admin{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}

4、创建Admin数据库访问接口

import com.qf.pojo.Admin;

import java.util.List;

/**
 * @author Kuke
 * @date 2021/8/19
 * 针对Admin数据库访问接口
 */
public interface AdminDao {

    /**
     * 获取所有管理员列表
     * @return 列表
     */
    List<Admin> findAll();

    /**
     * 查询编号获取Admin实体
     * @param id  编号
     * @return 返回实体对象
     */
    Admin findAdminById(int id);


    /**
     * 查询总记录
     * @return
     */
    long selectTotalCount();

    /**
     * 修改admin
     * @param selectAdmin
     * @return
     */
    int updateAdmin(Admin selectAdmin);
}

5、Admin的数据库访问接口实现类

import com.qf.dao.AdminDao;
import com.qf.pojo.Admin;
import com.qf.utils.DruidJdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

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

/**
 * @author Kuke
 * @date 2021/8/19
 * 针对Admin的数据库访问接口实现类
 */
public class AdminDaoImpl implements AdminDao {


    @Override
    public List<Admin> findAll() {
        try {
            //创建执行对象
            QueryRunner qr = new QueryRunner(DruidJdbcUtils.getDataSource()) ;

            //准备sql语句
            String sql = "select *  from admin" ;
            //执行查询
            //query(String sql,ResuletSetHandler handler)
            //参数1:sql
            //参数2:结果集的处理
            //子类:BeanListHandler<T> 将查询的多条记录封装到List集合中
            //List<当前指定的javeBean实体>
            // BeanListHandler<将查询的结果封装实体类型>(当前实体的类Class)

            List<Admin> list = qr.query(sql, new BeanListHandler<Admin>(Admin.class));
            return list ;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }


    //通过id查询Admin实体
    @Override
    public Admin findAdminById(int id) {
        try {
            //创建执行对象
            QueryRunner qr = new QueryRunner(DruidJdbcUtils.getDataSource()) ;
            //sql
            String sql = "select * from admin where id = ?" ;
            //执行查询
            //query(String sql,ResultSetHandler handler,Object...params)
            //将查询的某一条记录封装到实体类(JavaBean)中,使用到类BeanHandler<T>
            Admin admin = qr.query(sql, new BeanHandler<Admin>(Admin.class), id);
            return admin;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }

    //查询总记录数
    @Override
    public long selectTotalCount() {
        //QueryRunner执行对象
        try {
            QueryRunner qr = new QueryRunner(DruidJdbcUtils.getDataSource()) ;
            //sql
            String sql = "select count(id) from admin" ;
            //查询一些单行单列的数据(总记录数),使用单类ScalerHandler<>
            long count = (Long)qr.query(sql, new ScalarHandler<>());
            return count ;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }


    //修改Admin

    @Override
    public int updateAdmin(Admin selectAdmin) {
        try {
            //QueryRunner
            QueryRunner qr = new QueryRunner(DruidJdbcUtils.getDataSource()) ;
            //sql
            String sql = "update admin set username = ? ,gender =?,age = ?,address = ? ,phone =? where id = ?" ;
            //更新操作
            int count = qr.update(sql,
                    selectAdmin.getUsername(),
                    selectAdmin.getGender(),
                    selectAdmin.getAge(),
                    selectAdmin.getAddress(),
                    selectAdmin.getPhone(),
                    selectAdmin.getId());
            System.out.println(count);
            return count ;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return 0;
    }
}

6、Admin业务接口

import com.qf.pojo.Admin;

import java.util.List;

/**
 * @author Kuke
 * @date 2021/8/19
 *
 * 针对Admin业务接口
 */
public interface AdminService {


    /**
     * 获取所有管理员列表
     * @return 列表
     */
    List<Admin> getAllAdmin() ;

    /**
     * 查询编号获取Admin实体
     * @param id  编号
     * @return 返回实体对象
     */
    Admin getAdmin(int id) ;


    /**
     * 查询总记录
     * @return
     */
    long getTotal() ;


    /**
     * 根据id修改admin
     * @param admin
     * @return
     */
    int update(Admin admin) ;
}

7、针对Admin的业务接口实现类

import com.qf.dao.AdminDao;
import com.qf.dao.impl.AdminDaoImpl;
import com.qf.pojo.Admin;
import com.qf.service.AdminService;

import java.util.List;

/**
 * @author Kuke
 * @date 2021/8/19
 * 针对Admin的业务接口实现类
 */
public class AdminServiceImpl implements AdminService {
    @Override
    public List<Admin> getAllAdmin() {

        //调用数据库访问接口
        AdminDao adminDao = new AdminDaoImpl() ;
        List<Admin> list =  adminDao.findAll() ;
        if(list!=null){
            return list ;
        }
        return null ;

    }

    @Override
    public Admin getAdmin(int id) {
        //调用数据库访问接口
        AdminDao adminDao = new AdminDaoImpl() ;
        Admin admin = adminDao.findAdminById(id) ;
        if(admin!=null){
            return admin ;
        }
        return null;
    }

    @Override
    public long getTotal() {
        //调用数据库访问jiekou
        AdminDao adminDao = new AdminDaoImpl() ;
        long count = adminDao.selectTotalCount() ;
        return count;
    }

    @Override
    public int update(Admin admin) {
        //1)修改管理员数据,需要通过id查询Admin
        AdminDao adminDao = new AdminDaoImpl() ;
        //通过编号查询Admin
        Admin selectAdmin = adminDao.findAdminById(admin.getId());
        if(selectAdmin !=null){
            //存在
            //进行修改
            int count = adminDao.updateAdmin(admin) ;
            return  count ;
        }
        return 0;
    }

    public static void main(String[] args) {
        AdminService adminService = new AdminServiceImpl() ;
        Admin admin = new Admin() ;
        admin.setId(3) ;
        admin.setUsername("张三丰");
        admin.setGender("男");
        admin.setAge(20);
        admin.setAddress("南窑国际");
        admin.setPhone("13588889999");
        int count = adminService.update(admin);
        System.out.println(count);

    }
}

8、提供一些业务测试 (单元测试)

import com.qf.pojo.Admin;
import com.qf.service.AdminService;
import com.qf.service.impl.AdminServiceImpl;
import org.junit.Test;

import java.util.List;

/**
 * @author Kuke
 * @date 2021/8/19
 * 提供一些业务测试 (单元测试)
 *
 */
public class DbutilsTest {

    @Test
    public void testFindAll(){
        //调用业务层方法
        AdminService adminService = new AdminServiceImpl() ;
        List<Admin> list = adminService.getAllAdmin();
        for (Admin admin : list) {
            System.out.println(admin);
        }
    }

    @Test
    public void testFindById(){
        AdminService adminService = new AdminServiceImpl() ;
        Admin admin = adminService.getAdmin(3);
        System.out.println(admin);
    }

    @Test
    public void testSelectTotalCount(){
        AdminService adminService = new AdminServiceImpl() ;
        long count = adminService.getTotal();
        System.out.println(count);
    }


    @Test
    public void testUpdateAdmin(){
        AdminService adminService = new AdminServiceImpl() ;
        //创建Admin
        Admin admin = new Admin() ;
        admin.setId(3) ;
        admin.setUsername("张三丰2");
        admin.setGender("男2");
        admin.setAge(22);

        admin.setAddress("南窑国际2");
        admin.setPhone("13588889888");
        int count = adminService.update(admin);
        System.out.println(count);
    }
}