मैं अपने स्प्रिंग बूट ऐप में HikariCP को अपने एप्लिकेशन में कैसे कॉन्फ़िगर करूं?


94

मैं अपने स्प्रिंग बूट (1.2.0.M1) ऐप में HikariCP स्थापित करने की कोशिश कर रहा हूं ताकि मैं Tomcat DBCP के स्थान पर इसका उपयोग करके परीक्षण कर सकूं। मैं अपने एप्लिकेशन में कनेक्शन पूल को कॉन्फ़िगर करना चाहता हूं। मैं टॉमकैट के साथ ऐसा कर रहा था जैसे मैं कर रहा था, लेकिन मैं यह पता नहीं लगा सकता कि मुझे यह कैसे करना चाहिए। सभी उदाहरण मुझे मिले हैं या तो JavaConfig शैली दिखाते हैं, या एक अलग HikariCP गुण फ़ाइल का उपयोग कर रहे हैं। क्या कोई मुझे आवेदन.प्रोपरेट में कॉन्फ़िगर करने के लिए संपत्ति के नामों का पता लगाने में मदद कर सकता है? मैं भी DataSourceClassName दृष्टिकोण के लिए DriverClassName दृष्टिकोण का उपयोग करने से स्विच करना चाहूंगा क्योंकि यह क्लीनर दिखता है और इसकी सिफारिश की जाती है। क्या यह मेरे अनुप्रयोग में भी संभव है। फ़ाइल (फ़ाइलें)?

यहाँ मैं Tomcat DBCP के लिए क्या था (बस कुछ बुनियादी विन्यास, पूरी तरह से बाहर फ्लश नहीं)

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

और मैं वर्तमान में कनेक्शन स्थापित करने के लिए DriverClassName और jdbc url का उपयोग कर रहा हूं:

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

आप स्प्रिंग बूट के किस संस्करण का उपयोग कर रहे हैं?
जियोन्ड

1.2.0.M1 मुझे लगता है कि मुझे पता चल गया होगा कि कैसे hikariCP के लिए maxPoolSize जैसी चीजों को सेट करने के लिए गुण सेट करें। लेकिन मैं hikariCP द्वारा अनुशंसित तरीके से काम कर पाने में असमर्थ रहा हूं, जैसे कि dataClassName और jdbc url के बजाय dataSourceClassName और serverName का उपयोग करके अनुशंसित तरीका। इसलिए मैंने उस हिस्से को छोड़ दिया। अगर कोई उस हिस्से का पता लगा सकता है, तो वह मदद करेगा
केविन एम

मैं 1.2.0.M1 को बाद में कोशिश करूँगा, और मुझे कुछ भी पता चलेगा कि मैं इसे पोस्ट करूँगा
जियोन्ड

2
आप DataSourceClassName दृष्टिकोण का उपयोग स्प्रिंग बूट के डेटा कॉन्फ़िगरेशन के ऑटो-कॉन्फ़िगरेशन के साथ नहीं कर सकते क्योंकि इसके लिए यह आवश्यक है कि spring.datasource.url सेट हो। ध्यान दें कि आपको DriverClassName को निर्दिष्ट करने की आवश्यकता नहीं है क्योंकि बूट इसे jdbcUrl से हटा देगा।
एंडी विल्किंसन

1
application.properties: spring.datasource.hikari.*, प्रलेखन: github.com/brettwooldridge/HikariCP
kinjelom

जवाबों:


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

अपडेट किया! संस्करण स्प्रिंग बूट 1.3.0 के बाद से :

  1. बस आश्रितों को HikariCP जोड़ें
  2. अनुप्रयोग कॉन्फ़िगर करें

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

अपडेट किया! संस्करण वसंत बूट 2.0.0 के बाद से :

डिफ़ॉल्ट कनेक्शन पूल Tomcat से Hikari में बदल गया है :)


1
मुझे लगता है कि यह अधिक बेहतर, अधिक पोर्टेबल दृष्टिकोण है। चीयर्स!
जेसुज़ ज़ज़ुता

