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:
- Spring Boot Starter JPA (Web y seguridad - opcional)
- Gradle también
- 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')
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')
compile('com.zaxxer:HikariCP:2.5.1') {
exclude group: 'org.hibernate', module: 'hibernate-core'
}
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
- 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
- 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.
- 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:
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