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

小开

所以除了数据库连接的数量之外，几乎所有 HikariCP 的默认设置都适用于我。我在 application.properties 中设置了该属性:

spring.datasource.maximumPoolSize=20

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

小开

这适用于我的引导应用程序，如果有帮助的话。这个类告诉您 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
}
}

小开

you can't use dataSourceClassName approach in application.properties configurations as said by @Andy Wilkinson. if you want to have dataSourceClassName anyway you can use Java Config as:

@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.

which mean spring boot infers from spring.datasource.url property the Driver and at the same time setting the dataSourceClassName creates this exception. To make it right your application.properties should look something like this for HikariCP datasource:

# 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，大多数情况下是通过传递依赖添加的。如果类路径中存在这些内容，SpringBoot 将使用默认的连接池 tomcat 来配置数据源。只有在类路径中没有其他提供程序的情况下，才会使用 HikariCP 来创建数据源。有一个从 tomcat-> 到 HikariCP-> 到 Commons DBCP 的回退序列。

小开

将属性值放入变量不需要冗余代码。

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

小开

最佳答案

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


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


}

应用

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 添加到依赖项
Configure 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:)

小开

您可以使用 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>

应用性能

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

Then just add

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

I created a test project here: https://github.com/ydemartino/spring-boot-hikaricp

小开

You could simply make use of application.yml/application.properties only. There is no need to explicitly create any 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

In your application.yml / application.properties, you could configure Hikari specific parameters such as pool size etc in spring.datasource.hikari.*

小开

我偶然发现了 HikariCP，我被它的基准所震惊，我想试试它，而不是我的默认选择 C3P0，令我惊讶的是，我努力得到 configurations的权利可能是因为配置不同的组合技术堆栈你使用。

我使用 JPA, Web, Security启动器(使用 Spring 初始化程序)设置了 Spring Boot项目，使用 PostgreSQL作为数据库，使用 HikariCP作为连接池。
我已经使用 Gradle作为构建工具，我想分享什么工作对我来说下面的假设:

SpringBootStarterJPA (Web 和安全性-可选)
身材也很好
PostgreSQL running and setup with a database (i.e. schema, user, db)

如果您使用的是 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中有一些排除，这是因为

首先排除，指示 gradle 在下载 spring-boot-starter-data-jpa依赖项时排除 jdbc-tomcat连接池。这也可以通过设置 spring.datasource.type=com.zaxxer.hikari.HikariDataSource来实现，但是，如果我不需要的话，我不想要一个额外的依赖项
第二个排除，指示 gradle 在下载 com.zaxxer依赖时排除 hibernate-core，这是因为 hibernate-core已经被 Spring Boot下载了，我们不想以不同的版本结束。
Third exclude, instructs gradle to exclude hibernate-core when downloading hibernate-hikaricp module which is needed in order to make HikariCP use org.hibernate.hikaricp.internal.HikariCPConnectionProvider as connection provider instead of deprecated com.zaxxer.hikari.hibernate.HikariConnectionProvider

一旦我弄清楚了 build.gradle以及保留什么和不保留什么，我准备复制/粘贴一个 datasource配置到我的 application.properties，并期望一切顺利工作，但是，不是真的，我偶然发现了以下问题

因此，Spring 启动无法找到数据库详细信息(即 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能够选择属性(即数据源是 db 的细节，以及池属性)以及 SpingBoot 的行为如预期，我最终得到了以下 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

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

Data ource.x (Spring auto-configure 会选择这些，HikariCP 也会选择这些)
Hikari.x (HikariCP 选择这些来设置池，记下 camelCase 字段名)
Provider _ class (指示 Spring 使用新的 HibernateConnectionProvider)
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 维基百科中的文章展示了如何使用 JPA 设置 Spring 启动，但是缺乏解释和细节。

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

小开

随着后来的弹簧启动版本切换到 Hikari 完全可以在配置中完成。我使用的是 1.5.6.RELEASE，这种方法是有效的。

打造:

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

Change connectionTestQuery to suit your underlying DB. That's it, no code required.

小开

好消息是，HikariCP 现在是 SpringBoot2.0.0的默认连接池。

SpringBoot2.0.0发行说明

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

小开

我的设置:
Spring Boot v1.5.10
Hikari v. 3.2.x (用于评估)

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

向 application.properties 添加以下内容:-

Autoconfigure. 排除 = org.springframework.boot.autoconfigure.jdbc. DataSourceAutoConfiguration

这将禁用 SpringBoot 自行配置 DataSource 的能力。

现在您有机会定义自己的 Custom Configuration 来创建 HikariDataSource bean 并用所需的属性填充它。

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

你必须这么做

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

我相信定义自己的 Custom Configuration 类 ( @ Configuration) 创建数据源并填充它的数据源属性定义在一个单独的文件(比传统: application.properties) 我可以用这种方式来定义使用 Hibernate 的我自己的 sessionFactory Bean 推荐: “ LocalSessionFactoryBean”类，并用 Hikari Data Source > 和其他基于 Hiberante-JPA 的属性填充它。

基于 Spring Boot 的 Hikari DataSource 属性概述:-

spring.datasource.hikari.allow-pool-suspension=true
Auto-commit = false
Datource.hikari.catalog =
Connection-init-sql =
Connect-test-query =
Connect-timeout = 100
Data-source-class-name =
Data-source-j-n-d-i =
Driver-class-name =
Idle- 超时 = 50
Initialization-fall-fast = true
GB/T14779 -1993 spring.datource.hikari. 內部查問 = true
Jdbc-url =
spring.datasource.hikari.leak-detection-threshold=
Login-timeout = 60
Max-life =
Max-pool-size = 500
最小-空闲 = 30
Password =
spring.datasource.hikari.pool-name=
Read-only = true
Register-mbeans = true
事务隔离 =
spring.datasource.hikari.username=
Valid- timeout =

小开

根据文件上的修改,

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

小开

我使用的是 SpringBoot2.0.4. RELEASE。 Hikari 是默认连接池，不再需要 .hikari。

应用性能

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

应用

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

小开

This will help anyone who wants to configure hikaricp for their application with spring auto configuration. For my project, im using spring boot 2 with hikaricp as the JDBC connection pool and mysql as the database. One thing I didn't see in other answers was the data-source-properties which can be used to set various properties that are not available at the spring.datasource.hikari.* path. This is equivalent to using the HikariConfig class. To configure the datasource and hikaricp connection pool for mysql specific properties I used the spring auto configure annotation and the following properties in the application.yml file.

在配置 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

小开

我面临的问题和问题是 spring.datasource.type = com.zaxxer.hikari.HikariDataSource结束时的空格

小开

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

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

小开

Now with HikcariCp as default connection pooling with new version of spring boot.It can be directly done as shown below.

@Configuration
public class PurchaseOrderDbConfig {
    

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


}

应用

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

If you will print the value of idle timeout value

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

you will get value as 600000 where as default value is 300000 if you dont define any custom value

小开

一起工作

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，这是个好消息。

I had to put in following configurations for 2 different DS in my resources/application.properties

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.datource.hikari. * 配置，因为它是默认的 new。