Post Views: 2.227

Hey, theeliefhebbers!. Heb je ooit gehoord over connection pooling in JDBC of HikariCP? Zo niet, helemaal geen zorgen, dat is waar dit bericht over gaat. We zullen praten over alle dingen over de JDBC connection pool en de implementatie ervan met behulp van HikariCP.

HikariCP is een van de snelste poolen van verbindingen die beschikbaar is op de markt voor JDBC-verbindingen. Het maakt verbinding pooling zeer eenvoudig. maak je klaar om meer te leren over dit beest. Maar eerst, maak je thee om te drinken en te leren. En voor het voorbeeld gebruikt in de post, je kunt het vinden op GitHub hier of het volledige project hier.

Instagram, Twitter, Linkedin, Facebook of social @coderstea kun je me volgen. We delen ook hoogwaardige video ‘ s over programmeren op ons Youtube-kanaal u kunt ook uw eigen bericht publiceren op CodersTea.com, net deel uw mening over Contact met ons op.

Wat is pooling van verbindingen?

Connection pooling in JDBC stelt ons in staat om de JDBC-verbinding te hergebruiken in plaats van elke keer opnieuw aan te maken. Wanneer er een beroep op wordt gedaan, retourneert het de JDBC-verbinding die niet in gebruik is( of maak een nieuwe aan als de limiet voor de eerste aanvraag of pool nog niet is bereikt). Zie het als uw resource pooling zoals printers in een gedeeld netwerk of DHCP of Thread Pool die we hebben besproken in “Recycle de Threads en sla de bronnen op met Thread Pool” post.

Waarom Connection Pool Gebruiken?

het maken van een verbinding met de database is een duur proces. Het kost tijd om verbinding te maken met de database. Het is niet merkbaar voor een paar keer, maar dit te doen voor duizenden keren, de zeer frequentie van uw toepassing voor nodig om de databases te bellen, het kan zeer traag worden. Stel dat er 5ms nodig is om verbinding te maken met DB en 10 ms voor een query, dus ongeveer 15 ms voor de eerste keer. Doe het voor 1000 keer en je kunt het verschil voelen. Meer dan 30% van de tijd wordt verspild aan het creëren van de verbinding.

een ander scenario zou, stel dat de verbinding 5ms neemt maar de query slechts 4ms neemt dan gaat meer dan 60% voor creatie. Je snapt het wel.

maar in connection pooling maakt u niet elke keer een verbinding, maar hergebruikt u deze. Recycling helpt niet alleen het milieu, maar ook onze systeemprestaties. Door deze recycling resource overhead vermindert. U kunt het aantal verbindingen te beperken en die kunnen helpen bij het verkeer controle naar de database. Er zijn ook andere factoren voor het verbeteren van de prestaties. Je kunt er meer over leren in mijn andere artikel “How to Achieve Greatness In JDBC Performance”;

wanneer gebruik je Connection Pool?

Ok, het heeft veel voordelen, maar er kunnen scenario ‘ s zijn waar het geen zin heeft om connection pooling te gebruiken. Ik denk dat we het waar mogelijk moeten gebruiken, omdat het veel werk vermindert. Zoals automatisch verbinding maken met de database in geval van time-out. Het zou uw primaire keuze moeten zijn, in het geval dat uw applicatie vaak de database aanroept of sterk afhankelijk is van de database.

voor een eenvoudige toepassing waarbij je de database af en toe aanroept, zoals een dag of zoiets, heb je het waarschijnlijk niet nodig. Of u kunt gewoon de poollimiet instellen op één, zodat er slechts één verbinding in het zwembad zal zijn. In een multithreaded omgeving, als je wilt dat alle threads dezelfde verbinding gebruiken in plaats van elke thread om hun eigen DB-verbindingen te maken, is het poolen van verbindingen de redder voor jou.

dingen om in gedachten te houden bij het gebruik van Connection Pooling

een ding moet je voorzichtig zijn met het sluiten van de verbinding. Als u de verbinding niet sluit nadat u deze hebt gebruikt, gaat deze niet terug naar het zwembad. En een ander deel van je programma kan erop wachten. De beste aanpak is om try-with-resources te gebruiken, die je hier in detail ziet. En je zou kunnen hebben om uit te leggen aan uw nieuwe collega/ vriend over wat, waarom, en hoe te gebruiken connection pooling als hij of zij niet weet. Dat is niet zo veel van een grote taak, omdat je kunt gewoon delen dit bericht met hen voor het geval (zelfpromotie ?).

