In the project, the database connection pool is basically an essential component. In the current database connection pool selection, mainly

Druid , a database connection pool for monitoring .
HikariCP , known as the database connection pool with the best performance .

In Spring Boot 2.X version, the HikariCP connection pool is used by default. And Ali adopts Druid on a large scale. The following describes the use of HikariCP and Druid connection pools in SpringBoot.

1. HikariCP database connection pool

1.1 HikariCP single data source configuration

1.1.1 pom file

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>HikariCP-Boot</artifactId>

    <dependencies>
        <!-- 实现对数据库连接池的自动化配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>


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

        <!-- 写单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

There is no need to actively introduce HikariCP dependencies. Because in Spring Boot 2.X, dependenciesspring-boot-starter-jdbc are introduced by default .com.zaxxer.HikariCP

1.1.2 yml configuration

server:
  port: 7890


spring:
  # datasource 数据源配置内容，对应 DataSourceProperties 配置属性类
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.jdbc.Driver
    username: root # 数据库账号
    password: root # 数据库密码
    # HikariCP 自定义配置，对应 HikariConfig 配置属性类
    hikari:
      minimum-idle: 10 # 池中维护的最小空闲连接数，默认为 10 个。
      maximum-pool-size: 10 # 池中最大连接数，包括闲置和使用中的连接，默认为 10 个。

spring.datasourceUnder the configuration item, we can add the general configuration of the data source.
spring.datasource.hikariUnder configuration item, we can add custom configuration of HikariCP connection pool. Then the HikariCP connection pool DataSourceConfiguration.Hikariis automatically configured.

1.1.3 Main startup class

package com.yyds;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

@SpringBootApplication
public class ApplicationBak implements CommandLineRunner {
    
    

    private Logger logger = LoggerFactory.getLogger(ApplicationBak.class);

    @Autowired
    private DataSource dataSource;

    public static void main(String[] args) {
    
    
        // 启动 Spring Boot 应用
        SpringApplication.run(ApplicationBak.class, args);
    }

    @Override
    public void run(String... args) {
    
    
        try (Connection conn = dataSource.getConnection()) {
    
    
            // 这里，可以做点什么
            logger.info("[run][获得连接：{}]", conn);
        } catch (SQLException e) {
    
    
            throw new RuntimeException(e);
        }
    }

}

By implementing the CommandLineRunner interface, after the application is started, #run(String... args)the method to output the Connection information.

1.2 HikariCP multi-data source configuration

1.2.1 pom file

As shown in 1.2.1.

1.2.2 yml configuration

spring:
  # datasource 数据源配置内容
  datasource:
    # 订单数据源配置
    orders:
      url: jdbc:mysql://127.0.0.1:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password: root
      # HikariCP 自定义配置，对应 HikariConfig 配置属性类
      hikari:
        minimum-idle: 20 # 池中维护的最小空闲连接数，默认为 10 个。
        maximum-pool-size: 20 # 池中最大连接数，包括闲置和使用中的连接，默认为 10 个。
    # 用户数据源配置
    users:
      url: jdbc:mysql://127.0.0.1:3306/test_users?useSSL=false&useUnicode=true&characterEncoding=UTF-8
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password: root
      # HikariCP 自定义配置，对应 HikariConfig 配置属性类
      hikari:
        minimum-idle: 15 # 池中维护的最小空闲连接数，默认为 10 个。
        maximum-pool-size: 15 # 池中最大连接数，包括闲置和使用中的连接，默认为 10 个。

1.2.3 Main startup class

package com.yyds;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@SpringBootApplication
public class Application implements CommandLineRunner {
    
    

    private Logger logger = LoggerFactory.getLogger(Application.class);

    @Resource(name = "ordersDataSource")
    private DataSource ordersDataSource;

    @Resource(name = "usersDataSource")
    private DataSource usersDataSource;

    public static void main(String[] args) {
    
    
        // 启动 Spring Boot 应用
        SpringApplication.run(Application.class, args);
    }

    @Override
    public void run(String... args) {
    
    
        // orders 数据源
        try (Connection conn = ordersDataSource.getConnection()) {
    
    
            // 这里，可以做点什么
            logger.info("[run][ordersDataSource 获得连接：{}]", conn);
        } catch (SQLException e) {
    
    
            throw new RuntimeException(e);
        }

        // users 数据源
        try (Connection conn = usersDataSource.getConnection()) {
    
    
            // 这里，可以做点什么
            logger.info("[run][usersDataSource 获得连接：{}]", conn);
        } catch (SQLException e) {
    
    
            throw new RuntimeException(e);
        }
    }

}

1.2.4 Configuration class

package com.yyds.config;


