¿Cómo configuro HikariCP en mi aplicación Spring Boot en mis archivos application.properties?

Estoy intentando configurar HikariCP en mi aplicación Spring Boot (1.2.0.M1) para poder probar su uso en lugar de Tomcat DBCP. Me gustaría configurar el grupo de conexiones en mi archivo application.properties como lo estaba haciendo con Tomcat, pero no puedo entender cómo debería hacerlo. Todos los ejemplos que he encontrado muestran el estilo JavaConfig o el uso de un archivo de propiedades HikariCP separado. ¿Puede alguien ayudarme a averiguar los nombres de las propiedades para configurarlas en application.properties? También me gustaría cambiar de usar el enfoque driverClassName al enfoque DataSourceClassName, ya que se ve más limpio y se recomienda. ¿Es esto también posible en mi (s) archivo (s) application.properties?

Esto es lo que tenía para Tomcat DBCP (solo una configuración básica, no completamente eliminada)

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

Y actualmente estoy usando driverClassName y jdbc url para configurar la conexión:

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

¡ACTUALIZADO! Desde la versión Spring Boot 1.3.0 :

1. Simplemente agregue HikariCP a las dependencias
2. Configurar 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

¡ACTUALIZADO! Desde la versión Spring Boot 2.0.0 :

El grupo de conexiones predeterminado ha cambiado de Tomcat a Hikari :)

Me encontré HikariCPy me sorprendieron los puntos de referencia y quería probarlo en lugar de mi elección predeterminada C3P0y, para mi sorpresa, luché para obtener el configurationscorrecto probablemente porque las configuraciones difieren según la combinación de pila tecnológica que esté utilizando.

Tengo un Spring Bootproyecto de configuración con JPA, Web, Securityiniciadores (usando Spring Initializer ) para usar PostgreSQLcomo una base de datos con una HikariCPagrupación de conexiones.
Lo he usado Gradlecomo herramienta de construcción y me gustaría compartir lo que funcionó para mí para las siguientes suposiciones:

1. Spring Boot Starter JPA (Web y seguridad - opcional)
2. Gradle también
3. PostgreSQL en ejecución y configuración con una base de datos (es decir, esquema, usuario, base de datos)

Necesita lo siguiente build.gradlesi está usando Gradleo equivalente pom.xmlsi está usando 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'
    }
}

Hay un montón de exclusiones en lo anterior build.gradley eso se debe a

1. Primero excluir, instruye a gradle que excluya el jdbc-tomcatgrupo de conexiones al descargar las spring-boot-starter-data-jpadependencias. Esto se puede lograr configurando spring.datasource.type=com.zaxxer.hikari.HikariDataSourcetambién, pero no quiero una dependencia adicional si no la necesito
2. La segunda exclusión, indica a gradle que excluya hibernate-coreal descargar la com.zaxxerdependencia y eso se debe a hibernate-coreque ya se descargó Spring Booty no queremos terminar con versiones diferentes.
3. Tercera exclusión, indica a gradle que excluya hibernate-coreal descargar el hibernate-hikaricpmódulo que se necesita para que HikariCP se use org.hibernate.hikaricp.internal.HikariCPConnectionProvidercomo proveedor de conexión en lugar de obsoletocom.zaxxer.hikari.hibernate.HikariConnectionProvider

Una vez que descubrí build.gradlequé guardar y qué no, estaba listo para copiar / pegar una datasourceconfiguración en mi application.propertiesy esperaba que todo funcionara con gran éxito, pero no realmente y me topé con los siguientes problemas

• Spring boot no pudo encontrar los detalles de la base de datos (es decir, url, controlador), por lo tanto, no puedo configurar jpa e hibernar (porque no nombré correctamente los valores de clave de propiedad)
• HikariCP recurriendo a com.zaxxer.hikari.hibernate.HikariConnectionProvider
• Después de indicarle a Spring que use un nuevo proveedor de conexión para cuando se configura automáticamente hibernate / jpa, HikariCP falló porque estaba buscando algo key/valueen el application.propertiesy se estaba quejando dataSource, dataSourceClassName, jdbcUrl. Tuve que depurar HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvidery descubrí que HikariCPno podía encontrar las propiedades de application.propertiesporque tenía un nombre diferente.

