Connection pooling met HikariCP
Verbindingen efficiënt hergebruiken
Connection pooling met HikariCP is een gratis Java Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
Waarom verbindingspools?
Een databaseverbinding openen is duur: een TCP-handshake, authenticatie en sessie-instelling kunnen tientallen milliseconden duren.
Een verbindingspool houdt een aantal geopende verbindingen klaar. Je code leent er één, gebruikt die en geeft die terug — zo wordt een dure opening een goedkope uitleenactie.
Maak kennis met HikariCP
HikariCP is de feitelijke standaard voor verbindingspools in Java. De pool is klein, snel en de standaard in Spring Boot.
De pool implementeert javax.sql.DataSource, dus de rest van je JDBC-code blijft hetzelfde — je haalt verbindingen alleen uit de pool in plaats van bij DriverManager.
De pool configureren
Je configureert HikariCP met een object van het type HikariConfig: de JDBC-URL, aanmeldgegevens en poolgrootte.
Daarna maak je er een HikariDataSource van. Dit doe je meestal één keer bij het opstarten van de toepassing en vervolgens deel je die.
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();
}
}Een verbinding lenen
Roep ds.getConnection() aan om een verbinding te lenen. Gebruik die zoals gewoonlijk in try-with-resources.
Dit is het belangrijkste inzicht: het sluiten van een verbinding uit een pool sluit de fysieke socket niet — het geeft de verbinding terug aan de pool voor hergebruik.
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() betekent teruggeven
Dit brengt veel ontwikkelaars in de war. Met een pool:
conn.close()geeft de verbinding terug aan de pool.- De pool houdt de echte socket open voor de volgende lener.
Je moet een verbinding dus nog steeds altijd sluiten — try-with-resources is correct. Je geeft de verbinding terug, je vernietigt haar niet.
De poolgrootte bepalen
Groter is niet beter. Een pool die te groot is, overbelast de database met gelijktijdig werk.
De richtlijn van HikariCP: een kleine pool, vaak ongeveer (core_count * 2) + effective_spindle_count, werkt meestal beter dan een enorme pool. maximumPoolSize is de bovengrens; minimumIdle houdt een paar verbindingen warm.
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);
}
}Belangrijke time-outs
HikariCP biedt time-outs die je toepassing beschermen tegen een vastgelopen database:
connectionTimeout— hoe lang het lenen op een verbinding wacht voordat het mislukt (standaard 30 seconden).idleTimeout— hoe lang een niet-gebruikte verbinding blijft bestaan.maxLifetime— een verbinding na deze leeftijd buiten gebruik stellen (houd deze lager dan de eigen time-out van de database).
Verbindingsvalidatie
Netwerken verbreken verbindingen soms stilletjes. Voordat HikariCP een verbinding uitleent, kan het die controleren.
Moderne JDBC-stuurprogramma's gebruiken Connection.isValid(timeout); HikariCP roept dit automatisch aan. Je kunt ook connectionTestQuery instellen voor oude stuurprogramma's die isValid niet hebben.
Lekken opsporen
Een verbindingslek ontstaat wanneer code een verbinding leent maar nooit sluit — uiteindelijk raakt de pool leeg en mislukt elke leenpoging door een time-out.
Stel leakDetectionThreshold in (bijv. 20.000 ms) en HikariCP registreert een aanroepstack voor elke verbinding die langer dan dat wordt vastgehouden, zodat je meteen ziet welke code het probleem veroorzaakt.
Eén pool per toepassing
Maak de HikariDataSource één keer en hergebruik die gedurende de hele levensduur van de toepassing.
Een nieuwe pool per verzoek maken ondermijnt het doel — je betaalt dan elke keer de opstartkosten. Sluit de pool alleen af bij het afsluiten met ds.close().
De pool bewaken
HikariCP biedt metriekgegevens tijdens de uitvoering, zodat je de gezondheid van de pool kunt volgen.
- Actieve, niet-gebruikte en totale verbindingen.
- Threads die momenteel wachten op een verbinding.
De pool kan worden geïntegreerd met Micrometer, Dropwizard Metrics en JMX. Een blijvend hoog aantal 'wachtende' threads betekent dat de pool te klein is of dat verbindingen te lang worden vastgehouden.
Korte controle
Wat doet het aanroepen van close() op een geleende verbinding bij gebruik van HikariCP?
Samenvatting
HikariCP maakt hergebruik van verbindingen efficiënt:
- Configureer bij het opstarten één keer een
HikariDataSource. - Leen een verbinding met
getConnection()in try-with-resources;close()geeft die terug aan de pool. - Houd
maximumPoolSizebescheiden. - Stem
connectionTimeout,maxLifetimeen validatie af. - Gebruik
leakDetectionThresholdom niet-teruggegeven verbindingen op te sporen.
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Connection pooling met HikariCP” gratis?
Ja — de volledige tekst van “Connection pooling met HikariCP” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “Connection pooling met HikariCP”?
Verbindingen efficiënt hergebruiken Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Connection pooling met HikariCP”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- De basis van JDBC
- PreparedStatement
- Transacties
- Connection pooling met HikariCP