2
यह मानक वसंत विन्यास के लिए भी इस्तेमाल किया जा सकता है, लेकिन एक विचार महत्वपूर्ण है। Hikari ने jdbcUrl के माध्यम से डेटासोर्स के url का उपयोग किया, लेकिन url के माध्यम से वसंत। {निजी स्ट्रिंग url; @Bean सार्वजनिक डेटा स्रोत डेटा स्रोत () SQLException {नया HikariDataSource (यह) लौटाता है; } सार्वजनिक स्ट्रिंग getUrl () {वापसी url; } public void setUrl (स्ट्रिंग url) {this.url = url; // HikariConfig jdbcUrl संपत्ति में JDBC-URL को धारण करता है, लेकिन वसंत इस संपत्ति को url के रूप में प्रदान करता है ।setJdbcUrl (url); }}
टॉमस हनस

क्षमा करें यह थोड़ा देर से उत्तर है, लेकिन सभी गुणों को प्राप्त करने के लिए @ समाधान समाधान को थोड़ा बदला जाना चाहिए। Hikari विशिष्ट DS गुण प्राप्त करने के लिए, आपको "spring.datasource। DataSourceProperties" के बजाय "spring.datasource.hikari" के रूप में कुंजी सेट करने की आवश्यकता है
Bluelabel

3
इससे पहले, हमें केवल यह देखने की आवश्यकता है कि डेटासोर्स के दस्तावेज़ को देखकर इसे कैसे कॉन्फ़िगर किया गया है, अब यह खराब हो गया है, हमें अब यह भी जानना होगा कि स्प्रिंग बूट का उपयोग करते समय इसे कैसे कॉन्फ़िगर किया गया है। मैं वास्तव में यह नहीं देखता हूं कि यह स्वचालित कॉन्फ़िगरेशन वास्तव में हमारी मदद कर रहा है।
सुपरटनस्की

31

मैं भर आया HikariCPथा और मैं बेंचमार्क से चकित था और मैं अपनी डिफ़ॉल्ट पसंद के बजाय इसे आज़माना चाहता था C3P0और अपने आश्चर्य के लिए मैं configurationsसही पाने के लिए संघर्ष कर रहा था क्योंकि कॉन्फ़िगरेशन आपके द्वारा उपयोग किए जा रहे तकनीकी स्टैक के संयोजन के आधार पर भिन्न होते हैं।

मेरे पास कनेक्शन पूलिंग के साथ डेटाबेस के रूप में उपयोग करने के लिए स्टार्टर्स ( स्प्रिंग इनिशियलर का उपयोग करके ) के Spring Bootसाथ सेटअप प्रोजेक्ट है । मैंने बिल्ड टूल के रूप में उपयोग किया है और मैं निम्नलिखित मान्यताओं के लिए मेरे लिए काम करना साझा करना चाहूंगा:JPA, Web, SecurityPostgreSQLHikariCP
Gradle

  1. स्प्रिंग बूट स्टार्टर जेपीए (वेब ​​और सुरक्षा - वैकल्पिक)
  2. ग्रेड का निर्माण भी करें
  3. PostgreSQL डेटाबेस के साथ चल रहा है और सेटअप है (यानी स्कीमा, उपयोगकर्ता, db)

यदि आप मावेन का उपयोग कर रहे build.gradleहैं तो आपको निम्न Gradleया समकक्ष का उपयोग करने की आवश्यकता हैpom.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'
    }
}