import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.util.StringUtils;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {
    
    

    /**
     * 创建 orders 数据源的配置对象
     */
    @Primary
    @Bean(name = "ordersDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.orders") // 读取 spring.datasource.orders 配置到 DataSourceProperties 对象
    public DataSourceProperties ordersDataSourceProperties() {
    
    
        return new DataSourceProperties();
    }

    /**
     * 创建 orders 数据源
     */
    @Bean(name = "ordersDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.orders.hikari") // 读取 spring.datasource.orders 配置到 HikariDataSource 对象
    public DataSource ordersDataSource() {
    
    
        // <1.1> 获得 DataSourceProperties 对象
        DataSourceProperties properties =  this.ordersDataSourceProperties();
        // <1.2> 创建 HikariDataSource 对象
        return createHikariDataSource(properties);
    }

    /**
     * 创建 users 数据源的配置对象
     */
    @Bean(name = "usersDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.users") // 读取 spring.datasource.users 配置到 DataSourceProperties 对象
    public DataSourceProperties usersDataSourceProperties() {
    
    
        return new DataSourceProperties();
    }

    /**
     * 创建 users 数据源
     */
    @Bean(name = "usersDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.users.hikari")
    public DataSource usersDataSource() {
    
    
        // 获得 DataSourceProperties 对象
        DataSourceProperties properties =  this.usersDataSourceProperties();
        // 创建 HikariDataSource 对象
        return createHikariDataSource(properties);
    }

    private static HikariDataSource createHikariDataSource(DataSourceProperties properties) {
    
    
        // 创建 HikariDataSource 对象
        HikariDataSource dataSource = properties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
        // 设置线程池名
        if (StringUtils.hasText(properties.getName())) {
    
    
            dataSource.setPoolName(properties.getName());
        }
        return dataSource;
    }

}

ordersDataSourceProperties() method, orders数据源createdDataSourceProperties配置对象。

The @Primary annotation ensures that there is a main DataSourceProperties Bean in the project.
Adding the @Bean(name = "ordersDataSourceProperties") annotation will create a DataSourceProperties Bean whose name is ordersDataSourceProperties
@ConfigurationProperties(prefix = "spring.datasource.orders") annotation will assign spring.datasource.orders configuration items to DataSourceProperties Bean one by one

ordersDataSource() method to create ordersa data source.

DataSourceProperties properties = this.ordersDataSourceProperties();Get the order data sourceDataSourceProperties配置对象
The createHikariDataSource() method creates a HikariDataSource object, so that "spring.datasource.orders"the configuration items are assigned to the HikariDataSource Bean one by one.
With @Bean(name = "ordersDataSource")the annotation , a "ordersDataSource"HikariDataSource Bean named will be created.
@ConfigurationProperties(prefix = "spring.datasource.orders.hikari")The annotation will assign the "spring.datasource.orders.hikari"custom to the HikariDataSource Bean one by one.

insert image description here

2. Druid database connection pool

2.1 Druid single data source configuration

2.1.1 pom file

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>Druid-Boot</artifactId>


    <dependencies>
        <!-- 保证 Spring JDBC 的依赖健全 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- 实现对 Druid 连接池的自动化配置 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>
        <dependency> 
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

        <!-- 实现对 Spring MVC 的自动化配置，因为我们需要看看 Druid 的监控功能 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 方便等会写单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

2.1.2 yml configuration

spring:
  # datasource 数据源配置内容，对应 DataSourceProperties 配置属性类
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.jdbc.Driver
    username: root # 数据库账号
    password: root # 数据库密码
    type: com.alibaba.druid.pool.DruidDataSource # 设置类型为 DruidDataSource
    # Druid 自定义配置，对应 DruidDataSource 中的 setting 方法的属性
    druid:
      min-idle: 0 # 池中维护的最小空闲连接数，默认为 0 个。
      max-active: 20 # 池中最大连接数，包括闲置和使用中的连接，默认为 8 个。
      filter:
        stat: # 配置 StatFilter ，对应文档 https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatFilter
          log-slow-sql: true # 开启慢查询记录
          slow-sql-millis: 5000 # 慢 SQL 的标准，单位：毫秒
      stat-view-servlet: # 配置 StatViewServlet ，对应文档 https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatViewServlet%E9%85%8D%E7%BD%AE
        enabled: true # 是否开启 StatViewServlet
        login-username: root # 账号
        login-password: root # 密码

2.1.3 Main startup class

package com.yyds;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.sql.DataSource;

@SpringBootApplication
public class ApplicationBak implements CommandLineRunner {
    
    

    private Logger logger = LoggerFactory.getLogger(ApplicationBak.class);

    @Autowired
    private DataSource dataSource;

    public static void main(String[] args) {
    
    
        // 启动 Spring Boot 应用
        SpringApplication.run(ApplicationBak.class, args);
    }

