Como configuro o HikariCP em meu aplicativo Spring Boot em meus arquivos application.properties?

Estou tentando configurar o HikariCP em meu aplicativo Spring Boot (1.2.0.M1) para que possa testar usando-o no lugar do Tomcat DBCP. Gostaria de configurar o pool de conexão em meu arquivo application.properties como estava fazendo com o Tomcat, mas não consigo descobrir como deveria estar fazendo isso. Todos os exemplos que encontrei mostram o estilo JavaConfig ou o uso de um arquivo de propriedades HikariCP separado. Alguém pode me ajudar a descobrir os nomes das propriedades para configurá-lo em application.properties? Também gostaria de alternar do uso da abordagem driverClassName para a abordagem DataSourceClassName, uma vez que parece mais limpo e é recomendado. Isso também é possível em meu (s) arquivo (s) application.properties?

Aqui está o que eu tinha para Tomcat DBCP (apenas algumas configurações básicas, não totalmente descarregadas)

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

E atualmente estou usando driverClassName e jdbc url para configurar a conexão:

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

ATUALIZADA! Desde a versão Spring Boot 1.3.0 :

1. Basta adicionar HikariCP às dependências
2. Configure 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

ATUALIZADA! Desde a versão Spring Boot 2.0.0 :

O pool de conexão padrão mudou de Tomcat para Hikari :)

Descobri HikariCPe fiquei impressionado com os benchmarks e queria tentar em vez da minha escolha padrão C3P0e para minha surpresa, tive dificuldade em configurationsacertar, provavelmente porque as configurações diferem com base na combinação de pilha de tecnologia que você está usando.

Eu configurei o Spring Bootprojeto com JPA, Web, Securitystarters (usando Spring Initializer ) para usar PostgreSQLcomo um banco de dados com um HikariCPpool de conexão.
Eu usei Gradlecomo ferramenta de construção e gostaria de compartilhar o que funcionou para mim para as seguintes suposições:

1. Spring Boot Starter JPA (Web e segurança - opcional)
2. Gradle build também
3. PostgreSQL em execução e configuração com um banco de dados (ou seja, esquema, usuário, banco de dados)

Você precisa do seguinte build.gradlese estiver usando Gradleou equivalente pom.xmlse estiver usando o 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'
    }
}

Há um monte de exclusões acima build.gradlee isso porque

1. Em primeiro lugar, exclua, instrui o gradle a excluir o jdbc-tomcatpool de conexão ao baixar as spring-boot-starter-data-jpadependências. Isso pode ser conseguido configurando o spring.datasource.type=com.zaxxer.hikari.HikariDataSourcetambém, mas não quero uma dependência extra se não precisar dela
2. Em segundo lugar, exclui, instrui o gradle a excluir hibernate-coreao baixar a com.zaxxerdependência e isso porque hibernate-corejá foi baixado pelo Spring Boote não queremos ter versões diferentes.
3. Terceiro exclude, instrui gradle a excluir hibernate-coreao baixar o hibernate-hikaricpmódulo que é necessário para fazer o HikariCP usar org.hibernate.hikaricp.internal.HikariCPConnectionProvidercomo provedor de conexão em vez de obsoletocom.zaxxer.hikari.hibernate.HikariConnectionProvider

Depois de descobrir o build.gradleque manter e o que não, estava pronto para copiar / colar uma datasourceconfiguração no meu application.propertiese esperava que tudo funcionasse com louvor, mas não realmente e me deparei com os seguintes problemas

• O Spring boot falhou em descobrir os detalhes do banco de dados (ou seja, url, driver), portanto, não foi possível configurar jpa e hibernar (porque eu não nomeiei os valores da chave de propriedade corretamente)
• HikariCP voltando para com.zaxxer.hikari.hibernate.HikariConnectionProvider
• Depois de instruir o Spring a usar o novo provedor de conexão para quando autoconfigurar hibernate / jpa, o HikariCP falhou porque estava procurando por algum key/valueno application.propertiese estava reclamando dataSource, dataSourceClassName, jdbcUrl. Tive que depurar HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvidere descobri que HikariCPnão consegui encontrar as propriedades application.propertiesporque tinha um nome diferente.

