0Pricing
Java Academy · Lezione

Connection pooling con HikariCP

Riutilizzare efficientemente le connessioni

Connection pooling con HikariCP è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Perché usare un pool di connessioni

Aprire una connessione al database è costoso: l'handshake TCP, l'autenticazione e la configurazione della sessione possono richiedere decine di millisecondi.

Un pool di connessioni mantiene pronte diverse connessioni aperte. Il codice ne prende una in prestito, la usa e la restituisce, trasformando un'apertura costosa in un'acquisizione rapida.

Alla scoperta di HikariCP

HikariCP è lo standard de facto per i pool in Java. È compatto, veloce e costituisce l'impostazione predefinita in Spring Boot.

Implementa javax.sql.DataSource, quindi il resto del codice JDBC rimane invariato: è sufficiente ottenere le connessioni dal pool invece che da DriverManager.

Configurare il pool

HikariCP si configura con un oggetto HikariConfig: URL JDBC, credenziali e dimensionamento del pool.

In seguito si crea un HikariDataSource a partire da tale oggetto. In genere questa operazione viene eseguita una sola volta all'avvio dell'applicazione e la risorsa viene condivisa.

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();
    }
}

Acquisire una connessione

Chiami ds.getConnection() per acquisire una connessione. Come di consueto, la racchiuda in un try-with-resources.

Ecco l'idea fondamentale: chiudere una connessione del pool non chiude il socket fisico, ma restituisce la connessione al pool perché venga riutilizzata.

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 restituire

Questo comportamento confonde molti sviluppatori. Con un pool:

  • conn.close() restituisce la connessione al pool.
  • Il pool mantiene aperto il socket reale per il prossimo utilizzatore.

Quindi deve comunque chiudere sempre la connessione: try-with-resources è la scelta corretta. La sta restituendo, non distruggendo.

Dimensionamento del pool

Più grande non significa migliore. Un pool troppo grande sovraccarica il database con un numero eccessivo di operazioni concorrenti.

Le indicazioni di HikariCP suggeriscono che un pool piccolo, spesso vicino a (core_count * 2) + effective_spindle_count, sia in genere migliore di uno enorme. maximumPoolSize è il limite massimo; minimumIdle mantiene alcune connessioni già pronte.

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);
    }
}

Timeout principali

HikariCP espone timeout che proteggono l'applicazione da un database bloccato:

  • connectionTimeout — per quanto tempo si attende una connessione prima di generare un errore (predefinito: 30 s).
  • idleTimeout — per quanto tempo rimane attiva una connessione inattiva.
  • maxLifetime — ritira una connessione dopo questo intervallo (lo mantenga al di sotto del timeout del database).

Validazione della connessione

Le reti possono interrompere le connessioni senza segnalarlo. Prima di consegnarne una, HikariCP può verificarne la validità.

I driver JDBC moderni utilizzano Connection.isValid(timeout); HikariCP lo chiama automaticamente. È anche possibile impostare connectionTestQuery per i driver meno recenti che non dispongono di isValid.

Rilevamento delle perdite

Si verifica una perdita di connessione quando il codice acquisisce una connessione ma non la chiude mai: alla fine il pool si esaurisce e ogni acquisizione va in timeout.

Imposti leakDetectionThreshold (ad esempio 20000 ms) e HikariCP registrerà uno stack trace per ogni connessione mantenuta oltre tale durata, indicando direttamente il codice responsabile.

Un solo pool per applicazione

Crei HikariDataSource una sola volta e lo riutilizzi per l'intero ciclo di vita dell'applicazione.

Creare un nuovo pool per ogni richiesta vanifica lo scopo del pool: si sosterebbe il costo di avvio ogni volta. Chiuda il pool solo durante l'arresto dell'applicazione con ds.close().

Monitorare il pool

HikariCP espone metriche di runtime che consentono di monitorare lo stato del pool.

  • Connessioni attive, inattive e totali.
  • Thread attualmente in attesa di una connessione.

Si integra con Micrometer, Dropwizard Metrics e JMX. Un numero costantemente elevato di thread 'in attesa' indica che il pool è troppo piccolo oppure che le connessioni vengono mantenute troppo a lungo.

Verifica rapida

Quando utilizza HikariCP, che cosa comporta chiamare close() su una connessione acquisita?

Riepilogo

HikariCP rende efficiente il riutilizzo delle connessioni:

  • Configuri un HikariDataSource una sola volta all'avvio.
  • Acquisisca la connessione con getConnection() in un try-with-resources; close() la restituisce al pool.
  • Mantenga moderato maximumPoolSize.
  • Regoli connectionTimeout, maxLifetime e la validazione.
  • Utilizzi leakDetectionThreshold per individuare le connessioni non restituite.

Domande Frequenti

La lezione «Connection pooling con HikariCP» è gratuita?

Sì — il testo completo di «Connection pooling con HikariCP» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Connection pooling con HikariCP»?

Riutilizzare efficientemente le connessioni Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Connection pooling con HikariCP»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Fondamenti di JDBC
  2. PreparedStatement
  3. Transazioni
  4. Connection pooling con HikariCP
← Torna a Java Academy