数据库连接池和DBUtils

数据库连接池

实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池.

数据库连接池好处

用池来管理Connection，这样可以重复使用Connection。当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池

在这里插入图片描述

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

连接池工具类

/**
 * DBCP连接池工具类
 */
public class DBCPUtil {
    public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
    public static final String USER = "root";
    public static final String PASSWORD = "123";
    //创建连接池对象（有DBCP提供的实现类）
    public static BasicDataSource basicDataSource = new BasicDataSource();
    //使用静态代码块进行配置
    static {
        //设置参数
        basicDataSource.setDriverClassName(DRIVERNAME);
        basicDataSource.setUrl(URL);
        basicDataSource.setUsername(USER);
        basicDataSource.setPassword(PASSWORD);
//        basicDataSource.setMaxActive(20); //默认为8
//        basicDataSource.setMaxIdle(10); //最大空闲连接,默认为8
//        basicDataSource.setMinIdle(5);  //最小空闲连接,默认为0
//        basicDataSource.setInitialSize(2); //初始化连接,默认为0
    }
    //获取链接方法
    public static Connection getConnection(){
        //在连接池中获取
        try {
            return basicDataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }
    //归还连接
    public static void close(Connection connection, Statement statement){
        try {
            if (null != statement){
                statement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //重载
    public static void close(Connection connection, PreparedStatement prepareStatement){
        try {
            if (null != prepareStatement){
                prepareStatement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //重载
    public static void close(Connection connection, Statement statement, ResultSet resultSet){
        try {
            if (null != resultSet){
                resultSet.close();
            }
            if (null != statement){
                statement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

测试类

/**
 * 测试DBCP连接池
 * @param args
 */
public static void main(String[] args) throws SQLException {
    Connection connection = DBCPUtil.getConnection();
    //获取执行对象
    PreparedStatement select_ename_from_employee = connection.prepareStatement("select ename from employee");
    ResultSet resultSet = select_ename_from_employee.executeQuery();
    while (resultSet.next()){
        String ename = resultSet.getString("ename");
        System.out.println("员工姓名：" + ename);
    }
    DBCPUtil.close(connection,select_ename_from_employee);
}

常用配置项

driverClassName 数据库驱动名称

url 数据库地址

username 用户名

password 密码

maxActive 最大连接数量

maxIdle 最大空闲连接

minIdle 最小空闲连接

initialSize 初始化连接

C3P0连接池

C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等

c3p0-config.xml配置类（官方提供）

<c3p0-config>
  
  <!--默认配置-->
    <default-config>  
   
      <!-- initialPoolSize：初始化时获取三个连接，
           取值应在minPoolSize与maxPoolSize之间。 --> 
        <property name="initialPoolSize">3</property>  
      
      <!-- maxIdleTime：最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
        <property name="maxIdleTime">60</property>  
      
      <!-- maxPoolSize：连接池中保留的最大连接数 -->
        <property name="maxPoolSize">100</property>  
      <!-- minPoolSize: 连接池中保留的最小连接数 -->
        <property name="minPoolSize">10</property>  
      
    </default-config>  
  
   <!--配置连接池mysql-->

    <named-config name="mysql">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8</property>
        <property name="user">root</property>
        <property name="password">123</property>
        <property name="initialPoolSize">10</property>
        <property name="maxIdleTime">30</property>
        <property name="maxPoolSize">100</property>
        <property name="minPoolSize">10</property>
    </named-config>
    <!--配置连接池2,可以配置多个-->

</c3p0-config>

封装工具类

/**
 * C3P0Util连接池工具类
 */
public class C3P0Util {
    //创建连接池对象
    //使用配置为文件中默认配置
//    public static ComboPooledDataSource comboPooledDataSource =new ComboPooledDataSource();
    //使用指定配置
    public static ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("mysql");

    public static Connection getConnection(){
        try {
            return comboPooledDataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    //归还连接
    public static void close(Connection connection, Statement statement){
        try {
            if (null != statement){
                statement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //重载
    public static void close(Connection connection, PreparedStatement prepareStatement){
        try {
            if (null != prepareStatement){
                prepareStatement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //重载
    public static void close(Connection connection, Statement statement, ResultSet resultSet){
        try {
            if (null != resultSet){
                resultSet.close();
            }
            if (null != statement){
                statement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

测试类

/**
 * 测试C3P0连接池
 * 查询姓名为李白的记录
 * @param args
 */
public static void main(String[] args) throws SQLException {
    Connection connection = C3P0Util.getConnection();
    PreparedStatement preparedStatement = connection.prepareStatement("select * from employee where ename = ?");
    preparedStatement.setString(1,"李白");
    ResultSet resultSet = preparedStatement.executeQuery();
    while (resultSet.next()){
        System.out.print(resultSet.getInt("eid") + "  ");
        System.out.print(resultSet.getString("ename") + "  ");
        System.out.print(resultSet.getInt("age") + "  ");
        System.out.print(resultSet.getString("sex") + "  ");
        System.out.print(resultSet.getDouble("salary") + "  ");
        System.out.print(resultSet.getDate("empdate") + "  ");
    }
    C3P0Util.close(connection,preparedStatement);
}

在这里插入图片描述

Druid连接池

Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况

druid.properties配置类

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8
username=root
password=123
initialSize=5
maxActive=10
maxWait=3000

封装工具类

/**
 * Druid连接池工具类
 */
public class DruidUtil {
    public static DataSource dataSource;
    static {
        try {
             /*通过工厂来来获取 DruidDataSourceFactory类的createDataSource方法
            createDataSource(Properties properties) 方法参数可以是一个属性集对象*/
            Properties properties = new Properties();
            //Druid不能主动加载配置文件
            //加载配置文件
            InputStream resourceAsStream = DruidUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            //Properties从字节流中读取配置信息
            properties.load(resourceAsStream);
            //通过工厂类获取连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取连接
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }
    //获取数据库连接池方法
    public static DataSource getDataSource(){
        return dataSource;
    }
    //归还连接
    public static void close(Connection connection, Statement statement){
        try {
            if (null != statement){
                statement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //重载
    public static void close(Connection connection, PreparedStatement prepareStatement){
        try {
            if (null != prepareStatement){
                prepareStatement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //重载
    public static void close(Connection connection, Statement statement, ResultSet resultSet){
        try {
            if (null != resultSet){
                resultSet.close();
            }
            if (null != statement){
                statement.close();
            }
            if (null != connection){
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

测试类

/**
 * 测试Druid连接池
 * 查询薪资3000到5000之间的员工信息
 * @param args
 */
public static void main(String[] args) throws SQLException {
    Connection connection = DruidUtil.getConnection();
    PreparedStatement preparedStatement = connection.prepareStatement("select * from employee where salary between ? and ?");
    preparedStatement.setDouble(1,3000);
    preparedStatement.setDouble(2,5000);
    ResultSet resultSet = preparedStatement.executeQuery();
    while (resultSet.next()){
        System.out.print(resultSet.getInt("eid") + "  ");
        System.out.print(resultSet.getString("ename") + "  ");
        System.out.print(resultSet.getInt("age") + "  ");
        System.out.print(resultSet.getString("sex") + "  ");
        System.out.print(resultSet.getDouble("salary") + "  ");
        System.out.println(resultSet.getDate("empdate") + "  ");
    }
    DruidUtil.close(connection,preparedStatement);
}

DBUtils工具类

Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能

核心功能

QueryRunner 中提供对sql语句操作的API.
ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
DbUtils类,他就是一个工具类,定义了关闭资源与事务处理相关方法.

JavaBean组件

需要实现序列化接口, Serializable (暂时可以省略)
提供私有字段: private 类型变量名;
提供 getter 和 setter
提供空参构造

例

/**
 * javabean
 * 用来存储数据
 */
public class Employee implements Serializable {
    
    private int eid;
    private String ename;
    private int age;
    private String sex;
    private double salary;
    private Date empdate;

    public Employee() {
    }

    public Employee(int eid, String ename, int age, String sex, double salary, Date empdate) {
        this.eid = eid;
        this.ename = ename;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
        this.empdate = empdate;
    }

    public int getEid() {
        return eid;
    }

    public void setEid(int eid) {
        this.eid = eid;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Date getEmpdate() {
        return empdate;
    }

    public void setEmpdate(Date empdate) {
        this.empdate = empdate;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "eid=" + eid +
                ", ename='" + ename + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", salary=" + salary +
                ", empdate=" + empdate +
                '}';
    }
}

DBUtils完成 CRUD

QueryRunner核心类

构造方法

QueryRunner()

QueryRunner(DataSource ds) ,提供数据源（连接池），DBUtils底层自动维护连接connection常用方法

update(Connection conn, String sql, Object… params) ，用来完成表数据的增加、删除、更新操作

query(Connection conn, String sql, ResultSetHandler rsh, Object… params) ，用来完成表数据的查询操作

QueryRunner实现增、删、改操作

核心方法：update(Connection conn, String sql, Object… params)

Connection conn 数据库连接对象, 自动模式创建QueryRun 可以不传 ,手动模式必须传递

String sql 占位符形式的SQL ,使用 ? 号占位符

Object… param Object类型的可变参,用来设置占位符上的参数

/**
 * 使用QueryRunner实现增、删、改操作
 * update(Connection conn, String sql, Object... params)
 */
public class DBUtilDemo02 {
    @Test
    public void testInsert() throws SQLException {
        //手动模式创建
        QueryRunner queryRunner = new QueryRunner();
        String sql = "insert into employee values(?,?,?,?,?,?)";
        Object[] param = {null,"张三",20,"男",10000,"19901211"};
        Connection connection = DruidUtil.getConnection();
        int update = queryRunner.update(connection, sql, param);
        DbUtils.closeQuietly(connection);
    }
    @Test
    public void testUpdate() throws SQLException {
        QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
        String sql = "update employee set salary = ? where ename = ?";
        Object[] param = {200,"张三"};
        int update = queryRunner.update(sql,param);
    }
    @Test
    public void testDelete() throws SQLException {
        QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
        String sql = "delete from employee where eid = ?";
        int update = queryRunner.update(sql, 5);
    }
}

QueryRunner实现查询操作

ResultSetHandler接口

ResultSetHandler 可以对查询出来的ResultSet结果集进行处理，达到一些业务上的需求

ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值

ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。

BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中.

BeanListHandler 将结果集中每一条记录封装到指定的javaBean中，再将这些javaBean在封装到List集合中

ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中KeyedHandler将结果集中每一条记录封装到Map<String,Object>,在将这个map集合做为另一个Map的value,另一个Map集合的key是指定的字段的值。

MapHandler 将结果集中第一条记录封装到了Map<String,Object>集合中，key就是字段名称，value就是字段值

MapListHandler 将结果集中每一条记录封装到了Map<String,Object>集合中，key就是字段名称，value就是字段值，在将这些Map封装到List集合中。

ScalarHandler 它是用于封装单个数据。例如 select count(*) from 表操作。

/**
 * 查询id为4的记录,封装到数组中
 * ArrayHandler
 */
@Test
public void testFindById() throws SQLException {
    QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
    String sql = "select * from employee where eid = ?";
    Object[] query = queryRunner.query(sql, new ArrayHandler(), 4);
    System.out.println(Arrays.toString(query));
}
/**
 * 查询所有数据,封装到List集合中
 * ArrayListHandler
 */
@Test
public void testAll() throws SQLException {
    QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
    String sql = "select * from employee";
    List<Object[]> query = queryRunner.query(sql, new ArrayListHandler());
    query.forEach(item -> System.out.println(Arrays.toString(item)));
}
/**
 * 查询id为4的记录,封装到指定JavaBean中
 * BeanHandler
 */
@Test
public void testJavaById() throws SQLException {
    QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
    String sql = "select * from employee where eid = ?";
    Employee query = queryRunner.query(sql, new BeanHandler<>(Employee.class), 4);
    System.out.println(query.toString());
}
/**
 * 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
 * BeanListHandler
 */
@Test
public void testBeanBySalary() throws SQLException {
    QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
    String sql = "select * from employee where salary > ?";
    List<Employee> query = queryRunner.query(sql, new BeanListHandler<>(Employee.class), 3000);
    query.forEach(item -> System.out.println(item.toString()));
}
/**
 * 查询姓名是 李白的员工信息,将结果封装到Map集合中
 * MapHandler
 */
@Test
public void testMapByName() throws SQLException {
    QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
    String sql = "select * from employee where ename = ?";
    Map<String, Object> map = queryRunner.query(sql, new MapHandler(), "李白");
    System.out.println(map.values());
}
/**
 * 查询所有员工的薪资总额
 * ScalarHandler
 */
@Test
public void testMapSalary() throws SQLException {
    QueryRunner queryRunner = new QueryRunner(DruidUtil.getDataSource());
    String sql = "select sum(salary) from employee";
    Double query = (Double) queryRunner.query(sql, new ScalarHandler<>());
    System.out.println(query);
}

批处理

批处理指的是一次操作中执行多条SQL语句，批处理相比于一次一次执行效率会提高很多。

当向数据库中添加大量的数据时，需要用到批处理。

实现批处理

Statement和PreparedStatement都支持批处理操作

PreparedStatement

void addBatch() 将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。

通过调用方法 executeBatch 可以批量执行此列表中的命令。

int[] executeBatch() 每次提交一批命令到数据库中执行，如果所有的命令都成功执行了，那么返回一个数组，这个数组是说明每条命令所影响的行数

mysql 批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加

url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-&rewriteBatchedStatements=true

批处理插入10000条数据

//使用批处理，向表中添加10000条数据
public static void main(String[] args) throws SQLException {
    Connection connection = DruidUtil.getConnection();
    PreparedStatement preparedStatement = connection.prepareStatement("insert into testbatch(uname) values(?)");
    //执行批量插入操作
    for (int i = 0 ; i < 10000 ; i++){
        preparedStatement.setString(1,"小五" + i);
        preparedStatement.addBatch();
    }
    //添加时间戳，测试批处理
    long start = System.currentTimeMillis();
    //统一执行批量插入
    preparedStatement.executeBatch();
    long end = System.currentTimeMillis();
    System.out.println("插入10000条数据需要使用" + (end - start) + "毫秒！");
    DruidUtil.close(connection,preparedStatement);
}

MySql元数据

除了表之外的数据都是元数据,可以分为三类

查询结果信息

： UPDATE 或 DELETE语句受影响的记录数。

数据库和数据表的信息

：包含了数据库及数据表的结构信息。

MySQL服务器信息

：包含了数据库服务器的当前状态，版本号等。

常用命令

-- 元数据相关的命令介绍
-- 1.查看服务器当前状态
SHOW STATUS;
-- 2.查看MySQl的版本信息
SELECT VERSION();
-- 3.查询表中的详细信息
SHOW COLUMNS FROM employee;
-- 4.显示数据表的详细索引信息
SHOW INDEX FROM testbatch;
-- 5.列出所有数据库
SHOW DATABASES;
-- 6.显示当前数据库的所有表
SHOW TABLES;
-- 7.获取当前的数据库名
SELECT DATABASE();

使用JDBC 获取元数据

DatabaseMetaData 描述数据库的元数据对象

ResultSetMetaData 描述结果集的元数据对象

获取元数据对象的方法 : getMetaData ()

connection连接对象, 调用 getMetaData () 方法,获取的是DatabaseMetaData 数据库元数据对象

PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象

DatabaseMetaData的常用方法
getURL() : 获取数据库的URL getUserName(): 获取当前数据库的用户名 getDatabaseProductName(): 获取数据库的产品名称 getDatabaseProductVersion(): 获取数据的版本号 getDriverName(): 返回驱动程序的名称 isReadOnly(): 判断数据库是否只允许只读 true 代表只读

ResultSetMetaData的常用方法
getColumnCount() : 当前结果集共有多少列 getColumnName(int i) : 获取指定列号的列名, 参数是整数从1开始 getColumnTypeName(int i): 获取指定列号列的类型, 参数是整数从1开始

//获取数据库相关元数据 使用DatabaseMetaData
@Test
public void testDatabaseMetaData() throws SQLException {
    Connection connection = DruidUtil.getConnection();
    DatabaseMetaData metaData = connection.getMetaData();
    //获取数据库相关元数据信息
    System.out.println("数据库URL：" + metaData.getURL());
    System.out.println("数据库当前用户：" + metaData.getUserName());
    System.out.println("数据库产品名称：" + metaData.getDatabaseProductName());
    System.out.println("数据库版本信息：" + metaData.getDatabaseProductVersion());
    System.out.println("数据库驱动程序：" + metaData.getDriverName());
    //判断当前数据库是否只允许只读
    if (metaData.isReadOnly()){
        System.out.println("当前数据库只允许读操作！");
    } else {
        System.out.println("不是只读数据库！");
    }
    connection.close();
}

//获取结果集中的元数据信息 使用ResultSetMetaData
@Test
public void testResultSetMetaData() throws SQLException {
    Connection connection = DruidUtil.getConnection();
    PreparedStatement preparedStatement = connection.prepareStatement("select * from employee");
    ResultSet resultSet = preparedStatement.executeQuery();
    //获取结果集元数据对象
    ResultSetMetaData metaData = preparedStatement.getMetaData();
    System.out.println("当前结果集共有 " + metaData.getColumnCount() + " 列");
    //获取当前结果集中列的名称和类型
    for (int i = 1 ; i <= metaData.getColumnCount() ; i++){
        System.out.print("当前结果集中第" + i + "列的名称为：" + metaData.getColumnName(i) + "  ");
        System.out.println("当前结果集中第" + i + "列的类型为：" + metaData.getColumnTypeName(i));
    }


    DruidUtil.close(connection,preparedStatement,resultSet);
}

原文链接：https://blog.csdn.net/weixin_49741990/article/details/110772032

数据库连接池和DBUtils