De qualquer forma, foi aqui que eu tive que confiar em tentativa e erro e ter certeza de que HikariCPé capaz de escolher as propriedades (ou seja, fonte de dados que contém detalhes de banco de dados, bem como propriedades de pool), bem como o Sping Boot se comportou como esperado e acabei com o seguinte application.propertiesarquivo.

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 

Conforme mostrado acima, as configurações são divididas em categorias com base nos seguintes padrões de nomenclatura

• spring.datasource.x (a configuração automática do Spring irá selecioná-los, assim como o HikariCP)
• spring.datasource.hikari.x (HikariCP escolhe-os para configurar o pool, anote os nomes dos campos camelCase)
• spring.jpa.hibernate.connection.provider_class (instrui Spring a usar o novo HibernateConnectionProvider)
• spring.jpa.properties.hibernate.x (usado pelo Spring para configurar automaticamente o JPA, anote os nomes dos campos com sublinhados)

É difícil encontrar um tutorial ou postagem ou algum recurso que mostre como o arquivo de propriedades acima é usado e como as propriedades devem ser nomeadas. Bem, aí está.

Jogando o acima application.propertiescom build.gradle(ou pelo menos similar) em uma versão do projeto Primavera Bota JPA (1.5.8) deve funcionar como um encanto e se conectar ao seu banco de dados pré-configurado (ou seja, no meu caso, do PostgreSQL que tanto HikariCP & Springa figura para fora do spring.datasource.urlem que driver de banco de dados a ser usado).

Eu não vi a necessidade de criar um DataSourcebean e isso porque o Spring Boot é capaz de fazer tudo por mim apenas olhando application.propertiese isso é legal.

O artigo no github do HikariCP wiki mostra como configurar Primavera Bota com JPA, mas carece de explicação e detalhes.

Os dois arquivos acima também estão disponíveis como uma essência pública https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

Você poderia simplesmente usar application.yml / application.properties apenas. Não há necessidade de criar explicitamente qualquer DataSourceBean

Você precisa excluir tomcat-jdbc conforme mencionado por 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 você não criará o DataSourcebean, você deve especificar explicitamente o uso de Hikari spring.datasource.typecom valor com.zaxxer.hikari.HikariDataSourceem 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

Em seu application.yml / application.properties, você pode configurar parâmetros específicos do Hikari, como tamanho do pool, etc. em spring.datasource.hikari.*

Estou usando o Spring Boot 2.0.4.RELEASE. Hikari é o pool de conexão padrão e .hikarinão é mais necessário.

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

E configurationnão precisa ser ampliado HikariConfige DataSourceBuilderpode ser usado como antes.

@Configuration
public class DataSourceConfiguration {

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

De acordo com a documentação é alterado,

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

Exemplo:

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

Estas são as seguintes alterações de configuração que podemos fazer no hikari, adicione / atualize de acordo com sua necessidade.

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

Você não precisa de código redundante para colocar valores de propriedade em variáveis. Você pode definir propriedades diretamente com um arquivo de propriedades.

Coloque o hikari.propertiesarquivo no classpath.

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

E faça um bean de fonte de dados como este.

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

    return dataSource;
}

Isso funciona para meu aplicativo de inicialização, caso ajude. Esta classe informa quais propriedades o objeto config está procurando:

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

Eu acho que várias fontes de dados podem ser suportadas adicionando datasource_whateveràs chaves de propriedade no arquivo de configuração de origem. Felicidades!

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

Você pode usar a abordagem dataSourceClassName, aqui está um exemplo com MySQL. (Testado com bota de mola 1.3 e 1.4)

Primeiro você precisa excluir tomcat-jdbc do caminho de classe, pois ele será escolhido em 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

Depois é só adicionar

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

Criei um projeto de teste aqui: https://github.com/ydemartino/spring-boot-hikaricp

você não pode usar a abordagem dataSourceClassName nas configurações de application.properties como dito por @Andy Wilkinson. se quiser ter dataSourceClassName de qualquer maneira, você pode usar o 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ão pela qual você não pode usar dataSourceClassName porque ele lançará uma exceção

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

o que significa que o spring boot infere da propriedade spring.datasource.url o Driver e, ao mesmo tempo, a configuração de dataSourceClassName cria essa exceção. Para acertar, seu application.properties deve ser parecido com isto para a fonte de dados 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

