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


94

Spring Boot(1.2.0.M1)アプリでHikariCPをセットアップして、TomcatDBCPの代わりに使用してテストできるようにしようとしています。Tomcatで行っていたようにapplication.propertiesファイルで接続プールを構成したいのですが、どのように行うべきかわかりません。私が見つけたすべての例は、JavaConfigスタイル、または別のHikariCPプロパティファイルの使用を示しています。誰かが私がapplication.propertiesでそれを構成するためにプロパティ名を理解するのを手伝ってもらえますか?また、見た目がすっきりしていて推奨されているため、driverClassNameアプローチの使用からDataSourceClassNameアプローチの使用に切り替えたいと思います。これは私のapplication.propertiesファイルでも可能ですか?

これがTomcatDBCP用に持っていたものです(完全にフラッシュされていない、いくつかの基本的な構成のみ)

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とjdbcurlを使用して接続を設定しています。

spring.datasource.url=jdbc:mysql://localhost:3306/myDb
spring.datasource.driverClassName=com.mysql.jdbc.Driver

どのバージョンのSpringBootを使用していますか?
geoand 2014年

1.2.0.M1hikariCPのmaximumPoolSizeなどを設定するためのプロパティの設定方法を理解したかもしれません。しかし、driverClassNameとjdbc urlの代わりにdataSourceClassNameとserverNameを使用するhikariCP推奨の方法を使用して、構成を機能させることができませんでした。だから私はその部分をあきらめました。誰かがその部分を理解できれば、それは助けになるでしょう
Kevin M

後で1.2.0.M1を試してみますが、投稿するものは何でも見つかります
geoand 2014年

2
Spring.datasource.urlが設定されている必要があるため、SpringBootのデータソースの自動構成でdataSourceClassNameアプローチを使用することはできません。BootはjdbcUrlから推測するため、driverClassNameを指定する必要はないことに注意してください。
アンディウィルキンソン

1
application.properties :spring.datasource.hikari.*、ドキュメント:github.com/brettwooldridge/HikariCP
kinjelom

回答:


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

更新しました!バージョンSpringBoot 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

更新しました!バージョンSpringBoot 2.0.0以降

デフォルトの接続プールがTomcatからHikariに変更されました:)


1
これははるかに優れた、よりポータブルなアプローチだと思います。乾杯!
ヘスス・Zazueta

2
これは標準のばね構成にも使用できますが、重要だと考えられます。ひかりはjdbcUrl経由でデータソースのURLを使用しましたが、URL経由でスプリングを使用しました。{プライベート文字列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はjdbcUrlプロパティにJDBC-URLを保持しますが、Springはこのプロパティをurl this.setJdbcUrl(url);として提供します。}}
Tomas Hanus 2015

申し訳ありませんが、これは少し遅れた返信ですが、すべてのプロパティを取得するには、@ Sergeyソリューションを少し変更する必要があります。hikari固有のDSプロパティを取得するには、キーを「spring.datasource.hikari」ではなく「spring.datasource.dataSourceProperties」として設定する必要があります
bluelabel 2017年

3
以前は、データソースのドキュメントを見て、どのように構成されているかを確認する必要がありましたが、さらに悪化しました。また、SpringBootを使用するときにどのように構成されているかも知る必要があります。このautomagic構成が本当に私たちを助けているとは思いません。
supertonsky 2018年

31

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

接続プールとしてデータベースとして使用Spring BootするJPA, Web, Securityスターター(Spring Initializerを使用)を使用PostgreSQLしてプロジェクトをセットアップしましたHikariCP
私はGradleビルドツールとして使用しましたが、次の仮定で何がうまくいったかを共有したいと思います。

  1. Spring Boot Starter JPA(Webおよびセキュリティ-オプション)
  2. Gradleビルドも
  3. データベース(つまり、スキーマ、ユーザー、データベース)を使用したPostgreSQLの実行とセットアップ

Mavenを使用している場合build.gradleは以下が必要です。Mavenを使用している場合はGradle同等のものが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. 最初にexcludeし、依存関係をjdbc-tomcatダウンロードするときに接続プールを除外するgradleに指示しますspring-boot-starter-data-jpa。これspring.datasource.type=com.zaxxer.hikari.HikariDataSourceも設定することで実現できますが、必要がなければ追加の依存関係は必要ありません
  2. 2番目の除外は、依存関係をhibernate-coreダウンロードするときに除外するようにgradleに指示します。com.zaxxerこれhibernate-coreは、がすでにダウンロードされてSpring Bootおり、異なるバージョンになってしまうことを望まないためです。
  3. 3番目の除外、HikariCPを非推奨ではなく接続プロバイダーとして使用するために必要なモジュールをhibernate-coreダウンロードするときに除外hibernate-hikaricpするようにgradleに指示しますorg.hibernate.hikaricp.internal.HikariCPConnectionProvidercom.zaxxer.hikari.hibernate.HikariConnectionProvider

