JDBC（四、连接池和DbUtils）

JDBC（四、连接池和DbUtils）

数据库连接池

为什么使用数据库连接池

不使用数据库连接池：

• 数据库连接资源没有得到很好的重复利用
  • 我们每次使用想数据库建立连接时都要创建一个Connection对象，这个过程要验证IP地址、用户名和密码，用完之后再close断开连接，这样的方式会消耗大量的资源和时间
• 内存泄漏
  • 数据库连接每次都要创建和关闭，如果程序出现异常为能执行关闭操作，那么就会导致内存泄漏
• 无法控制连接对象数
  • 如果有几千人需要对数据库进行操作，我们无法控制创建数据库连接对象的数量，大量的资源分配出去，甚至服务器崩溃

数据库连接池的基本思想：

• 为数据库连接建立一个“缓冲池”，预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”取出一个，使用完毕后再放回去
• 数据库连接池负责分配、管理和释放数据库连接。它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
• 连接池最大的连接数量，限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

使用连接池：

• 资源重复使用
• 速度快
• 资源分配良好
• 统一连接管理，烦那个纸数据库连接泄露

注意：

• 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可
• 当数据库访问结束后，程序还是可以像以前一样关闭数据库连接，但是这个时候的close()是释放数据库连接，将Connection归还给连接池。

开源的数据库连接池

JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由服务器提供实现，一些开源组织提供实现：

• DBCP：Apache提供的数据库连接池，速度比C3P0快
• C3P0：开源组织提供的数据库连接池，速度一般，较稳定
• Proxool：SourceForge下的一个开源项目的数据库连接池，有监控连接池的功能
• BoneCP：开源组织提供的数据库连接池，速度快
• Druid：阿里提供的数据库连接池，据说是及DBCP、C3P0、Proxool优点于一身的数据库连接池

Druid

阿里巴巴开源平台上的一个数据库连接池实现，加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，据说是目前最好的连接池。

连接池的使用：

• 导入jar包

• 准备properties配置文件（我放在了src目录下）

  • 数据库连接池中有很多的配置参数，自行参考官网

  # 数据库用户名
  username=root
  # 数据库密码
  password=root
  # 数据库连接url
  url=jdbc:mysql://localhost:3306/my_db01?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
  # 数据库驱动类位置
  driverClassName=com.mysql.cj.jdbc.Driver
  ## 初始数量
  initialSize=5
  ## 最大数量
  maxActive=10
  ## 最小数量
  minIdle=3
  

• 使用数据库连接池获取连接对象

      public static void main(String[] args) {
          //获取配置druid.properties文件
          InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("druid.properties");
          Properties p = new Properties();
          try {
              p.load(is);
          } catch (IOException e) {
              e.printStackTrace();
          }
          try {
              //创建数据库连接池对象
              DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
              //在从连接池中获取一个Connection对象
              Connection conn = dataSource.getConnection();
              System.out.println(conn);
              conn.close();
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  

ThreadLocal类

代表一个线程的局部变量。

JDK1.2就提供了java.lang.ThreadLocal，为解决多线程程序并发问题提供了一种新的思路。

ThreadLocal用于保存一个共享变量的副本。

我们这里使用它仅为解决一个问题：

• 当一个线程在执行事务时，每执行一个DAO操作就会从连接池中获得一次Connection，但是一个事务中会有多个DAO操作，那么就不能保证这个线程在每次执行DAO操作时，使用的是同一个Connection对象，如果每一次执行不是同一个Connection对象，根本就无法完成一个事务

• 所以，我们使用ThreadLocal，它根据从连接池中获取的Connection提供一个Connection的副本，当我们这个线程需要使用Connection时，就可以使用这个线程中ThreadLocal提供的副本Connection对象，这个Connection只属于这个线程，当这个线程使用副本的Connection执行完事务后，将其关闭掉就可以了

封装JDBCTools

package com.bdit.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

public class JdbcTools {
   //准备连接池
   private static DataSource dataSource;
   private static ThreadLocal<Connection> threadLocal;
   static {
       Properties properties = new Properties();
       try {
           properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("druid.properties"));
           dataSource = DruidDataSourceFactory.createDataSource(properties);
           threadLocal = new ThreadLocal<>();
       } catch (Exception e) {
           e.printStackTrace();
       }
   }

   public static Connection getConnection(){
       Connection connection = threadLocal.get();
       if (connection==null){
           try {
               connection = dataSource.getConnection();
               threadLocal.set(connection);
           } catch (SQLException throwables) {
               throwables.printStackTrace();
           }
       }
       return connection;
   }

   public static void releaseConnection(){
       Connection connection = threadLocal.get();
       if (connection!=null){
           try {
               connection.close();
               threadLocal.remove();
           } catch (SQLException throwables) {
               throwables.printStackTrace();
           }
       }
   }
}

Apache-DbUtils

Apache组织提供的一个开源的JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用DbUtils能极大简化jdbc编码的工作量，同时也不会影响程序的性能

DbUtils类

提供了如何关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的方法都是静态的

常用方法：

返回值	方法名	说明
static void	close(···)	提供了三个重载的关闭方法（Connection、 Statement、ResultSet），这些方法检查所提供的参数是不是NULL，如果不是就关闭它们
static void	closeQuietly(···)	这类方法不仅能在Connection、Statement、ResultSet为空时避免关闭，还能隐藏一些在程序中抛出的SQLException
static void	commitAndClose(Connection conn)	提交事务，并关闭连接
static void	commitAndCloseQuietly(Connection conn)	交事务，并关闭连接，而且不会跑出SQL异常
static void	rollback(Connection conn)	事务回滚，允许conn为空，因为在方法的内部做了判断
static void	rollbackAndClose(Connection conn)	事务回滚，并关闭连接
static void	rollbackAndCloseQuietly(Connection conn)	事务回滚，并关闭连接，而且不会跑出SQL异常
static boolean	loadDriver(String driverClassName)	装载并注册JDBC驱动程序，成功返回true，使用这个方法就不需要处理ClassNotFoundException

QueryRunner类

封装了SQL的执行，是线程安全的

• 可以完成增、删、改、查、批处理
• 而且考虑到了一个事务的处理需要共用Connection
• 该类最主要的还是简化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，极大的减少了代码量

构造方法：

• QueryRunner();默认的构造方法
• QueryRunner(DataSource ds);需要一个javax.sql.DataSource作为参数

常用方法：

返回值	方法名	说明
int	update(Connection conn,String sql,Object… params)	执行一个跟更新操作（插入、修改、删除），返回的是影响的行数
T	insert(Connection conn,String sql,ResultSetHandler rsh,Object… params)	执行一个插入操作，只支持insert
int[]	baech(Connection conn,String sql,Object[] params)	批处理，支持insert、update、delete
T	insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object[] params)	批处理，只支持insert语句
Object	query(Connection conn,String sql,ResultSetHandler rsh,Object… params)	执行一个查询操作，