verken JDBC Connection Poling met HikariCP

op dit moment hoop ik dat u hebt begrepen wat JDBC connection pooling is, waarom en wanneer het te gebruiken, en de voor-en nadelen ervan. Een ding blijft, hoe het te gebruiken. Het kan heel gemakkelijk worden gedaan door HikariCP en geeft veel meer prestaties dan elke andere connection pooling bibliotheek. HikariCP is een zeer snelle en lichtgewicht Java-verbinding pool bibliotheek die er zijn. De API en de totale codebase zijn relatief klein, een groot ding, en zeer geoptimaliseerd. Het is zeer eenvoudig op te zetten en te gebruiken.

voordat we het gebruiken, laten we eerst de vereisten doornemen.

Hikaricp toevoegen aan uw Project

er zijn meerdere manieren waarop u de HikariCP op uw project kunt laden.

handmatig HikariCP-bibliotheek

toevoegen voor gewoon Java-project, kunt u de jar downloaden van Maven Repo en de nieuwste ‘HikariCP’downloaden. Er is ondersteuning voor oudere Java-versies ook, die gemakkelijk kan worden geïdentificeerd op de download pagina.

Hikaricp toevoegen met Build Frameworks

voor build frameworks, zoals Maven of Gradle kunt u afhankelijkheden toevoegen. Op het moment van de oprichting van deze blog, 3.4.1 was de laatste. Controleer de laatste wanneer u deze gebruikt, die u kunt vinden op MvnRepository. Het kan u afhankelijkheden tekst in zowel Maven of Gradle formaat.

Maven

<!--Java 8 to 11 maven artifact--><dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> <!-- use the latest verion if possible. This was the latest on the birth of this blog --> <version>3.4.1</version></dependency><!-- Java 7 maven artifact (maintenance mode) --><dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP-java7</artifactId> <version>2.4.13</version></dependency><!-- Java 6 maven artifact (maintenance mode) --><dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP-java6</artifactId> <version>2.3.13</version></dependency>

Gradle

//Java 8 to 11compile "com.zaxxer:HikariCP:3.4.1"//java 7compile "com.zaxxer:HikariCP-java7:2.4.13"//Java 6compile "com.zaxxer:HikariCP-java6:2.3.13"

JDBC-verbindingspool aanmaken met HikariCP

tijdens het maken van Hikaricp DataSource-object, een interface voor verbindingspool die door Java wordt geleverd, moeten we de pool configureren. Dit omvat onder andere JDBC URL, gebruiker, wachtwoord, pool grootte. De volgende zijn de essentiële en gemeenschappelijke configuratie-instellingen en hun beschrijvingen.

Methoden Descreptions
setJdbcUrl(String) Stel de JDBC-URL
setUsername(String) het Instellen van de Gebruikersnaam
setPassword(String) het wachtwoord Instellen
setDriverClassName(String) Pas de bestuurder class naam
setMaximumPoolSize(int) De maximale verbinding die kan worden gemaakt door of verblijft in het zwembad
setConnectionTimeout(lang) hoeveel tijd een gebruiker kan wachten tot haal een verbinding uit het zwembad. als het de tijdslimiet overschrijdt dan wordt een SQlException gegooid
setMaximumPoolSize (int) De maximale tijd dat een verbinding inactief kan zitten in de pool. Als het de tijdslimiet overschrijdt, wordt het uit de pool verwijderd. Als u niet wilt dat de verbindingen met pensioen te zetten gewoon 0.
setPoolName (String) Het stelt de huidige poolnaam in. Dit is optioneel je hoeft het niet te doen.
Hkari CP configuratie

voorbeeld en Code voor HikariCP

ik heb de commentaren gezet om te laten zien wat het precies doet. Ik heb de code geschreven in de omgekeerde volgorde van het maken van de configuratie, het doorgeven van het aan de gegevensbron, het krijgen van de verbinding van de gegevensbron, en ten slotte, het uitvoeren van een query. Laten we eens kijken hoe het voorbeeld werkt.

we noemen statische getConnection methode voor een verbinding. Die getDataSource() voor DataSource object. Dit object getConnection geeft ons de verbinding vanuit de pool.

