Wie konfiguriere ich HikariCP in meiner Spring Boot-App in meinen application.properties-Dateien?

Ich versuche, HikariCP in meiner Spring Boot (1.2.0.M1) -App einzurichten, damit ich es anstelle von Tomcat DBCP testen kann. Ich möchte den Verbindungspool in meiner Datei application.properties wie bei Tomcat konfigurieren, kann aber nicht herausfinden, wie ich das tun soll. Alle gefundenen Beispiele zeigen entweder den JavaConfig-Stil oder die Verwendung einer separaten HikariCP-Eigenschaftendatei. Kann mir jemand helfen, die Eigenschaftsnamen herauszufinden, um sie in application.properties zu konfigurieren? Ich möchte auch von der Verwendung des driverClassName-Ansatzes zum DataSourceClassName-Ansatz wechseln, da dieser sauberer aussieht und empfohlen wird. Ist dies auch in meinen application.properties-Dateien möglich?

Folgendes hatte ich für Tomcat DBCP (nur einige grundlegende Konfigurationen, die nicht vollständig gelöscht wurden)

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

Und ich verwende derzeit driverClassName und jdbc url, um die Verbindung herzustellen:

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

AKTUALISIERT! Seit Version Spring Boot 1.3.0 :

1. Fügen Sie einfach HikariCP zu Abhängigkeiten hinzu
2. Konfigurieren Sie 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

AKTUALISIERT! Seit Version Spring Boot 2.0.0 :

Der Standardverbindungspool wurde von Tomcat zu Hikari geändert :)

Ich HikariCPbin auf die Benchmarks gestoßen und war erstaunt. Ich wollte sie anstelle meiner Standardauswahl ausprobieren. C3P0Zu meiner Überraschung hatte ich Probleme, das configurationsRichtige zu finden, wahrscheinlich weil sich die Konfigurationen je nach verwendeter Kombination von Tech-Stacks unterscheiden.

Ich habe ein Setup- Spring BootProjekt mit JPA, Web, SecurityStartern (Using Spring Initializer ) zur Verwendung PostgreSQLals Datenbank mit HikariCPals Verbindungspooling.
Ich habe Gradleals Build-Tool verwendet und möchte mitteilen, was für mich unter den folgenden Annahmen funktioniert hat:

1. Spring Boot Starter JPA (Web & Sicherheit - optional)
2. Gradle bauen auch
3. PostgreSQL wird ausgeführt und mit einer Datenbank eingerichtet (z. B. Schema, Benutzer, Datenbank).

Sie benötigen Folgendes, build.gradlewenn Sie Maven verwenden, Gradleoder ein gleichwertiges pom.xmlElement, wenn Sie Maven verwenden

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

Es gibt eine Reihe von Ausschlüssen oben build.gradleund das liegt daran

1. Zuerst ausschließen, weist gradle an, den jdbc-tomcatVerbindungspool beim Herunterladen der spring-boot-starter-data-jpaAbhängigkeiten auszuschließen . Dies kann erreicht werden, indem Sie spring.datasource.type=com.zaxxer.hikari.HikariDataSourceauch einrichten. Ich möchte jedoch keine zusätzliche Abhängigkeit, wenn ich sie nicht benötige
2. Zweitens ausschließen, weist gradle an, hibernate-corebeim Herunterladen von com.zaxxerAbhängigkeiten auszuschließen, und das liegt daran, dass hibernate-corees bereits von heruntergeladen wurde Spring Bootund wir nicht mit unterschiedlichen Versionen enden möchten.
3. Drittens weist gradle an, gradle hibernate-corebeim Herunterladen des hibernate-hikaricpModuls auszuschließen, das erforderlich ist, damit HikariCP org.hibernate.hikaricp.internal.HikariCPConnectionProviderals Verbindungsanbieter verwendet wird, anstatt veraltet zu seincom.zaxxer.hikari.hibernate.HikariConnectionProvider

Nachdem ich herausgefunden hatte, build.gradlewas und was ich behalten sollte und was nicht, war ich bereit, eine datasourceKonfiguration in meine zu kopieren / einzufügen application.propertiesund erwartete, dass alles mit Bravour funktioniert, aber nicht wirklich, und ich stieß auf die folgenden Probleme