ऊपर में बहिष्कृतों का एक समूह है build.gradleऔर ऐसा इसलिए है

  1. पहले बाहर निकालें, निर्भरता को jdbc-tomcatडाउनलोड करते समय कनेक्शन पूल को बाहर करने वाले ग्रेडेल को निर्देश देता है spring-boot-starter-data-jpa। यह spring.datasource.type=com.zaxxer.hikari.HikariDataSourceभी स्थापित करके प्राप्त किया जा सकता है लेकिन, मुझे अतिरिक्त निर्भरता नहीं चाहिए अगर मुझे इसकी आवश्यकता नहीं है
  2. दूसरा बहिष्कृत, निर्भरता hibernate-coreडाउनलोड करते समय बाहर करने के लिए ढाल को निर्देश देता है com.zaxxerऔर ऐसा इसलिए hibernate-coreहै क्योंकि पहले से ही डाउनलोड किया गया है Spring Bootऔर हम विभिन्न संस्करणों के साथ समाप्त नहीं करना चाहते हैं।
  3. तीसरा अपवर्जित करता है, hibernate-coreउस hibernate-hikaricpमॉड्यूल को डाउनलोड करने के लिए अपग्रेड करने का निर्देश देता है जिसे org.hibernate.hikaricp.internal.HikariCPConnectionProviderपदावनत करने के बजाय HikariCP का उपयोग कनेक्शन प्रदाता के रूप में करने की आवश्यकता होती हैcom.zaxxer.hikari.hibernate.HikariConnectionProvider

एक बार जब मुझे पता चल गया build.gradleकि क्या रखना है और क्या नहीं, तो मैं datasourceअपने कॉन्फ़िगरेशन को कॉपी / पेस्ट करने के लिए तैयार था application.propertiesऔर उम्मीद थी कि सब कुछ उड़ने वाले रंगों के साथ काम करेगा, लेकिन वास्तव में नहीं और मैं निम्नलिखित मुद्दों पर ठोकर खाई।

  • स्प्रिंग बूट डेटाबेस विवरण (यानी url, ड्राइवर) का पता लगाने में विफल होने पर इसलिए, jpa और हाइबरनेट सेटअप करने में सक्षम नहीं है (क्योंकि मैंने संपत्ति के प्रमुख मूल्यों को सही नहीं बताया है)
  • HikariCP वापस गिरने के लिए com.zaxxer.hikari.hibernate.HikariConnectionProvider
  • जब ऑटो-हाइबरनेट / जेपीए के लिए नए कनेक्शन-प्रदाता का उपयोग करने के लिए स्प्रिंग को निर्देश देने के बाद, HikariCP विफल हो गया क्योंकि यह कुछ key/valueमें देख रहा application.propertiesथा और इसके बारे में शिकायत कर रहा था dataSource, dataSourceClassName, jdbcUrl। मुझे इसमें डिबग करना पड़ा HikariConfig, HikariConfigurationUtil, HikariCPConnectionProviderऔर पता चला कि इसमें HikariCPसे गुण नहीं मिल सकते application.propertiesक्योंकि इसे अलग नाम दिया गया था।

वैसे भी, यह वह जगह है जहाँ मुझे परीक्षण और त्रुटि पर भरोसा करना था और यह सुनिश्चित करना था कि HikariCPगुण (यानी डेटा स्रोत जो डीबी विवरण, साथ ही पूलिंग गुण) के साथ-साथ स्पिंग बूट की अपेक्षा के अनुसार व्यवहार करता है और मैं समाप्त हो गया है। निम्न application.propertiesफ़ाइल।

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 

जैसा कि विन्यास के ऊपर दिखाया गया है, निम्नलिखित नामकरण पैटर्न के आधार पर श्रेणियों में विभाजित किया गया है

  • spring.datasource.x (स्प्रिंग ऑटो-कॉन्फिगर इन्हें चुनेंगे, इसलिए HikariCP)
  • spring.datasource.hikari.x (HikariCP पूल सेटअप करने के लिए इन्हें चुनता है, कैमलकेस फ़ील्ड नामों पर ध्यान दें)
  • Spring.jpa.hibernate.connection.provider_class (नए HibernateConnectionProvider का उपयोग करने के लिए वसंत निर्देश)
  • spring.jpa.properties.hibernate.x (स्प्रिंग को ऑटो से कॉन्फ़िगर करने के लिए जेपीए द्वारा उपयोग किया जाता है, अंडरस्कोर वाले फ़ील्ड नामों पर ध्यान दें)

