Spring Boot hikaricp 配置

Posted 2023-04-25

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring Boot hikaricp 配置相关的知识，希望对你有一定的参考价值。

参考技术A       driverClassName: com.mysql.jdbc.Driver
      jdbcUrl: jdbc:mysql://ip:3306/db?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&autoReconnect=true
      username: username
      password: password
      maxActive: 5
      initialSize: 1
      idleTimeout: 60000
      connectionTimeout: 60000
      validationTimeout: 3000
      maxLifetime: 60000
      cachePrepStmts: true
      prepStmtCacheSize: 500
      prepStmtCacheSqlLimit: 2048
      useServerPrepStmts: true
      useLocalSessionState: true
      useLocalTransactionState: true
      rewriteBatchedStatements: true
      cacheResultSetMetadata: true
      cacheServerConfiguration: true
      elideSetAutoCommits: true
      maintainTimeStats: false

如何在 application.properties 文件中的 Spring Boot 应用程序中配置 HikariCP？

【中文标题】如何在 application.properties 文件中的 Spring Boot 应用程序中配置 HikariCP？【英文标题】：How do I configure HikariCP in my Spring Boot app in my application.properties files? 【发布时间】：2014-12-16 22:19:00 【问题描述】：

我正在尝试在我的 Spring Boot (1.2.0.M1) 应用程序中设置 HikariCP，以便可以使用它来代替 Tomcat DBCP 进行测试。我想在我的 application.properties 文件中配置连接池，就像我对 Tomcat 所做的那样，但我不知道应该怎么做。我发现的所有示例都显示了 JavaConfig 样式或使用单独的 HikariCP 属性文件。有人可以帮我找出在 application.properties 中配置它的属性名称吗？我还想从使用 driverClassName 方法切换到 DataSourceClassName 方法，因为它看起来更干净并且被推荐。这在我的 application.properties 文件中也可以吗？

这是我对 Tomcat DBCP 所做的（只是一些基本配置，没有完全清除）

spring.datasource.validation-query=SELECT 1
spring.datasource.max-active=10
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=5
spring.datasource.test-on-borrow=true
spring.datasource.test-on-return=true

我目前正在使用 driverClassName 和 jdbc url 来建立连接：

spring.datasource.url=jdbc:mysql://localhost:3306/myDb
spring.datasource.driverClassName=com.mysql.jdbc.Driver

【问题讨论】：

你使用的是什么版本的 Spring Boot？ 1.2.0.M1 我想我可能已经想出了如何设置属性来为 hikariCP 设置诸如 maximumPoolSize 之类的东西。但是我无法使用 hikariCP 推荐的方式使用 dataSourceClassName 和 serverName 而不是 driverClassName 和 jdbc url 来使配置工作。所以我放弃了那部分。如果有人能弄清楚那部分，那会有所帮助我稍后会尝试 1.2.0.M1，我会找到任何我会发布的内容您不能将 dataSourceClassName 方法与 Spring Boot 的 DataSource 自动配置一起使用，因为它需要设置 spring.datasource.url。请注意，您不需要指定 driverClassName，因为 Boot 会从 jdbcUrl 推断它。 application.properties：spring.datasource.hikari.*，文档：github.com/brettwooldridge/HikariCP 【参考方案1】：

@Configuration
@ConfigurationProperties(prefix = "params.datasource")
public class JpaConfig extends HikariConfig 

    @Bean
    public DataSource dataSource() throws SQLException 
        return new HikariDataSource(this);

application.yml

params:
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/myDb
    username: login
    password: password
    maximumPoolSize: 5

已更新！从 Spring Boot 1.3.0 版本开始：

只需将 HikariCP 添加到依赖项中配置application.yml

application.yml

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:h2:mem:TEST
    driver-class-name: org.h2.Driver
    username: username
    password: password
    hikari:
      idle-timeout: 10000

已更新！从 Spring Boot 2.0.0 版本开始：

默认连接池已从 Tomcat 更改为 Hikari :)

【讨论】：