• Spring Boot konnte die Datenbankdetails (z. B. URL, Treiber) nicht herausfinden und konnte daher jpa und den Ruhezustand nicht einrichten (da ich die Eigenschaftsschlüsselwerte nicht richtig benannt habe).
• HikariCP fällt zurück auf com.zaxxer.hikari.hibernate.HikariConnectionProvider
• Nachdem Spring angewiesen wurde, einen neuen Verbindungsanbieter für die automatische Konfiguration von hibernate / jpa zu verwenden, schlug HikariCP fehl, weil es nach einigen key/valueim Internet suchte application.propertiesund sich darüber beschwerte dataSource, dataSourceClassName, jdbcUrl. Ich musste debuggen HikariConfig, HikariConfigurationUtil, HikariCPConnectionProviderund fand heraus, dass ich HikariCPdie Eigenschaften nicht finden konnte, application.propertiesweil sie anders benannt waren.

Auf HikariCPjeden Fall musste ich mich hier auf Versuch und Irrtum verlassen und sicherstellen, dass die Eigenschaften (dh die Datenquelle, die Datenbankdetails enthält, sowie die Pooling-Eigenschaften) sowie das Sping-Boot-Verhalten sich wie erwartet verhalten die folgende application.propertiesDatei.

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 

Wie oben gezeigt, werden die Konfigurationen basierend auf den folgenden Namensmustern in Kategorien unterteilt

• spring.datasource.x (Spring Auto-Configure wählt diese aus, ebenso HikariCP)
• spring.datasource.hikari.x (HikariCP wählt diese aus, um den Pool einzurichten, notiert sich die Namen der camelCase-Felder)
• spring.jpa.hibernate.connection.provider_class ( Weist Spring an, den neuen HibernateConnectionProvider zu verwenden)
• spring.jpa.properties.hibernate.x (Wird von Spring verwendet, um JPA automatisch zu konfigurieren. Notieren Sie sich die Feldnamen mit Unterstrichen.)

Es ist schwierig, auf ein Tutorial, einen Beitrag oder eine Ressource zu stoßen, die zeigt, wie die obige Eigenschaftendatei verwendet wird und wie die Eigenschaften benannt werden sollten. Nun, da hast du es.

Das oben Genannte application.propertiesmit build.gradle(oder zumindest ähnlich) in eine Spring Boot JPA-Projektversion (1.5.8) zu werfen, sollte wie ein Zauber funktionieren und eine Verbindung zu Ihrer vorkonfigurierten Datenbank herstellen (dh in meinem Fall ist es PostgreSQL, die beide HikariCP & Springherausfinden, spring.datasource.urlauf welcher zu verwendender Datenbanktreiber).

Ich habe nicht die Notwendigkeit gesehen, eine DataSourceBohne zu kreieren , und das liegt daran, dass Spring Boot in der Lage ist, alles für mich zu tun, indem ich nur nachschaue, application.propertiesund das ist ordentlich.

Der Artikel im Github- Wiki von HikariCP zeigt, wie Spring Boot mit JPA eingerichtet wird, es fehlen jedoch Erklärungen und Details.

Die beiden oben genannten Dateien sind auch als öffentlicher Inhalt verfügbar: https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Sie können einfach nur application.yml / application.properties verwenden. Es ist nicht erforderlich, eine DataSourceBean explizit zu erstellen

Sie müssen tomcat-jdbc ausschließen, wie von ydemartino erwähnt

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

Da Sie keine DataSourceBean erstellen , müssen Sie die Verwendung von Hikari spring.datasource.typemit dem Wert com.zaxxer.hikari.HikariDataSourcein application.yml / application.properties explizit angeben

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 Ihrer application.yml / application.properties können Sie Hikari-spezifische Parameter wie Poolgröße usw. in konfigurieren spring.datasource.hikari.*

Ich verwende Spring Boot 2.0.4.RELEASE. Hikari ist der Standardverbindungspool und .hikariwird nicht mehr benötigt.

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