एक ट्यूटोरियल या पोस्ट या कुछ संसाधन में आना मुश्किल है जो दिखाता है कि उपरोक्त गुणों की फ़ाइल का उपयोग कैसे किया जाता है और गुणों का नाम कैसे दिया जाना चाहिए। खैर, यह लो।

ऊपर फेंकने application.propertiesके साथ build.gradle(या इसी तरह कम से कम) एक स्प्रिंग बूट जेपीए परियोजना संस्करण (1.5.8) में एक आकर्षण की तरह काम करते हैं और अपने पूर्व कॉन्फ़िगर डेटाबेस से कनेक्ट करना चाहिए (यानी मेरे मामले में यह के PostgreSQL में है कि दोनों HikariCP & Springसे बाहर आंकड़ा spring.datasource.urlहै जिस पर डेटाबेस ड्राइवर का उपयोग करने के लिए)।

मुझे DataSourceबीन बनाने की आवश्यकता नहीं दिखी और ऐसा इसलिए है क्योंकि स्प्रिंग बूट मेरे लिए हर चीज को देखने में सक्षम है application.propertiesऔर यह साफ-सुथरा है।

लेख HikariCP के GitHub में विकि कैसे जेपीए के साथ सेटअप स्प्रिंग बूट लेकिन, शो स्पष्टीकरण और विवरण का अभाव है।

उपर्युक्त दो फ़ाइल भी सार्वजनिक रूप से उपलब्ध हैं https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6


आपके पोस्ट करने से पहले मैं इस अधिकार से जूझ रहा था। धन्यवाद!
बोगदान पुक्कू

खुशी है कि यह आपकी मदद की! 👍
आरएएफ

रफ आप एक भयानक जवाब है। मैं उत्सुक था कि क्या आपके लिए स्प्रिंग बूट 2.0.0.M6 के लिए आवश्यक परिवर्तनों को पोस्ट करना संभव होगा। कॉन्फ़िगरेशन के साथ संघर्ष नहीं किया जा रहा है और माइग्रेशन गाइड अभी तक अपडेट नहीं किया गया है
मैथ्यू फोंटाना

हे मैट, मैं 1.5.8 रिलीज का उपयोग कर रहा था जब मैंने यहां अपना समाधान साझा किया। मैं 2.0.0.M6 को एक त्वरित प्रयास देना चाहता था लेकिन, दुर्भाग्यवश उन्हें आपको एक उच्चतर संस्करण के लिए आवश्यकता होती है। एकमात्र बदलाव जो मैं 2.0.0 में याद रख सकता हूं। वसंत जपा के लिए HikariCP डिफ़ॉल्ट कनेक्शन पूलिंग कर रहा होगा। यहाँ देखें github.com/spring-projects/spring-boot/commit/… HikariConfigurationUtil, HikariCPConnectionProvider को सुनिश्चित करने के लिए डिबगिंग का प्रयास करें संपत्तियों को उठाया जाता है।
रफ

26

आप केवल application.yml / application.properties का ही उपयोग कर सकते हैं। किसी DataSourceबीन को स्पष्ट रूप से बनाने की कोई आवश्यकता नहीं है

आपको ydemartino द्वारा बताए गए tomcat-jdbc को बाहर करना होगा

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

आप नहीं बनाएगा के रूप में DataSourceसेम, आप स्पष्ट रूप से के माध्यम से हिकारी का उपयोग कर निर्दिष्ट करना spring.datasource.typeमूल्य के साथ com.zaxxer.hikari.HikariDataSourceapplication.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

आपके एप्लिकेशन.आईएमएल / एप्लीकेशन.प्रोचैटिटीज में, आप Hikari विशिष्ट मापदंडों जैसे पूल आकार आदि को कॉन्फ़िगर कर सकते हैं spring.datasource.hikari.*


इस काम को करने के लिए आपको टॉमकैट को बाहर करने की आवश्यकता नहीं है, जोड़ना spring.datasource.typeकाफी है।
माइकल पिफेल 12

3
@MichaelPiefel आपको बहिष्करण करने की आवश्यकता है। DataSourceBuilderजेवाडॉक का कहना है: अगर टॉमकैट, हिकारीपीपी या कॉमन्स डीबीसीपी क्लासपाथ पर हैं, तो उनमें से एक का चयन किया जाएगा (उस क्रम में पहले टॉमकैट के साथ)। मेरा परीक्षण इसकी पुष्टि करता है।
Jan Bodnar

1
@JanBodnar:, DataSourceConfigurationजिसका उपयोग ऑटो-कॉन्फ़िगरेशन में किया जाता है, कॉन्फ़िगरेशन पर निर्भर करता है spring.datasource.typeयदि यह बिल्कुल सेट है। इसलिए, मेरे पास tomcat-jdbcमेरी कक्षा है, और अभी भी मेरे पूल के रूप में HikariCP का उपयोग करता हूं। मेरा परीक्षण इसकी पुष्टि करता है। शायद हम यहां बहुत अलग स्प्रिंग बूट संस्करणों के बारे में बात कर रहे हैं।
माइकल पिफेल 12:00

1
@MichaelPiefel दिलचस्प बात यह है कि, मैंने इसे केवल DataSourceBuilder.create () ... प्रकार (com.zaxxer.hikari.HikariDataSource.class) का उपयोग करके जावा कॉन्फ़िगरेशन के साथ बहिष्करण के बिना ठीक चलाने में कामयाब रहा है। यमल फ़ाइल में कॉन्फ़िगरेशन के साथ, यह मेरे लिए काम नहीं करता था। इसलिए कुछ पकड़ना होगा।
Jan Bodnar

15

मैं स्प्रिंग बूट 2.0.4 का उपयोग कर रहा हूँ। कृपया। Hikari डिफ़ॉल्ट कनेक्शन पूल है और .hikariअब आवश्यक नहीं है।

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

और configurationविस्तार करने की आवश्यकता नहीं है HikariConfig, और DataSourceBuilderइसका उपयोग किया जा सकता है जैसा कि पहले था।

@Configuration
public class DataSourceConfiguration {

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

10

प्रलेखन के अनुसार इसे बदल दिया गया है,

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

उदाहरण :

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

ये निम्नलिखित विन्यास परिवर्तन हैं जो हम शिकारी पर कर सकते हैं, कृपया अपनी आवश्यकता के अनुसार जोड़ें / अपडेट करें।

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

9

आपको वैरिएबल के लिए प्रॉपर्टी वैल्यू डालने के लिए अनावश्यक कोड की आवश्यकता नहीं है। आप सीधे गुण फ़ाइल के साथ गुण सेट कर सकते हैं।

hikari.propertiesक्लासपाथ में फाइल रखो ।

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

और इस तरह से एक डेटा स्रोत बीन बनाओ।

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

    return dataSource;
}

8

यदि यह मदद करता है तो यह मेरे बूट एप्लिकेशन के लिए काम करता है। यह वर्ग बताता है कि कॉन्फिग ऑब्जेक्ट किस गुणों की तलाश में है:

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

मुझे लगता है कि मल्टीपल डेटा datasource_whateverस्रोत स्रोत फ़ाइल में संपत्ति कुंजियों को जोड़कर समर्थन कर सकते हैं। चीयर्स!

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

यह है। हालांकि यह आसानी से जावा के लिए अनुवाद योग्य है।
जेसुज़ ज़ाजुता

हाँ, अब मुझे एहसास हो रहा है कि मुझे ऐसा करने की आवश्यकता है क्योंकि अब मैं मेट्रिक्स को कॉन्फ़िगर करना चाहता हूं। और जिस तरह से मैं यह देखने के लिए कर सकता हूं वह ऑटोकॉन्फिगेशन को ओवरराइड करने के लिए इस JavaConfig के साथ है। धन्यवाद।
केविन एम

