Comment configurer HikariCP dans mon application de démarrage de printemps dans mon application.les propriétés des fichiers?

vous pouvez simplement faire usage de l'application.yml/de l'application.les propriétés. Il n'est pas nécessaire de créer explicitement tout DataSource Bean

vous devez exclure tomcat-jdbc comme mentionné par 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>

comme vous ne voulez pas créer DataSource bean, vous devez spécifier explicitement en utilisant Hikari par spring.datasource.type avec la valeur com.zaxxer.hikari.HikariDataSource dans l'application.yml / de l'application.propriétés 151980920"

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

In votre application.yml / de l'application.propriétés, Vous pouvez configurer des paramètres spécifiques à Hikari tels que la taille de la piscine, etc dans spring.datasource.hikari.*

je suis tombé sur HikariCP et j'ai été étonné par les benchmarks et je voulais l'essayer à la place de mon choix par défaut C3P0 et à ma surprise j'ai lutté pour obtenir le configurations raison probablement parce que les configurations diffèrent en fonction de quelle combinaison de pile de technologie vous utilisez.

j'ai mis en place Spring Boot projet avec JPA, Web, Security démarreurs (en utilisant Spring Initializer ) pour utiliser PostgreSQL comme une base de données avec HikariCP comme mise en commun de connexion.

J'ai utilisé Gradle comme outil de construction et je voudrais partager ce qui a fonctionné pour moi pendant les hypothèses suivantes:

1. démarrage à ressort JPA (Web & Security - optional)
2. Gradle construire trop
3. PostgreSQL exécution et setup avec une base de données (c.-à-d. schéma, utilisateur, db)

vous avez besoin de ce qui suit build.gradle si vous utilisez Gradle ou l'équivalent pom.xml si vous utilisez 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'
    }
}

il y a un tas d'exclus dans le ci-dessus build.gradle et c'est parce que

1. première exclusion, instruction gradle qui exclut le pool de connexion jdbc-tomcat lors du téléchargement des dépendances spring-boot-starter-data-jpa . Cela peut être réalisé en mettant en place le spring.datasource.type=com.zaxxer.hikari.HikariDataSource aussi, mais, je ne veux pas d'une dépendance supplémentaire si je Je n'en ai pas besoin
2. deuxième exclusion, instruction gradle d'exclure hibernate-core lors du téléchargement com.zaxxer dépendance et c'est parce que hibernate-core est déjà téléchargé par Spring Boot et nous ne voulons pas finir avec des versions différentes.
3. Troisièmement exclure, instruction gradle d'exclure hibernate-core lors du téléchargement du module hibernate-hikaricp nécessaire pour que HikariCP utilise org.hibernate.hikaricp.internal.HikariCPConnectionProvider comme fournisseur de connexion au lieu de déprécié com.zaxxer.hikari.hibernate.HikariConnectionProvider

une fois que j'ai compris le build.gradle et ce qu'il faut garder et ce qu'il ne faut pas, j'étais prêt à copier/coller un datasource configuration dans mon application.properties et je m'attendais à ce que tout fonctionne avec brio mais, pas vraiment et je suis tombé sur les questions suivantes

• démarrage à ressort ne pas trouver les détails de la base de données (i.e. url, driver) donc, pas en mesure de configurer jpa et hibernate (parce que je n'ai pas le nom de la propriété de valeurs de clé de droite)
• HikariCP retombant à com.zaxxer.hikari.hibernate.HikariConnectionProvider
• après avoir demandé à Spring D'utiliser un nouveau fournisseur de connexion pour quand auto-configuration hibernate/jpa puis HikariCP échoué parce qu'il cherchait quelque key/value dans le application.properties et se plaignait de dataSource, dataSourceClassName, jdbcUrl . J'ai dû déboguer dans HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider et ai découvert que HikariCP ne pouvait pas trouver les propriétés de application.properties parce qu'il a été nommée différemment.

quoi qu'il en soit, c'est là que j'ai dû me fier aux essais et à l'erreur et m'assurer que HikariCP est capable de choisir les propriétés (c'est-à-dire la source de données qui est les détails de la base de données, ainsi que les propriétés de mise en commun) ainsi que le démarrage de Sping se comportent comme prévu et je me suis retrouvé avec le fichier application.properties suivant.

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 

comme indiqué ci-dessus, les configurations sont divisées en catégories basées sur les motifs suivants:

• "1519870920 de" printemps".source de données.x (le Printemps de l'auto-configure va chercher ces, il en sera de HikariCP)
• "1519870920 de" printemps".source de données.hikari.x (HikariCP les choisit pour configurer le pool, noter les noms des champs camelCase)
• "1519870920 de" printemps".jpa.hiberner.connexion.provider_class (donne à Spring L'instruction d'utiliser un nouveau Provider D'hibernation)
• "1519870920 de" printemps".jpa.propriété.hiberner.x (utilisé par Spring pour auto-configurer JPA, faire une note des noms de champ avec des underscores)

il est difficile de trouver un tutoriel ou un post ou une ressource qui montre comment le fichier de propriétés ci-dessus est utilisé et comment les propriétés doivent être nommées. Eh bien, là vous l'avez.

Jeter application.properties avec build.gradle (ou au moins similaire) dans un La version de projet JPA (1.5.8) devrait fonctionner comme un charme et se connecter à votre base de données préconfigurée (i.e. dans mon cas, C'est PostgreSQL que les deux HikariCP & Spring comprendre à partir du spring.datasource.url sur lequel pilote de base de données à utiliser).

Je n'ai pas vu la nécessité de créer un DataSource haricot et c'est parce que la botte à ressort est capable de tout faire pour moi juste en regardant dans application.properties et c'est bien.

Le l'article dans Github wiki de HikariCP montre comment configurer la botte de ressort avec JPA mais, manque d'explication et de détails.

Les deux ci-dessus fichier est également disponible en tant que public essentiel https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

vous n'avez pas besoin de code redondant pour mettre des valeurs de propriété aux variables. Vous pouvez définir des propriétés avec un fichier de propriétés directement.

Mettre hikari.properties fichier dans le classpath.

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

et faire un haricot source de données comme ceci.

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

    return dataSource;
}

cela fonctionne pour mon application de démarrage dans le cas où il aide. Cette classe vous indique les propriétés que l'objet config recherche:

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

je pense que plusieurs sources de données pourraient être supportées en ajoutant datasource_whatever aux clés de propriétés dans le fichier de configuration source. Acclamations!

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

vous ne pouvez pas utiliser l'approche dataSourceClassName dans l'application.les configurations des propriétés comme l'a dit @Andy Wilkinson. si vous voulez tout de même avoir dataSourceClassName, vous pouvez utiliser Java Config comme:

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

raison vous ne pouvez pas utiliser dataSourceClassName parce qu'il lancera et l'exception

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

qui signifie que la botte à ressort est tirée du ressort.source de données.propriété de l'url le pilote et en même temps la définition du dataSourceClassName crée cette exception. Pour faire droit à votre demande.les propriétés devraient ressembler à quelque chose comme ceci pour hikaricp datasource:

# 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

Note: veuillez vérifier s'il y a un tomcat-jdbc.jar ou commons-dbcp.jar dans votre classpath ajouté la plupart du temps par la dépendance transitive. Si ceux-ci sont présents dans classpath Spring Boot configurera la source de données en utilisant le pool de connexion par défaut qui est tomcat. HikariCP ne sera utilisé pour créer la source de données que s'il n'y a pas autre fournisseur en classpath. il y a une séquence de repli de tomcat -> à HikariCP -> vers DBCP commun.

vous pouvez utiliser l'approche dataSourceClassName, voici un exemple avec MySQL. (Testé avec les amorces à ressort 1.3 et 1.4)

tout d'abord, vous devez exclure tomcat-jdbc du chemin de classe car il sera choisi en faveur de 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>

de l'application.propriétés

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

puis juste ajouter

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

j'ai créé un projet d'essai ici: https://github.com/ydemartino/spring-boot-hikaricp

Voici la bonne nouvelle. HikariCP est le pool de connexion par défaut avec Spring Boot 2.0.0.

Amortisseur À Ressort 2.0.0 Notes De Mise À Jour

la technologie de mise en commun de bases de données par défaut dans le démarrage à ressort 2.0 a été transférée de Tomcat Pool à HikariCP. Nous avons découvert que Hakari offre des performances supérieures, et beaucoup de nos utilisateurs le préfèrent à Tomcat Pool.

il s'avère donc que presque tous les paramètres par défaut pour HikariCP fonctionnent pour moi sauf le nombre de connexions DB. J'ai mis cette propriété dans ma demande.propriétés:

spring.datasource.maximumPoolSize=20

et Andy Wilkinson est correct pour autant que je puisse dire que vous ne pouvez pas utiliser l'approche de configuration dataSourceClassName pour HikariCP avec le démarrage à ressort.

avec les versions de démarrage à ressort ultérieures, le passage à Hikari peut se faire entièrement en configuration. J'utilise 1.5.6.RELEASE et cette approche fonctionne.

"151970920 de construire".Grad le:

compile "com.zaxxer:HikariCP:2.7.3"

application YAML

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

Change connectionTestQuery pour correspondre à votre base de données sous-jacente. C'est ça, aucun code n'est requis.

selon la documentation il est changé,

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

exemple:

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

ce sont les changements de configuration suivants que nous pouvons faire sur hikari, s'il vous plaît ajouter/mettre à jour en fonction de vos besoins.

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

Mon Installation:

Botte de printemps v1.5.10

Hikari v. 3.2.x (pour évaluation)

pour vraiment comprendre la configuration de la source de données Hikari, je recommande de désactiver L'Auto-Configuration de la source de données de la botte de printemps.

ajouter ce qui suit à la demande.propriétés: -

printemps.auto-configurer.exclude=org.springframework.démarrage.auto-configurer.jdbc.Source des donnéesauto-configuration

cela va désactiver la capacité de la botte de printemps pour configurer la source de données sur son propre.

est maintenant l'occasion pour vous de définir votre propre Configuration personnalisée pour créer hikaridatasource bean et le peupler avec les propriétés désirées.

REMARQUE :::

public class HikariDataSource extends HikariConfig

Vous devez

1. peupler HikariConfig objet using desired Hikari Properties
2. initialise L'objet HikariDataSource avec L'objet HikariConfig passé comme argument au constructeur.

je crois en la définition de ma propre classe de Configuration personnalisée ( @Configuration ) pour créer la source de données sur mon propre et remplir avec les propriétés de source de données définie dans un fichier séparé (que traditionnel: demande.propriétés)



De cette manière, je peux définir mon propre haricot de sessionFactory en utilisant Hibernate recommandé: "LocalSessionFactoryBean" class et le peupler avec votre source de données Hikari > et d'autres propriétés basées Hiberante-JPA.

Résumé du printemps Propriétés des sources de données Hikari basées sur Boot: -

"151900920 de" printemps".source de données.hikari.permettez-piscine-suspension=true

printemps.source de données.hikari.auto-commit=false

printemps.source de données.hikari.catalogue=

printemps.source de données.hikari.connection-init-sql=

printemps.source de données.hikari.connection-test-query=

printemps.source de données.hikari.connexion-délai=100

printemps.source de données.hikari.source des données-Classe-nom=

printemps.source de données.hikari.source des données-j-n-d-i=

printemps.source de données.hikari.chauffeur-classe-nom=

printemps.source de données.hikari.temps mort=50

printemps.source de données.hikari.initialisation-fail-fast=true

printemps.source de données.hikari.isolez-interne-requêtes=true

printemps.source de données.hikari.JDBC-url=

printemps.source de données.hikari.détection des fuites-seuil=

printemps.source de données.hikari.login-timeout=60

printemps.source de données.hikari.max-durée de vie=

printemps.source de données.hikari.maximum-pool-size=500

printemps.source de données.hikari.minimum-ralenti=30

printemps.source de données.hikari.mot de passe=

printemps.source de données.hikari.pool-name=

printemps.source de données.hikari.lecture seule=true

printemps.source de données.hikari.register-mbeans=true

printemps.source de données.hikari.transaction-isolation=

printemps.source de données.hikari.nom d'utilisateur=

printemps.source de données.hikari.validation-timeout=

j'utilise la botte de printemps 2.0.4.PUBLIER. Hikari est le pool de connexion par défaut et .hikari n'est plus nécessaire.

de l'application.propriétés

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.autocommit=false
spring.datasource.poolname=myPool

de l'application.yml

spring:
    datasource:
        driverClassName: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://localhost:3306/myDB...
        username: xxx
        password: xxx
        autoCommit: false
        poolName: myPool

et configuration n'a pas besoin d'étendre HikariConfig , et DataSourceBuilder peut être utilisé comme il était avant.

@Configuration
public class DataSourceConfiguration {

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