Jak skonfigurować HikariCP w mojej aplikacji Spring Boot w moich plikach application.properties?

Próbuję skonfigurować HikariCP w mojej aplikacji Spring Boot (1.2.0.M1), aby móc przetestować, używając go zamiast Tomcat DBCP. Chciałbym skonfigurować pulę połączeń w moim pliku application.properties, tak jak robiłem to z Tomcat, ale nie wiem, jak mam to zrobić. Wszystkie znalezione przeze mnie przykłady pokazują styl JavaConfig lub osobny plik właściwości HikariCP. Czy ktoś może mi pomóc w ustaleniu nazw właściwości, aby skonfigurować je w application.properties? Chciałbym również przełączyć się z używania podejścia driverClassName na podejście DataSourceClassName, ponieważ wygląda to bardziej przejrzysto i jest zalecane. Czy jest to również możliwe w moich plikach application.properties?

Oto, co miałem dla Tomcat DBCP (tylko podstawowa konfiguracja, nie do końca wypłukana)

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

Obecnie używam driverClassName i jdbc url do skonfigurowania połączenia:

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

AKTUALIZACJA! Od wersji Spring Boot 1.3.0 :

1. Po prostu dodaj HikariCP do zależności
2. Skonfiguruj plik 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

AKTUALIZACJA! Od wersji Spring Boot 2.0.0 :

Domyślna pula połączeń zmieniła się z Tomcat na Hikari :)

Natknąłem się HikariCPi byłem zdumiony testami porównawczymi i chciałem go wypróbować zamiast mojego domyślnego wyboru C3P0i ku mojemu zdziwieniu walczyłem, aby uzyskać configurationswłaściwą, prawdopodobnie dlatego, że konfiguracje różnią się w zależności od kombinacji stosu technologicznego, którego używasz.

Mam Spring Bootprojekt instalacyjny ze JPA, Web, Securitystarterami (przy użyciu Spring Initializer ) do wykorzystania PostgreSQLjako baza danych HikariCPjako pule połączeń.
Użyłem Gradlejako narzędzia do budowania i chciałbym podzielić się tym, co zadziałało dla mnie przy następujących założeniach:

1. Spring Boot Starter JPA (Internet i zabezpieczenia - opcjonalnie)
2. Kompilacja Gradle też
3. Uruchomienie PostgreSQL i konfiguracja z bazą danych (tj. Schemat, użytkownik, baza danych)

Potrzebujesz następujących elementów, build.gradlejeśli używasz Gradlelub odpowiednika, pom.xmljeśli używasz maven

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

W powyższym jest kilka wykluczeń, build.gradlea to dlatego, że

1. Najpierw wyklucz, instruuje gradle, że jdbc-tomcatpodczas pobierania spring-boot-starter-data-jpazależności wyklucza pulę połączeń . Można to osiągnąć, konfigurując spring.datasource.type=com.zaxxer.hikari.HikariDataSourcerównież, ale nie chcę dodatkowej zależności, jeśli jej nie potrzebuję
2. Drugie wykluczanie instruuje gradle, aby wykluczył zależność hibernate-corepodczas pobierania, com.zaxxera to dlatego, że hibernate-corezostało już pobrane przez Spring Booti nie chcemy mieć różnych wersji.
3. Trzecie wykluczanie, instruuje gradle, aby wykluczył hibernate-corepodczas pobierania hibernate-hikaricpmodułu, który jest potrzebny, aby HikariCP był używany org.hibernate.hikaricp.internal.HikariCPConnectionProviderjako dostawca połączenia, zamiast być przestarzałymcom.zaxxer.hikari.hibernate.HikariConnectionProvider

Kiedy już zorientowałem się, build.gradleco zachować, a czego nie, byłem gotowy do skopiowania / wklejenia datasourcekonfiguracji do mojej application.propertiesi spodziewałem się, że wszystko będzie działać śpiewająco, ale nie do końca i natknąłem się na następujące problemy

• Podczas rozruchu wiosennego nie udało się znaleźć szczegółów bazy danych (tj. Adresu URL, sterownika), w związku z czym nie można skonfigurować jpa i hibernacji (ponieważ nie nadałem właściwej nazwy wartości klucza właściwości)
• HikariCP cofa się do com.zaxxer.hikari.hibernate.HikariConnectionProvider
• Po poinstruowaniu Springa, aby używał nowego dostawcy połączenia podczas automatycznej konfiguracji hibernacji / jpa, HikariCP zawiódł, ponieważ szukał niektórych key/valuew application.propertiesi narzekał dataSource, dataSourceClassName, jdbcUrl. Musiałem przeprowadzić debugowanie HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvideri okazało się, że HikariCPnie mogę znaleźć właściwości, application.propertiesponieważ zostały one nazwane inaczej.