    @Override
    public void run(String... args) {
    
    
        logger.info("[run][获得数据源：{}]", dataSource.getClass());
    }

}

2.1.4 Monitoring

Because of doing the following:

By spring.datasource.filter.statconfiguring StatFilter, statistical monitoring information.
By spring.datasource.filter.stat-view-servletconfiguring StatViewServlet, it provides html pages and JSON API for displaying monitoring information

So after we start the project, visit http://127.0.0.1:8080/druidthe address , the account password is the configured root, and we can see the monitoring html page.

insert image description here

At the top of the interface, functions such as data source, SQL monitoring, and SQL firewall are provided.
On each interface, the source of data can be obtained through [View JSON API].
Because the monitoring information is stored in the JVM memory, the information will be lost when the JVM process is restarted. If we want to persist to storage such as MySQL, Elasticsearch, HBase, etc., we can collect monitoring information through the JSON API interface provided by StatViewServlet.

Documentation for Druid: https://github.com/alibaba/druid/wiki/.

2.2 Druid multi data source configuration

2.2.1 pom file

Such as 2.1.1

2.2.2 yml configuration

spring:
  # datasource 数据源配置内容
  datasource:
    # 订单数据源配置
    orders:
      url: jdbc:mysql://127.0.0.1:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password:
      type: com.alibaba.druid.pool.DruidDataSource # 设置类型为 DruidDataSource
      # Druid 自定义配置，对应 DruidDataSource 中的 setting 方法的属性
      min-idle: 0 # 池中维护的最小空闲连接数，默认为 0 个。
      max-active: 20 # 池中最大连接数，包括闲置和使用中的连接，默认为 8 个。
    # 用户数据源配置
    users:
      url: jdbc:mysql://127.0.0.1:3306/test_users?useSSL=false&useUnicode=true&characterEncoding=UTF-8
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password: root
      type: com.alibaba.druid.pool.DruidDataSource # 设置类型为 DruidDataSource
      # Druid 自定义配置，对应 DruidDataSource 中的 setting 方法的属性
      min-idle: 0 # 池中维护的最小空闲连接数，默认为 0 个。
      max-active: 20 # 池中最大连接数，包括闲置和使用中的连接，默认为 8 个。
    # Druid 自定已配置
    druid:
      # 过滤器配置
      filter:
        stat: # 配置 StatFilter ，对应文档 https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatFilter
          log-slow-sql: true # 开启慢查询记录
          slow-sql-millis: 5000 # 慢 SQL 的标准，单位：毫秒
      # StatViewServlet 配置
      stat-view-servlet: # 配置 StatViewServlet ，对应文档 https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatViewServlet%E9%85%8D%E7%BD%AE
        enabled: true # 是否开启 StatViewServlet
        login-username: root # 账号
        login-password: root # 密码

2.2.3 Main startup class

package com.yyds;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;
import javax.sql.DataSource;

@SpringBootApplication
public class Application implements CommandLineRunner {
    
    

    private Logger logger = LoggerFactory.getLogger(Application.class);

    @Resource(name = "ordersDataSource")
    private DataSource ordersDataSource;

    @Resource(name = "usersDataSource")
    private DataSource usersDataSource;

    public static void main(String[] args) {
    
    
        // 启动 Spring Boot 应用
        SpringApplication.run(Application.class, args);
    }

    @Override
    public void run(String... args) {
    
    
        // orders 数据源
        logger.info("[run][获得数据源：{}]", ordersDataSource.getClass());

        // users 数据源
        logger.info("[run][获得数据源：{}]", usersDataSource.getClass());
    }

}

2.2.4 Configuration class

package com.yyds.config;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {
    
    

    /**
     * 创建 orders 数据源
     */
    @Primary
    @Bean(name = "ordersDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.orders") 
    public DataSource ordersDataSource() {
    
    
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 创建 users 数据源
     */
    @Bean(name = "usersDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.users")
    public DataSource usersDataSource() {
    
    
        return DruidDataSourceBuilder.create().build();
    }

}

You can see that the data source is loaded successfully.

insert image description here

SpringBoot integration (5) HikariCP, Druid database connection pool - multiple data source configuration

1. HikariCP database connection pool

1.1 HikariCP single data source configuration

1.1.1 pom file

1.1.2 yml configuration

1.1.3 Main startup class

1.2 HikariCP multi-data source configuration

1.2.1 pom file

1.2.2 yml configuration

1.2.3 Main startup class

1.2.4 Configuration class

2. Druid database connection pool

2.1 Druid single data source configuration

2.1.1 pom file

2.1.2 yml configuration

2.1.3 Main startup class

2.1.4 Monitoring

2.2 Druid multi data source configuration

2.2.1 pom file

2.2.2 yml configuration

2.2.3 Main startup class

2.2.4 Configuration class

Guess you like