【问题标题】:How do I configure HikariCP in my Spring Boot app in my application.properties files?如何在 application.properties 文件中的 Spring Boot 应用程序中配置 HikariCP?
【发布时间】: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

标签: java spring spring-boot 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 版本开始

  1. 只需将 HikariCP 添加到依赖项中
  2. 配置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 作为构建工具,我想分享对我有用的以下假设:

  1. Spring Boot Starter JPA(Web 和安全 - 可选)
  2. Gradle 也可以构建
  3. 使用数据库(即模式、用户、数据库)运行和设置 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中有一堆排除,那是因为

  1. 首先排除,指示gradle在下载spring-boot-starter-data-jpa依赖项时排除jdbc-tomcat连接池。这也可以通过设置spring.datasource.type=com.zaxxer.hikari.HikariDataSource 来实现,但是,如果我不需要它,我不想要额外的依赖
  2. 第二次排除,指示gradle在下载com.zaxxer依赖时排除hibernate-core,这是因为hibernate-core已经被Spring Boot下载了,我们不想最终得到不同的版本。
  3. 第三个排除,指示 gradle 在下载 hibernate-hikaricp 模块时排除 hibernate-core 模块,这是使 HikariCP 使用 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.propertiesbuild.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不需要扩展HikariConfigDataSourceBuilder可以照旧使用。

@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

            你需要

            1. 使用所需的 Hikari 属性填充 HikariConfig 对象
            2. 使用作为参数传递给构造函数的 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=

            【讨论】:

            【解决方案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.* 配置不是必需的,因为它是默认的新配置。

                    【讨论】: