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

Sie können einfach nur application.yml/application.properties verwenden. Es ist nicht notwendig, DataSource Bean explizit zu erstellen

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

<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 DataSource bean nicht erstellen, müssen Sie explizit die Verwendung von Hikari über spring.datasource.type mit dem Wert com.zaxxer.hikari.HikariDataSource in application.yml/application.properties 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 die Poolgröße usw. in spring.datasource.hikari.* konfigurieren. 

Ich stieß auf HikariCP und war von den Benchmarks erstaunt. Ich wollte es anstelle meiner Standardwahl C3P0 ausprobieren. Zu meiner Überraschung hatte ich Schwierigkeiten, die configurations richtig zu machen, wahrscheinlich, weil die Konfigurationen je nach verwendeter Kombination des Tech-Stacks unterschiedlich sind.

Ich habe Spring Boot-Projekt mit JPA, Web, Security-Startern (Verwenden von Spring Initializer ) eingerichtet, um PostgreSQL als Datenbank mit HikariCP als Verbindungspooling zu verwenden. 
Ich habe Gradle als Build-Tool verwendet und möchte mitteilen, was bei den folgenden Annahmen für mich funktioniert hat: 

1. Spring Boot Starter JPA (Web & Sicherheit - optional) 
2. Gradle auch bauen 
3. PostgreSQL-Ausführung und Einrichtung mit einer Datenbank (d. H. Schema, Benutzer, Datenbank)

Sie benötigen den folgenden build.gradle, wenn Sie Gradle oder einen gleichwertigen pom.xml verwenden, 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'
    }
}

build.gradle enthält eine Reihe von Ausschlüssen 

1. Zuerst ausschließen, weist gradle an, dass der jdbc-Tomcat-Verbindungspool beim Herunterladen der spring-boot-starter-data-jpa-Abhängigkeiten ausgeschlossen wird. Dies kann durch die Einrichtung von spring.datasource.type=com.zaxxer.hikari.HikariDataSource auch erreicht werden, aber ich möchte keine zusätzliche Abhängigkeit, wenn ich sie nicht brauche 
2. Zweitens ausschließen, weist Gradle an, hibernate-core beim Herunterladen von com.zaxxer-Abhängigkeit auszuschließen. Dies liegt daran, dass hibernate-core bereits von Spring Boot heruntergeladen wurde und wir keine verschiedenen Versionen verwenden möchten. 
3. Dritter Ausschluss, weist Gradle an, hibernate-core beim Herunterladen des hibernate-hikaricp-Moduls auszuschließen, das erforderlich ist, damit HikariCP org.hibernate.hikaricp.internal.HikariCPConnectionProvider als Verbindungsanbieter anstelle von veraltetem com.zaxxer.hikari.hibernate.HikariConnectionProvider verwendet. 

Nachdem ich den build.gradle herausgefunden hatte, was ich behalten und was nicht, war ich bereit, eine datasource-Konfiguration in meinen application.properties zu kopieren/einfügen und erwartete, dass alles mit Bravour funktioniert, aber nicht wirklich und ich bin über die folgenden Probleme gestolpert 

• Spring Boot konnte die Datenbankdetails (d. H. URL, Treiber) nicht ermitteln, daher können Sie jpa und den Ruhezustand nicht einrichten (da ich die Eigenschaftenschlüsselwerte nicht richtig benannt habe). 
• HikariCP fällt auf com.zaxxer.hikari.hibernate.HikariConnectionProvider zurück 
• Nach der Anweisung von Spring, einen neuen Verbindungsanbieter für die automatische Konfiguration von hibernate/jpa zu verwenden, schlug HikariCP fehl, weil es nach key/value im application.properties suchte und sich über dataSource, dataSourceClassName, jdbcUrl beschwerte. Ich musste in HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider debuggen und fand heraus, dass HikariCP die Eigenschaften von application.properties nicht finden konnte, da sie anders benannt wurde. 

Auf jeden Fall musste ich mich auf Trial and Error verlassen und sicherstellen, dass HikariCP in der Lage ist, die Eigenschaften auszuwählen (dh Datenquelle mit DB-Details sowie Pooling-Eigenschaften) sowie Sping-Boot-Verhalten wie erwartet und ich landete am Ende mit der folgenden application.properties-Datei. 

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, sind die Konfigurationen basierend auf den folgenden Benennungsmustern in Kategorien unterteilt 

• spring.datasource.x (Spring Auto-configure wählt diese aus, HikariCP ebenfalls)
• spring.datasource.hikari.x (HikariCP wählt diese aus, um den Pool einzurichten, notieren Sie 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 zur automatischen Konfiguration von JPA verwendet, notieren Sie sich die Feldnamen mit Unterstrichen.) 

Es ist schwierig, ein Tutorial oder einen Beitrag oder eine Ressource zu finden, die zeigt, wie die oben genannte Eigenschaftendatei verwendet wird und wie die Eigenschaften benannt werden sollen. Nun, da hast du es. 

Wenn Sie den obigen application.properties mit build.gradle (oder zumindest ähnlich) in eine Spring Boot JPA-Projektversion (1.5.8) werfen, sollte es wie ein Zauber funktionieren und eine Verbindung zu Ihrer vorkonfigurierten Datenbank herstellen (dh in meinem Fall ist es PostgreSQL, von dem beide HikariCP & Spring herausfinden der spring.datasource.url für den zu verwendenden Datenbanktreiber). 

