application.propertiesファイルのSpring BootアプリでHikariCPを構成するにはどうすればよいですか？

Question

Tomcat DBCPの代わりにそれを使用してテストできるように、Spring Boot（1.2.0.M1）アプリでHikariCPを設定しようとしています。 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

Answer 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に変更されました:)

Answer 2

単に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でspring.datasource.typeを介して値com.zaxxer.hikari.HikariDataSourceでHikariを使用することを明示的に指定する必要があります

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固有のパラメータを設定できます

Answer 3

HikariCPに出会い、ベンチマークに驚いたので、デフォルトの選択肢C3P0の代わりに試してみたいと思いましたが、驚いたことに、使用している技術スタックの組み合わせに基づいて構成が異なるため、configurationsを正しく取得するのに苦労しました。

Spring Boot startersを使用してJPA, Web, Securityプロジェクトをセットアップし（ Spring Initializer を使用）、PostgreSQLをデータベースとして使用し、HikariCPを接続プールとして使用します。
ビルド変数ツールとしてGradleを使用しましたが、次のような前提で機能するものを共有したいと思います。

1. Spring Boot Starter JPA（Webおよびセキュリティ-オプション）
2. Gradleビルドも
3. PostgreSQLの実行とデータベース（つまり、スキーマ、ユーザー、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には多数の除外がありますが、それは

1. 最初に除外し、jdbc-Tomcat依存関係をダウンロードするときにspring-boot-starter-data-jpa接続プールを除外するgradleに指示します。これはspring.datasource.type=com.zaxxer.hikari.HikariDataSourceも設定することで実現できますが、必要ない場合は余分な依存関係は必要ありません。
2. 2番目の除外は、hibernate-core依存関係をダウンロードするときにcom.zaxxerを除外するようにgradleに指示します。これは、hibernate-coreがSpring Bootによって既にダウンロードされており、異なるバージョンになりたくないからです。
3. 3番目の除外、hibernate-coreモジュールをダウンロードするときにhibernate-hikaricpを除外するようgradleに指示します。これは、HikariCPが非推奨のorg.hibernate.hikaricp.internal.HikariCPConnectionProviderではなくcom.zaxxer.hikari.hibernate.HikariConnectionProviderを接続プロバイダーとして使用するために必要です。

build.gradleと何を保持し、何をしないかを理解したら、datasource構成をapplication.propertiesにコピーして貼り付ける準備ができ、すべてが飛ぶ色で動作することを期待していましたが、実際には次の問題に遭遇しました

• データベースの詳細（つまり、url、ドライバー）を見つけることができず、jpaとhibernateをセットアップできない（プロパティキーの値に正しい名前を付けなかったため）
• com.zaxxer.hikari.hibernate.HikariConnectionProviderにフォールバックするHikariCP
• Hibernate/jpaの自動設定時に新しい接続プロバイダーを使用するようにSpringに指示した後、HikariCPはkey/valueでapplication.propertiesを探していて、dataSource, dataSourceClassName, jdbcUrlについて不平を言っていたため失敗しました。 HikariConfig, HikariConfigurationUtil, HikariCPConnectionProviderをデバッグする必要があり、HikariCPがapplication.propertiesからプロパティを見つけることができないことがわかりました。

とにかく、これは私が試行錯誤に頼り、HikariCPがプロパティ（つまり、データベースの詳細であるデータソース、プーリングプロパティ）を選択できることを確認する必要がある場所であり、Spingブートは期待どおりに動作し、最終的には次のapplication.propertiesファイルを使用します。

server.contextPath=/
debug=true

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

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

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

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

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

上記のように、構成は次の命名パターンに基づいてカテゴリに分けられます

• spring.datasource.x（Spring自動設定はこれらを選択するので、HikariCPも選択します）
• spring.datasource.hikari.x（HikariCPはこれらを選択してプールを設定し、camelCaseフィールド名をメモします）
• spring.jpa.hibernate.connection.provider_class（Springに新しいHibernateConnectionProviderを使用するよう指示します）
• spring.jpa.properties.hibernate.x（SpringがJPAを自動設定するために使用し、アンダースコアでフィールド名を書き留めます）