De todos modos, aquí es donde tuve que confiar en la prueba y error y asegurarme de que HikariCPpueda elegir las propiedades (es decir, la fuente de datos que es detalles de la base de datos, así como las propiedades de agrupación), así como Sping Boot se comporta como se esperaba y terminé con el siguiente application.propertiesarchivo.

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 

Como se muestra arriba, las configuraciones se dividen en categorías según los siguientes patrones de nomenclatura

• spring.datasource.x (la configuración automática de Spring los seleccionará, también lo hará HikariCP)
• spring.datasource.hikari.x (HikariCP elige estos para configurar el grupo, tome nota de los nombres de campo de camelCase)
• spring.jpa.hibernate.connection.provider_class (Indica a Spring que use el nuevo HibernateConnectionProvider)
• spring.jpa.properties.hibernate.x (Utilizado por Spring para configurar automáticamente JPA, tome nota de los nombres de los campos con guiones bajos)

Es difícil encontrar un tutorial, una publicación o algún recurso que muestre cómo se usa el archivo de propiedades anterior y cómo se deben nombrar las propiedades. Bueno, ahí lo tienes.

Lanzar el anterior application.propertiescon build.gradle(o al menos similar) en una versión del proyecto de Primavera de arranque de la APP (1.5.8) debería funcionar como un encanto y conectarse a la base de datos preconfigurada (es decir, en mi caso de PostgreSQL que tanto HikariCP & Springla figura hacia fuera del spring.datasource.urlsobre el cual controlador de base de datos a utilizar).

No vi la necesidad de crear un DataSourcebean y eso es porque Spring Boot es capaz de hacer todo por mí con solo mirar application.propertiesy eso es genial.

El artículo en la wiki de github de HikariCP muestra cómo configurar Spring Boot con JPA pero carece de explicación y detalles.

Los dos archivos anteriores también están disponibles como una esencia pública https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Simplemente puede hacer uso de application.yml / application.properties solamente. No es necesario crear explícitamente ningún DataSourceBean

Debe excluir tomcat-jdbc como lo menciona 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>

Como no creará un DataSourcebean, debe especificar explícitamente el uso de Hikari spring.datasource.typecon el valor com.zaxxer.hikari.HikariDataSourceen 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

En su application.yml / application.properties, puede configurar parámetros específicos de Hikari, como el tamaño del grupo, etc. spring.datasource.hikari.*

Estoy usando Spring Boot 2.0.4.RELEASE. Hikari es el grupo de conexiones predeterminado y .hikariya no es necesario.

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

Y configurationno necesita extenderse HikariConfig, y DataSourceBuilderpuede usarse como estaba antes.

@Configuration
public class DataSourceConfiguration {

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

Según la documentación se cambia,

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

Ejemplo:

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

Estos son los siguientes cambios de configuración que podemos hacer en hikari, agregue / actualice según su necesidad.

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

No necesita código redundante para poner valores de propiedad en variables. Puede establecer propiedades con un archivo de propiedades directamente.

Coloque el hikari.propertiesarchivo en la ruta de clases.

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

Y crea un bean de fuente de datos como este.

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

    return dataSource;
}

Esto funciona para mi aplicación de arranque en caso de que ayude. Esta clase le dice qué propiedades está buscando el objeto de configuración:

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

Creo que varias datasource_whateverfuentes de datos podrían ser compatibles agregando las claves de propiedad en el archivo de configuración de origen. ¡Salud!

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

Puede utilizar el enfoque dataSourceClassName, aquí hay un ejemplo con MySQL. (Probado con la bota de resorte 1.3 y 1.4)

Primero debe excluir tomcat-jdbc de la ruta de clase, ya que se seleccionará a favor 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

Entonces solo agrega

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

Creé un proyecto de prueba aquí: https://github.com/ydemartino/spring-boot-hikaricp

no puede usar el enfoque dataSourceClassName en configuraciones de application.properties como lo dijo @Andy Wilkinson. si desea tener dataSourceClassName de todos modos, puede usar Java Config como:

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

razón por la que no puede usar dataSourceClassName porque arrojará una excepción

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

lo que significa que el arranque de primavera infiere de la propiedad spring.datasource.url el controlador y, al mismo tiempo, la configuración de dataSourceClassName crea esta excepción. Para hacerlo bien, su application.properties debería verse así para la fuente de datos 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