我认为这是一种更好、更便携的方法。干杯！这也可以用于标准的弹簧配置，但有一点很重要。 Hikari 通过 jdbcUrl 使用数据源的 url，但通过 url 使用 spring。私有字符串网址； @Bean public DataSource dataSource() throws SQLException return new HikariDataSource(this); 公共字符串 getUrl() 返回网址； public void setUrl(String url) this.url = url; // HikariConfig 在 jdbcUrl 属性中保存 JDBC-URL，但是 spring 将此属性提供为 url this.setJdbcUrl(url); 抱歉，回复有点晚了，但是@Sergey 的解决方案应该稍微改变一下，以获取所有属性。要获取 hikari 特定的 DS 属性，您需要将键设置为“spring.datasource.dataSourceProperties”而不是“spring.datasource.hikari” 以前，我们只需要通过查看数据源的文档来了解它是如何配置的，现在它变得更糟了，我们现在还需要知道它在使用 Spring Boot 时是如何配置的。我真的不认为这种自动配置真的对我们有帮助。我只是浪费了几个小时试图让它工作，但 hikari 忽略了我在 yml 文件中的配置参数（在我的情况下是最大池大小）。万一其他人遇到这种情况：不要忘记在 hikari 下缩进参数！这篇文章中的示例是正确的，但在我的示例中，我将最大池大小排在 hikari 的“h”下方，而不是缩进 2 个空格...【参考方案2】：

我遇到了HikariCP，我对基准测试感到惊讶，我想尝试它而不是我的默认选择C3P0，令我惊讶的是，我努力获得configurations 可能是因为配置不同基于您正在使用哪种技术堆栈组合。

我已经设置了Spring Boot 项目和JPA, Web, Security 启动器（使用Spring Initializer）以使用PostgreSQL 作为数据库，HikariCP 作为连接池。我使用Gradle 作为构建工具，我想分享对我有用的以下假设：

Spring Boot Starter JPA（Web 和安全 - 可选） Gradle 也可以构建使用数据库（即模式、用户、数据库）运行和设置 PostgreSQL

如果您使用的是Gradle，则需要以下build.gradle；如果您使用的是maven，则需要等效的pom.xml

buildscript 
    ext 
        springBootVersion = '1.5.8.RELEASE'
    
    repositories 
        mavenCentral()
    
    dependencies 
        classpath("org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion")
    


apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'

group = 'com'
version = '1.0'
sourceCompatibility = 1.8

repositories 
    mavenCentral()


dependencies 
    compile('org.springframework.boot:spring-boot-starter-aop')

    // Exclude the tomcat-jdbc since it's used as default for connection pooling
    // This can also be achieved by setting the spring.datasource.type to HikariCP 
    // datasource see application.properties below
    compile('org.springframework.boot:spring-boot-starter-data-jpa') 
        exclude group: 'org.apache.tomcat', module: 'tomcat-jdbc'
    
    compile('org.springframework.boot:spring-boot-starter-security')
    compile('org.springframework.boot:spring-boot-starter-web')
    runtime('org.postgresql:postgresql')
    testCompile('org.springframework.boot:spring-boot-starter-test')
    testCompile('org.springframework.security:spring-security-test')

    // Download HikariCP but, exclude hibernate-core to avoid version conflicts
    compile('com.zaxxer:HikariCP:2.5.1') 
        exclude group: 'org.hibernate', module: 'hibernate-core'
    

    // Need this in order to get the HikariCPConnectionProvider
    compile('org.hibernate:hibernate-hikaricp:5.2.11.Final') 
        exclude group: 'com.zaxxer', module: 'HikariCP'
        exclude group: 'org.hibernate', module: 'hibernate-core'

上面build.gradle中有一堆排除，那是因为

spring-boot-starter-data-jpa

jdbc-tomcat

spring.datasource.type=com.zaxxer.hikari.HikariDataSource

com.zaxxer

hibernate-core

Spring Boot

hibernate-hikaricp

hibernate-core

org.hibernate.hikaricp.internal.HikariCPConnectionProvider

com.zaxxer.hikari.hibernate.HikariConnectionProvider

一旦我弄清楚了 build.gradle 以及要保留和不保留的内容，我就准备将 datasource 配置复制/粘贴到我的 application.properties 中，并希望一切都能顺利进行，但事实并非如此我偶然发现了以下问题

