Spring Boot uygulamamda HikariCP'yi application.properties dosyalarımda nasıl yapılandırabilirim?

Question 1

HikariCP'yi Spring Boot (1.2.0.M1) uygulamamda kurmaya çalışıyorum, böylece Tomcat DBCP yerine kullanmayı test edebilirim. Tomcat ile yaptığım gibi application.properties dosyamdaki bağlantı havuzunu yapılandırmak istiyorum, ancak bunu nasıl yapmam gerektiğini anlayamıyorum. Bulduğum tüm örnekler ya JavaConfig stilini gösteriyor ya da ayrı bir HikariCP özellikler dosyası kullanıyor. Biri application.properties dosyasında bunu yapılandırmak için özellik adlarını bulmama yardımcı olabilir mi? Ayrıca daha temiz göründüğü ve önerildiği için driverClassName yaklaşımını kullanmaktan DataSourceClassName yaklaşımına geçmek istiyorum. Bu, application.properties dosyalarımda da mümkün mü?

İşte Tomcat DBCP için sahip olduğum şeyler (sadece bazı temel yapılandırmalar, tamamen temizlenmemiş)

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

Ve şu anda bağlantıyı kurmak için driverClassName ve jdbc url kullanıyorum:

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

Question 2

@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

GÜNCELLENMİŞ! Spring Boot 1.3.0 sürümünden beri :

HikariCP'yi bağımlılıklara eklemeniz yeterli
Application.yml'yi yapılandırın

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

GÜNCELLENMİŞ! Spring Boot 2.0.0 sürümünden beri :

Varsayılan bağlantı havuzu Tomcat'ten Hikari'ye değiştirildi :)

Question 3

Karşılaştım HikariCPve kıyaslamalara hayran kaldım ve varsayılan seçimim yerine denemek istedim C3P0ve şaşkınlıkla configurationsdoğruyu bulmakta zorlandım çünkü konfigürasyonlar kullandığınız teknoloji yığını kombinasyonuna göre farklılık gösteriyor.

Bağlantı havuzu olarak bir veritabanı olarak kullanmak Spring Bootiçin JPA, Web, Securitybaşlatıcılarla ( Spring Initializer Kullanarak ) kurulum projem var . Oluşturma aracı olarak kullandım ve aşağıdaki varsayımlar için benim için neyin işe yaradığını paylaşmak istiyorum:PostgreSQLHikariCP
Gradle

Spring Boot Starter JPA (Web ve Güvenlik - isteğe bağlı)
Gradle inşa et
PostgreSQL çalıştırma ve bir veritabanı ile kurulum (yani şema, kullanıcı, db)

Maven build.gradlekullanıyorsanız Gradleveya eşdeğeri kullanıyorsanız aşağıdakilere ihtiyacınız varpom.xml

