Bagaimana cara mengkonfigurasi HikariCP di aplikasi Spring Boot saya di file application.properties saya?

Saya mencoba mengatur HikariCP di aplikasi Spring Boot (1.2.0.M1) saya sehingga saya dapat mengujinya sebagai pengganti Tomcat DBCP. Saya ingin mengonfigurasi kumpulan koneksi di file application.properties saya seperti yang saya lakukan dengan Tomcat, tetapi saya tidak tahu bagaimana saya harus melakukannya. Semua contoh yang saya temukan menunjukkan gaya JavaConfig, atau menggunakan file properti HikariCP yang terpisah. Dapatkah seseorang membantu saya mengetahui nama properti untuk mengkonfigurasinya di application.properties? Saya juga ingin beralih dari menggunakan pendekatan driverClassName ke pendekatan DataSourceClassName karena tampilannya lebih bersih dan direkomendasikan. Apakah ini juga mungkin dalam file application.properties saya?

Inilah yang saya miliki untuk Tomcat DBCP (hanya beberapa konfigurasi dasar, tidak sepenuhnya habis)

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

Dan saat ini saya menggunakan url driverClassName dan jdbc untuk mengatur koneksi:

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

DIPERBARUI! Sejak versi Spring Boot 1.3.0 :

1. Cukup tambahkan HikariCP ke dependensi
2. Konfigurasi 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

DIPERBARUI! Sejak versi Spring Boot 2.0.0 :

Kolam koneksi default telah berubah dari Tomcat ke Hikari :)

Saya menemukan HikariCPdan saya kagum dengan tolok ukur dan saya ingin mencobanya daripada pilihan default saya C3P0dan yang mengejutkan saya, saya berjuang untuk mendapatkan yang configurationsbenar mungkin karena konfigurasinya berbeda berdasarkan kombinasi tumpukan teknologi yang Anda gunakan.

Saya memiliki Spring Bootproyek pengaturan dengan JPA, Web, Securitypermulaan (Menggunakan Spring Initializer ) untuk digunakan PostgreSQLsebagai database dengan HikariCPpenggabungan koneksi.
Saya telah menggunakan Gradlesebagai alat pembuatan dan saya ingin membagikan apa yang berhasil untuk saya untuk asumsi berikut:

1. Spring Boot Starter JPA (Web & Keamanan - opsional)
2. Gradle membangun juga
3. PostgreSQL berjalan dan diatur dengan database (yaitu skema, pengguna, db)

Anda memerlukan yang berikut ini build.gradlejika Anda menggunakan Gradleatau yang setara pom.xmljika Anda menggunakan 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'
    }
}

Ada banyak pengecualian di atas build.gradledan itu karena

1. Pertama kecualikan, perintahkan gradle yang mengecualikan jdbc-tomcatkumpulan koneksi saat mengunduh spring-boot-starter-data-jpadependensi. Ini dapat dicapai dengan menyiapkan spring.datasource.type=com.zaxxer.hikari.HikariDataSourcejuga tetapi, saya tidak ingin ketergantungan tambahan jika saya tidak membutuhkannya
2. Kedua mengecualikan, memerintahkan gradle untuk mengecualikan hibernate-coresaat mengunduh com.zaxxerketergantungan dan itu karena hibernate-coresudah diunduh oleh Spring Bootdan kami tidak ingin berakhir dengan versi yang berbeda.
3. Kecualikan ketiga, perintahkan gradle untuk mengecualikan hibernate-coresaat mengunduh hibernate-hikaricpmodul yang diperlukan untuk membuat HikariCP digunakan org.hibernate.hikaricp.internal.HikariCPConnectionProvidersebagai penyedia koneksi alih-alih tidak digunakan lagicom.zaxxer.hikari.hibernate.HikariConnectionProvider

Setelah saya menemukan build.gradledan apa yang harus disimpan dan apa yang tidak, saya siap untuk menyalin / menempelkan datasourcekonfigurasi ke dalam saya application.propertiesdan mengharapkan semuanya bekerja dengan warna terbang tetapi, tidak benar-benar dan saya tersandung pada masalah berikut

• Spring boot gagal menemukan detail database (yaitu url, driver) sehingga, tidak dapat mengatur jpa dan hibernate (karena saya tidak memberi nama nilai kunci properti dengan benar)
• HikariCP kembali ke com.zaxxer.hikari.hibernate.HikariConnectionProvider
• Setelah menginstruksikan Spring untuk menggunakan penyedia koneksi baru ketika konfigurasi otomatis hibernate / jpa kemudian HikariCP gagal karena mencari beberapa key/valuedi application.propertiesdan yang dikeluhkan dataSource, dataSourceClassName, jdbcUrl. Saya harus men-debug HikariConfig, HikariConfigurationUtil, HikariCPConnectionProviderdan menemukan bahwa HikariCPtidak dapat menemukan properti dari application.propertieskarena namanya berbeda.