Spring boot 无法找到数据库详细信息（即 url、驱动程序），因此无法设置 jpa 和 hibernate（因为我没有正确命名属性键值） HikariCP 回退到com.zaxxer.hikari.hibernate.HikariConnectionProvider 在指示 Spring 在自动配置 hibernate/jpa 时使用新的连接提供程序后，HikariCP 失败了，因为它在 application.properties 中寻找一些 key/value 并抱怨 dataSource, dataSourceClassName, jdbcUrl。我不得不调试到HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider 并发现HikariCP 找不到来自application.properties 的属性，因为它的名称不同。

无论如何，这是我必须依靠反复试验并确保HikariCP 能够选择属性（即，数据库详细信息的数据源以及池属性）以及 Sping Boot 的行为预期，我最终得到了以下application.properties 文件。

server.contextPath=/
debug=true

# Spring data source needed for Spring boot to behave
# Pre Spring Boot v2.0.0.M6 without below Spring Boot defaults to tomcat-jdbc connection pool included 
# in spring-boot-starter-jdbc and as compiled dependency under spring-boot-starter-data-jpa
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.url=jdbc:postgresql://localhost:5432/somedb
spring.datasource.username=dbuser
spring.datasource.password=dbpassword

# Hikari will use the above plus the following to setup connection pooling
spring.datasource.hikari.minimumIdle=5
spring.datasource.hikari.maximumPoolSize=20
spring.datasource.hikari.idleTimeout=30000
spring.datasource.hikari.poolName=SpringBootJPAHikariCP
spring.datasource.hikari.maxLifetime=2000000
spring.datasource.hikari.connectionTimeout=30000

# Without below HikariCP uses deprecated com.zaxxer.hikari.hibernate.HikariConnectionProvider
# Surprisingly enough below ConnectionProvider is in hibernate-hikaricp dependency and not hibernate-core
# So you need to pull that dependency but, make sure to exclude it's transitive dependencies or you will end up 
# with different versions of hibernate-core 
spring.jpa.hibernate.connection.provider_class=org.hibernate.hikaricp.internal.HikariCPConnectionProvider

# JPA specific configs
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql=true
spring.jpa.properties.hibernate.id.new_generator_mappings=false
spring.jpa.properties.hibernate.default_schema=dbschema
spring.jpa.properties.hibernate.search.autoregister_listeners=false
spring.jpa.properties.hibernate.bytecode.use_reflection_optimizer=false

# Enable logging to verify that HikariCP is used, the second entry is specific to HikariCP
logging.level.org.hibernate.SQL=DEBUG
logging.level.com.zaxxer.hikari.HikariConfig=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

如上所示，配置根据以下命名模式分为几类

spring.datasource.x（Spring 自动配置会选择这些，HikariCP 也会选择） spring.datasource.hikari.x（HikariCP 选择这些来设置池，记下 camelCase 字段名称） spring.jpa.hibernate.connection.provider_class（指示 Spring 使用新的 HibernateConnectionProvider） spring.jpa.properties.hibernate.x（Spring用来自动配置JPA，用下划线记下字段名）

很难找到说明如何使用上述属性文件以及如何命名属性的教程、帖子或资源。好吧，你有它。

将上面的application.properties 和build.gradle（或至少类似）放入 Spring Boot JPA 项目版本（1.5.8）应该像一个魅力一样工作并连接到您的预配置数据库（即在我的情况下它是HikariCP & Spring 都从 spring.datasource.url 中找出要使用哪个数据库驱动程序的 PostgreSQL）。

我没有看到创建 DataSource bean 的必要性，这是因为 Spring Boot 只需查看 application.properties 就可以为我做所有事情，这很简洁。

HikariCP 的 github wiki 中的 article 展示了如何使用 JPA 设置 Spring Boot，但缺乏解释和细节。

以上两个文件也可以作为公共要点https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

【讨论】：

