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

121
我正在尝试在我的Spring Boot(1.2.0.M1)应用程序中设置HikariCP,以便我可以在测试中使用它来替代Tomcat DBCP。我想像使用Tomcat时那样在我的application.properties文件中配置连接池,但是我不知道该如何配置。我找到的所有示例都是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 版本是哪个? - geoand
1.2.0.M1我想我可能已经弄清楚了如何设置属性,例如hikariCP的maximumPoolSize。但是,我一直无法使用hikariCP推荐的方式(使用dataSourceClassName和serverName而不是driverClassName和jdbc url)使配置工作。所以我放弃了那部分。如果有人能够解决那部分问题,那会很有帮助。 - Kevin M
我稍后会尝试使用1.2.0.M1版本,如果发现任何问题我会发布它。 - geoand
2
你不能在Spring Boot自动配置DataSource时使用dataSourceClassName方法,因为它要求设置spring.datasource.url。请注意,你不需要指定driverClassName,因为Boot会从jdbcUrl中推断出它。 - Andy Wilkinson
1
应用配置:spring.datasource.hikari.*,文档请参见:https://github.com/brettwooldridge/HikariCP。 - kinjelom
感谢您的更新。最初在2014年,它们是这样指定的。 - Kevin M
18个回答

170
@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 :)


1
我认为这是一种更好、更便携的方法。干杯! - Jesús Zazueta
2
这也可以用于标准的Spring配置,但有一件事很重要。Hikari使用jdbcUrl来获取数据源的url,而Spring使用url。{ private String url;@Bean public DataSource dataSource() throws SQLException { return new HikariDataSource(this); } public String getUrl() { return url; } public void setUrl(String url) { this.url = url; // HikariConfig将JDBC-URL保存在jdbcUrl属性中,但Spring将此属性提供为url this.setJdbcUrl(url); }} - Tomas Hanus
抱歉回复晚了一点,但是@Sergey的解决方案需要稍作修改才能获取所有的属性。要获取Hikari特定的数据源属性,您需要将键设置为“spring.datasource.dataSourceProperties”,而不是“spring.datasource.hikari”。 - bluelabel
3
以前,我们只需要查看数据源的文档来了解它的配置方式,现在情况变得更糟了,我们还需要了解在使用Spring Boot时它是如何配置的。我真的不认为这种自动配置真的对我们有帮助。 - supertonsky
我刚刚浪费了几个小时尝试让它工作,但是 hikari 忽略了我在 yml 文件中的配置参数(在我的情况下是最大池大小)。如果其他人遇到这种情况:不要忘记在 hikari 下缩进参数!!这篇文章中的示例是正确的,但是在我的文件中,我的最大池大小与 hikari 的 'h' 对齐而不是缩进 2 个空格... - AnOttawan

40

我发现了 HikariCP,惊叹于其基准测试,想试用一下,代替我的默认选择C3P0。但出乎意料的是,我很难正确配置configurations,这可能是因为不同的技术堆栈组合所需的配置不同。

我使用Spring Initializer设置了一个Spring Boot项目,使用JPA、Web、Security starters,并将PostgreSQL作为数据库,HikariCP作为连接池。
我使用Gradle作为构建工具,并且我想分享以下内容,适用于以下假设:

  1. 使用Spring Boot Starter JPA(Web和Security - 可选)
  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、driver),因此无法设置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能够选择属性(即作为db详细信息的数据源以及池化属性),以及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选取这些来设置连接池,请注意驼峰命名法的字段名称)
  • spring.jpa.hibernate.connection.provider_class (指示Spring使用新的HibernateConnectionProvider)
  • spring.jpa.properties.hibernate.x (Spring用于自动配置JPA,请注意具有下划线的字段名称)
很难找到一个教程或文章或其他资源展示如何使用上述属性文件以及属性应该如何命名。现在你已经知道了。
将上述application.propertiesbuild.gradle(或类似的文件)一起放入Spring Boot JPA项目版本(1.5.8),就可以像魔术般地工作并连接到预配置的数据库(例如,在我的情况下,它是PostgreSQL,HikariCP和Springspring.datasource.url中找出要使用的数据库驱动程序)。
我没有看到创建DataSource bean的必要性,因为Spring Boot可以通过查看application.properties来为我完成所有操作,这很方便。

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

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