हाँ, यह मदद करता है! तुम मेरे opvote भी मिल ... यह groovie है? यह बहुत दिलचस्प है, यह जावास्क्रिप्ट की तरह है :-)
जोआओ पोलो

8

आप dataSourceClassName दृष्टिकोण का उपयोग कर सकते हैं, यहां MySQL के साथ एक उदाहरण है। (स्प्रिंग बूट 1.3 और 1.4 के साथ परीक्षण किया गया)

पहले आपको क्लासपैथ से टॉमकट-जेडडीबी को बाहर करने की आवश्यकता है क्योंकि इसे हाइकारिकप के पक्ष में चुना जाएगा।

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

फिर बस जोड़ें

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

मैंने यहां एक परीक्षण परियोजना बनाई: https://github.com/ydemartino/spring-boot-hikaricp


8

आप @Andy Wilkinson द्वारा कहा गया application.properties कॉन्फ़िगरेशन में dataSourceClassName दृष्टिकोण का उपयोग नहीं कर सकते। यदि आप dataSourceClassName वैसे भी रखना चाहते हैं, तो आप जावा कॉन्फिगरेशन का उपयोग कर सकते हैं:

@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 का उपयोग नहीं कर सकते क्योंकि यह फेंक और अपवाद होगा

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

जिसका मतलब है कि स्प्रिंग बूट, स्प्रिंग। infasource.url से ड्राइवर की संपत्ति को प्रभावित करता है और उसी समय डेटा सेट सोर्सक्लासनाम यह अपवाद बनाता है। इसे सही करने के लिए आपके एप्लिकेशन.प्रकार को 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

नोट: कृपया जाँच करें कि क्या आपके वर्गपथ में कोई टॉमकट-जेडबी.इनजर या कॉमन्स-डीबीसीपी.जर है जो अधिकांश समय सकर्मक निर्भरता द्वारा जोड़ा गया है। यदि ये क्लासपाथ में मौजूद हैं तो स्प्रिंग बूट डिफॉल्ट कनेक्शन पूल का उपयोग करके डेटासोर्स को कॉन्फ़िगर करेगा जो कि टॉमकैट है। HikariCP का उपयोग केवल Datasource बनाने के लिए किया जाएगा यदि कोई क्लासपैथ में कोई अन्य प्रदाता नहीं है। कॉमबैक्स DBCP के लिए टोमैट -> से HikariCP -> का फॉलबैक सीक्वेंस है।


1
यह सुपर मददगार था, हालांकि मुझे डेटा स्रोत प्रॉप्स को कॉन्फ़िगर करने के लिए स्ट्रिंग टाइप जैसी कुछ संपत्ति नामों का उल्लेख नहीं करना था।
comiventor

यह जानकर अच्छा लगा कि इससे मदद मिली।
शाहिद यूसुफ

8

यह उन लोगों की मदद करेगा जो वसंत ऑटो कॉन्फ़िगरेशन के साथ अपने आवेदन के लिए हाइकरिकॉप कॉन्फ़िगर करना चाहते हैं। मेरी परियोजना के लिए, डेटाबेस के रूप में JDBC कनेक्शन पूल और mysql के रूप में hikaricp के साथ स्प्रिंग बूट 2 का उपयोग करके im। एक चीज़ जो मैंने अन्य उत्तरों में नहीं देखी थी, वह थी data-source-propertiesविभिन्न गुणों को सेट करने के लिए इस्तेमाल किया जा सकता है जो spring.datasource.hikari.*पथ पर उपलब्ध नहीं हैं । यह HikariConfigकक्षा का उपयोग करने के बराबर है । Mysql विशिष्ट गुणों के लिए डेटा स्रोत और hikaricp कनेक्शन पूल को कॉन्फ़िगर करने के लिए मैंने स्प्रिंग ऑटो कॉन्फ़िगर एनोटेशन और निम्न गुणों का उपयोग किया। application.yml फ़ाइल में।