在您发布之前，我一直在努力解决这个问题。谢谢！很高兴它帮助了你！ ? Raf 你有一个很棒的答案。我很好奇您是否可以发布 Spring Boot 2.0.0.M6 所需的更改。苦苦挣扎的配置没有被拾取，迁移指南还没有更新嘿，垫子，当我在这里分享我的解决方案时，我使用的是 1.5.8 版本。我想快速尝试一下 2.0.0.M6，但不幸的是，它们要求您拥有更高版本的 gradle。我记得在 2.0.0.M6 中唯一的变化是让 HikariCP 默认连接池为 spring jpa 看到这里github.com/spring-projects/spring-boot/commit/… 尝试调试 HikariConfig、HikariConfigurationUtil、HikariCPConnectionProvider 以确保获取属性。【参考方案3】：

您可以只使用 application.yml/application.properties。无需显式创建任何DataSource Bean

您需要排除 ydemartino 提到的 tomcat-jdbc

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jdbc</artifactId>
        </exclusion>
    </exclusions>
</dependency>

由于您不会创建 DataSource bean，因此您必须通过 spring.datasource.type 显式指定使用 Hikari，并在 application.yml / application.properties 中使用值 com.zaxxer.hikari.HikariDataSource

spring:
    datasource:
        hikari:
            connection-test-query: SELECT 1 FROM DUAL
            minimum-idle: 1
            maximum-pool-size: 5
            pool-name: yourPoolName
            auto-commit: false
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/myDb
        username: login
        password: password
        type: com.zaxxer.hikari.HikariDataSource

在您的 application.yml / application.properties 中，您可以在 spring.datasource.hikari.* 中配置 Hikari 特定参数，例如池大小等

【讨论】：

你不需要排除Tomcat来使这个工作，添加spring.datasource.type就足够了。 @MichaelPiefel 您需要进行排除。 DataSourceBuilder 的 javadoc 说：如果 Tomcat、HikariCP 或 Commons DBCP 在类路径中，则将选择其中一个（按照 Tomcat 优先的顺序）。我的测试证实了这一点。 @JanBodnar: DataSourceConfiguration，在自动配置中使用，如果设置的话，其配置取决于spring.datasource.type。所以，我的类路径中有tomcat-jdbc，并且仍然使用 HikariCP 作为我的池。我的测试证实了这一点。也许我们在这里谈论的是非常不同的 Spring Boot 版本。 @MichaelPiefel 有趣的是，我只使用 DataSourceBuilder.create()...type(com.zaxxer.hikari.HikariDataSource.class) 成功地运行它，而没有排除 Java 配置。使用 yaml 文件中的配置，它对我不起作用。所以必须有一些收获。【参考方案4】：

我正在使用 Spring Boot 2.0.4.RELEASE。 Hikari 是默认连接池，不再需要.hikari。

application.properties

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.jdbcUrl=jdbc:mysql://localhost:3306/myDB...
spring.datasource.username=xxx
spring.datasource.password=xxx
spring.datasource.poolname=myPool

application.yml

spring:
    datasource:
        driverClassName: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://localhost:3306/myDB...
        username: xxx
        password: xxx
        poolName: myPool

并且configuration不需要扩展HikariConfig，DataSourceBuilder可以照旧使用。

@Configuration
public class DataSourceConfiguration 

    @Bean(name="myDataSource")
    @ConfigurationProperties("spring.datasource")
    public DataSource myDataSource() 
        return DataSourceBuilder.create().build();

【讨论】：

【参考方案5】：

您不需要多余的代码来将属性值放入变量中。您可以直接使用属性文件设置属性。

将hikari.properties 文件放在类路径中。

driverClassName=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/myDb
connectionTestQuery=SELECT 1
maximumPoolSize=20
username=...
password=...

然后制作一个像这样的数据源 bean。

@Bean(destroyMethod = "close")
public DataSource dataSource() throws SQLException 
    HikariConfig config = new HikariConfig("/hikari.properties");
    HikariDataSource dataSource = new HikariDataSource(config);

    return dataSource;

【讨论】：

【参考方案6】：

根据文档已更改，

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-sql.html

例子：

spring:
    datasource:
        url: 'jdbc:mysql://localhost/db?useSSL=false'
        username: root
        password: pass
        driver: com.mysql.jdbc.Driver
        hikari:
            minIdle: 10
            idle-timeout: 10000
            maximumPoolSize: 30