我在你发帖之前一直苦恼于此。谢谢! - Bogdan Pușcașu
很高兴能够帮到你! - Raf
Raf,你的回答太棒了。我想知道是否可能让你发布适用于Spring Boot 2.0.0.M6的更改所需的更改。我正在努力解决配置未被拾取的问题,而迁移指南尚未更新。 - Matthew Fontana
嘿,Mat,我在分享我的解决方案时使用的是1.5.8版本。我想快速尝试一下2.0.0.M6,但不幸的是,他们要求您拥有更高版本的gradle。我唯一记得在2.0.0.M6中的更改是将HikariCP作为Spring JPA的默认连接池,请参见此处https://github.com/spring-projects/spring-boot/commit/d48c414a647427d4fb586c0f362f52e6f5fa2bd8尝试调试HikariConfig、HikariConfigurationUtil、HikariCPConnectionProvider以确保属性被正确获取。 - Raf

26
您只需使用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,您必须在application.yml / application.properties中明确指定使用Hikari,通过spring.datasource.type设置为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即可。 - Michael Piefel
3
你需要进行排除。DataSourceBuilder 的 Javadoc 说:如果在类路径上有 Tomcat、HikariCP 或 Commons DBCP 其中之一将被选择(按照 Tomcat 优先的顺序)。我的测试证实了这一点。 - Jan Bodnar
1
@JanBodnar:DataSourceConfiguration是在自动配置中使用的,具体取决于sprig.datasource.type的配置,如果有设置的话。因此,即使我的类路径上有tomcat-jdbc,我仍然使用HikariCP作为我的池。我的测试证实了这一点。也许我们正在谈论非常不同的Spring Boot版本。 - Michael Piefel
1
有趣的是,我成功地使用Java配置(仅使用DataSourceBuilder.create()...type(com.zaxxer.hikari.HikariDataSource.class))运行它而不需要排除。但是,使用YAML文件中的配置时,它对我来说不起作用。所以肯定有一些问题。 - Jan Bodnar

21

我正在使用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

并且配置不需要扩展HikariConfigDataSourceBuilder可以像以前一样使用。

@Configuration
public class DataSourceConfiguration {

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

12

为将属性值放入变量中,您无需冗余代码。您可以直接使用属性文件设置属性。

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;
}

Hikari的属性也可以是.yml文件吗? - BugsOverflow
@BugsOverflow 我已经很久没有使用它了,所以我不确定,但似乎不是这样 https://www.javadoc.io/doc/com.zaxxer/HikariCP/3.2.0/com/zaxxer/hikari/HikariConfig.html - Sanghyun Lee

11

根据文档显示它已经被更改,

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

11

对于希望使用Spring自动配置来配置其应用程序中的HikariCP的任何人都将受益。对于我的项目,我正在使用Spring Boot 2,其中HikariCP作为JDBC连接池,MySQL作为数据库。在其他答案中我没有看到一个东西,即 data-source-properties,它可以用于设置不在spring.datasource.hikari.*路径下可用的各种属性。这相当于使用 HikariConfig 类。为了为MySQL特定属性配置数据源和HikariCP连接池,我使用了Spring auto configure注释以及application.yml文件中的以下属性。

在您的配置Bean文件之一上放置 @EnableAutoConfiguration

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

此回复对提供带有数据源属性的工作示例非常有价值! - Mauro Molinari

9

如果有帮助的话,这对我的引导应用程序有效。这个类告诉你配置对象正在寻找哪些属性:

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的。 - Jesús Zazueta
是的,我现在意识到我需要这样做,因为我想配置指标。而我能想到的唯一方法就是使用JavaConfig来覆盖自动配置。谢谢。 - Kevin M
是的,它很有帮助!你也得到了我的赞同... 它很酷吗?它非常有趣,就像 JavaScript :-) - Joao Polo

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

8

正如@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属性推断出驱动程序,同时设置dataSourceClassName会创建此异常。为了使它正确,您的application.properties应该类似于以下内容,用于HikariCP数据源:
# 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,这些通常是由传递依赖项添加的。如果这些jar包存在于类路径中,则Spring Boot将使用默认连接池(即tomcat)配置数据源。只有在类路径中没有其他提供程序时,才会使用HikariCP创建数据源。回退顺序为tomcat -> HikariCP -> Commons DBCP。

1
这非常有帮助,尽管我不得不自己找出一些未在此处提到的属性名称,例如stringType来配置数据源属性。 - comiventor
很高兴知道它有所帮助。 - Shahid Yousuf

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接