build.gradle何を保持し、何を保持しないかを理解したら、datasource構成をコピーして貼り付ける準備ができ、application.propertiesすべてがフライングカラーで機能することを期待していましたが、実際にはそうではなく、次の問題に遭遇しました。

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

とにかく、これは私が試行錯誤に頼らなければならなかった場所でありHikariCP、プロパティ(つまり、データベースの詳細であるデータソースとプールプロパティ)を選択できることを確認し、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 

上に示したように、構成は次の命名パターンに基づいてカテゴリに分類されます

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

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

上記application.propertiesbuild.gradle(または少なくとも同様の)Spring Boot JPAプロジェクトバージョン(1.5.8)に投入すると、魅力のように機能し、事前構成されたデータベースに接続する必要があります(つまり、私の場合、両方HikariCP & Springがそのspring.datasource.url上から理解するのはPostgreSQLです。使用するデータベースドライバ)。

DataSourceBeanを作成する必要性はわかりませんでした。それは、Spring Bootが調べるだけですべてを実行できるためapplication.properties、それはすばらしいことです。

記事HikariCPのgithubのの中のwikiどのようにJPAを使用してセットアップ春ブーツのショーだが、説明や詳細を欠いています。

上記の2つのファイルは、公開の要点としても利用できますhttps://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6


あなたが投稿する直前に私はこれに苦労していました。ありがとうございました!
Bogdan Pușcașu 2017年

お役に立ててうれしいです!👍–
Raf

Rafあなたは素晴らしい答えを持っています。Spring Boot2.0.0.M6に必要な変更を投稿できるかどうか興味がありました。構成が取得されず、移行ガイドがまだ更新されていないことに苦労しています
Matthew Fontana

ちょっとマット、ここでソリューションを共有したとき、私は1.5.8リリースを使用していました。2.0.0.M6を簡単に試してみたかったのですが、残念ながら、より高いバージョンのgradleが必要です。2.0.0.M6で覚えている唯一の変更は、SpringjpaのHikariCPデフォルト接続プールを作成することです。github.com/ spring-projects / spring-boot / commit /を参照して ください…HikariConfig、HikariConfigurationUtil、HikariCPConnectionProviderをデバッグして、次のことを確認してください。プロパティが取得されます。
Raf 2017年

26

あなたは単に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.propertiesspring.datasource.typeで値を使用してHikariを使用して明示的に指定する必要があり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で、プールサイズなどのHikari固有のパラメーターを構成できます。 spring.datasource.hikari.*


これを機能させるためにTomcatを除外する必要はありませんspring.datasource.type。追加するだけで十分です。
Michael Piefel 2016年

3
@MichaelPiefel除外を行う必要があります。のjavadocはDataSourceBuilder次のように述べています。Tomcat、HikariCP、またはCommons DBCPがクラスパス上にある場合、そのうちの1つが選択されます(Tomcatが最初の順序で)。私のテストはこれを確認します。
Jan Bodnar 2017

1
DataSourceConfiguration自動設定で使用される@JanBodnar:は、設定されているspring.datasource.typeかどうかに応じて設定されます。そのtomcat-jdbcため、クラスパスを使用し、HikariCPをプールとして使用しています。私のテストはこれを確認します。たぶん、ここでは非常に異なるSpringBootバージョンについて話しているのでしょう。
Michael Piefel 2017

1
@MichaelPiefel興味深いことに、DataSourceBuilder.create()... type(com.zaxxer.hikari.HikariDataSource.class)を使用するだけで、Java構成を除外せずに正常に実行できました。yamlファイルの設定では、うまくいきませんでした。したがって、いくつかのキャッチが必要です。
Jan Bodnar 2017

15

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

10

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

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

ひかりでできる設定変更は以下のとおりです。必要に応じて追加・更新してください。