Ich habe nicht die Notwendigkeit gesehen, eine DataSource-Bean zu erstellen, und das liegt daran, dass Spring Boot in der Lage ist, alles für mich zu tun, indem ich einfach in application.properties schaue, und das ist ordentlich. 

Der Artikel in HikariCPs github wiki zeigt, wie Spring Boot mit JPA eingerichtet wird, es fehlen jedoch Erklärungen und Details. 

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

Sie benötigen keinen redundanten Code, um Variablenwerte mit Eigenschaftswerten zu versehen. Sie können Eigenschaften mit einer Eigenschaftendatei direkt festlegen.

Fügen Sie hikari.properties-Datei in den Klassenpfad ein.

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

Und so eine Datasource-Bean erstellen.

@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 sagt Ihnen, 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 von datasource_whatever zu 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 nicht in application.properties-Konfigurationen verwenden, wie von @Andy Wilkinson gesagt. Wenn Sie dennoch dataSourceClassName haben möchten, können Sie Java Config folgendermaßen verwenden:

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

aus diesem Grund können Sie dataSourceClassName nicht verwenden, da eine Ausnahme ausgelöst wird

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

dies bedeutet, dass der Spring-Boot aus der spring.datasource.url -Eigenschaft den Driver ableitet und gleichzeitig mit dem Setzen des dataSourceClassName diese Ausnahme erstellt. Um es richtig zu machen, sollte Ihre application.properties für HikariCP-Datenquelle 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 sich in Ihrem Klassenpfad Tomcat-jdbc.jar oder commons-dbcp.jar befindet, die meistens durch transitive Abhängigkeit hinzugefügt wurden. 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 im Klassenpfad kein anderer Anbieter befindet. Es gibt eine Rückfallsequenz von Tomcat -> zu HikariCP -> zu Commons DBCP.

Sie können den dataSourceClassName-Ansatz verwenden, hier ein Beispiel mit MySQL. (Getestet mit Spring Boot 1.3 und 1.4)

Zuerst müssen Sie Tomcat-jdbc aus dem Klassenpfad ausschließen, da dieser für 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

Laut 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 an hikari vornehmen können. Bitte fügen Sie sie entsprechend Ihren Anforderungen hinzu bzw. aktualisieren Sie sie.

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

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

spring.datasource.maximumPoolSize=20

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

Ich verwende Spring Boot 2.0.4.RELEASE. Hikari ist der Standardverbindungspool und .hikari ist nicht mehr erforderlich.

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 configuration muss HikariConfig nicht erweitern, und DataSourceBuilder kann wie zuvor verwendet werden.

@Configuration
public class DataSourceConfiguration {

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

Hier sind die guten Nachrichten. HikariCP ist jetzt der Standard-Verbindungspool mit Spring Boot 2.0.0.

Spring Boot 2.0.0 Versionshinweise

Die standardmäßige 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 Nutzer bevorzugen es gegenüber dem Tomcat Pool.

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

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

Fügen Sie Folgendes zu application.properties hinzu :-

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

Dadurch wird die Fähigkeit von Spring Boot zur eigenen Konfiguration der DataSource deaktiviert.

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

HINWEIS :::
Die öffentliche Klasse HikariDataSource erweitert HikariConfig

Du musst 

1. hikariConfig-Objekt mit den gewünschten Hikari-Eigenschaften füllen
2. initialisieren Sie das HikariDataSource-Objekt mit einem HikariConfig-Objekt, das als Argument an den Konstruktor übergeben wird.

Ich glaube an die Definition meiner eigenen benutzerdefinierten Konfigurationsklasse ( @Configuration), um die Datenquelle selbst zu erstellen und .__ zu füllen. mit den in einer separaten Datei definierten Datenquelleneigenschaften (als traditional: application.properties)

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

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.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-abfragen = true
spring.datasource.hikari.jdbc-url =
spring.datasource.hikari.leak-detection -eshold =
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 die Umstellung auf Hikari vollständig in der Konfiguration erfolgen. Ich verwende 1.5.6.RELEASE und 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

Ändern Sie connectionTestQuery entsprechend Ihrer zugrunde liegenden Datenbank. Das ist es, kein Code erforderlich.

Dies wird allen helfen, die Hikaricp für ihre Anwendung mit der automatischen Frühjahrskonfiguration konfigurieren möchten. Für mein Projekt verwende ich Spring Boot 2 mit Hikaricp als JDBC-Verbindungspool und Mysql als Datenbank. Was ich in anderen Antworten nicht gesehen habe, war data-source-properties, mit dem verschiedene Eigenschaften festgelegt werden können, die im spring.datasource.hikari.*-Pfad nicht verfügbar sind. Dies entspricht der Verwendung der Klasse HikariConfig. Um den Datenquellen- und Hikaricp-Verbindungspool für mysql-spezifische Eigenschaften zu konfigurieren, habe ich die Frühjahrskonfiguration zur automatischen Konfiguration und die folgenden Eigenschaften in der Datei application.yml verwendet.

Platzieren Sie @EnableAutoConfiguration in einer Ihrer Konfigurations-Bean-Dateien.

application.yml file kann so 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