Làm cách nào để định cấu hình HikariCP trong ứng dụng Spring Boot trong các tệp application.properties của tôi?


92

Tôi đang cố gắng thiết lập HikariCP trong ứng dụng Spring Boot (1.2.0.M1) của mình để tôi có thể thử nghiệm bằng cách sử dụng nó thay cho Tomcat DBCP. Tôi muốn định cấu hình nhóm kết nối trong tệp application.properties của mình giống như tôi đã làm với Tomcat, nhưng tôi không thể tìm ra cách mình nên thực hiện. Tất cả các ví dụ tôi đã tìm thấy đều hiển thị kiểu JavaConfig hoặc sử dụng tệp thuộc tính HikariCP riêng biệt. Ai đó có thể giúp tôi tìm ra tên thuộc tính để định cấu hình nó trong application.properties không? Tôi cũng muốn chuyển từ sử dụng phương pháp driverClassName sang phương pháp DataSourceClassName vì nó trông gọn gàng hơn và được khuyến nghị. Điều này cũng có thể xảy ra trong (các) tệp application.properties của tôi?

Đây là những gì tôi có cho Tomcat DBCP (chỉ là một số cấu hình cơ bản, chưa được xóa hoàn toàn)

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

Và tôi hiện đang sử dụng url driverClassName và jdbc để thiết lập kết nối:

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

Bạn đang sử dụng phiên bản Spring Boot nào?
geoand

1.2.0.M1 Tôi nghĩ rằng tôi có thể đã tìm ra cách đặt các thuộc tính để thiết lập những thứ như MaximumPoolSize cho hikariCP. Nhưng tôi đã không thể có được cấu hình hoạt động bằng cách sử dụng hikariCP được đề xuất bằng cách sử dụng dataSourceClassName và serverName thay vì url driverClassName và jdbc. Vì vậy, tôi đã từ bỏ phần đó. Nếu ai đó có thể hình dung phần đó, mà muốn giúp đỡ
Kevin M

Tôi sẽ đưa cho 1.2.0.M1 thử sau này, và tôi tìm hiểu bất cứ điều gì tôi sẽ đăng nó
geoand

2
Bạn không thể sử dụng phương pháp dataSourceClassName với cấu hình tự động DataSource của Spring Boot vì nó yêu cầu thiết lập spring.datasource.url. Lưu ý rằng bạn không cần chỉ định driverClassName vì Boot sẽ suy ra nó từ jdbcUrl.
Andy Wilkinson

1
application.properties spring.datasource.hikari.*
:,

Câu trả lời:


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

ĐÃ CẬP NHẬT! Kể từ phiên bản Spring Boot 1.3.0 :

  1. Chỉ cần thêm HikariCP vào các phần phụ thuộc
  2. Định cấu hình 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

ĐÃ CẬP NHẬT! Kể từ phiên bản Spring Boot 2.0.0 :

Nhóm kết nối mặc định đã thay đổi từ Tomcat thành Hikari :)


1
Tôi nghĩ đây là một cách tiếp cận tốt hơn, linh hoạt hơn nhiều. Chúc mừng!
Jesús Zazueta