ResultSetHandler接口

用于处理java.sql.ResultSet，将数据按要求转换为另一种形式。

此接口提供了一个单的的方法将返回值作为QueryRunner类的query()方法的返回值

该接口中有如下实现类可以使用：

• ArrayHandler：把结果集中的第一行数据转换成对象数值
• ArrayListHandler：把结果集中的每一行数据都转换成一个数组，然后再放入List中
• BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中
• BranListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，然后再放入List中
• ColumnListHandler：将结果集中某一列的数据存放到List中
• KeyedHandler：将结果集中的每一行数据都封装到一个Map中，再把这些map再存到一个map中，其key为指定的key
• MapHandler：将结果集中的第一行数据封装到一个Map中，key是列名，value就是对应值
• MapListHandler：将结果集中的每一行数据都封装到一个Map中，然后再放入List中

表与JavaBean

实际开发中对于数据库中的表数据，都会有与之对应的JavaBean，

• 在自定义JavaBean时，基本数据类型的变量都使用其包装类，因为数据库中的所有类型都有可能为NULL
• 如果在一些特殊情况下，JavaBean的实体类的属性名无法和数据库的列名相同，那么在执行SQL语句时，可以使用起别名的方式与之对应

示例：

(使用的是上面封装的JDBCTools，Account自定义的JavaBean和数据库中列相匹配)

package com.bdit;

import com.bdit.bean.Account;
import com.bdit.util.JdbcTools;
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.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * commons-DbUtils
 */
public class JdbcTest3 {
    private static QueryRunner queryRunner= new QueryRunner();

    public static void main(String[] args) {
        Account account = new Account();
        account.setName("xiaoming");
        account.setMoney(9999);
//        insert(account);
//        delete(2004);
//        update(4,account);
//        findById(1);
//        findAll();
        findCount();
    }

    public static void insert(Account account){
        String sql = "insert into account(name,money) values(?,?)";
        Object[] params = {account.getName(),account.getMoney()};
        try(Connection connection = JdbcTools.getConnection()){
            int n = queryRunner.update(connection,sql,params);
            if (n>0){
                System.out.println("-----------添加成功----------");
            }else {
                System.out.println("-----------添加失败----------");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    public static void delete(int id){
        String sql = "delete from account where id = ?";
        try(Connection connection = JdbcTools.getConnection()) {
            int i  =queryRunner.update(connection,sql,id);
            if (i>0){
                System.out.println("-----------删除成功----------");
            }else {
                System.out.println("-----------删除失败----------");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    public static void update(int id,Account account){
        String sql = "update account set name=?,money=? where id=?";
        Object[] params = {account.getName(),account.getMoney(),id};
        try(Connection connection = JdbcTools.getConnection()){
            int i  = queryRunner.update(connection,sql,params);
            if (i>0){
                System.out.println("-----------修改成功----------");
            }else {
                System.out.println("-----------修改失败----------");
            }
        }catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    public static void findById(int id){
        String sql ="select * from account where id =?";
        try(Connection connection  = JdbcTools.getConnection()) {
            Account account = queryRunner.query(connection,sql,new BeanHandler<Account>(Account.class),id);
            System.out.println(account);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    public static void findAll(){
        String sql = "select * from account";
        try(Connection connection = JdbcTools.getConnection()) {
            List<Account> list = queryRunner.query(connection,sql,new BeanListHandler<Account>(Account.class));
            for (Account a : list){
                System.out.println(a);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    public static void findCount(){
        String sql ="select count(id) from account";
        try(Connection connection = JdbcTools.getConnection()) {
            Long num = queryRunner.query(connection,sql,new ScalarHandler<Long>());
            System.out.println("表中共"+num+"行");
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}