@EnableAutoConfigurationअपने कॉन्फ़िगरेशन बीन फ़ाइलों में से एक पर रखें ।

application.yml फाइल इस तरह दिख सकती है।

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

डेटा-सोर्स-प्रॉपर्टीज़ के साथ काम करने का उदाहरण देने के लिए यह उत्तर मूल्यवान है!
मूरो मोलियारी

6

यहाँ अच्छी खबर है। HikariCP स्प्रिंग बूट 2.0.0 के साथ अब डिफ़ॉल्ट कनेक्शन पूल है।

स्प्रिंग बूट 2.0.0 रिलीज नोट्स

स्प्रिंग बूट 2.0 में डिफ़ॉल्ट डेटाबेस पूलिंग तकनीक को टॉमकैट पूल से HikariCP में बदल दिया गया है। हमने पाया है कि हकारी बेहतर प्रदर्शन प्रदान करता है, और हमारे कई उपयोगकर्ता इसे टॉमकैट पूल पर पसंद करते हैं।


5

तो यह पता चला है कि HikariCP के लिए लगभग सभी डिफ़ॉल्ट सेटिंग्स मेरे लिए DB कनेक्शन की संख्या को छोड़कर काम करती हैं। मैंने अपने आवेदन में वह संपत्ति निर्धारित की है।

spring.datasource.maximumPoolSize=20

और एंडी विल्किंसन सही है जहाँ तक मैं यह बता सकता हूँ कि आप स्प्रिंग बूट के साथ HikariCP के लिए डेटा सोर्स क्लैमनाम कॉन्फ़िगरेशन दृष्टिकोण का उपयोग नहीं कर सकते।


2
मैं कुछ समय के लिए विभिन्न अनुप्रयोगों में HikariCP का उपयोग कर रहा हूं, और अब तक कभी कोई समस्या नहीं थी। मैं HikariConfig दृष्टिकोण का उपयोग कर रहा हूं, जहां आपके पास गुण फ़ाइल पर आपके सभी कॉन्फ़िगरेशन हैं। स्प्रिंगबूट और स्प्रिंगकोर के साथ ही उम्मीद के मुताबिक काम करता है। मैं भी maxPoolSize कॉन्फ़िगर कर रहा हूँ।
डेवी अल्वेस

यह spring.datasource.maximum-pool-sizeतब होना चाहिए जब आप वसंत विन्यास गुणों का उपयोग करते हैं, अन्यथा maximumPoolSizeHikariCP पैरामीटर नाम है।
sura2k

3

मेरा सेटअप:
स्प्रिंग बूट v1.5.10
हिकारी v.3.2.x (मूल्यांकन के लिए)

हिकारी डेटा स्रोत के विन्यास को समझने के लिए, मैं डेटा स्रोत के लिए स्प्रिंग बूट के ऑटो-कॉन्फ़िगरेशन को अक्षम करने की सलाह देता हूं।

Application.properties के लिए निम्नलिखित जोड़ें:

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

यह अपने आप ही डेटा स्रोत को कॉन्फ़िगर करने के लिए स्प्रिंग बूट की क्षमता को अक्षम कर देगा।

अब आपके लिए मौका है कि आप HikariDataSource बीन बनाने के लिए अपने स्वयं के कस्टम कॉन्फ़िगरेशन को परिभाषित करें और इसे वांछित गुणों के साथ आबाद करें।

नोट :::
सार्वजनिक वर्ग HikariDataSource HikariConfig का विस्तार करता है

आपको

  1. वांछित Hikari गुणों का उपयोग करके HikariConfig ऑब्जेक्ट को आबाद करें
  2. HikariDataSource ऑब्जेक्ट को HikariConfig ऑब्जेक्ट के साथ आरम्भ करें, जो कंस्ट्रक्टर के तर्क के रूप में पारित हुआ है।

मैं अपने स्वयं के डेटा स्रोत बनाने के लिए अपने स्वयं के कस्टम कॉन्फ़िगरेशन वर्ग (@Configuration) को परिभाषित करने में विश्वास करता हूं और इसे एक अलग फ़ाइल (पारंपरिक: application.properties)

