Saltar al contenido

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

Solución:

@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é con HikariCP y me sorprendieron los puntos de referencia y quería probarlo en lugar de mi elección predeterminada C3P0 y para mi sorpresa luché por conseguir el configurations probablemente porque las configuraciones difieren según la combinación de pila tecnológica que esté utilizando.

He configurado Spring Boot proyecto con JPA, Web, Security arrancadores (usando Spring Initializer) para usar PostgreSQL como una base de datos con HikariCP como agrupación de conexiones.
He usado Gradle como 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)

Necesitas lo siguiente build.gradle si estas usando Gradle o equivalente pom.xml si estás 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.gradle y eso es porque

  1. Primero excluir, instruye al gradle que excluye el jdbc-tomcat grupo de conexiones al descargar el spring-boot-starter-data-jpa dependencias. Esto se puede lograr configurando el spring.datasource.type=com.zaxxer.hikari.HikariDataSource también pero, no quiero una dependencia adicional si no la necesito
  2. Segunda exclusión, indica a gradle que excluya hibernate-core al descargar com.zaxxer dependencia y eso es porque hibernate-core ya está descargado por Spring Boot y no queremos terminar con versiones diferentes.
  3. Tercera excluir, indica a gradle que excluya hibernate-core al descargar hibernate-hikaricp módulo que se necesita para hacer uso de HikariCP org.hibernate.hikaricp.internal.HikariCPConnectionProvider como proveedor de conexión en lugar de obsoleto com.zaxxer.hikari.hibernate.HikariConnectionProvider

Una vez que descubrí el build.gradle y qué conservar y qué no, estaba listo para copiar / pegar un datasource configuración en mi application.properties y esperaba que todo funcionara con gran éxito, pero no realmente y me topé con los siguientes problemas

  • Spring boot no puede 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 key/value en el application.properties y se quejaba de dataSource, dataSourceClassName, jdbcUrl. Tuve que depurar en HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider y descubrí que HikariCP no pude encontrar las propiedades de application.properties porque fue nombrado de manera diferente.

De todos modos, aquí es donde tuve que confiar en prueba y error y asegurarme de que HikariCP puede 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 lo siguiente application.properties expediente. 

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 (Le 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.

Tirando lo de arriba application.properties con build.gradle (o al menos similar) en una versión de proyecto Spring Boot JPA (1.5.8) debería funcionar como un encanto y conectarse a su base de datos preconfigurada (es decir, en mi caso, es PostgreSQL que ambos HikariCP & Spring averiguar a partir del spring.datasource.url en qué controlador de base de datos utilizar).

No vi la necesidad de crear un DataSource bean y eso es porque Spring Boot es capaz de hacer todo por mí con solo mirar en application.properties y 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 DataSource Frijol

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 vas a crear DataSource bean, debe especificar explícitamente el uso de Hikari a través de spring.datasource.type con valor com.zaxxer.hikari.HikariDataSource en 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.*

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)

Tags : / / / /

Utiliza Nuestro Buscador

Preguntas Relacionadas:

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *