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

我试图在我的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

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

我遇到HikariCP了这些测试，我对基准感到惊讶，我想尝试一下它而不是默认选择C3P0，但令我惊讶的是，我努力地找到了configurations正确的选择，可能是因为配置因所使用的技术堆栈的组合而异。

我有Spring Boot一个带有JPA, Web, Security启动程序的安装项目（使用Spring Initializer），可以PostgreSQL用作带有HikariCP连接池的数据库。
我已将其用作Gradle构建工具，并且我想分享以下假设对我有用的内容：

1. Spring Boot Starter JPA（网络和安全性-可选）
2. Gradle构建也
3. PostgreSQL运行并通过数据库（即模式，用户，数据库）进行设置

你需要以下build.gradle如果您正在使用Gradle或同等pom.xml如果你正在使用maven

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. 首先排除，指示gradlejdbc-tomcat在下载spring-boot-starter-data-jpa依赖项时排除连接池。这可以通过设置Also来实现，spring.datasource.type=com.zaxxer.hikari.HikariDataSource但是，如果不需要，我不需要额外的依赖关系
2. 第二个排除项，指示gradlehibernate-core在下载com.zaxxer依赖项时进行排除，这是因为hibernate-core已经下载了依赖项，Spring Boot并且我们不希望最终使用其他版本。
3. 第三排除，hibernate-core在下载hibernate-hikaricp模块时指示gradle排除，以使HikariCPorg.hibernate.hikaricp.internal.HikariCPConnectionProvider用作连接提供者而不是不推荐使用com.zaxxer.hikari.hibernate.HikariConnectionProvider

一旦弄清楚了build.gradle要保留的内容和不应该保留的内容，就可以将datasource配置复制/粘贴到我的文件中，application.properties并期望所有内容都可以正常工作，但实际上并没有，我偶然发现了以下问题

• Spring Boot无法找出数据库详细信息（即url，驱动程序），因此无法设置jpa和休眠状态（因为我没有正确命名属性键值）
• HikariCP回落到 com.zaxxer.hikari.hibernate.HikariConnectionProvider
• 后指示Spring使用新的连接提供商时自动配置休眠/ JPA然后HikariCP失败，因为它是寻找一些key/value在application.properties并抱怨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选择这些设置池，记下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）应该可以像魅力一样工作，并连接到预先配置的数据库（即，在我的情况下，这是PostgreSQL，两者都HikariCP & Spring可以从spring.datasource.url哪个数据库中找出来）数据库驱动程序使用）。

我没有看到创建一个DataSourcebean的需要，那是因为Spring Boot能够通过查看就能为我做所有事情application.properties，这很干净。

HikariCP的github Wiki中的文章显示了如何使用JPA设置Spring Boot，但是缺少解释和细节。

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

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

您需要排除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>

由于您不会创建DataSourcebean，因此必须通过application.yml / application.properties中的spring.datasource.type值显式指定使用Hikaricom.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中，您可以在以下位置配置Hikari特定参数，例如池大小等 spring.datasource.hikari.*

我正在使用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();
    }
}

根据文档进行了更改，

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

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

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

万一有帮助，这对我的启动应用程序有效。此类告诉您config对象正在寻找哪些属性：

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

您可以使用dataSourceClassName方法，这是MySQL的示例。（已通过弹簧靴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

您不能像@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从Driver的spring.datasource.url属性推断出，同时设置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）来配置数据源。如果在classpath中没有其他提供者，则HikariCP仅用于创建数据源。从tomcat->到HikariCP->到Commons DBCP都有一个后备序列。

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

广场@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

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

Spring Boot 2.0.0发行说明

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

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

spring.datasource.maximumPoolSize=20

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

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

为了真正理解Hikari数据源的配置，我建议禁用Spring Boot的数据源自动配置。

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

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

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

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

NOTE :::
公共类HikariDataSource扩展了HikariConfig

你需要

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

我相信定义自己的自定义配置类（@Configuration）可以自己创建数据源，并使用在单独文件中定义的数据源属性填充它（与传统的application.properties相比）。

通过这种方式，我可以定义自己的使用Hibernate的sessionFactory Bean建议使用：“ LocalSessionFactoryBean”类，并使用您的Hikari Data Source>和其他基于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-jndi =
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.maximum -idle = 30 .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-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以适合您的基础数据库。就是这样，不需要任何代码。

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

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

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

现在使用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