2021-06-16

最新推荐文章于 2024-10-14 17:54:13 发布

zhoudbw

最新推荐文章于 2024-10-14 17:54:13 发布

阅读量170

点赞数

文章标签： mysql java

本文链接：https://blog.csdn.net/weixin_45778024/article/details/117953069

版权

遍历数据库连接池【dbcp & c3p0 & druid】

说明

如果一个网站一天有非常大的访问量，数据库要在每次连接的时候创建一个数据库连接，这样是非常耗费数据库的资源的。而且数据库服务容易出现内存溢出、宕机等等不可控的因素。其实本质上，数据库连接是一种稀缺的资源，我们希望对它进行更加妥善的管理。比如说，我们查询完一次SQL语句之后，我们不关闭连接，暂时将其存放起来，那么如果后面还有查询或者SQL语句要执行的时候，那这个连接就可以复用了，相当于一次连接多次使用的方式。这也是一种非常著名的思想 —— “资源池”。

“资源池”本质是，我们对数据库的使用很频繁的时候，我们不能每次断开再连接，断开再连接…，太过浪费了。“资源池”本质上也是一种“缓冲池”，它解决的是资源频繁分配和释放，所造成的浪费问题。

“资源池”，也叫“缓冲池”，解决资源频繁被分配和释放的浪费问题。

与此相似的还有“线程池”，它们都是“资源池”的设计思想。

现在我们想要使用“数据库连接”只需要从“资源池”中取出一个使用，使用完毕之后放回“资源池”，这样就可以通过一定数量的“数据库连接”，来保证系统不会无尽的创建数据库连接，另外也可以多次去复用已经创建的连接。可以更好的调度资源的使用，以及监控数据库的压力和性能情况。是一种非常好的调度和监控的措施。

数据库连接池，需要实现的功能

1）从连接池获取或创建连接；
2）使用完毕后，将连接返回给连接池；
3）在系统关闭前，确认断开所有连接并释放资源；
4）管理连接数量，和已有连接的可用性(可能会出现无效的连接)。

这就是一个连接池，所需要具备的四大基本功能。

在一个程序中，对连接池的使用，一般是单例的，正常一个程序中只有一个连接池。

图示：
在这里插入图片描述

不管多少线程过来，都是将连接池中的已经创建的连接池分配给它，使用完毕归还连接池，连接池将连接置为可用。

当我们在使用这个连接的时候，有一些比较核心的参数：
1）最小连接数，是一直保持的数据库连接，不能很大，或造成资源浪费；
2）最大连接数，是可以申请的最多连接数量，如果超过此数值，新的连接请求会放到等待队列。

最大连接数和最小连接数的差值也是我们应该关注的，不宜过大，这里是需要设计的。

从我们前面对连接池的了解，我们知道，连接池的核心就是，对连接的一种复用。我们建立一个资源池，对连接进行统一的分配和管理。
那么对于连接池，它的核心原理是什么呢？
本质上是对连接的复用。是从创建连接、管理连接到释放连接的过程。
1）系统初始化时，创建连接(最小连接数)，使用容器来承装它们，如List。
2）分配和管理的策略：
有新的连接请求时，查看是否有空闲连接，如果有直接分配；如果没有查看是否达到最大连接数，如果没有达到，创建新的连接，如果达到，创建一个等待时间，如果超过等待时间返回请求失败或抛出异常。
有新的释放连接请求时，（引用计数：记录连接的使用者个数，服务于连接的复用。）查看连接的引用次数，如果超过了规定阈值，需要从池中删除连接；如果没有超过，继续使用。
3）连接池的关闭，关闭所有连接及释放所有的资源。
4）在并发和事务的使用上，需要注意。如果要事务相互独立，保障某一时间一个连接只分配给一个线程。

开源工具

dbcp

1.最老牌的一个数据库连接池，apache上的一个项目，
dbcp ( Database Connection Pool )，最早在Tomcat7之前都是默认使用这个dbcp作为数据库连接池的。
接下来我们使用一下，看看怎么使用，怎么给我们带来便利的。

首先引入需要的依赖（或者jar包）

<dependency>
	<groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>

<dependency>
	<groupId>commons-dbcp</groupId>
  <artifactId>commons-dbcp</artifactId>
  <version>2.1.1</version>
</dependency>

然后编写dbcp的基本参数配置文件dbcp.properties

driveClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/shop
username=root
password=zhoudbw_tian

# dbcp参数
initialSize=30    #初始连接数
maxActive=30      #最多可容纳的活跃连接数，最大活跃数。当连接数量到达此数时，不会再创建连接，而是等待其他连接释放
maxIdle=10        #最大空闲连接数，已经创建但是没有被使用，会被定期的回收掉，知道剩余maxIdle
minIdle=5         #最小空闲连接数
maxWait=1000      #获取连接的最大等待时间，如果超时抛出异常，单位是毫秒

