Comment configurer HikariCP dans mon application Spring Boot dans mes fichiers application.properties?

J'essaie de configurer HikariCP dans mon application Spring Boot (1.2.0.M1) afin de pouvoir tester son utilisation à la place de Tomcat DBCP. Je voudrais configurer le pool de connexions dans mon fichier application.properties comme je le faisais avec Tomcat, mais je ne peux pas comprendre comment je devrais le faire. Tous les exemples que j'ai trouvés montrent soit le style JavaConfig, soit l'utilisation d'un fichier de propriétés HikariCP distinct. Quelqu'un peut-il m'aider à trouver les noms de propriété pour le configurer dans application.properties? Je voudrais également passer de l'approche driverClassName à l'approche DataSourceClassName car elle semble plus propre et est recommandée. Est-ce également possible dans mon (mes) fichier (s) application.properties?

Voici ce que j'avais pour Tomcat DBCP (juste une configuration de base, pas complètement débusquée)

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

Et j'utilise actuellement driverClassName et jdbc url pour configurer la connexion:

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

MIS À JOUR! Depuis la version Spring Boot 1.3.0 :

1. Ajoutez simplement HikariCP aux dépendances
2. Configurer 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

MIS À JOUR! Depuis la version Spring Boot 2.0.0 :

Le pool de connexions par défaut est passé de Tomcat à Hikari :)

Je suis tombé sur HikariCPet j'ai été étonné par les repères et je voulais l'essayer au lieu de mon choix par défaut C3P0et à ma grande surprise, j'ai eu du mal à faire le configurationsbon probablement parce que les configurations diffèrent en fonction de la combinaison de pile technologique que vous utilisez.