Bagaimanapun, di sinilah saya harus mengandalkan trial and error dan memastikan bahwa HikariCPdapat memilih properti (yaitu sumber data yang detail db, serta properti penyatuan) serta Sping Boot berperilaku seperti yang diharapkan dan saya berakhir dengan application.propertiesfile berikut .

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 

Seperti yang ditunjukkan di atas, konfigurasi dibagi ke dalam kategori berdasarkan pola penamaan berikut

• spring.datasource.x (Konfigurasi otomatis musim semi akan memilih ini, begitu juga HikariCP)
• spring.datasource.hikari.x (HikariCP memilih ini untuk menyiapkan kolam, catat nama bidang CamelCase)
• spring.jpa.hibernate.connection.provider_class (Perintahkan Spring untuk menggunakan HibernateConnectionProvider baru)
• spring.jpa.properties.hibernate.x (Digunakan oleh Spring untuk mengkonfigurasi JPA secara otomatis, catat nama bidang dengan garis bawah)

Sulit untuk menemukan tutorial atau posting atau beberapa sumber daya yang menunjukkan bagaimana file properti di atas digunakan dan bagaimana properti harus diberi nama. Nah, begitulah.

Melempar hal di atas application.propertiesdengan build.gradle(atau setidaknya serupa) ke versi proyek JPA Spring Boot (1.5.8) akan bekerja seperti pesona dan terhubung ke database Anda yang telah dikonfigurasi sebelumnya (yaitu dalam kasus saya, PostgreSQL yang keduanya HikariCP & Springmencari tahu darispring.datasource.url mana driver database untuk digunakan).

Saya tidak melihat kebutuhan untuk membuat DataSourcekacang dan itu karena Spring Boot mampu melakukan segalanya untuk saya hanya dengan melihat ke dalam application.propertiesdan itu rapi.

The Artikel di HikariCP ini github wiki menunjukkan bagaimana untuk setup musim semi Boot dengan JPA tetapi, tidak memiliki penjelasan dan rincian.

Kedua file di atas juga tersedia sebagai inti publik https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Anda cukup menggunakan application.yml / application.properties saja. Tidak perlu membuat DataSourceBean apa pun secara eksplisit

Anda perlu mengecualikan tomcat-jdbc seperti yang disebutkan oleh 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>

Karena Anda tidak akan membuat DataSourcekacang, Anda harus secara eksplisit menentukan menggunakan Hikari melalui spring.datasource.typedengan nilai com.zaxxer.hikari.HikariDataSourcedi 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

Di application.yml / application.properties, Anda dapat mengonfigurasi parameter spesifik Hikari seperti ukuran pool, dll spring.datasource.hikari.*

Saya menggunakan Spring Boot 2.0.4.RELEASE. Hikari adalah kumpulan koneksi default dan .hikaritidak lagi diperlukan.

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

Dan configurationtidak perlu diperpanjang HikariConfig, dan DataSourceBuilderbisa digunakan seperti dulu.

@Configuration
public class DataSourceConfiguration {

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

Menurut dokumentasi itu diubah,

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

Contoh:

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

Berikut adalah perubahan konfigurasi yang dapat kami lakukan di hikari, silahkan tambahkan / perbarui sesuai kebutuhan Anda.

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

Anda tidak membutuhkan kode yang berlebihan untuk meletakkan nilai properti ke variabel. Anda dapat mengatur properti dengan file properti secara langsung.

Letakkan hikari.propertiesfile di classpath.

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

Dan buatlah sumber data bean seperti ini.

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

    return dataSource;
}

Ini berfungsi untuk aplikasi boot saya jika itu membantu. Kelas ini memberi tahu Anda properti apa yang dicari objek config:

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

Saya pikir beberapa sumber data dapat mendukung dengan menambahkan datasource_whateverke kunci properti di file konfigurasi sumber. Bersulang!

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

Anda dapat menggunakan pendekatan dataSourceClassName, berikut adalah contoh MySQL. (Diuji dengan spring boot 1.3 dan 1.4)

Pertama, Anda perlu mengecualikan tomcat-jdbc dari classpath karena akan dipilih untuk mendukung 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

Lalu tambahkan saja

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

Saya membuat proyek uji di sini: https://github.com/ydemartino/spring-boot-hikaricp

Anda tidak dapat menggunakan pendekatan dataSourceClassName dalam konfigurasi application.properties seperti yang dikatakan oleh @Andy Wilkinson. jika Anda tetap ingin memiliki dataSourceClassName, Anda dapat menggunakan Java Config sebagai:

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

alasan Anda tidak dapat menggunakan dataSourceClassName karena itu akan melempar dan pengecualian

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