2
Điều này cũng có thể được sử dụng cho cấu hình lò xo tiêu chuẩn, nhưng một người nghĩ là quan trọng. Hikari đã sử dụng url của nguồn dữ liệu thông qua jdbcUrl, nhưng mùa xuân thông qua url. {url chuỗi riêng tư; @Bean public DataSource dataSource () ném SQLException {trả về HikariDataSource mới (this); } public String getUrl () {return url; } public void setUrl (String url) {this.url = url; // HikariConfig giữ JDBC-URL trong thuộc tính jdbcUrl, nhưng mùa xuân cung cấp thuộc tính này dưới dạng url this.setJdbcUrl (url); }}
Tomas Hanus

Xin lỗi, đây là câu trả lời hơi muộn, nhưng giải pháp @Sergey nên được thay đổi một chút để có được tất cả các thuộc tính. Để có được hikari DS cụ thể thuộc tính, bạn cần phải thiết lập các khóa như "spring.datasource dataSourceProperties." Thay vì "spring.datasource.hikari"
bluelabel

3
Trước đây, chúng ta chỉ cần xem nó được cấu hình như thế nào bằng cách xem tài liệu của nguồn dữ liệu, bây giờ nó trở nên tồi tệ hơn, bây giờ chúng ta cũng cần biết nó được cấu hình như thế nào khi sử dụng Spring Boot. Tôi không thực sự thấy cấu hình tự động này thực sự giúp ích cho chúng tôi.
supertonsky

31

Tôi đã xem qua HikariCPvà tôi đã rất ngạc nhiên bởi các điểm chuẩn và tôi muốn thử nó thay vì lựa chọn mặc định của mình C3P0và thật ngạc nhiên, tôi đã đấu tranh để chọn configurationsđúng có lẽ vì các cấu hình khác nhau dựa trên sự kết hợp của ngăn xếp công nghệ bạn đang sử dụng.

Tôi có Spring Bootdự án thiết lập với trình JPA, Web, Securitykhởi động (Sử dụng Bộ khởi tạo mùa xuân ) để sử dụng PostgreSQLlàm cơ sở dữ liệu với HikariCPlàm tổng hợp kết nối.
Tôi đã sử dụng Gradlelàm công cụ xây dựng và tôi muốn chia sẻ những gì phù hợp với tôi cho các giả định sau:

  1. Spring Boot Starter JPA (Web & Security - tùy chọn)
  2. Gradle cũng xây dựng
  3. PostgreSQL đang chạy và thiết lập với cơ sở dữ liệu (tức là lược đồ, người dùng, db)

Bạn cần những thứ sau build.gradlenếu bạn đang sử dụng Gradlehoặc tương đương pom.xmlnếu bạn đang sử dụng 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'
    }
}

Có rất nhiều loại trừ ở trên build.gradlevà đó là bởi vì

  1. Loại trừ đầu tiên, hướng dẫn gradle loại trừ nhóm jdbc-tomcatkết nối khi tải xuống các phần spring-boot-starter-data-jpaphụ thuộc. Điều này có thể đạt được bằng cách thiết lập spring.datasource.type=com.zaxxer.hikari.HikariDataSourcecũng nhưng, tôi không muốn có thêm phụ thuộc nếu tôi không cần nó
  2. Loại trừ thứ hai, hướng dẫn gradle loại trừ hibernate-corekhi tải xuống com.zaxxerphụ thuộc và đó là vì hibernate-coređã được tải xuống bởi Spring Bootvà chúng tôi không muốn kết thúc với các phiên bản khác nhau.
  3. Loại trừ thứ ba, hướng dẫn gradle loại trừ hibernate-corekhi tải xuống hibernate-hikaricpmô-đun cần thiết để sử dụng HikariCP org.hibernate.hikaricp.internal.HikariCPConnectionProviderlàm nhà cung cấp kết nối thay vì không dùng nữacom.zaxxer.hikari.hibernate.HikariConnectionProvider

Khi tôi đã tìm ra build.gradlecái gì nên giữ và cái gì không, tôi đã sẵn sàng sao chép / dán một datasourcecấu hình vào cấu hình của tôi application.propertiesvà mong đợi mọi thứ hoạt động với màu sắc bị bay màu, nhưng không thực sự và tôi đã vấp phải những vấn đề sau

  • Khởi động mùa xuân không tìm ra chi tiết cơ sở dữ liệu (tức là url, trình điều khiển), do đó, không thể thiết lập jpa và ngủ đông (vì tôi không đặt tên cho các giá trị khóa thuộc tính đúng)
  • HikariCP giảm trở lại com.zaxxer.hikari.hibernate.HikariConnectionProvider
  • Sau khi hướng dẫn Spring sử dụng trình cung cấp kết nối mới khi tự động định cấu hình hibernate / jpa thì HikariCP không thành công vì nó đang tìm kiếm một số key/valuetrong đó application.propertiesvà đang phàn nàn dataSource, dataSourceClassName, jdbcUrl. Tôi đã phải gỡ lỗi vào HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvidervà phát hiện ra rằng HikariCPkhông thể tìm thấy các thuộc tính từ application.propertiesđó vì nó được đặt tên khác.