Nota: compruebe si hay tomcat-jdbc.jar o commons-dbcp.jar en su ruta de clases agregado la mayoría de las veces por dependencia transitiva. Si estos están presentes en classpath, Spring Boot configurará el origen de datos utilizando el grupo de conexiones predeterminado que es tomcat. HikariCP solo se utilizará para crear la fuente de datos si no hay otro proveedor en classpath. hay una secuencia de respaldo de tomcat -> a HikariCP -> a Commons DBCP.

Esto ayudará a cualquiera que quiera configurar hikaricp para su aplicación con la configuración automática de Spring. Para mi proyecto, estoy usando Spring Boot 2 con hikaricp como grupo de conexiones JDBC y mysql como base de datos. Una cosa que no vi en otras respuestas fue data-source-propertiesque se puede usar para establecer varias propiedades que no están disponibles en la spring.datasource.hikari.*ruta. Esto es equivalente a usar la HikariConfigclase. Para configurar la fuente de datos y el grupo de conexiones hikaricp para propiedades específicas de mysql, utilicé la anotación de configuración automática de Spring y las siguientes propiedades en el archivo application.yml.

Colóquelo @EnableAutoConfigurationen uno de sus archivos de bean de configuración.

El archivo application.yml puede verse así.

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

Estas son las buenas noticias. HikariCP es el grupo de conexiones predeterminado ahora con Spring Boot 2.0.0.

Notas de la versión de Spring Boot 2.0.0

La tecnología de agrupación de bases de datos predeterminada en Spring Boot 2.0 se ha cambiado de Tomcat Pool a HikariCP. Descubrimos que Hakari ofrece un rendimiento superior y muchos de nuestros usuarios lo prefieren a Tomcat Pool.

Entonces resulta que casi todas las configuraciones predeterminadas para HikariCP funcionan para mí, excepto la cantidad de conexiones de base de datos. Establecí esa propiedad en mi application.properties:

spring.datasource.maximumPoolSize=20

Y Andy Wilkinson tiene razón, por lo que puedo decir, que no puede usar el enfoque de configuración dataSourceClassName para HikariCP con Spring Boot.

Mi configuración:
Spring Boot v1.5.10
Hikari v.3.2.x (para evaluación)

Para comprender realmente la configuración de la fuente de datos de Hikari, recomiendo deshabilitar la configuración automática de Spring Boot para la fuente de datos.

Agregue lo siguiente a application.properties:-

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

Esto deshabilitará la capacidad de Spring Boot para configurar el DataSource por sí solo.

Ahora tiene la oportunidad de definir su propia configuración personalizada para crear un bean HikariDataSource y completarlo con las propiedades deseadas.

NOTA :::
la clase pública HikariDataSource extiende HikariConfig

Necesitas

1. rellenar el objeto HikariConfig utilizando las propiedades de Hikari deseadas
2. inicialice el objeto HikariDataSource con el objeto HikariConfig pasado como argumento al constructor.

Creo en definir mi propia clase de configuración personalizada (@Configuration) para crear la fuente de datos por mi cuenta y completarla con las propiedades de la fuente de datos definidas en un archivo separado (que el tradicional: application.properties)

De esta manera puedo definir la mía propia Se recomienda sessionFactory Bean usando Hibernate: clase "LocalSessionFactoryBean" y rellénela con su fuente de datos Hikari> y otras propiedades basadas en Hiberante-JPA.

Resumen de las propiedades de la fuente de datos Hikari basada en 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 -nombre-clase =
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-detección-umbral =
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-aislamiento =
spring.datasource.hikari .username =
spring.datasource.hikari.validation-timeout =

Con las últimas versiones de arranque de primavera, el cambio a Hikari se puede hacer completamente en la configuración. Estoy usando 1.5.6.RELEASEy este enfoque funciona.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

aplicación YAML

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

Cambie connectionTestQuerypara adaptarse a su base de datos subyacente. Eso es todo, no se requiere código.

El siguiente código se puede utilizar para la inicialización de una fuente de datos estática.

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

Tenía problemas y el problema era un espacio en blanco al final despring.datasource.type = com.zaxxer.hikari.HikariDataSource