这些是我们可以对 hikari 进行的以下配置更改，请根据您的需要添加/更新。

autoCommit
connectionTimeout
idleTimeout
maxLifetime
connectionTestQuery
connectionInitSql
validationTimeout
maximumPoolSize
poolName
allowPoolSuspension
readOnly
transactionIsolation
leakDetectionThreshold

【讨论】：

【参考方案7】：

这适用于我的启动应用程序，以防万一。这个类告诉你配置对象正在寻找什么属性：

https://github.com/brettwooldridge/HikariCP/blob/2.3.x/hikaricp-common/src/main/java/com/zaxxer/hikari/AbstractHikariConfig.java

我认为可以通过将datasource_whatever 添加到源配置文件中的属性键来支持多个数据源。干杯！

@Configuration
class DataSourceConfig 

   @Value('$spring.datasource.username')
   private String user;

   @Value('$spring.datasource.password')
   private String password;

   @Value('$spring.datasource.url')
   private String dataSourceUrl;

   @Value('$spring.datasource.dataSourceClassName')
   private String dataSourceClassName;

   @Value('$spring.datasource.connectionTimeout')
   private int connectionTimeout;

   @Value('$spring.datasource.maxLifetime')
   private int maxLifetime;

   @Bean
   public DataSource primaryDataSource() 
      Properties dsProps = [url: dataSourceUrl, user: user, password: password]
      Properties configProps = [
            connectionTestQuery: 'select 1 from dual',
            connectionTimeout: connectionTimeout,
            dataSourceClassName: dataSourceClassName,
            dataSourceProperties: dsProps,
            maxLifetime: maxLifetime
      ]

      // A default max pool size of 10 seems reasonable for now, so no need to configure for now.
      HikariConfig hc = new HikariConfig(configProps)
      HikariDataSource ds = new HikariDataSource(hc)
      ds

【讨论】：

是的。不过，它很容易翻译成 Java。是的，我现在意识到我需要这样做，因为现在我想配置指标。我能看到的唯一方法是使用这个 JavaConfig 来覆盖自动配置。谢谢。是的，它有帮助！你也得到了我的支持……这很时髦吗？这很有趣，就像 javascript :-)【参考方案8】：

这将帮助任何想要使用 spring 自动配置为其应用程序配置 hikaricp 的人。对于我的项目，我使用带有 hikaricp 作为 JDBC 连接池和 mysql 作为数据库的 spring boot 2。我在其他答案中没有看到的一件事是data-source-properties，它可用于设置spring.datasource.hikari.* 路径中不可用的各种属性。这相当于使用HikariConfig 类。为了为 mysql 特定属性配置数据源和 hikaricp 连接池，我使用了 spring auto configure 注释和 application.yml 文件中的以下属性。

将@EnableAutoConfiguration 放在您的一个配置bean 文件中。

application.yml 文件可能如下所示。

spring:
  datasource:
    url: 'jdbc:mysql://127.0.0.1:3306/DATABASE?autoReconnect=true&useSSL=false'
    username: user_name
    password: password
    hikari:
      maximum-pool-size: 20
      data-source-properties:
        cachePrepStmts: true
        prepStmtCacheSize: 250
        prepStmtCacheSqlLimit: 2048
        useServerPrepStmts: true
        useLocalSessionState: true
        rewriteBatchedStatements: true
        cacheResultSetMetadata: true
        cacheServerConfiguration: true
        elideSetAutoCommits: true
        maintainTimeStats: false

【讨论】：

此回复对于提供具有数据源属性的工作示例很有价值！【参考方案9】：

您可以使用 dataSourceClassName 方法，这里以 MySQL 为例。（使用 spring boot 1.3 和 1.4 测试）

首先，您需要从类路径中排除 tomcat-jdbc，因为它将被选中以支持 hikaricp。

pom.xml

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.apache.tomcat</groupId>
                <artifactId>tomcat-jdbc</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

application.properties

spring.datasource.dataSourceClassName=com.mysql.jdbc.jdbc2.optional.MysqlDataSource
spring.datasource.dataSourceProperties.serverName=localhost
spring.datasource.dataSourceProperties.portNumber=3311
spring.datasource.dataSourceProperties.databaseName=mydb
spring.datasource.username=root
spring.datasource.password=root