autoCommit
connectionTimeout
idleTimeout
maxLifetime
connectionTestQuery
connectionInitSql
validationTimeout
maximumPoolSize
poolName
allowPoolSuspension
readOnly
transactionIsolation
leakDetectionThreshold

9

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

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

8

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

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に簡単に翻訳できます。
ヘスス・Zazueta

ええ、メトリックを構成したいので、これを行う必要があることに気づきました。そして、それを行うために私が見ることができる唯一の方法は、このJavaConfigを使用して自動構成をオーバーライドすることです。ありがとう。
ケビンM

はい、役に立ちます!あなたも私の反対を得る...それはグルービーですか?それは非常に興味深いです、それはjavascriptのようなものです:-)
Joao Polo

8

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


8

@Andy Wilkinsonが言ったように、application.properties構成でdataSourceClassNameアプローチを使用することはできません。とにかくdataSourceClassNameが必要な場合は、JavaConfigを次のように使用できます。

@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があるかどうかを確認してください。これらがクラスパスに存在する場合、SpringBootはデフォルトの接続プールであるtomcatを使用してデータソースを構成します。HikariCPは、クラスパスに他のプロバイダーがない場合にのみ、データソースの作成に使用されます。tomcat->からHikariCP-> CommonsDBCPへのフォールバックシーケンスがあります。


1
これは非常に役に立ちましたが、データソースの小道具を構成するためにstringTypeのようにここで言及されていないいくつかのプロパティ名を理解する必要がありました。
comiventor 2018年

それが役に立ったことを知って良かった。
Shahid Yousuf 2018

8

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

@EnableAutoConfiguration構成Beanファイルの1つに配置します。

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

この返信は、data-source-propertiesを使用した実用的な例を提供するのに役立ちます。
マウロ・モリナーリ

6

これが朗報です。HikariCPは、Spring Boot2.0.0のデフォルトの接続プールです。

Spring Boot2.0.0リリースノート

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


5

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

spring.datasource.maximumPoolSize=20

そして、Andy Wilkinsonは、SpringBootでHikariCPのdataSourceClassName構成アプローチを使用できないという点で私が知る限り正しいです。


2
私はHikariCPをさまざまなアプリケーションでしばらく使用してきましたが、これまでのところ問題はありませんでした。私はHikariConfigアプローチを使用しています。このアプローチでは、すべての構成がプロパティファイルにあります。SpringBootおよびSpringCoreでも期待どおりに機能します。また、maximumPoolSizeを構成しています。
Davi Alves

これはspring.datasource.maximum-pool-size、spring configプロパティを使用する場合に使用する必要があります。それ以外の場合maximumPoolSizeは、HikariCPパラメーター名です。
sura2k 2017

3

私のセットアップ:
Spring Boot v1.5.10
Hikari v.3.2.x(評価用)

Hikariデータソースの構成を実際に理解するには、SpringBootのデータソースの自動構成を無効にすることをお勧めします。

application.propertiesに以下を追加します:-

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

これにより、SpringBootが独自にデータソースを構成する機能が無効になります。

今こそ、独自のカスタム構成を定義してHikariDataSource Beanを作成し、必要なプロパティを設定するチャンスです。

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

必要がある

  1. 必要なHikariプロパティを使用してHikariConfigオブジェクトにデータを入力します
  2. コンストラクターに引数として渡されたHikariConfigオブジェクトを使用してHikariDataSourceオブジェクトを初期化します。

独自のカスタム構成クラス(@Configuration)を定義して、独自にデータソースを作成し、別のファイル(従来の:application.propertiesよりも)で定義されたデータソースプロパティを入力することを信じています

。このようにして、独自のデータソースを定義できます。 Hibernateを使用するsessionFactoryBean推奨:「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-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 .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.datasource.hikari.maximumプールサイズ= 500本当に恐ろしい、それはひかり:)から推奨されていませんgithub.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing
mertaksu

これは、Valuesを使用した構成のサンプルにすぎません:)
PhilipDilip19年

2

後の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基盤となるDBに合わせて変更します。それだけです。コードは必要ありません。


2

以下のコードは、静的データソースの初期化に使用できます。

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

1

私は問題に直面していました、そして問題は終わりの空白でしたspring.datasource.type = com.zaxxer.hikari.HikariDataSource


0

現在、HikcariCpをデフォルトの接続プールとして使用し、新しいバージョンのSpringBootを使用しています。以下に示すように直接実行できます。

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

カスタム値を定義しない場合、デフォルト値は300000であるのに対し、値は600000になります。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.