Dù sao, đây là nơi tôi phải dựa vào thử và sai và đảm bảo rằng HikariCPcó thể chọn các thuộc tính (tức là nguồn dữ liệu có chi tiết db, cũng như các thuộc tính tổng hợp) cũng như Sping Boot hoạt động như mong đợi và tôi đã kết thúc với application.propertiestệp sau đây .

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 

Như được hiển thị ở trên, các cấu hình được chia thành các loại dựa trên các mẫu đặt tên sau

  • spring.datasource.x (Tự động cấu hình mùa xuân sẽ chọn những thứ này, HikariCP cũng vậy)
  • spring.datasource.hikari.x (HikariCP chọn những thứ này để thiết lập nhóm, ghi chú tên trường camelCase)
  • spring.jpa.hibernate.connection.provider_class (Hướng dẫn Spring sử dụng HibernateConnectionProvider mới)
  • spring.jpa.properties.hibernate.x (Được Spring sử dụng để tự động định cấu hình JPA, ghi chú các tên trường có dấu gạch dưới)

Thật khó để bắt gặp một hướng dẫn hoặc bài đăng hoặc một số tài nguyên cho thấy cách sử dụng tệp thuộc tính ở trên và cách đặt tên các thuộc tính. Được, bạn đã có nó.

Việc ném những thứ trên application.propertiesvới build.gradle(hoặc ít nhất là tương tự) vào phiên bản dự án Spring Boot JPA (1.5.8) sẽ hoạt động giống như một sự quyến rũ và kết nối với cơ sở dữ liệu được định cấu hình trước của bạn (nghĩa là trong trường hợp của tôi, đó là PostgreSQL mà cả hai đều HikariCP & Springtìm ra từ spring.datasource.urlđó trình điều khiển cơ sở dữ liệu để sử dụng).

Tôi không thấy cần thiết phải tạo DataSourcebean và đó là bởi vì Spring Boot có khả năng làm mọi thứ cho tôi chỉ bằng cách xem xét application.propertiesvà điều đó thật gọn gàng.

Các bài viết trong github HikariCP của wiki chương trình làm thế nào để thiết lập mùa xuân Boot với JPA nhưng, thiếu giải thích và chi tiết.

Hai tệp trên cũng có sẵn dưới dạng ý chính công khai https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6


Tôi đã đấu tranh với điều này ngay trước khi bạn đăng. Cảm ơn bạn!
Bogdan Pușcașu

Rất vui vì nó đã giúp bạn! 👍
Raf

Nếu bạn có một câu trả lời tuyệt vời. Tôi rất tò mò liệu bạn có thể đăng những thay đổi cần thiết cho Spring Boot 2.0.0.M6 hay không. Vật lộn với cấu hình không được chọn và Hướng dẫn di chuyển chưa được cập nhật
Matthew Fontana

Này Mat, tôi đang sử dụng Bản phát hành 1.5.8 khi tôi chia sẻ giải pháp của mình ở đây. Tôi muốn dùng thử nhanh 2.0.0.M6 nhưng rất tiếc là họ yêu cầu bạn phải có phiên bản gradle cao hơn. Thay đổi duy nhất mà tôi có thể nhớ trong 2.0.0.M6 sẽ là đặt kết nối mặc định HikariCP thành tổng hợp cho Spring jpa, hãy xem tại đây github.com/spring-projects/spring-boot/commit/… Hãy thử gỡ lỗi HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider để đảm bảo rằng tài sản được chọn.
Raf

26

Bạn chỉ có thể sử dụng application.yml / application.properties. Không cần tạo DataSourceBean rõ ràng