然后添加

@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() 
    return DataSourceBuilder.create().build();

我在这里创建了一个测试项目：https://github.com/ydemartino/spring-boot-hikaricp

【讨论】：

【参考方案10】：

如@Andy Wilkinson 所说，您不能在 application.properties 配置中使用 dataSourceClassName 方法。如果你想拥有 dataSourceClassName ，你可以使用 Java Config 作为：

@Configuration
@ComponentScan
class DataSourceConfig 

 @Value("$spring.datasource.username")
private String user;

@Value("$spring.datasource.password")
private String password;

@Value("$spring.datasource.url")
private String dataSourceUrl;

@Value("$spring.datasource.dataSourceClassName")
private String dataSourceClassName;

@Value("$spring.datasource.poolName")
private String poolName;

@Value("$spring.datasource.connectionTimeout")
private int connectionTimeout;

@Value("$spring.datasource.maxLifetime")
private int maxLifetime;

@Value("$spring.datasource.maximumPoolSize")
private int maximumPoolSize;

@Value("$spring.datasource.minimumIdle")
private int minimumIdle;

@Value("$spring.datasource.idleTimeout")
private int idleTimeout;

@Bean
public DataSource primaryDataSource() 
    Properties dsProps = new Properties();
    dsProps.put("url", dataSourceUrl);
    dsProps.put("user", user);
    dsProps.put("password", password);
    dsProps.put("prepStmtCacheSize",250);
    dsProps.put("prepStmtCacheSqlLimit",2048);
    dsProps.put("cachePrepStmts",Boolean.TRUE);
    dsProps.put("useServerPrepStmts",Boolean.TRUE);

    Properties configProps = new Properties();
       configProps.put("dataSourceClassName", dataSourceClassName);
       configProps.put("poolName",poolName);
       configProps.put("maximumPoolSize",maximumPoolSize);
       configProps.put("minimumIdle",minimumIdle);
       configProps.put("minimumIdle",minimumIdle);
       configProps.put("connectionTimeout", connectionTimeout);
       configProps.put("idleTimeout", idleTimeout);
       configProps.put("dataSourceProperties", dsProps);

   HikariConfig hc = new HikariConfig(configProps);
   HikariDataSource ds = new HikariDataSource(hc);
   return ds;

不能使用 dataSourceClassName 的原因是它会抛出异常

Caused by: java.lang.IllegalStateException: both driverClassName and dataSourceClassName are specified, one or the other should be used.

这意味着 spring boot 从 spring.datasource.url 属性推断 Driver 并同时设置 dataSourceClassName 会创建此异常。为了使它正确，对于 HikariCP 数据源，您的 application.properties 应该看起来像这样：

# hikariCP 
  spring.jpa.databasePlatform=org.hibernate.dialect.MySQLDialect
  spring.datasource.url=jdbc:mysql://localhost:3306/exampledb
  spring.datasource.username=root
  spring.datasource.password=
  spring.datasource.poolName=SpringBootHikariCP
  spring.datasource.maximumPoolSize=5
  spring.datasource.minimumIdle=3
  spring.datasource.maxLifetime=2000000
  spring.datasource.connectionTimeout=30000
  spring.datasource.idleTimeout=30000
  spring.datasource.pool-prepared-statements=true
  spring.datasource.max-open-prepared-statements=250

注意：请检查您的类路径中是否有任何tomcat-jdbc.jar 或commons-dbcp.jar 在大多数情况下通过传递依赖添加。如果这些存在于类路径中，Spring Boot 将使用默认连接池（即 tomcat）配置数据源。如果类路径中没有其他提供者，HikariCP 将仅用于创建数据源。有一个从 tomcat -> 到 HikariCP -> 到 Commons DBCP 的后备序列。

【讨论】：

这非常有用，尽管我必须弄清楚这里没有提到的几个属性名称，比如 stringType 来配置数据源道具。很高兴知道它有帮助。【参考方案11】：

这是个好消息。 HikariCP 现在是 Spring Boot 2.0.0 的默认连接池。

Spring Boot 2.0.0 Release Notes