Und configurationmuss nicht erweitert HikariConfigwerden und DataSourceBuilderkann wie bisher verwendet werden.

@Configuration
public class DataSourceConfiguration {

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

Entsprechend der Dokumentation wird es geändert,

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-sql.html

Beispiel:

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

Dies sind die folgenden Konfigurationsänderungen, die wir auf hikari vornehmen können. Bitte fügen Sie sie entsprechend Ihren Anforderungen hinzu / aktualisieren Sie sie.

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

Sie benötigen keinen redundanten Code, um Eigenschaftswerte in Variablen einzufügen. Sie können Eigenschaften mit einer Eigenschaftendatei direkt festlegen.

Legen Sie die hikari.propertiesDatei in den Klassenpfad.

driverClassName=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/myDb
connectionTestQuery=SELECT 1
maximumPoolSize=20
username=...
password=...

Und machen Sie eine Datenquellen-Bean wie diese.

@Bean(destroyMethod = "close")
public DataSource dataSource() throws SQLException {
    HikariConfig config = new HikariConfig("/hikari.properties");
    HikariDataSource dataSource = new HikariDataSource(config);

    return dataSource;
}

Dies funktioniert für meine Boot-Anwendung, falls es hilft. Diese Klasse gibt an, nach welchen Eigenschaften das Konfigurationsobjekt sucht:

https://github.com/brettwooldridge/HikariCP/blob/2.3.x/hikaricp-common/src/main/java/com/zaxxer/hikari/AbstractHikariConfig.java

Ich denke, mehrere Datenquellen könnten durch Hinzufügen datasource_whateverzu den Eigenschaftsschlüsseln in der Quellkonfigurationsdatei unterstützt werden . Prost!

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

Sie können den dataSourceClassName-Ansatz verwenden. Hier ist ein Beispiel für MySQL. (Getestet mit Federmanschette 1.3 und 1.4)

Zuerst müssen Sie tomcat-jdbc vom Klassenpfad ausschließen, da es zugunsten von hikaricp ausgewählt wird.

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

Dann einfach hinzufügen

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

Ich habe hier ein Testprojekt erstellt: https://github.com/ydemartino/spring-boot-hikaricp

Sie können den dataSourceClassName-Ansatz nicht in application.properties-Konfigurationen verwenden, wie von @Andy Wilkinson angegeben. Wenn Sie trotzdem dataSourceClassName haben möchten, können Sie Java Config verwenden als:

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

Grund, warum Sie dataSourceClassName nicht verwenden können, da es eine Ausnahme auslöst

Caused by: java.lang.IllegalStateException: both driverClassName and dataSourceClassName are specified, one or the other should be used.

Dies bedeutet, dass Spring Boot aus der Eigenschaft spring.datasource.url den Treiber ableitet und gleichzeitig durch Festlegen des dataSourceClassName diese Ausnahme erstellt wird. Um es richtig zu machen, sollten Ihre application.properties für die HikariCP-Datenquelle ungefähr so ​​aussehen:

# 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

Hinweis: Bitte überprüfen Sie, ob in Ihrem Klassenpfad Tomcat-jdbc.jar oder commons-dbcp.jar vorhanden ist, die meistens durch transitive Abhängigkeit hinzugefügt werden. Wenn diese im Klassenpfad vorhanden sind, konfiguriert Spring Boot die Datenquelle mithilfe des Standardverbindungspools Tomcat. HikariCP wird nur zum Erstellen der Datenquelle verwendet, wenn sich kein anderer Anbieter im Klassenpfad befindet. Es gibt eine Fallback-Sequenz von Tomcat -> zu HikariCP -> zu Commons DBCP.

Dies hilft jedem, der Hikaricp für seine Anwendung mit Spring Auto Configuration konfigurieren möchte. Für mein Projekt verwende ich Spring Boot 2 mit Hikaricp als JDBC-Verbindungspool und MySQL als Datenbank. Eine Sache, die ich in anderen Antworten nicht gesehen habe, war die data-source-properties, mit der verschiedene Eigenschaften festgelegt werden können, die im spring.datasource.hikari.*Pfad nicht verfügbar sind . Dies entspricht der Verwendung der HikariConfigKlasse. Um die Datenquelle und den Hikaricp-Verbindungspool für MySQL-spezifische Eigenschaften zu konfigurieren, habe ich die Annotation zur automatischen Konfiguration von spring und die folgenden Eigenschaften in der Datei application.yml verwendet.

Platzieren Sie es @EnableAutoConfigurationin einer Ihrer Konfigurations-Bean-Dateien.

application.yml Datei kann folgendermaßen aussehen.

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

Hier sind die guten Nachrichten. HikariCP ist jetzt mit Spring Boot 2.0.0 der Standardverbindungspool.

Versionshinweise zu Spring Boot 2.0.0

Die Standard-Datenbank-Pooling-Technologie in Spring Boot 2.0 wurde von Tomcat Pool auf HikariCP umgestellt. Wir haben festgestellt, dass Hakari eine überlegene Leistung bietet, und viele unserer Benutzer bevorzugen es gegenüber Tomcat Pool.

Es stellt sich also heraus, dass fast alle Standardeinstellungen für HikariCP für mich funktionieren, mit Ausnahme der Anzahl der DB-Verbindungen. Ich habe diese Eigenschaft in meiner application.properties festgelegt:

spring.datasource.maximumPoolSize=20

Und Andy Wilkinson hat Recht, soweit ich das beurteilen kann, dass Sie den Konfigurationsansatz dataSourceClassName für HikariCP mit Spring Boot nicht verwenden können.

Mein SetUp:
Spring Boot v1.5.10
Hikari v.3.2.x (zur Auswertung)

Um die Konfiguration der Hikari-Datenquelle wirklich zu verstehen, empfehle ich, die automatische Konfiguration für die Datenquelle von Spring Boot zu deaktivieren.

Fügen Sie application.properties Folgendes hinzu:

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

Dadurch wird die Fähigkeit von Spring Boot deaktiviert, die DataSource selbst zu konfigurieren.

Jetzt haben Sie die Möglichkeit, Ihre eigene benutzerdefinierte Konfiguration zu definieren, um eine HikariDataSource-Bean zu erstellen und diese mit den gewünschten Eigenschaften zu füllen.

HINWEIS :::
öffentliche Klasse HikariDataSource erweitert HikariConfig

Du musst

1. Füllen Sie das HikariConfig-Objekt mit den gewünschten Hikari-Eigenschaften
2. Initialisieren Sie das HikariDataSource-Objekt mit dem HikariConfig-Objekt, das als Argument an den Konstruktor übergeben wurde.

Ich glaube daran, meine eigene benutzerdefinierte Konfigurationsklasse (@Configuration) zu definieren, um die Datenquelle selbst zu erstellen und sie mit den Datenquelleneigenschaften zu füllen , die in einer separaten Datei definiert sind (als herkömmlich: application.properties).

Auf diese Weise kann ich meine eigene definieren sessionFactory Bean mit Hibernate empfohlen: Klasse "LocalSessionFactoryBean" und füllen Sie sie mit Ihrer Hikari-Datenquelle> und anderen Hiberante-JPA-basierten Eigenschaften.

Zusammenfassung der Spring Boot-basierten Hikari DataSource-Eigenschaften: -

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. Verbindungstestabfrage =
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-Erkennung-Schwelle =
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 =

Mit den späteren Spring-Boot-Releases kann der Wechsel zu Hikari vollständig in der Konfiguration erfolgen. Ich benutze 1.5.6.RELEASEund dieser Ansatz funktioniert.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

Anwendung YAML

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      idleTimeout: 60000
      minimumIdle: 2
      maximumPoolSize: 20
      connectionTimeout: 30000
      poolName: MyPoolName
      connectionTestQuery: SELECT 1

Passen Sie es connectionTestQueryan Ihre zugrunde liegende Datenbank an. Das war's, kein Code erforderlich.

Der folgende Code kann für eine statische Datenquelleninitialisierung verwendet werden.

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

Ich hatte Probleme und das Problem war ein Leerzeichen am Ende vonspring.datasource.type = com.zaxxer.hikari.HikariDataSource