Bạn cần loại trừ tomcat-jdbc như được đề cập bởi 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>

Vì bạn sẽ không tạo DataSourcebean, bạn phải chỉ định rõ ràng bằng cách sử dụng Hikari thông qua spring.datasource.typevới giá trị com.zaxxer.hikari.HikariDataSourcetrong 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

Trong application.yml / application.properties của bạn, bạn có thể định cấu hình các thông số cụ thể của Hikari như kích thước hồ bơi, v.v. trong spring.datasource.hikari.*


Bạn không cần phải loại trừ Tomcat để thực hiện công việc này, thêm vào spring.datasource.typelà đủ.
Michael Piefel

3
@MichaelPiefel Bạn cần thực hiện loại trừ. Các javadoc của DataSourceBuildernói: Nếu Tomcat, HikariCP hoặc Commons DBCP đang ở trên một classpath trong số họ sẽ được lựa chọn (theo thứ tự đó với Tomcat đầu tiên). Thử nghiệm của tôi xác nhận điều này.
Jan Bodnar

1
@JanBodnar:, DataSourceConfigurationđược sử dụng trong cấu hình tự động, có các cấu hình tùy thuộc vào việc spring.datasource.typenó có được đặt hay không. Vì vậy, tôi có tomcat-jdbctrên classpath của mình và vẫn sử dụng HikariCP làm nhóm của mình. Thử nghiệm của tôi xác nhận điều này. Có thể chúng ta đang nói về các phiên bản Spring Boot rất khác nhau ở đây.
Michael Piefel

1
@MichaelPiefel Thật thú vị, tôi đã quản lý để chạy nó OK mà không bị loại trừ với cấu hình Java chỉ bằng cách sử dụng DataSourceBuilder.create () ... gõ (com.zaxxer.hikari.HikariDataSource.class). Với cấu hình trong tệp yaml, nó không hoạt động đối với tôi. Vì vậy, phải có một số bắt.
Jan Bodnar

14

Tôi đang sử dụng Spring Boot 2.0.4.RELEASE. Hikari là nhóm kết nối mặc định và .hikarikhông còn cần thiết nữa.

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

configurationkhông cần phải mở rộng HikariConfig, và DataSourceBuildercó thể được sử dụng như trước đây.

@Configuration
public class DataSourceConfiguration {

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

10

Theo tài liệu, nó đã được thay đổi,

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

Thí dụ :

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

Đây là những thay đổi cấu hình sau đây chúng tôi có thể thực hiện trên hikari, vui lòng thêm / cập nhật theo nhu cầu của bạn.

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

9

Bạn không cần mã thừa để đặt giá trị thuộc tính cho các biến. Bạn có thể đặt thuộc tính trực tiếp bằng tệp thuộc tính.

Đặt hikari.propertiestệp vào đường dẫn classpath.

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

Và tạo một bean nguồn dữ liệu như thế này.

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

    return dataSource;
}

8

Điều này hoạt động cho ứng dụng khởi động của tôi trong trường hợp nó hữu ích. Lớp này cho bạn biết những thuộc tính mà đối tượng cấu hình đang tìm kiếm:

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

Tôi nghĩ rằng nhiều nguồn dữ liệu có thể hỗ trợ bằng cách thêm datasource_whatevervào các khóa thuộc tính trong tệp cấu hình nguồn. Chúc mừng!

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

Nó là. Nó có thể dễ dàng dịch sang Java.
Jesús Zazueta

Vâng, bây giờ tôi nhận ra rằng tôi cần phải làm điều này vì bây giờ tôi muốn định cấu hình các Chỉ số. Và cách duy nhất tôi có thể thấy để làm điều đó là sử dụng JavaConfig này để ghi đè cấu hình tự động. Cảm ơn.
Kevin M

Có, nó giúp! Bạn cũng nhận được opvote của tôi ... Nó có phải là Groovie không? Nó rất thú vị, nó giống như javascript :-)
Joao Polo

8