yang berarti booting musim semi menyimpulkan dari properti spring.datasource.url Driver dan pada saat yang sama menyetel dataSourceClassName membuat pengecualian ini. Untuk memperbaikinya, properti aplikasi Anda akan terlihat seperti ini untuk sumber data 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

Catatan: Harap periksa apakah ada tomcat-jdbc.jar atau commons-dbcp.jar di classpath Anda yang sering kali ditambahkan oleh dependensi transitif. Jika ini ada di classpath, Spring Boot akan mengonfigurasi Sumber Data menggunakan kumpulan koneksi default yaitu tomcat. HikariCP hanya akan digunakan untuk membuat Sumber Data jika tidak ada penyedia lain di classpath. ada fallback sequence dari tomcat -> ke HikariCP -> ke Commons DBCP.

Ini akan membantu siapa saja yang ingin mengkonfigurasi hikaricp untuk aplikasinya dengan konfigurasi pegas otomatis. Untuk proyek saya, saya menggunakan boot musim semi 2 dengan hikaricp sebagai kumpulan koneksi JDBC dan mysql sebagai database. Satu hal yang tidak saya lihat di jawaban lain adalah data-source-propertiesyang dapat digunakan untuk mengatur berbagai properti yang tidak tersedia di spring.datasource.hikari.*jalur. Ini sama dengan menggunakan HikariConfigkelas. Untuk mengonfigurasi sumber data dan kumpulan koneksi hikaricp untuk properti spesifik mysql, saya menggunakan anotasi konfigurasi otomatis pegas dan properti berikut di file application.yml.

Tempatkan @EnableAutoConfigurationdi salah satu file kacang konfigurasi Anda.

File application.yml bisa terlihat seperti ini.

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

Inilah kabar baiknya. HikariCP adalah kumpulan koneksi default sekarang dengan Spring Boot 2.0.0.

Catatan Rilis Spring Boot 2.0.0

Teknologi penggabungan database default di Spring Boot 2.0 telah dialihkan dari Tomcat Pool ke HikariCP. Kami telah menemukan bahwa Hakari menawarkan kinerja yang unggul, dan banyak pengguna kami lebih memilihnya daripada Tomcat Pool.

Jadi ternyata hampir semua pengaturan default untuk HikariCP berfungsi untuk saya kecuali jumlah koneksi DB. Saya menyetel properti itu di application.properties saya:

spring.datasource.maximumPoolSize=20

Dan Andy Wilkinson benar sejauh yang saya tahu bahwa Anda tidak dapat menggunakan pendekatan konfigurasi dataSourceClassName untuk HikariCP dengan Spring Boot.

Pengaturan Saya:
Spring Boot v1.5.10
Hikari v.3.2.x (untuk evaluasi)

Untuk benar-benar memahami konfigurasi Sumber Data Hikari, saya sarankan untuk menonaktifkan Konfigurasi Otomatis Spring Boot untuk Sumber Data.

Tambahkan yang berikut ke application.properties:-

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

Ini akan menonaktifkan kemampuan Spring Boot untuk mengonfigurasi Sumber Data sendiri.

Sekarang adalah kesempatan bagi Anda untuk menentukan Konfigurasi Kustom Anda sendiri untuk membuat kacang HikariDataSource dan mengisinya dengan properti yang diinginkan.

CATATAN :::
kelas publik HikariDataSource memperluas HikariConfig

Kamu butuh

1. isi Objek HikariConfig menggunakan Properti Hikari yang diinginkan
2. menginisialisasi objek HikariDataSource dengan objek HikariConfig yang diteruskan sebagai argumen ke konstruktor.

Saya percaya dalam mendefinisikan kelas Konfigurasi Kustom saya sendiri (@Configuration) untuk membuat sumber data saya sendiri dan mengisinya dengan properti sumber data yang ditentukan dalam file terpisah (daripada tradisional: application.properties)

Dengan cara ini saya dapat menentukan milik saya sendiri sessionFactory Bean yang menggunakan Hibernate direkomendasikan: kelas "LocalSessionFactoryBean" dan mengisinya dengan Hikari Data Source> dan properti berbasis Hiberante-JPA lainnya.

Ringkasan Properti DataSource Hikari berbasis Spring Boot: -

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.login-timeout = 60
spring.datasource.hikari.leak-detection-threshold =

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 =

Dengan rilis boot musim semi yang lebih baru, peralihan ke Hikari dapat dilakukan sepenuhnya dalam konfigurasi. saya menggunakan1.5.6.RELEASE dan pendekatan ini berhasil.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

aplikasi YAML

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

Ubah connectionTestQueryagar sesuai dengan DB Anda. Itu saja, tidak perlu kode.

Kode di bawah ini dapat digunakan untuk inisialisasi sumber data statis.

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

Saya menghadapi masalah dan masalahnya adalah spasi di akhirspring.datasource.type = com.zaxxer.hikari.HikariDataSource