in getDataSource als dataSource null is,static DataSource object, dan maken we een één met de createDataSource en configureren we de pool met getHikariConfig. In de main doen we gewoon enkele eenvoudige query ‘ s.

import com.zaxxer.hikari.HikariConfig;import com.zaxxer.hikari.HikariDataSource;import javax.sql.DataSource;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.time.Duration;public class HikariCP { // static global DataSource object. private static DataSource dataSource; public static void main(String args) { String query = "SELECT COUNT(*) FROM employee"; //Using try-with-resources for auto closing connection, pstmt, and rs. try (Connection connection = getConnection(); PreparedStatement pstmt = connection.prepareStatement(query); ResultSet rs = pstmt.executeQuery(); ) { if (rs.next()) { System.out.println("Total employees are " + rs.getInt(1)); } } catch (SQLException e) { e.printStackTrace(); } } //Call the get connection method. static Connection getConnection() throws SQLException { return getDataSource().getConnection(); } //Get the DataSource. If not available create the new one //It is not threadsafe. I didn't wanted to complicate things. private static DataSource getDataSource() { if (null == dataSource) { System.out.println("No DataSource is available. We will create a new one."); createDataSource(); } return dataSource; } //To create a DataSource and assigning it to variable dataSource. private static void createDataSource() { HikariConfig hikariConfig = getHikariConfig(); System.out.println("Configuration is ready."); System.out.println("Creating the HiakriDataSource and assigning it as the global"); HikariDataSource hikariDataSource = new HikariDataSource(hikariConfig); dataSource = hikariDataSource; } //returns HikariConfig containing JDBC connection properties //which will be used by HikariDataSource object. private static HikariConfig getHikariConfig() { System.out.println("Creating the config with HikariConfig with maximum pool size of 5"); HikariConfig hikaConfig = new HikariConfig(); //This is same as passing the Connection info to the DriverManager class. //your jdbc url. in my case it is mysql. hikaConfig.setJdbcUrl("jdbc:mysql://localhost:3306/test"); //username hikaConfig.setUsername("root"); //password hikaConfig.setPassword("IWontTellYouThis ;)"); //driver class name hikaConfig.setDriverClassName("com.mysql.jdbc.Driver"); // Information about the pool //pool name. This is optional you don't have to do it. hikaConfig.setPoolName("MysqlPool-1"); //the maximum connection which can be created by or resides in the pool hikaConfig.setMaximumPoolSize(5); //how much time a user can wait to get a connection from the pool. //if it exceeds the time limit then a SQlException is thrown hikaConfig.setConnectionTimeout(Duration.ofSeconds(30).toMillis()); //The maximum time a connection can sit idle in the pool. // If it exceeds the time limit it is removed form the pool. // If you don't want to retire the connections simply put 0. hikaConfig.setIdleTimeout(Duration.ofMinutes(2).toMillis()); return hikaConfig; }}

Create Multi-Database Connection Pool

er zijn meerdere redenen waarom u toegang moet krijgen tot meerdere databases in een enkel project of codebase. De meest voorkomende is het migreren van de gegevens van de ene server naar de andere, of het is een architectonische vereiste. Wat de reden ook is, op het moment dat je hetzelfde werk moet doen, heb je de neiging om de code te kopiëren-plakken, en JDBC is op zich is een definitie van standaardcode.

alle details over het maken van een multi-database verbinding pool worden beschreven in deze post: Hoe maak je een multi-Database Pool In HikariCP

Multi-Database Hikaricp pool code heeft als doel om de boilerplate code tot een minimum te reduceren, waardoor je een kleine en leesbare code krijgt.

conclusie

in dit bericht hebben we gesproken over wat connection pooling is, waarom het te gebruiken en wanneer het te gebruiken. Het verbetert sterk de prestaties van database zware applicatie, maar het kan verder worden verbeterd met een aantal trucs in mijn andere post “Hoe om grootheid te bereiken in JDBC prestaties”. We onderzoeken hoe je connection pooling kunt gebruiken met behulp van HikariCP, de snelste en lichtgewicht connection pool bibliotheek voor java op het moment van schrijven van dit bericht. Je kunt de code van het voorbeeld op GitHub hier vinden of het volledige project hier.

Posted on

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.