Bạn có thể sử dụng cách tiếp cận dataSourceClassName, đây là một ví dụ với MySQL. (Đã thử nghiệm với khởi động lò xo 1.3 và 1.4)

Đầu tiên, bạn cần loại trừ tomcat-jdbc khỏi classpath vì nó sẽ được chọn có lợi cho 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

Sau đó, chỉ cần thêm

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

Tôi đã tạo một dự án thử nghiệm tại đây: https://github.com/ydemartino/spring-boot-hikaricp


8

bạn không thể sử dụng phương pháp dataSourceClassName trong các cấu hình application.properties như đã nói bởi @Andy Wilkinson. nếu bạn vẫn muốn có dataSourceClassName, bạn có thể sử dụng Java Config như sau:

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

lý do bạn không thể sử dụng dataSourceClassName vì nó sẽ ném và ngoại lệ

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

có nghĩa là khởi động mùa xuân thông báo từ thuộc tính spring.datasource.url Trình điều khiển và đồng thời thiết lập dataSourceClassName sẽ tạo ra ngoại lệ này. Để làm cho nó phù hợp với ứng dụng của bạn. Các nhân viên sẽ trông giống như sau cho nguồn dữ liệu 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

Lưu ý: Vui lòng kiểm tra xem có bất kỳ tomcat-jdbc.jar hoặc commons-dbcp.jar nào trong classpath của bạn được thêm vào hầu hết các lần theo phụ thuộc bắc cầu không. Nếu chúng xuất hiện trong classpath Spring Boot sẽ cấu hình Datasource bằng cách sử dụng nhóm kết nối mặc định là tomcat. HikariCP sẽ chỉ được sử dụng để tạo Nguồn dữ liệu nếu không có nhà cung cấp nào khác trong classpath. có một chuỗi dự phòng từ tomcat -> đến HikariCP -> đến Commons DBCP.


1
điều này cực kỳ hữu ích, mặc dù tôi phải tìm ra một số tên thuộc tính không được đề cập ở đây như stringType để định cấu hình đạo cụ nguồn dữ liệu.
comiventor

Thật tốt khi biết nó đã giúp.
Shahid Yousuf,

8

Điều này sẽ giúp bất kỳ ai muốn định cấu hình hikaricp cho ứng dụng của họ với cấu hình tự động mùa xuân. Đối với dự án của tôi, tôi đang sử dụng spring boot 2 với hikaricp làm nhóm kết nối JDBC và mysql làm cơ sở dữ liệu. Một điều tôi không thấy trong các câu trả lời khác là data-source-propertiescó thể được sử dụng để đặt các thuộc tính khác nhau không có sẵn tại spring.datasource.hikari.*đường dẫn. Điều này tương đương với việc sử dụng HikariConfiglớp. Để định cấu hình nguồn dữ liệu và nhóm kết nối hikaricp cho các thuộc tính cụ thể của mysql, tôi đã sử dụng chú thích tự động cấu hình mùa xuân và các thuộc tính sau trong tệp application.yml.

Đặt @EnableAutoConfigurationtrên một trong các tệp bean cấu hình của bạn.

Tệp application.yml có thể trông như thế này.

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

Câu trả lời này có giá trị để cung cấp một ví dụ làm việc với các thuộc tính data-source-!
Mauro Molinari

6

Đây là tin tốt. HikariCP hiện là nhóm kết nối mặc định với Spring Boot 2.0.0.

Ghi chú phát hành Spring Boot 2.0.0

Công nghệ tổng hợp cơ sở dữ liệu mặc định trong Spring Boot 2.0 đã được chuyển từ Tomcat Pool sang HikariCP. Chúng tôi nhận thấy rằng Hakari cung cấp hiệu suất vượt trội và nhiều người dùng của chúng tôi thích nó hơn Tomcat Pool.


5

Vì vậy, hóa ra hầu như tất cả các cài đặt mặc định cho HikariCP đều hoạt động với tôi ngoại trừ số lượng kết nối DB. Tôi đặt thuộc tính đó trong application.properties của mình:

spring.datasource.maximumPoolSize=20

Và Andy Wilkinson đúng theo như tôi có thể nói rằng bạn không thể sử dụng phương pháp cấu hình dataSourceClassName cho HikariCP với Spring Boot.


2
Tôi đã sử dụng HikariCP một thời gian trong các ứng dụng khác nhau và cho đến nay chưa bao giờ gặp sự cố nào. Tôi đang sử dụng phương pháp HikariConfig, nơi bạn có tất cả cấu hình của mình trên một tệp thuộc tính. Hoạt động như mong đợi với SpringBoot và SpringCore. Tôi cũng đang định cấu hình MaximumPoolSize.
Davi Alves

Nó phải là spring.datasource.maximum-pool-sizekhi bạn sử dụng thuộc tính cấu hình mùa xuân, nếu không maximumPoolSizelà tên tham số HikariCP.
sura2k

3

My
SetUp : Spring Boot v1.5.10
Hikari v.3.2.x (để đánh giá)

Để thực sự hiểu cấu hình của Nguồn dữ liệu Hikari, tôi khuyên bạn nên tắt Tự động cấu hình cho Nguồn dữ liệu của Spring Boot.

Thêm phần sau vào application.properties:-

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

Điều này sẽ vô hiệu hóa khả năng của Spring Boot để tự cấu hình DataSource.

Bây giờ là cơ hội để bạn xác định Cấu hình tùy chỉnh của riêng mình để tạo đậu HikariDataSource và điền vào nó các thuộc tính mong muốn.

LƯU Ý :::
lớp công khai HikariDataSource mở rộng HikariConfig

Bạn cần phải

  1. điền Đối tượng HikariConfig bằng các Thuộc tính Hikari mong muốn
  2. khởi tạo đối tượng HikariDataSource với đối tượng HikariConfig được truyền làm đối số cho hàm tạo.

Tôi tin tưởng vào việc xác định lớp Cấu hình tùy chỉnh của riêng mình (@Configuration) để tự tạo nguồn dữ liệu và điền nó với các thuộc tính nguồn dữ liệu được xác định trong một tệp riêng (so với truyền thống: application.properties)

Theo cách này, tôi có thể xác định nguồn dữ liệu của riêng mình sessionFactory Bean sử dụng Hibernate được khuyến nghị: lớp "LocalSessionFactoryBean" và điền nó vào Nguồn dữ liệu Hikari của bạn> và các thuộc tính dựa trên Hiberante-JPA khác.

Tóm tắt về Thuộc tính Nguồn dữ liệu Hikari dựa trên Spring Boot: -

spring.datasource.hikari.allow-pool-
Treo = 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-phát hiện-ngưỡng =
spring.datasource.hikari.login-timeout = 60
spring.datasource.hikari.max-life =
spring.datasource.hikari.maximum-pool-size = 500
spring.datasource.hikari.minimum-id = 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-
isol = spring.datasource.hikari .username =
spring.datasource.hikari.validation-timeout =


spring.datasource.hikari.maximum-pool-size = 500 thực sự khủng khiếp và nó không được khuyến cáo từ hikari :) github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing
mertaksu

Đó chỉ là một cấu hình mẫu với giá trị :)
Philip Dilip

2

Với các bản phát hành khởi động mùa xuân sau đó, việc chuyển sang Hikari có thể được thực hiện hoàn toàn trong cấu hình. Tôi đang sử dụng 1.5.6.RELEASEvà cách tiếp cận này hoạt động.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

ứng dụng YAML

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

Thay đổi connectionTestQueryđể phù hợp với DB cơ bản của bạn. Vậy là xong, không cần mã.


2

Đoạn mã dưới đây có thể được sử dụng để khởi tạo nguồn dữ liệu tĩnh.

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

1

Tôi đang đối mặt với các vấn đề và vấn đề là một khoảng trắng ở cuốispring.datasource.type = com.zaxxer.hikari.HikariDataSource

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.