Spring Boot 2.0 中默认的数据库池技术已从 Tomcat Pool 切换到 HikariCP。我们发现 Hakari 提供了卓越的性能，我们的许多用户更喜欢它而不是 Tomcat Pool。

【讨论】：

【参考方案12】：

事实证明，除了数据库连接数之外，几乎所有 HikariCP 的默认设置都对我有用。我在 application.properties 中设置了该属性：

spring.datasource.maximumPoolSize=20

据我所知，Andy Wilkinson 是正确的，因为您不能在 Spring Boot 中使用 HikariCP 的 dataSourceClassName 配置方法。

【讨论】：

我在不同的应用程序中使用 HikariCP 已经有一段时间了，到目前为止从未遇到任何问题。我正在使用 HikariConfig 方法，您将所有配置都放在属性文件中。也可以与 SpringBoot 和 SpringCore 一起按预期工作。我也在配置 maximumPoolSize。使用spring config属性时应为spring.datasource.maximum-pool-size，否则maximumPoolSize为HikariCP参数名称。【参考方案13】：

我的设置： Spring Boot v1.5.10 Hikari v.3.2.x（用于评估）

要真正了解 Hikari Data Source 的配置，建议禁用 Spring Boot 的 Auto-Configuration for Data Source。

在 application.properties 中添加以下内容：-

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

这将禁用 Spring Boot 自行配置 DataSource 的功能。

现在是您定义自己的自定义配置以创建 HikariDataSource bean 并使用所需属性填充它的机会。

注意 ::: 公共类 HikariDataSource 扩展 HikariConfig

你需要

使用所需的 Hikari 属性填充 HikariConfig 对象使用作为参数传递给构造函数的 HikariConfig 对象初始化 HikariDataSource 对象。

我相信定义我自己的自定义配置类( @Configuration ) 自行创建数据源并填充它与在单独文件中定义的数据源属性（比传统：application.properties) 通过这种方式，我可以定义我自己的 sessionFactory Bean 使用 Hibernate 推荐： “LocalSessionFactoryBean”类并使用您的 Hikari 数据源 > 和其他基于 Hiberante-JPA 的属性填充它。

基于 Spring Boot 的 Hikari 数据源属性总结：-

spring.datasource.hikari.allow-pool-suspension=true spring.datasource.hikari.auto-commit=false spring.datasource.hikari.catalog= spring.datasource.hikari.connection-init-sql= spring.datasource.hikari.connection-test-query= spring.datasource.hikari.connection-timeout=100 spring.datasource.hikari.data-source-class-name= spring.datasource.hikari.data-source-j-n-d-i= spring.datasource.hikari.driver-class-name= spring.datasource.hikari.idle-timeout=50 spring.datasource.hikari.initialization-fail-fast=true spring.datasource.hikari.isolate-internal-queries=true spring.datasource.hikari.jdbc-url= spring.datasource.hikari.leak-detection-threshold= spring.datasource.hikari.login-timeout=60 spring.datasource.hikari.max-lifetime= spring.datasource.hikari.maximum-pool-size=500 spring.datasource.hikari.minimum-idle=30 spring.datasource.hikari.password= spring.datasource.hikari.pool-name= spring.datasource.hikari.read-only=true spring.datasource.hikari.register-mbeans=true spring.datasource.hikari.transaction-isolation= spring.datasource.hikari.username= spring.datasource.hikari.validation-timeout=

【讨论】：

spring.datasource.hikari.maximum-pool-size=500 真的太可怕了，hikari 不推荐 :) github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing 这只是一个带有值的示例配置:)【参考方案14】：

随着以后的 spring-boot 版本切换到 Hikari 可以完全在配置中完成。我正在使用1.5.6.RELEASE，这种方法有效。

build.gradle：

compile "com.zaxxer:HikariCP:2.7.3"

应用 YAML

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      idleTimeout: 60000
      minimumIdle: 2
      maximumPoolSize: 20
      connectionTimeout: 30000
      poolName: MyPoolName
      connectionTestQuery: SELECT 1

更改 connectionTestQuery 以适合您的基础数据库。就是这样，不需要代码。

【讨论】：

【参考方案15】：

