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:
- Spring Boot Starter JPA (Web e segurança - opcional)
- Gradle build também
- 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')
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'
}
}
Há um monte de exclusões acima build.gradlee isso porque
- 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
- 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.
- 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:
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