में परिभाषित डेटा स्रोत गुणों के साथ पॉप्युलेट करता हूं। इस तरीके से मैं अपने स्वयं को परिभाषित कर सकता हूं सेफ़रनेट बीन ने हाइबरनेट का उपयोग करते हुए सिफारिश की: "लोकलसेशनफैक्टरीबीन" वर्ग और इसे अपने हाइकरी डेटा स्रोत> और अन्य हाइबरेंट-जेपीए आधारित गुणों के साथ आबाद करें।

वसंत बूट आधारित शिकारी डेटा स्रोत का सारांश: -

spring.datasource.hikari.allow-pool-suspension = true
spring.datasource.hikari.auto-प्रतिबद्ध = झूठी
spring.datasource.hikari.catalog =
spring.datasource.hikari.conitection-init-sql =
spring.datasource.hikari। कनेक्शन-परीक्षण-क्वेरी =
spring.datasource.hikari.connection-timeout = 100
spring.datasource.hikari.data-source-class-name =
spring.datasource.hikari.data-source-jndi =
spring.datasource.hikari.driver -क्लास-नाम =
spring.datasource.hikari.idle-timeout = 50
spring.datasource.hikari.initialization-fast-true = true
spring.datasource.hikari.isolate-internal-
questions = true spring.datasource.hikari.jdbc- url =
spring.datasource.hikari.leak-डिटेक्शन-थ्रेशोल्ड =
spring.datasource.hikari.login-timeout = 60
spring.datasource.hikari.max- जीवनकाल =
spring.datasource.hikari.maximum-pool-size = 500
spring.datasource.hikari.minari- 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-आइसोलेशन =
spring.datasource.hikari .username =
spring.datasource.hikari.validation-timeout =


spring.datasource.hikari.maximum-पूल आकार = 500 वास्तव में भयानक है और यह हिकारी :) से अनुशंसित नहीं है github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing
mertaksu

यह सिर्फ वैल्यू के साथ एक नमूना विन्यास था :)
फिलिप दिलीप

2

बाद के वसंत-बूट रिलीज के साथ Hikari पर स्विच करना पूरी तरह से कॉन्फ़िगरेशन में किया जा सकता है। मैं उपयोग कर रहा हूं 1.5.6.RELEASEऔर यह दृष्टिकोण काम करता है।

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

आवेदन YAML

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

connectionTestQueryअपने अंतर्निहित DB के अनुरूप बदलें । यह है, कोई कोड की आवश्यकता है।


2

नीचे दिए गए कोड का उपयोग स्थैतिक डेटा स्रोत इनिशियलाइज़ेशन के लिए किया जा सकता है।

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

मैं मुद्दों का सामना कर रहा था और समस्या अंत में एक व्हाट्सएप थाspring.datasource.type = com.zaxxer.hikari.HikariDataSource


0

अब वसंत बूट के नए संस्करण के साथ डिफ़ॉल्ट कनेक्शन पूलिंग के रूप में HikcariCp के साथ। इसे सीधे नीचे दिखाया गया है।

@Configuration
public class PurchaseOrderDbConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "com.sysco.purchaseorder.datasoure")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }

}

application.yml

com:
  sysco:
    purchaseorder:
      datasoure:
        driverClassName: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://localhost:3306/purchaseorder
        username: root
        password: root123
        idleTimeout: 600000

यदि आप निष्क्रिय टाइमआउट मान को प्रिंट करेंगे

ApplicationContext context=SpringApplication.run(ApiBluePrint.class, args);
   HikariDataSource dataSource=(HikariDataSource) context.getBean(DataSource.class);
   System.out.println(dataSource.getIdleTimeout());

यदि आप किसी भी कस्टम मूल्य को परिभाषित नहीं करते हैं तो आपको 600000 के रूप में मान मिलेगा जहां डिफ़ॉल्ट मान 300000 है

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.