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

92

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
Kevin M.
quelle
Welche Version von Spring Boot verwenden Sie?
Geo und
1.2.0.M1 Ich glaube, ich habe herausgefunden, wie man die Eigenschaften so einstellt, dass Dinge wie MaximumPoolSize für hikariCP festgelegt werden. Ich konnte die Konfiguration jedoch nicht mit der von hikariCP empfohlenen Methode zum Laufen bringen, indem ich dataSourceClassName und serverName anstelle von driverClassName und jdbc url verwendete. Also habe ich diesen Teil aufgegeben. Wenn jemand diesen Teil herausfinden kann, würde das helfen
Kevin M
Ich werde 1.2.0.M1 später ausprobieren, und ich finde heraus, was ich posten werde
Geo und
2
Sie können den dataSourceClassName-Ansatz nicht mit der automatischen Konfiguration einer DataSource durch Spring Boot verwenden, da spring.datasource.url festgelegt werden muss. Beachten Sie, dass Sie driverClassName nicht angeben müssen, da Boot es von jdbcUrl ableitet.
Andy Wilkinson
1
application.properties : spring.datasource.hikari.*, Dokumentation: github.com/brettwooldridge/HikariCP
kinjelom

Antworten:

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

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

Sergey Bulavkin
quelle
1
Ich denke, dies ist ein viel besserer und tragbarerer Ansatz. Prost!
Jesús Zazueta
2
Dies könnte auch für die Standardfederkonfiguration verwendet werden, aber ein Gedanke ist wichtig. Hikari verwendete die URL der Datenquelle über jdbcUrl, aber den Frühling über die URL. {private String url; @Bean public DataSource dataSource () löst SQLException aus {return new HikariDataSource (this); } public String getUrl () {return url; } public void setUrl (String url) {this.url = url; // HikariConfig enthält JDBC-URL in der Eigenschaft jdbcUrl, aber spring stellt diese Eigenschaft als URL bereit this.setJdbcUrl (url); }}
Tomas Hanus
Entschuldigung, dies ist eine etwas späte Antwort, aber die @ Sergey-Lösung sollte leicht geändert werden, um alle Eigenschaften zu erhalten. Um hikari-spezifische DS-Eigenschaften zu erhalten, müssen Sie den Schlüssel als "spring.datasource. DataSourceProperties" anstelle von "spring.datasource.hikari"
festlegen
3
Früher mussten wir nur anhand der Dokumentation der Datenquelle sehen, wie sie konfiguriert ist. Jetzt wurde es schlimmer. Jetzt müssen wir auch wissen, wie sie bei Verwendung von Spring Boot konfiguriert ist. Ich sehe nicht wirklich, dass diese automagische Konfiguration uns wirklich hilft.
Supertonsky
31

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

Raf
quelle
Ich hatte damit zu kämpfen, kurz bevor du gepostet hast. Vielen Dank!
Bogdan Pușcașu
Ich bin froh, dass es dir geholfen hat! 👍
Raf
Raf du hast eine tolle Antwort. Ich war gespannt, ob Sie die für Spring Boot 2.0.0.M6 erforderlichen Änderungen veröffentlichen können. Probleme mit der Konfiguration, die nicht übernommen wird und der Migrationsleitfaden ist noch nicht aktualisiert
Matthew Fontana
Hey Mat, ich habe 1.5.8 Release verwendet, als ich meine Lösung hier geteilt habe. Ich wollte 2.0.0.M6 kurz ausprobieren, aber leider benötigen Sie eine höhere Version von gradle. Die nur ändern , kann ich in 2.0.0.M6 erinnern würde HikariCP Standard Connection Pooling für den Frühling werden machen JPA siehe hier github.com/spring-projects/spring-boot/commit/... Versuchen Debuggen HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider zu vergewissern , dass Eigenschaften wird abgeholt.
Raf
26

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

user3544765
quelle
Sie müssen den Tomcat nicht ausschließen, damit dies funktioniert. Das Hinzufügen spring.datasource.typeist ausreichend.
Michael Piefel
3
@ MichaelPiefel Du musst den Ausschluss machen. Das Javadoc von DataSourceBuildersagt: Wenn sich Tomcat, HikariCP oder Commons DBCP im Klassenpfad befinden, wird einer von ihnen ausgewählt (in dieser Reihenfolge zuerst mit Tomcat). Meine Tests bestätigen dies.
Jan Bodnar
1
@JanBodnar:, DataSourceConfigurationdas in der automatischen Konfiguration verwendet wird, hat die Konfigurationen abhängig davon, spring.datasource.typeob es überhaupt eingestellt ist. Also habe ich tomcat-jdbcauf meinem Klassenpfad und benutze immer noch HikariCP als meinen Pool. Meine Tests bestätigen dies. Vielleicht sprechen wir hier über sehr unterschiedliche Spring Boot-Versionen.
Michael Piefel
1
@MichaelPiefel Interessanterweise habe ich es geschafft, es ohne Ausschluss mit der Java-Konfiguration nur mit dem Typ DataSourceBuilder.create () ... (com.zaxxer.hikari.HikariDataSource.class) in Ordnung zu bringen. Mit der Konfiguration in der yaml-Datei hat es bei mir nicht funktioniert. Es muss also einen Haken geben.
Jan Bodnar
14

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

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
Sthita
quelle
9

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;
}
Sanghyun Lee
quelle
8

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
   }
}
Jesús Zazueta
quelle
Es ist. Es ist jedoch leicht in Java zu übersetzen.
Jesús Zazueta
Ja, mir ist jetzt klar, dass ich das tun muss, weil ich jetzt die Metriken konfigurieren möchte. Und die einzige Möglichkeit, die ich sehen kann, besteht darin, mit dieser JavaConfig die Autokonfiguration zu überschreiben. Vielen Dank.
Kevin M
Ja, es hilft! Du bekommst auch meine Opvote ... Ist es groovig? Es ist sehr interessant, es ist wie Javascript :-)
Joao Polo
8

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

ydemartino
quelle
8

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.

Shahid Yousuf
quelle
1
Dies war super hilfreich, obwohl ich einige Eigenschaftsnamen herausfinden musste, die hier nicht erwähnt wurden, wie stringType, um Datenquellen-Requisiten zu konfigurieren.
comiventor
Gut zu wissen, dass es geholfen hat.
Shahid Yousuf
7

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
patelb
quelle
Diese Antwort ist wertvoll, um ein funktionierendes Beispiel mit Datenquelleneigenschaften bereitzustellen!
Mauro Molinari
6

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.

Leventunver
quelle
5

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.

Kevin M.
quelle
2
Ich benutze HikariCP seit einiger Zeit in verschiedenen Anwendungen und hatte bisher nie Probleme. Ich verwende den HikariConfig-Ansatz, bei dem Sie Ihre gesamte Konfiguration in einer Eigenschaftendatei haben. Funktioniert wie erwartet auch mit SpringBoot und SpringCore. Ich konfiguriere auch die maximumPoolSize.
Davi Alves
Dies sollte der Fall sein, spring.datasource.maximum-pool-sizewenn Sie Spring-Konfigurationseigenschaften verwenden. Andernfalls maximumPoolSizewird der HikariCP-Parametername verwendet.
sura2k
3

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 =

Philip Dilip
quelle
spring.datasource.hikari.maximum-pool-size = 500 wirklich schrecklich und es wird von hikari nicht empfohlen :) github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing
mertaksu
Das war nur eine Beispielkonfiguration mit Werten :)
Philip Dilip
2

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.

Andy Brown
quelle
2

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();
    }
}
Nagendra Babu
quelle
1

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

CelinHC
quelle