W każdym razie w tym miejscu musiałem polegać na próbach i błędach i upewnić się, że HikariCPjest w stanie wybrać właściwości (tj. Źródło danych, które jest szczegółami bazy danych, a także właściwościami puli), a także Sping Boot zachowuje się zgodnie z oczekiwaniami i skończyło się na następujący application.propertiesplik.

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 

Jak pokazano powyżej, konfiguracje są podzielone na kategorie w oparciu o następujące wzorce nazewnictwa

• spring.datasource.x (automatyczna konfiguracja Springa wybierze te, więc HikariCP)
• spring.datasource.hikari.x (HikariCP wybiera je do konfiguracji puli, zanotuj nazwy pól camelCase)
• spring.jpa.hibernate.connection.provider_class ( instruuje Spring, aby używał nowego HibernateConnectionProvider)
• spring.jpa.properties.hibernate.x (używany przez Spring do automatycznej konfiguracji JPA, zanotuj nazwy pól z podkreśleniami)

Trudno znaleźć samouczek, post lub jakiś zasób, który pokazuje, jak używany jest powyższy plik właściwości i jak należy nazywać właściwości. Cóż, masz to.

Rzucanie wyżej application.propertiesz build.gradle(lub przynajmniej podobny) do wersji projektu Wiosna Boot JPA (1.5.8) powinien działać jak czar i połączyć się z bazą danych wstępnie skonfigurowana (czyli w moim przypadku jest to, że zarówno PostgreSQL HikariCP & Springpostać się od spring.datasource.url, na którym sterownik bazy danych do użycia).

Nie widziałem potrzeby tworzenia DataSourcefasoli, a to dlatego, że Spring Boot jest w stanie zrobić dla mnie wszystko, po prostu zaglądając application.propertiesi to jest fajne.

Artykuł w GitHub HikariCP za wiki pokazuje sposób konfiguracji wiosennego rozruchu z JPA, ale brakuje wyjaśnień i szczegółów.

Powyższe dwa pliki są również dostępne jako publiczna treść https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Możesz po prostu użyć tylko pliku application.yml / application.properties. Nie ma potrzeby jawnego tworzenia DataSourcefasoli

Musisz wykluczyć tomcat-jdbc, o czym wspomniał ydemartino

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

Ponieważ nie utworzysz DataSourcefasoli, musisz jawnie określić użycie Hikari spring.datasource.typez wartością com.zaxxer.hikari.HikariDataSourcew application.yml / application.properties

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

W pliku application.yml / application.properties można skonfigurować specyficzne parametry Hikari, takie jak rozmiar puli itp spring.datasource.hikari.*

Używam Spring Boot 2.0.4.RELEASE. Hikari to domyślna pula połączeń i .hikarinie jest już potrzebna.

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

I configurationnie trzeba przedłużyć HikariConfig, i DataSourceBuildermogą być używane jak to było wcześniej.

@Configuration
public class DataSourceConfiguration {

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

Zgodnie z dokumentacją to się zmienia,

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

Przykład:

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

Są to następujące zmiany konfiguracji, które możemy wprowadzić na hikari, dodaj / zaktualizuj zgodnie z potrzebami.

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

Nie potrzebujesz dodatkowego kodu do umieszczania wartości właściwości w zmiennych. Właściwości można ustawić bezpośrednio za pomocą pliku właściwości.

Umieść hikari.propertiesplik w ścieżce klas.

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

I stwórz fasolę źródła danych w ten sposób.

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

    return dataSource;
}

Działa to w przypadku mojej aplikacji rozruchowej na wypadek, gdyby to pomogło. Ta klasa informuje, jakich właściwości szuka obiekt konfiguracyjny:

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

Myślę, że wiele datasource_whateverźródeł danych może być obsługiwanych przez dodanie do kluczy właściwości w źródłowym pliku konfiguracyjnym. Twoje zdrowie!

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

Możesz użyć podejścia dataSourceClassName, oto przykład z MySQL. (Testowane z butem sprężynowym 1.3 i 1.4)

Najpierw musisz wykluczyć tomcat-jdbc ze ścieżki klas, ponieważ zostanie on wybrany na korzyść 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

Następnie po prostu dodaj

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

Stworzyłem projekt testowy tutaj: https://github.com/ydemartino/spring-boot-hikaricp

nie można używać podejścia dataSourceClassName w konfiguracjach application.properties, jak powiedział @Andy Wilkinson. jeśli mimo wszystko chcesz mieć dataSourceClassName, możesz użyć Java Config jako:

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

powód, dla którego nie możesz użyć dataSourceClassName, ponieważ spowoduje zgłoszenie i wyjątek

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