上記のプロパティファイルの使用方法とプロパティの名前の付け方を示すチュートリアルや投稿、またはリソースに出くわすことは困難です。さて、あなたはそれを持っています。

上記のapplication.propertiesをbuild.gradle（または少なくとも同様の）とともにSpring Boot JPAプロジェクトバージョン（1.5.8）にスローすると、チャームのように機能し、事前に構成されたデータベースに接続します（つまり、私の場合はHikariCP & Springが両方とも使用するデータベースドライバーのspring.datasource.url）。

DataSource Beanを作成する必要はありませんでした。これは、Spring Bootがapplication.propertiesを調べるだけですべてを実行できるためです。

記事 HikariCPのgithubで wiki は、JPAでSpring Bootをセットアップする方法を示していますが、説明と詳細が欠けています。

上記の2つのファイルは、パブリックGistとしても利用可能です https://Gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Answer 4

プロパティ値を変数に設定するための冗長コードは必要ありません。プロパティはプロパティファイルで直接設定できます。

クラスパスに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;
}

Answer 5

これは、ブートアプリケーションに役立ちます。このクラスは、構成オブジェクトが探しているプロパティを示します。

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

Answer 6

@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.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へのフォールバックシーケンスがあります。

Answer 7

ドキュメントによると、変更されています。

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

Answer 8

DataSourceClassNameアプローチを使用できます。これはMySQLの例です。 （スプリングブート1.3および1.4でテスト済み）

まず、hikaricpが優先されるため、Tomcat-jdbcをクラスパスから除外する必要があります。

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

Answer 9

したがって、DB接続の数を除き、HikariCPのほぼすべてのデフォルト設定が機能することがわかりました。 application.propertiesでそのプロパティを設定します。

spring.datasource.maximumPoolSize=20

Andy Wilkinsonは、Spring BootでHikariCPのdataSourceClassName構成アプローチを使用できないことを伝えることができる限り正しいです。

Answer 10

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

Answer 11

ここに朗報があります。現在、HikariCPは、Spring Boot 2.0.0のデフォルトの接続プールです。

スプリングブート2.0.0リリースノート

Spring Boot 2.0のデフォルトのデータベースプーリング技術は、TomcatプールからHikariCPに切り替えられました。 Hakariは優れたパフォーマンスを提供し、多くのユーザーがTomcatプールよりもそれを好むことがわかりました。

Answer 12

私のセットアップ：
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を作成し、必要なプロパティを設定することができます。

注:::
パブリッククラスHikariDataSourceはHikariConfigを拡張します

必要がある

1. 目的の光プロパティを使用して、HikariConfigオブジェクトを設定します
2. コンストラクターに引数として渡されたHikariConfigオブジェクトでHikariDataSourceオブジェクトを初期化します。

独自のカスタム構成クラス（@Configuration）を定義して、独自にデータソースを作成し、別のファイル（従来より：application.properties）

この方法で、Hibernateが推奨する「LocalSessionFactoryBean」クラスを使用して独自のsessionFactory Beanを定義し、Hikari Data Sourceおよびその他のHiberante-JPAベースのプロパティを設定できます。

Spring BootベースのHikari DataSourceプロパティの概要：–

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 =

Answer 13

後のスプリングブートリリースでは、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

基になるDBに合わせてconnectionTestQueryを変更します。それだけです、コードは不要です。

Answer 14

これは、spring auto構成を使用してアプリケーションのhikaricpを構成する場合に役立ちます。私のプロジェクトでは、JDBC接続プールとしてhikaricp、データベースとしてmysqlを使用して、Spring Boot 2を使用しています。他の回答では見られなかったものの1つは、data-source-propertiesでした。これは、spring.datasource.hikari.*パスでは使用できないさまざまなプロパティを設定するために使用できます。これは、HikariConfigクラスを使用するのと同等です。 mysql固有のプロパティのデータソースとhikaricp接続プールを設定するには、application.ymlファイルでspring auto configureアノテーションと次のプロパティを使用しました。

構成Beanファイルの1つに@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