下面的代码可用于静态数据源初始化。

public class MyDataSource 
    private static final String DB_USERNAME="spring.datasource.username";
    private static final String DB_PASSWORD="spring.datasource.password";
    private static final String DB_URL ="spring.datasource.url";
    private static final String DB_DRIVER_CLASS="spring.datasource.driver-class-name";

    private static Properties properties = null;
    private static HikariDataSource dataSource;

    static 
        try 
            properties = new Properties();
            properties.load(new FileInputStream("src/main/resources/application.properties"));

            dataSource = new HikariDataSource();
            dataSource.setDriverClassName(properties.getProperty(DB_DRIVER_CLASS));

            dataSource.setJdbcUrl(properties.getProperty(DB_URL));
            dataSource.setUsername(properties.getProperty(DB_USERNAME));
            dataSource.setPassword(properties.getProperty(DB_PASSWORD));

            dataSource.setMinimumIdle(100);
            dataSource.setMaximumPoolSize(2000);
            dataSource.setAutoCommit(false);
            dataSource.setLoginTimeout(3);

         catch (IOException | SQLException e) 
            ((Throwable) e).printStackTrace();
        
    

    public static DataSource getDataSource()
        return dataSource;
    

    public static Connection getConnection() throws SQLException
        return getDataSource().getConnection();

【讨论】：

【参考方案16】：

现在用HikcariCp作为新版spring boot的默认连接池，直接如下图即可。

@Configuration
public class PurchaseOrderDbConfig 
    
    @Bean
    @ConfigurationProperties(prefix = "com.sysco.purchaseorder.datasoure")
    public DataSource dataSource() 
        return DataSourceBuilder.create().build();

application.yml

com:
  sysco:
    purchaseorder:
      datasoure:
        driverClassName: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://localhost:3306/purchaseorder
        username: root
        password: root123
        idleTimeout: 600000

如果你将打印空闲超时值的值

ApplicationContext context=SpringApplication.run(ApiBluePrint.class, args);
   HikariDataSource dataSource=(HikariDataSource) context.getBean(DataSource.class);
   System.out.println(dataSource.getIdleTimeout());

如果您不定义任何自定义值，您将获得 600000 的值，其中默认值为 300000

【讨论】：

【参考方案17】：

我遇到了问题，问题是spring.datasource.type = com.zaxxer.hikari.HikariDataSource末尾的空白

【讨论】：

【参考方案18】：

我正在合作

HikariCP-4.0.3.jar
spring-boot-2.6.2.jar
spring-core-5.3.14.jar
spring-jdbc-5.3.14.jar
spring-web-5.3.14.jar
thymeleaf-3.0.14.RELEASE.jar

看起来 spring-boot 2.x 默认支持 HikariCP 开箱即用，这是个好消息。

我必须在我的 resources/application.properties 中为 2 个不同的 DS 进行以下配置

spring.sid1.datasource.jdbcUrl=jdbc:oracle:thin:@XXX:1521:SID1
spring.sid1.datasource.username=<user>
spring.sid1.datasource.password=<password>
spring.sid1.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.sid1.datasource.connectionTimeout=20000
spring.sid1.datasource.poolName=SID1Pool
spring.sid1.datasource.minimumIdle=5
spring.sid1.datasource.maximumPoolSize=10

spring.sid2.datasource.jdbcUrl=jdbc:oracle:thin:@XXX:1521:SID2
spring.sid2.datasource.username=<user2>
spring.sid2.datasource.password=<password2>
spring.sid2.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.sid2.datasource.connectionTimeout=20000
spring.sid2.datasource.poolName=SID2Pool
spring.sid2.datasource.minimumIdle=5
spring.sid2.datasource.maximumPoolSize=10

注意：spring.sid2.datasource.hikari.* 配置不是必需的，因为它是默认的新配置。

【讨论】：

以上是关于Spring Boot hikaricp 配置的主要内容，如果未能解决你的问题，请参考以下文章

Spring Boot 2：如何使用 application.properties 文件配置 HikariCP

如何在 application.properties 文件中的 Spring Boot 应用程序中配置 HikariCP？

spring-boot2默认的数据源--HikariCP

HikariConfig配置详解