Observação: verifique se há algum tomcat-jdbc.jar ou commons-dbcp.jar em seu classpath adicionado na maioria das vezes por dependência transitiva. Se eles estiverem presentes no classpath, o Spring Boot configurará a fonte de dados usando o pool de conexão padrão que é o tomcat. O HikariCP só será usado para criar a fonte de dados se não houver outro provedor no classpath. há uma sequência de fallback de tomcat -> para HikariCP -> para Commons DBCP.

Isso ajudará quem deseja configurar o hikaricp para sua aplicação com a configuração automática da mola. Para o meu projeto, estou usando o spring boot 2 com hikaricp como o pool de conexão JDBC e mysql como banco de dados. Uma coisa que não vi nas outras respostas foi o data-source-propertiesque pode ser usado para definir várias propriedades que não estão disponíveis no spring.datasource.hikari.*caminho. Isso é equivalente a usar a HikariConfigclasse. Para configurar a fonte de dados e o pool de conexão hikaricp para propriedades específicas do mysql, usei a anotação de configuração automática do spring e as seguintes propriedades no arquivo application.yml.

Coloque @EnableAutoConfigurationem um de seus arquivos de bean de configuração.

O arquivo application.yml pode ter esta aparência.

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

Aqui está a boa notícia. HikariCP é o pool de conexão padrão agora com Spring Boot 2.0.0.

Spring Boot 2.0.0 Release Notes

A tecnologia de pool de banco de dados padrão no Spring Boot 2.0 foi trocada de Tomcat Pool para HikariCP. Descobrimos que o Hakari oferece desempenho superior, e muitos de nossos usuários preferem isso ao Tomcat Pool.

Portanto, quase todas as configurações padrão do HikariCP funcionam para mim, exceto o número de conexões de banco de dados. Eu defino essa propriedade em meu application.properties:

spring.datasource.maximumPoolSize=20

E Andy Wilkinson está correto até onde posso dizer que você não pode usar a abordagem de configuração dataSourceClassName para HikariCP com Spring Boot.

Minha configuração:
Spring Boot v1.5.10
Hikari v.3.2.x (para avaliação)

Para realmente entender a configuração da fonte de dados Hikari, recomendo desabilitar a configuração automática do Spring Boot para fonte de dados.

Adicione o seguinte a application.properties:-

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

Isso desativará a capacidade do Spring Boot de configurar a fonte de dados por conta própria.

Agora é a chance de você definir sua própria configuração personalizada para criar o bean HikariDataSource e preenchê-lo com as propriedades desejadas.

NOTA :::
public class HikariDataSource estende HikariConfig

Você precisa

1. preencher o objeto HikariConfig usando as propriedades Hikari desejadas
2. inicializar o objeto HikariDataSource com o objeto HikariConfig passado como um argumento para o construtor.

Acredito em definir minha própria classe de configuração personalizada (@Configuration) para criar a fonte de dados por conta própria e preenchê-la com as propriedades da fonte de dados definidas em um arquivo separado (diferente do tradicional: application.properties).

Desta forma, posso definir a minha própria sessionFactory Bean usando Hibernate recomendado: "LocalSessionFactoryBean" classe e populá-lo com sua fonte de dados Hikari> e outras propriedades baseadas em Hiberante-JPA.

Resumo das propriedades da fonte de dados Hikari com base em Spring Boot: -

spring.datasource.hikari.allow-pool-suspensão = 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-verification-threshold =
spring.datasource.hikari.login- tempo limite = 60
spring.datasource.hikari.max-lifetime =
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 =

Com as versões posteriores do Spring Boot, a mudança para o Hikari pode ser feita inteiramente na configuração. Estou usando 1.5.6.RELEASEe essa abordagem funciona.

build.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

aplicativo YAML

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

Mude connectionTestQuerypara se adequar ao seu banco de dados subjacente. É isso, nenhum código necessário.

O código abaixo pode ser usado para uma inicialização de fonte de dados 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();
    }
}

Eu estava enfrentando problemas e o problema era um espaço em branco no final dospring.datasource.type = com.zaxxer.hikari.HikariDataSource

Agora com HikcariCp como pool de conexão padrão com a nova versão do spring boot. Isso pode ser feito diretamente como mostrado abaixo.

@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

Se você imprimir o valor do tempo limite de inatividade

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

você obterá o valor 600000, onde o valor padrão é 300000 se você não definir nenhum valor personalizado