Java Academy · Aula

Pool de conexões com HikariCP

Reutilização eficiente de conexões.

Pool de conexões com HikariCP é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Por que agrupar conexões?

Abrir uma conexão com o banco de dados é caro: o handshake TCP, a autenticação e a configuração da sessão podem levar dezenas de milissegundos.

Um conjunto de conexões mantém várias conexões abertas e prontas. Seu código obtém uma, utiliza-a e a devolve — transformando uma abertura dispendiosa em uma obtenção barata.

Conheça o HikariCP

O HikariCP é o conjunto de conexões padrão de fato para Java. Ele é pequeno, rápido e o padrão no Spring Boot.

Ele implementa javax.sql.DataSource, portanto o restante do seu código JDBC permanece igual — você apenas obtém as conexões do conjunto em vez de usar o DriverManager.

Configurando o conjunto de conexões

Você configura o HikariCP com um objeto HikariConfig: a URL do JDBC, as credenciais e o dimensionamento do conjunto.

Depois, cria um HikariDataSource a partir dele. Normalmente, isso é feito uma vez na inicialização da aplicação, e o objeto é compartilhado.

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class Main {
    public static void main(String[] args) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/shop");
        config.setUsername("app");
        config.setPassword("secret");
        config.setMaximumPoolSize(10);
        HikariDataSource ds = new HikariDataSource(config);
        System.out.println("Pool ready, max size " + config.getMaximumPoolSize());
        ds.close();
    }
}

Obtendo uma conexão

Chame ds.getConnection() para obter uma conexão. Envolva-a em try-with-resources, como de costume.

A ideia principal é a seguinte: fechar uma conexão do conjunto não fecha o soquete físico — a conexão é devolvida ao conjunto para ser reutilizada.

import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;

public class Main {
    public static void main(String[] args) {
        DataSource ds = new HikariDataSource();
        try (Connection conn = ds.getConnection();
             PreparedStatement ps = conn.prepareStatement("SELECT count(*) FROM users");
             ResultSet rs = ps.executeQuery()) {
            if (rs.next()) System.out.println("Users: " + rs.getInt(1));
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}

close() significa devolver

Isso confunde muitos desenvolvedores. Com um conjunto de conexões:

conn.close() devolve a conexão ao conjunto.
O conjunto mantém o soquete real aberto para o próximo solicitante.

Por isso, você ainda deve sempre fechar a conexão — try-with-resources é a opção correta. Você está devolvendo a conexão, não destruindo-a.

Dimensionamento do conjunto de conexões

Maior não significa melhor. Um conjunto grande demais sobrecarrega o banco de dados com trabalho simultâneo.

A recomendação do HikariCP é usar um conjunto pequeno, geralmente em torno de (core_count * 2) + effective_spindle_count, que costuma superar um conjunto enorme. maximumPoolSize é o limite máximo; minimumIdle mantém algumas conexões prontas.

public class Main {
    public static void main(String[] args) {
        int cores = 4;
        int spindles = 1; // SSD-ish
        int recommended = (cores * 2) + spindles;
        System.out.println("Suggested max pool size: " + recommended);
    }
}

Tempos limite principais

O HikariCP oferece tempos limite que protegem sua aplicação contra um banco de dados travado:

connectionTimeout — por quanto tempo uma obtenção aguarda antes de falhar (padrão: 30 s).
idleTimeout — por quanto tempo uma conexão ociosa permanece ativa.
maxLifetime — encerra uma conexão depois desse tempo de vida (mantenha-o abaixo do tempo limite do próprio banco de dados).

Validação de conexões

As redes podem interromper conexões silenciosamente. Antes de entregar uma conexão, o HikariCP pode validá-la.

Os drivers JDBC modernos utilizam Connection.isValid(timeout); o HikariCP chama esse método automaticamente. Você também pode definir connectionTestQuery para drivers antigos que não têm isValid.

Detecção de vazamentos

Um vazamento de conexão acontece quando o código obtém uma conexão, mas nunca a fecha — com o tempo, o conjunto fica sem conexões disponíveis e toda obtenção excede o tempo limite.

Defina leakDetectionThreshold (por exemplo, 20 000 ms), e o HikariCP registrará um rastreamento da pilha para qualquer conexão mantida por mais tempo, indicando diretamente o trecho de código responsável.

Um conjunto por aplicação

Crie o HikariDataSource uma vez e reutilize-o durante todo o tempo de vida da aplicação.

Criar um novo conjunto por solicitação anula o propósito — você pagaria o custo de inicialização todas as vezes. Feche o conjunto apenas durante o encerramento, usando ds.close().

Monitorando o conjunto de conexões

O HikariCP oferece métricas de execução para que você acompanhe a saúde do conjunto.

Conexões ativas, ociosas e totais.
Linhas atualmente aguardando uma conexão.

Ele se integra ao Micrometer, às métricas do Dropwizard e ao JMX. Uma contagem persistentemente alta de linhas aguardando significa que o conjunto é pequeno demais ou que as conexões estão sendo mantidas por tempo excessivo.

Verificação rápida

Ao utilizar o HikariCP, o que acontece quando você chama close() em uma conexão obtida?

Recapitulação

O HikariCP torna eficiente a reutilização de conexões:

Configure um HikariDataSource uma vez, na inicialização.
Obtenha a conexão com getConnection() em try-with-resources; close() a devolve ao conjunto.
Mantenha maximumPoolSize moderado.
Ajuste connectionTimeout, maxLifetime e a validação.
Utilize leakDetectionThreshold para detectar conexões não devolvidas.

Perguntas Frequentes

A aula “Pool de conexões com HikariCP” é grátis?

Sim — o texto completo de “Pool de conexões com HikariCP” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Pool de conexões com HikariCP”?

Reutilização eficiente de conexões. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Pool de conexões com HikariCP”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Fundamentos de JDBC
PreparedStatement
Transações
Pool de conexões com HikariCP

← Voltar para Java Academy