最后编写Java代码看看如何使用DBCPTest.java

import org.apache.commons.dbcp2.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.Properties;

/**
 * 这个类，演示通过连接池获取连接，关闭连接的过程。
 *  通过演示打印数据库的名称和版本号，作为案例去演示，主要业务代码都在static{。。。}内。
 *
 *  通过main方法简单的执行看看，我们配置的参数，和我们写的业务
 */
public class DBCPTest {
    /**
     * 首先编写配置文件（统一参数的配置）—— dbcp.properties
     */

    // 需要数据源
    private static DataSource dataSource;
    static {
        Properties properties = new Properties();
        try {
            properties.load(DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties"));
            // 通过基础数据源工厂类，来创建连接池
            dataSource = BasicDataSourceFactory.createDataSource(properties);
            // 接下来补充两个静态方法：getConnection(), closeConnection(Connection conn)
            Connection conn = getConnection();
            DatabaseMetaData metaData = conn.getMetaData(); // 存在很多的元数据，比如数据库的类型，版本信息
            System.out.println("数据库名称：" + metaData.getDatabaseProductName() + " "
                    + "数据库版本号：" + metaData.getDatabaseProductVersion());
            closeConnection(conn);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过连接池获取连接
     * @return 返回一个连接
     */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 关闭连接
     * @param conn  需要关闭的连接
     */
    public static void closeConnection(Connection conn) {
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Connection conn = getConnection();
            System.out.println("成功获取连接" + i);
            closeConnection(conn);
        }
    }
}

c3p0

2.和dbcp一样出名的数据库连接池c3p0，这个名字的来源，有人说是因为，这个连接池的作者是《星球大战》的影迷，c3p0是其中的一个机器人。这个名字又包含了connect和pool的首写字母，所以就叫了这个名字。
接下来看看如何使用？

首先，引入相关的依赖（或者jar包）

<dependency>
	<groupId>com.mchange</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.5.5</version>
</dependency>

然后，编写基本的参数配置，名字必须是这个c3p0-config.xml

<?xml version="1.0" encoding="utf-8"?>

<!-- 根标签，和文件名一致，而且文件名必须是c3p0-config -->
<c3p0-config>
<!--    使用<default-config>无法指定数据源的名字，所以我们使用<named-config>来指定数据源的名字-->

    <!-- 默认配置标签，数据源的名字是随机初始化的 -->
<!--    <default-config>-->

    <!-- 可以指定数据源配置的名字，适用于多个数据源的场景 -->
    <named-config name="myC3p0">

        <!--   使用properties进行配置-->

<!--        基础配置-->
        <properties name="driverClass">com.mysql.jdbc.Driver</properties>
        <properties name="jdbcUrl">jdbc:mysql://localhost:3306/shop</properties>
        <properties name="user">root</properties>
        <properties name="password">zhoudbw_tian</properties>

<!--        初始化连接池的连接数量-->
        <properties name="initialPoolSize">10</properties>
<!--        最大可创建连接数-->
        <properties name="maxPoolSize">10</properties>
<!--        最小连接数量-->
        <properties name="minPoolSize">2</properties>
<!--        当没有空闲连接时，一次性创建的新连接数量-->
        <properties name="acquireIncrement">2</properties>
<!--        连接的最大空闲时间，如果一直未使用，则断掉此连接，如果配置为0，则永远不会断掉-->
        <properties name="maxIdleTime">0</properties>

    </named-config>


<!--    </default-config>-->


</c3p0-config>

最后，书写代码C3P0Test.java来看看如何使用，同时说明一些需要注意的地方

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.Connection;
import java.sql.SQLException;

public class C3P0Test {

    // 需要一个数据源
    private static ComboPooledDataSource dataSource;

    static {
        // 约定优于配置，下面这行代码，会自动去读取名字叫做"c3p0-config.xml"的配置文件，并加载出里面的所有标签。
        dataSource = new ComboPooledDataSource();
        // 此时数据源是有名字的，由于我们是通过默认配置<default-config>配置的数据源，名字是随机的，通过以下代码可以拿到
        String name = dataSource.getDataSourceName();
        System.out.println("数据源的名字：" + name);
        // 当我们配置多个数据源的时候，我们希望将它们区分开来，这时候需要为其制定名字，就不使用<default-config>,使用<named-config>
        // 此时写法就发生了变化，我们在创建数据源对象的时候，就将数据源的名字通过参数的形式传递进去

        // 当使用的是"无参构造器"的时候，dataSource = new comboPooledDataSource()默认读取的是默认配置<default-config>
        // 当使用的是"有参构造器"的时候，dataSource = new comboPooledDataSource(string configName)读取的是<named-config name="configName">下对应名称的配置
    }

    static {
        // 约定优于配置，下面这行代码，会自动去读取名字叫做"c3p0-config.xml"的配置文件，并加载出里面的所有标签。
        dataSource = new ComboPooledDataSource("myC3p0");
        // 此时数据源是有名字的，由于我们是通过默认配置<default-config>配置的数据源，名字是随机的，通过以下代码可以拿到
        String name = dataSource.getDataSourceName();
        System.out.println("数据源的名字：" + name);
        // 当我们配置多个数据源的时候，我们希望将它们区分开来，这时候需要为其制定名字，就不使用<default-config>,使用<named-config>
        // 此时写法就发生了变化，我们在创建数据源对象的时候，就将数据源的名字通过参数的形式传递进去
    }

    /**
     * 从数据源中获取连接
     * @return 返回一个连接
     */
    public static Connection getConnection() {
        try {
            return  dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭指定的连接
     * @param conn 需要关闭的连接
     */
    public static void closeConnection(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) {
        Connection conn = getConnection();
        if (conn != null) {
            System.out.println("成功获取连接");
        }
        // 关闭连接
        closeConnection(conn);
    }
}

druid

3.大名鼎鼎的，阿里开源的一种连接池druid，官网说: Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。应该不是徒有虚名，提供了很多监控和拓展的功能，中文名叫德鲁伊，起源于魔兽世界。阿里云计算平台DataWorks(https://help.aliyun.com/document_detail/137663.html) 团队出品，为监控而生的数据库连接池。
druid实际上参考了dbcp的设计方式，所以我们可以类比这dbcp来学习如何使用druid。

首先，引入相关的依赖（或者jar包）

<dependency>
	<groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.21</version>
</dependency>

然后编写druid.properties

driveClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/shop
username=root
password=zhoudbw_tian

# druid兼容dbcp中的配置

initialSize=5   #初始化大小
minIdle=10      #最小空闲数
maxActive=20    #最大活跃数
maxWait=10000   #获取连接的等待时间

#间隔多长时间，检测是否关闭空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis=2000
#控制一个连接在资源池中，最大或最小生存时间，单位是毫秒
minEvictableIdleTimeMills=6000
maxEvictableIdleTimeMills=9000

编写示例代码DruidTest.java

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.Properties;

public class DruidTest {

    // 需要数据源
    private static DataSource dataSource;
    static {
        Properties properties = new Properties();
        try {
            properties.load(DBCPTest.class.getClassLoader().getResourceAsStream("druid.properties"));
            // 通过Druid的数据源工厂类，来创建连接池
            dataSource = DruidDataSourceFactory.createDataSource(properties);
            // 接下来补充两个静态方法：getConnection(), closeConnection(Connection conn)
            Connection conn = getConnection();
            DatabaseMetaData metaData = conn.getMetaData(); // 存在很多的元数据，比如数据库的类型，版本信息
            System.out.println("数据库名称：" + metaData.getDatabaseProductName() + " "
                    + "数据库版本号：" + metaData.getDatabaseProductVersion());
            closeConnection(conn);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过连接池获取连接
     * @return 返回一个连接
     */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 关闭连接
     * @param conn  需要关闭的连接
     */
    public static void closeConnection(Connection conn) {
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Connection conn = getConnection();
            System.out.println("成功获取连接" + i);
            closeConnection(conn);
        }
    }
}

除了在普通的项目中使用druid，我们更多的是在springboot或spring项目中使用druid。
我们下载druid的源码，在源码中可以看到druid-spring-boot-starter的项目，这个项目是druid和springboot集成的代码，我们可以参考这个代码来看如何使用druid。

首先要引入druid和springboot集成的依赖（或者jar包）

<dependency>
	<groupId>com.alibaba</groupId>
  <artifactId>druid-spring-boot-starter</artifactId>
  <version>1.1.17</version>
</dependency>

compile 'com.alibaba:druid-spring-boot-starter:1.1.17'

然后添加配置

# 只有下面三个是必填项（使用内嵌数据库的话这三个也可以不用填，会使用默认配置）
spring.datasource.url=...
spring.datasource.username=...
spring.datasource.password=...
# driver-class-name 非必填可以通过url推断
spring.datasource.driver-class-name=...

# Druid的数据源配置，集成spring。datasource.* 配置， 相同则覆盖
。。。很多。—— 查文档。参考“application。properties”。

让spring帮我们读取配置文件，创建数据源，参考Issue1796Configurer.java

/*
@Configuration
@Profile("issue-1796")
*/
pubic class Issue1796Configurer {
  @Bean
  public DataSource dataSource(Environment environment) {
    return DruidDataSourceBuilder.create().build(environment, "spring.datasource.druid.");
  }
}