co oznacza, że ​​rozruch sprężynowy wnioskuje z właściwości spring.datasource.url Driver i jednocześnie ustawienie dataSourceClassName tworzy ten wyjątek. Aby to naprawić, twoja application.properties powinna wyglądać mniej więcej tak dla źródła danych 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

Uwaga: Sprawdź, czy w Twojej ścieżce klas znajduje się jakikolwiek tomcat-jdbc.jar lub commons-dbcp.jar dodawany najczęściej przez zależność przechodnią. Jeśli są one obecne w ścieżce klasy, Spring Boot skonfiguruje źródło danych przy użyciu domyślnej puli połączeń, którą jest tomcat. HikariCP będzie używany tylko do tworzenia źródła danych, jeśli w ścieżce klas nie ma innego dostawcy. istnieje sekwencja awaryjna z tomcat -> do HikariCP -> do Commons DBCP.

Pomoże to każdemu, kto chce skonfigurować hikaricp do swojej aplikacji z automatyczną konfiguracją wiosny. W moim projekcie używam spring boot 2 z hikaricp jako pulą połączeń JDBC i mysql jako bazą danych. Jedną rzeczą, której nie widziałem w innych odpowiedziach, było to, data-source-propertiesco można wykorzystać do ustawienia różnych właściwości, które nie są dostępne na spring.datasource.hikari.*ścieżce. Jest to równoważne użyciu HikariConfigklasy. Aby skonfigurować źródło danych i pulę połączeń hikaricp dla właściwości specyficznych dla mysql, użyłem adnotacji spring auto configure i następujących właściwości w pliku application.yml.

Umieść @EnableAutoConfigurationna jednym z plików konfiguracyjnych bean.

plik application.yml może wyglądać następująco.

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

Oto dobra wiadomość. HikariCP jest teraz domyślną pulą połączeń w Spring Boot 2.0.0.

Informacje o wydaniu Spring Boot 2.0.0

Domyślna technologia buforowania baz danych w Spring Boot 2.0 została zmieniona z Tomcat Pool na HikariCP. Odkryliśmy, że Hakari oferuje doskonałą wydajność i wielu naszych użytkowników woli go od Tomcat Pool.

Okazuje się więc, że prawie wszystkie ustawienia domyślne dla HikariCP działają u mnie poza liczbą połączeń DB. Ustawiłem tę właściwość w mojej application.properties:

spring.datasource.maximumPoolSize=20

Andy Wilkinson ma rację, o ile mogę powiedzieć, że nie można użyć podejścia konfiguracyjnego dataSourceClassName dla HikariCP ze Spring Boot.

My SetUp:
Spring Boot v1.5.10
Hikari v.3.2.x (do oceny)

Aby naprawdę zrozumieć konfigurację źródła danych Hikari, zalecam wyłączenie automatycznej konfiguracji Spring Boot dla źródła danych.

Dodaj do application.properties:

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

Spowoduje to wyłączenie możliwości Spring Boot do samodzielnego konfigurowania źródła danych.

Teraz masz szansę zdefiniować własną konfigurację niestandardową w celu utworzenia komponentu bean HikariDataSource i wypełnienia go żądanymi właściwościami.

UWAGA :::
klasa publiczna HikariDataSource rozszerza HikariConfig

Musisz

1. wypełnij obiekt HikariConfig przy użyciu żądanych właściwości Hikari
2. zainicjuj obiekt HikariDataSource za pomocą obiektu HikariConfig przekazanego jako argument do konstruktora.

Wierzę w zdefiniowanie własnej klasy konfiguracji niestandardowej (@Configuration), aby samodzielnie utworzyć źródło danych i wypełnić je właściwościami źródła danych zdefiniowanymi w osobnym pliku (niż tradycyjny: application.properties).

W ten sposób mogę zdefiniować własne SessionFactory Bean przy użyciu Hibernate zaleca: klasę „LocalSessionFactoryBean” i wypełnij ją swoim Hikari Data Source> i innymi właściwościami opartymi na Hiberante-JPA.

Podsumowanie właściwości źródła danych Hikari opartych na rozruchu sprężynowym: -

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

W późniejszych wersjach Spring-Boot przejście na Hikari może odbywać się całkowicie w konfiguracji. Używam 1.5.6.RELEASEi to podejście działa.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

aplikacja YAML

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

Zmień, connectionTestQueryaby dopasować bazową bazę danych. To wszystko, kod nie jest wymagany.

Poniższy kod może służyć do inicjalizacji statycznego źródła danych.

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

Miałem problemy, a problemem był biały znak na końcuspring.datasource.type = com.zaxxer.hikari.HikariDataSource