J'ai un Spring Bootprojet d' installation avec des JPA, Web, Securitydémarreurs (à l'aide de Spring Initializer ) à utiliser PostgreSQLcomme base de données avec HikariCPcomme pool de connexion.
J'ai utilisé Gradlecomme outil de construction et j'aimerais partager ce qui a fonctionné pour moi pour les hypothèses suivantes:

1. Spring Boot Starter JPA (Web et sécurité - en option)
2. Gradle construit aussi
3. PostgreSQL en cours d'exécution et configuration avec une base de données (ie schéma, utilisateur, base de données)

Vous avez besoin des éléments suivants build.gradlesi vous utilisez Gradleou un équivalent pom.xmlsi 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'exclusions dans ce qui précède build.gradleet c'est parce que

1. Exclure d'abord, indique gradle qui exclut le jdbc-tomcatpool de connexions lors du téléchargement des spring-boot-starter-data-jpadépendances. Cela peut être réalisé en configurant spring.datasource.type=com.zaxxer.hikari.HikariDataSourceaussi mais, je ne veux pas de dépendance supplémentaire si je n'en ai pas besoin
2. La deuxième exclusion, indique à Gradle d'exclure hibernate-corelors du téléchargement de la com.zaxxerdépendance, car elle hibernate-coreest déjà téléchargée par Spring Bootet nous ne voulons pas nous retrouver avec des versions différentes.
3. Troisième exclusion, indique à gradle d'exclure hibernate-corelors du téléchargement du hibernate-hikaricpmodule nécessaire pour que HikariCP soit utilisé org.hibernate.hikaricp.internal.HikariCPConnectionProvidercomme fournisseur de connexion au lieu d'être obsolètecom.zaxxer.hikari.hibernate.HikariConnectionProvider

Une fois que j'ai compris build.gradlece qu'il fallait conserver et ce qu'il ne fallait pas, j'étais prêt à copier / coller une datasourceconfiguration dans mon application.propertieset je m'attendais à ce que tout fonctionne avec brio, mais pas vraiment et je suis tombé sur les problèmes suivants

• Spring boot ne parvient pas à trouver les détails de la base de données (c'est-à-dire l'URL, le pilote), par conséquent, impossible de configurer jpa et hibernate (car je n'ai pas nommé les valeurs de clé de propriété correctement)
• HikariCP revient à com.zaxxer.hikari.hibernate.HikariConnectionProvider
• Après avoir demandé à Spring d'utiliser un nouveau fournisseur de connexion pour la configuration automatique de hibernate / jpa, HikariCP a échoué car il en recherchait key/valuedans le application.propertieset se plaignait de dataSource, dataSourceClassName, jdbcUrl. J'ai dû déboguer HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvideret découvrir que HikariCPje ne pouvais pas trouver les propriétés application.propertiescar il était nommé différemment.

Quoi qu'il en soit, c'est là que je devais compter sur des essais et des erreurs et m'assurer que c'était HikariCPcapable de choisir les propriétés (c'est-à-dire la source de données qui contient les détails de la base de données, ainsi que les propriétés de mise en commun) ainsi que Sping Boot se comportent comme prévu et j'ai fini avec le application.propertiesfichier 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 en fonction des modèles de dénomination suivants

• spring.datasource.x (la configuration automatique de Spring les choisira, tout comme HikariCP)
• spring.datasource.hikari.x (HikariCP les choisit pour configurer le pool, notez les noms des champs camelCase)
• spring.jpa.hibernate.connection.provider_class ( demande à Spring d'utiliser le nouveau HibernateConnectionProvider)
• spring.jpa.properties.hibernate.x (Utilisé par Spring pour configurer automatiquement JPA, notez les noms de champ avec des traits de soulignement)

Il est difficile de trouver un didacticiel, une publication 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. Bien, tu l'as maintenant.

Lancer ce qui précède application.propertiesavec build.gradle(ou au moins similaire) dans une version de projet Spring Boot JPA (1.5.8) devrait fonctionner comme un charme et se connecter à votre base de données préconfigurée (c'est-à-dire dans mon cas, c'est PostgreSQL qui HikariCP & Springdétermine à partir spring.datasource.urlde laquelle pilote de base de données à utiliser).

Je n'ai pas vu la nécessité de créer un DataSourcebean et c'est parce que Spring Boot est capable de tout faire pour moi juste en regardant application.propertieset c'est bien.

L' article du wiki github de HikariCP montre comment configurer Spring Boot avec JPA mais manque d'explications et de détails.

Les deux fichiers ci-dessus sont également disponibles en tant que contenu public https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Vous pouvez simplement utiliser application.yml / application.properties uniquement. Il n'est pas nécessaire de créer explicitement un DataSourceBean

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 créerez pas de DataSourcebean, vous devez spécifier explicitement en utilisant Hikari spring.datasource.typeavec la valeur com.zaxxer.hikari.HikariDataSourcedans 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

Dans votre application.yml / application.properties, vous pouvez configurer des paramètres spécifiques à Hikari tels que la taille du pool, etc. spring.datasource.hikari.*

J'utilise Spring Boot 2.0.4.RELEASE. Hikari est le pool de connexions par défaut et .hikarin'est plus nécessaire.

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

Et configurationn'a pas besoin de s'étendre HikariConfig, et DataSourceBuilderpeut être utilisé comme avant.

@Configuration
public class DataSourceConfiguration {

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

Selon la documentation, il est modifié,

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, veuillez ajouter / mettre à jour en fonction de vos besoins.

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

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

Placez le hikari.propertiesfichier dans le chemin de classe.

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

Et créez un bean de source de données comme celui-ci.

@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 au cas où cela aiderait. Cette classe vous indique quelles propriétés l'objet de configuration 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 prises en charge en ajoutant datasource_whateveraux clés de propriété dans le fichier de configuration source. À votre santé!

@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 pouvez utiliser l'approche dataSourceClassName, voici un exemple avec MySQL. (Testé avec la botte à ressort 1.3 et 1.4)

Vous devez d'abord 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>

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

Ensuite, ajoutez simplement

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

J'ai créé un projet de test ici: https://github.com/ydemartino/spring-boot-hikaricp

vous ne pouvez pas utiliser l'approche dataSourceClassName dans les configurations application.properties comme indiqué par @Andy Wilkinson. si vous voulez quand 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 pour laquelle vous ne pouvez pas utiliser dataSourceClassName car il lancera une exception

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

ce qui signifie que spring boot déduit de la propriété spring.datasource.url le pilote et en même temps la définition de dataSourceClassName crée cette exception. Pour faire les choses correctement, votre application.properties devrait ressembler à quelque chose comme ceci pour la source de données 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

Remarque: veuillez vérifier s'il y a un tomcat-jdbc.jar ou commons-dbcp.jar dans votre chemin de classe ajouté la plupart du temps par une dépendance transitive. Si ceux-ci sont présents dans le chemin de classe, 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 d'autre fournisseur dans le chemin de classe. il y a une séquence de secours de tomcat -> à HikariCP -> à Commons DBCP.

Cela aidera tous ceux qui souhaitent configurer hikaricp pour leur application avec la configuration automatique de printemps. Pour mon projet, j'utilise Spring Boot 2 avec hikaricp comme pool de connexion JDBC et mysql comme base de données. Une chose que je n'ai pas vue dans d'autres réponses était celle data-source-propertiesqui peut être utilisée pour définir diverses propriétés qui ne sont pas disponibles sur le spring.datasource.hikari.*chemin. Cela équivaut à utiliser la HikariConfigclasse. Pour configurer la source de données et le pool de connexions hikaricp pour les propriétés spécifiques de mysql, j'ai utilisé l'annotation de configuration automatique de printemps et les propriétés suivantes dans le fichier application.yml.

Placez @EnableAutoConfigurationsur l'un de vos fichiers bean de configuration.

Le fichier application.yml peut ressembler à ceci.

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

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

Notes de mise à jour de Spring Boot 2.0.0

La technologie de mise en commun de bases de données par défaut dans Spring Boot 2.0 est passée de Tomcat Pool à HikariCP. Nous avons constaté 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, à l'exception du nombre de connexions DB. J'ai défini cette propriété dans mon application.properties:

spring.datasource.maximumPoolSize=20

Et Andy Wilkinson a raison pour autant que je sache en ce sens que vous ne pouvez pas utiliser l'approche de configuration dataSourceClassName pour HikariCP avec Spring Boot.

Ma configuration:
Spring Boot 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 la configuration automatique de Spring Boot pour la source de données.

Ajoutez ce qui suit à application.properties :-

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

Cela désactivera la capacité de Spring Boot à configurer le DataSource seul.

Vous avez maintenant la possibilité de définir votre propre configuration personnalisée pour créer le bean HikariDataSource et le remplir avec les propriétés souhaitées.

NOTE :::
la classe publique HikariDataSource étend HikariConfig

Tu dois

1. remplir l'objet HikariConfig à l'aide des propriétés Hikari souhaitées
2. initialisez l'objet HikariDataSource avec l'objet HikariConfig passé en 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 par moi-même et la remplir avec les propriétés de la source de données définies dans un fichier séparé (que traditionnel: application.properties)

De cette manière, je peux définir la mienne sessionFactory Bean utilisant Hibernate recommandé: classe "LocalSessionFactoryBean" et remplissez-la avec votre source de données Hikari> et d'autres propriétés basées sur Hiberante-JPA.

Résumé des propriétés de Hikari DataSource basées sur 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.leak-detection-threshold =
spring.datasource.hikari.login-timeout = 60
spring.datasource.hikari.max-life =
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 =

Avec les dernières versions de Spring-Boot, le passage à Hikari peut se faire entièrement en configuration. J'utilise 1.5.6.RELEASEet cette approche fonctionne.

build.gradle:

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

Modifiez connectionTestQueryen fonction de votre DB sous-jacent. Voilà, aucun code requis.

Le code ci-dessous peut être utilisé pour une initialisation de source de données statique.

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

J'étais confronté à des problèmes et le problème était un espace à la fin despring.datasource.type = com.zaxxer.hikari.HikariDataSource