buildscript {
    ext {
        springBootVersion = '1.5.8.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'

group = 'com'
version = '1.0'
sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    compile('org.springframework.boot:spring-boot-starter-aop')

    // Exclude the tomcat-jdbc since it's used as default for connection pooling
    // This can also be achieved by setting the spring.datasource.type to HikariCP 
    // datasource see application.properties below
    compile('org.springframework.boot:spring-boot-starter-data-jpa') {
        exclude group: 'org.apache.tomcat', module: 'tomcat-jdbc'
    }
    compile('org.springframework.boot:spring-boot-starter-security')
    compile('org.springframework.boot:spring-boot-starter-web')
    runtime('org.postgresql:postgresql')
    testCompile('org.springframework.boot:spring-boot-starter-test')
    testCompile('org.springframework.security:spring-security-test')

    // Download HikariCP but, exclude hibernate-core to avoid version conflicts
    compile('com.zaxxer:HikariCP:2.5.1') {
        exclude group: 'org.hibernate', module: 'hibernate-core'
    }

    // Need this in order to get the HikariCPConnectionProvider
    compile('org.hibernate:hibernate-hikaricp:5.2.11.Final') {
        exclude group: 'com.zaxxer', module: 'HikariCP'
        exclude group: 'org.hibernate', module: 'hibernate-core'
    }
}

Yukarıda bir grup dışlama build.gradlevar ve bunun nedeni

İlk dışlama, bağımlılıkları jdbc-tomcatindirirken bağlantı havuzunu dışlayan gradle'a talimat verir spring-boot-starter-data-jpa. Bu aynı zamanda kurarak da sağlanabilir, spring.datasource.type=com.zaxxer.hikari.HikariDataSourceancak ihtiyacım yoksa fazladan bir bağımlılık istemiyorum
İkinci hariç tutma, gradle'a bağımlılığı hibernate-coreindirirken dışarıda bırakma talimatı verir com.zaxxerve bunun nedeni hibernate-core, tarafından zaten indirilmiş olmasıdır Spring Bootve farklı sürümlerle sonuçlanmak istemiyoruz.
Üçüncü talimatını dışlamak gradle, dışlamak hibernate-coreindirirken hibernate-hikaricpHikariCP faydalanmak amacıyla ihtiyaç duyulan modül org.hibernate.hikaricp.internal.HikariCPConnectionProviderbağlantı sağlayıcı olarak yerine kullanımdan kaldırılmıştırcom.zaxxer.hikari.hibernate.HikariConnectionProvider

build.gradleNeyi saklayıp neyi saklamayacağımı anladıktan sonra , bir datasourcekonfigürasyonu kopyalayıp yapıştırmaya hazırdım application.propertiesve her şeyin uçan renklerle çalışmasını bekliyordum ama gerçekten değil ve aşağıdaki sorunlara rastladım.

Spring boot veritabanı ayrıntılarını (ör. Url, sürücü) bulamıyor, bu nedenle jpa ve hazırda bekletme kurulamıyor (çünkü özellik anahtar değerlerini doğru adlandırmadım)
HikariCP geri dönüyor com.zaxxer.hikari.hibernate.HikariConnectionProvider
Bahar talimat için yeni bağlantı-sağlayıcısını kullanmak üzere sonra zaman otomatik yapılandıran hazırda / JPA bazı arıyordu çünkü o HikariCP başarısız key/valueiçinde application.propertiesve yaklaşık şikayetçi oldu dataSource, dataSourceClassName, jdbcUrl. Hata ayıklamak zorunda kaldım HikariConfig, HikariConfigurationUtil, HikariCPConnectionProviderve farklı adlandırıldığı HikariCPiçin özelliklerin bulunamadığını öğrendim application.properties.

Her neyse, burası deneme yanılma HikariCPyöntemine güvenmem ve özellikleri seçebildiğimden emin olmam gerektiğidir (yani veri kaynağı db ayrıntıları ve havuz özellikleri) ve Sping Boot beklendiği gibi davranıyor ve sonuçta aşağıdaki application.propertiesdosya.

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

Yukarıda gösterildiği gibi konfigürasyonlar aşağıdaki adlandırma modellerine göre kategorilere ayrılmıştır.

spring.datasource.x (İlkbahar otomatik yapılandırması bunları seçecek, HikariCP de seçecektir)
spring.datasource.hikari.x (HikariCP havuzu kurmak için bunları seçer, camelCase alan adlarını not edin)
spring.jpa.hibernate.connection.provider_class ( Spring'e yeni HibernateConnectionProvider'ı kullanma talimatı verir)
spring.jpa.properties.hibernate.x (Spring tarafından, JPA'yı otomatik olarak yapılandırmak için kullanılır, alan adlarını alt çizgili olarak not edin)

Yukarıdaki özellikler dosyasının nasıl kullanıldığını ve özelliklerin nasıl adlandırılması gerektiğini gösteren bir öğretici veya gönderiye veya bazı kaynaklara rastlamak zordur. İşte orada var.

Yukarıda Fırlatma application.propertiesile build.gradle(veya benzer en azından) bir bahar Boot JPA proje sürümü (1.5.8) içine Acayip işe ve önceden yapılandırılmış veritabanına bağlanmak gerekir (yani benim durumumda 's PostgreSQL o hem HikariCP & Springdışarı rakam spring.datasource.urlhangi veritabanı sürücüsü).

DataSourceFasulye yaratma ihtiyacını görmedim ve bunun nedeni Spring Boot'un sadece içine bakarak benim için her şeyi yapabilmesi application.propertiesve bu harika.

Makale HikariCP en github içinde wiki nasıl kurulum Bahar JPA Boot ancak bunlarla gösterileri açıklama ve ayrıntıları yoksundur.

Yukarıdaki iki dosya aynı zamanda genel bir öz olarak da mevcuttur https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Question 4

Yalnızca application.yml / application.properties öğesini kullanabilirsiniz. Açıkça herhangi bir DataSourceBean oluşturmaya gerek yoktur

Ydemartino tarafından belirtildiği gibi tomcat-jdbc'yi hariç tutmanız gerekir

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

DataSourceFasulye oluşturmayacağınız için , Hikari'yi application.yml / application.properties dosyasındaki spring.datasource.typedeğerle açıkça belirtmeniz gerekir.com.zaxxer.hikari.HikariDataSource

spring:
    datasource:
        hikari:
            connection-test-query: SELECT 1 FROM DUAL
            minimum-idle: 1
            maximum-pool-size: 5
            pool-name: yourPoolName
            auto-commit: false
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/myDb
        username: login
        password: password
        type: com.zaxxer.hikari.HikariDataSource

Application.yml / application.properties dosyanızda, Hikari'ye özel parametreler, örneğin havuz boyutu vb. spring.datasource.hikari.*

Question 5

Spring Boot 2.0.4.RELEASE kullanıyorum. Hikari varsayılan bağlantı havuzudur ve .hikariartık gerekli değildir.

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

Ve configurationuzatılmasına gerek yoktur HikariConfigve DataSourceBuilderdaha önce olduğu gibi kullanılabilir.

@Configuration
public class DataSourceConfiguration {

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

Question 6

Belgelere göre değiştirilir,

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

Misal :

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

Hikari'de yapabileceğimiz aşağıdaki yapılandırma değişiklikleri, lütfen ihtiyacınıza göre ekleyin / güncelleyin.

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

Question 7

Özellik değerlerini değişkenlere koymak için yedek koda ihtiyacınız yoktur. Özellikleri doğrudan bir özellikler dosyasıyla ayarlayabilirsiniz.

hikari.propertiesDosyayı sınıf yoluna koyun .

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

Ve bunun gibi bir veri kaynağı çekirdeği yapın.

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

    return dataSource;
}

Question 8

Bu, yardımcı olması durumunda önyükleme uygulamam için çalışır. Bu sınıf, yapılandırma nesnesinin hangi özellikleri aradığını söyler:

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

datasource_whateverKaynak yapılandırma dosyasındaki özellik anahtarlarına ekleyerek birden fazla veri kaynağının desteklenebileceğini düşünüyorum . Şerefe!

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

Question 9

DataSourceClassName yaklaşımını kullanabilirsiniz, işte MySQL ile bir örnek. (1.3 ve 1.4 yaylı körük ile test edilmiştir)

Hikaricp lehine seçileceği için önce tomcat-jdbc'yi sınıf yolundan çıkarmanız gerekir.

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

O zaman sadece ekle

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

Burada bir test projesi oluşturdum: https://github.com/ydemartino/spring-boot-hikaricp

Question 10

@Andy Wilkinson'ın söylediği gibi application.properties yapılandırmalarında dataSourceClassName yaklaşımını kullanamazsınız. yine de dataSourceClassName'e sahip olmak istiyorsanız Java Config'i şu şekilde kullanabilirsiniz:

@Configuration
@ComponentScan
class DataSourceConfig {

 @Value("${spring.datasource.username}")
private String user;

@Value("${spring.datasource.password}")
private String password;

@Value("${spring.datasource.url}")
private String dataSourceUrl;

@Value("${spring.datasource.dataSourceClassName}")
private String dataSourceClassName;

@Value("${spring.datasource.poolName}")
private String poolName;

@Value("${spring.datasource.connectionTimeout}")
private int connectionTimeout;

@Value("${spring.datasource.maxLifetime}")
private int maxLifetime;

@Value("${spring.datasource.maximumPoolSize}")
private int maximumPoolSize;

@Value("${spring.datasource.minimumIdle}")
private int minimumIdle;

@Value("${spring.datasource.idleTimeout}")
private int idleTimeout;

@Bean
public DataSource primaryDataSource() {
    Properties dsProps = new Properties();
    dsProps.put("url", dataSourceUrl);
    dsProps.put("user", user);
    dsProps.put("password", password);
    dsProps.put("prepStmtCacheSize",250);
    dsProps.put("prepStmtCacheSqlLimit",2048);
    dsProps.put("cachePrepStmts",Boolean.TRUE);
    dsProps.put("useServerPrepStmts",Boolean.TRUE);

    Properties configProps = new Properties();
       configProps.put("dataSourceClassName", dataSourceClassName);
       configProps.put("poolName",poolName);
       configProps.put("maximumPoolSize",maximumPoolSize);
       configProps.put("minimumIdle",minimumIdle);
       configProps.put("minimumIdle",minimumIdle);
       configProps.put("connectionTimeout", connectionTimeout);
       configProps.put("idleTimeout", idleTimeout);
       configProps.put("dataSourceProperties", dsProps);

   HikariConfig hc = new HikariConfig(configProps);
   HikariDataSource ds = new HikariDataSource(hc);
   return ds;
   }
  }

dataSourceClassName kullanamamanın nedeni

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

Bu, spring.datasource.url özelliğinden Spring boot anlamına gelir ve aynı zamanda dataSourceClassName'in ayarlanması bu istisnayı oluşturur. Bunu doğru yapmak için application.properties dosyanızın HikariCP veri kaynağı için şuna benzemesi gerekir:

# 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

Not: Lütfen sınıf yolunuzda geçişli bağımlılıkla çoğu kez eklenen tomcat-jdbc.jar veya commons-dbcp.jar olup olmadığını kontrol edin. Bunlar sınıf yolunda mevcutsa, Spring Boot, Tomcat olan varsayılan bağlantı havuzunu kullanarak Veri kaynağını yapılandırır. HikariCP, yalnızca sınıf yolunda başka sağlayıcı yoksa Veri Kaynağını oluşturmak için kullanılacaktır. tomcat -> 'den HikariCP -> Commons DBCP'ye bir geri dönüş dizisi var.

Question 11

Bu, hikaricp'i uygulamaları için yay otomatik yapılandırmasıyla yapılandırmak isteyen herkese yardımcı olacaktır. Projem için, JDBC bağlantı havuzu olarak hikaricp ve veritabanı olarak mysql ile spring boot 2 kullanıyorum. Diğer yanıtlarda görmediğim bir şey data-source-properties, spring.datasource.hikari.*yolda bulunmayan çeşitli özellikleri ayarlamak için kullanılabilen şeydi . Bu, HikariConfigsınıfı kullanmaya eşdeğerdir . Veri kaynağını ve hikaricp bağlantı havuzunu mysql'e özgü özellikler için yapılandırmak için spring auto configure annotation ve application.yml dosyasında aşağıdaki özellikleri kullandım.

Yeri @EnableAutoConfigurationyapılandırma fasulye dosyalarından birinde.

application.yml dosyası şöyle görünebilir.

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

Question 12

İyi haberler burada. HikariCP, artık Spring Boot 2.0.0 ile varsayılan bağlantı havuzudur.

Spring Boot 2.0.0 Sürüm Notları

Spring Boot 2.0'daki varsayılan veritabanı havuzu teknolojisi Tomcat Pool'dan HikariCP'ye geçirildi. Hakari'nin üstün performans sunduğunu ve birçok kullanıcımızın Tomcat Pool yerine tercih ettiğini gördük.

Question 13

Dolayısıyla, DB bağlantılarının sayısı dışında HikariCP için neredeyse tüm varsayılan ayarların benim için çalıştığı ortaya çıktı. Bu özelliği application.properties dosyamda ayarlıyorum:

spring.datasource.maximumPoolSize=20

Ve Andy Wilkinson, HikariCP için Spring Boot ile dataSourceClassName yapılandırma yaklaşımını kullanamayacağınız konusunda anlayabildiğim kadarıyla haklı.

Question 14

Kurulumum : Spring Boot v1.5.10
Hikari v.3.2.x (değerlendirme için)

Hikari Veri Kaynağının yapılandırmasını gerçekten anlamak için, Spring Boot'un Veri Kaynağı için Otomatik Yapılandırmasını devre dışı bırakmanızı öneririm.

Application.properties:- için aşağıdakileri ekleyin

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

Bu, Spring Boot'un DataSource'u kendi başına yapılandırma yeteneğini devre dışı bırakır.

Şimdi HikariDataSource çekirdeği oluşturmak ve onu istenen özelliklerle doldurmak için kendi Özel Yapılandırmanızı tanımlama şansınız var.

NOT :::
genel sınıf HikariDataSource HikariConfig'i genişletir

Gerek

İstenen Hikari Özelliklerini kullanarak HikariConfig Nesnesini doldurun
Yapıcıya bağımsız değişken olarak iletilen HikariConfig nesnesiyle HikariDataSource nesnesini başlatın.

Veri kaynağını kendi başıma oluşturmak ve onu ayrı bir dosyada tanımlanan veri kaynağı özellikleriyle doldurmak için kendi Özel Yapılandırma sınıfımı (@Configuration) tanımlamaya inanıyorum (geleneksel: application.properties'ten)

Bu şekilde kendi sınıfımı tanımlayabilirim Hibernate kullanan sessionFactory Bean önerilen: "LocalSessionFactoryBean" sınıfı ve Hikari Veri Kaynağınız> ve diğer Hiberante-JPA tabanlı mülklerle doldurun.

Spring Boot tabanlı Hikari DataSource Özelliklerinin Özeti: -

spring.datasource.hikari.allow-pool-süspansiyon = true
spring.datasource.hikari.auto-commit = false
spring.datasource.hikari.catalog =
spring.datasource.hikari.connection-init-sql =
spring.datasource.hikari. bağlantı-test-sorgu =
spring.datasource.hikari.connection-zaman aşımı = 100
spring.datasource.hikari.data-kaynak sınıfı-adı =
spring.datasource.hikari.data-kaynak-jndi =
spring.datasource.hikari.driver -sınıf-adı =
spring.datasource.hikari.idle-zaman aşımı = 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-eşiği =
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 =

Question 15

Daha sonraki ilkbahar önyükleme sürümleriyle Hikari'ye geçiş tamamen yapılandırmada yapılabilir. Ben kullanıyorum 1.5.6.RELEASEve bu yaklaşım işe yarıyor.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

uygulama YAML

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

connectionTestQueryTemel DB'nize uyacak şekilde değiştirin . İşte bu, kod gerekmez.

Question 16

Aşağıdaki kod, statik bir veri kaynağı başlatma için kullanılabilir.

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

Question 17

Sorunlarla karşılaşıyordum ve sorun, sonundaki bir boşluktuspring.datasource.type = com.zaxxer.hikari.HikariDataSource