Inleiding tot HikariCP

1. Overzicht

In dit inleidende artikel leren we over het HikariCP JDBC-verbindingspoolproject. Dit is een zeer lichtgewicht (ongeveer 130Kb) en razendsnel JDBC-verbindingspoolkader ontwikkeld door Brett Wooldridge rond 2012.

2. Inleiding

Er zijn verschillende benchmarkresultaten beschikbaar om de prestaties van HikariCP te vergelijken met andere frameworks voor het poolen van verbindingen, zoals c3p0, dbcp2, kater, en vibur. Het HikariCP-team publiceerde bijvoorbeeld onderstaande benchmarks (originele resultaten zijn hier beschikbaar):

Het framework is zo snel omdat de volgende technieken zijn toegepast:

  • Engineering op bytecode-niveau - er is een aantal extreme bytecode-niveau-engineering uitgevoerd (inclusief native codering op assemblageeniveau)
  • Micro-optimalisaties - Hoewel ze nauwelijks meetbaar zijn, zorgen deze optimalisaties samen voor een verbetering van de algehele prestaties
  • Intelligent gebruik van het Collections framework - de ArrayList is vervangen door een aangepaste klasse FastList dat elimineert bereikcontrole en voert verwijderingsscans uit van staart tot kop

3. Maven Afhankelijkheid

Laten we een voorbeeldtoepassing bouwen om het gebruik ervan te benadrukken. HikariCP wordt geleverd met ondersteuning voor alle hoofdversies van JVM. Elke versie vereist zijn afhankelijkheid; voor Java 8 t / m 11 hebben we:

 com.zaxxer HikariCP 3.4.5 

Oudere JDK-versies zoals 6 en 7 worden ook ondersteund. De juiste versies zijn hier en hier te vinden. Ook kunnen we de laatste versies bekijken in de Central Maven Repository.

4. Gebruik

Laten we nu een demo-applicatie maken. Houd er rekening mee dat we een geschikte JDBC-stuurprogrammaklasse-afhankelijkheid moeten opnemen in het pom.xml. Als er geen afhankelijkheden zijn opgegeven, genereert de applicatie een ClassNotFoundException.

4.1. Een Databron

We zullen HikariCP's gebruiken Databron om een ​​enkele instantie van een gegevensbron voor onze applicatie te maken:

openbare klasse DataSource {privé statische HikariConfig config = nieuwe HikariConfig (); privé statische HikariDataSource ds; statische {config.setJdbcUrl ("jdbc_url"); config.setUsername ("database_username"); config.setPassword ("database_password"); config.addDataSourceProperty ("cachePrepStmts", "true"); config.addDataSourceProperty ("prepStmtCacheSize", "250"); config.addDataSourceProperty ("prepStmtCacheSqlLimit", "2048"); ds = nieuwe HikariDataSource (config); } private DataSource () {} openbare statische verbinding getConnection () gooit SQLException {return ds.getConnection (); }}

Let op: hier is de initialisatie in het statisch blok.

HikariConfig is de configuratieklasse die wordt gebruikt om een ​​gegevensbron te initialiseren. Het wordt geleverd met vier bekende parameters die u moet gebruiken gebruikersnaam, wachtwoord, jdbcUrl, dataSourceClassName.

Uit jdbcUrl en dataSourceClassName, beide moeten tegelijkertijd worden gebruikt. Als u deze eigenschap echter met oudere stuurprogramma's gebruikt, moeten we mogelijk beide eigenschappen instellen.

Naast deze eigenschappen zijn er verschillende andere eigenschappen beschikbaar die mogelijk niet allemaal worden aangeboden door andere pooling-frameworks:

  • autoCommit
  • connectionTimeout
  • idleTimeout
  • maxLifetime
  • connectionTestQuery
  • connectionInitSql
  • validationTimeout
  • maximumPoolSize
  • poolName
  • allowPoolSuspension
  • alleen lezen
  • transactieIsolatie
  • leakDetectionThreshold

HikariCP valt op door deze database-eigenschappen. Het is geavanceerd genoeg om zelfs zelf verbindingslekken te detecteren!

Een uitgebreide beschrijving van deze eigenschappen vindt u hier.

We kunnen ook initialiseren HikariConfig met een eigenschappenbestand in het middelen directory:

privé statische HikariConfig config = nieuwe HikariConfig ("datasource.properties");

Het eigenschappenbestand zou er ongeveer zo uit moeten zien:

dataSourceClassName = // TBD dataSource.user = // TBD // andere eigenschapsnaam moet beginnen met dataSource zoals hierboven weergegeven

We kunnen gebruiken java.util.Properties-gebaseerde configuratie ook:

Eigenschappen rekwisieten = nieuwe Eigenschappen (); props.setProperty ("dataSourceClassName", // TBD); props.setProperty ("dataSource.user", // TBD); // setter voor andere vereiste eigenschappen private static HikariConfig config = new HikariConfig (props);

Als alternatief kunnen we een gegevensbron rechtstreeks initialiseren:

ds.setJdbcUrl (// TBD); ds.setUsername (// TBD); ds.setPassword (// TBD);

4.2. Met behulp van een gegevensbron

Nu we de gegevensbron hebben gedefinieerd, kunnen we deze gebruiken om een ​​verbinding te verkrijgen van de geconfigureerde verbindingspool en JDBC-gerelateerde acties uit te voeren.

Stel dat we twee tabellen hebben met de naam afd en emp om een ​​use-case van een medewerker-afdeling te simuleren. We zullen een klasse schrijven om die details uit de database op te halen met behulp van HikariCP.

Hieronder vermelden we de SQL-instructies die nodig zijn om de voorbeeldgegevens te maken:

maak een tabelafdeling (afd.nr. numeriek, dname varchar (14), loc varchar (13), beperking pk_dept primaire sleutel (afd.nr.)); maak tabel emp (empno numeriek, ename varchar (10), job varchar (9), mgr numeriek, huurdatum, sal numeriek, comm numeriek, afdelingsnummer numeriek, beperking pk_emp primaire sleutel (empno), beperking fk_deptno externe sleutel (afdelingsnummer) referenties afd (afdno)); invoegen in afdelingswaarden (10, 'ACCOUNTING', 'NEW YORK'); invoegen in afdelingswaarden (20, 'ONDERZOEK', 'DALLAS'); invoegen in afdelingswaarden (30, 'SALES', 'CHICAGO'); invoegen in afdelingswaarden (40, 'OPERATIONS', 'BOSTON'); invoegen in emp-waarden (7839, 'KING', 'PRESIDENT', null, to_date ('17 -11-1981 ',' dd-mm-jjjj '), 7698, null, 10); invoegen in emp-waarden (7698, 'BLAKE', 'MANAGER', 7839, to_date ('1-5-1981', 'dd-mm-jjjj'), 7782, null, 20); invoegen in emp-waarden (7782, 'CLARK', 'MANAGER', 7839, to_date ('9-6-1981', 'dd-mm-jjjj'), 7566, null, 30); invoegen in emp-waarden (7566, 'JONES', 'MANAGER', 7839, to_date ('2-4-1981', 'dd-mm-jjjj'), 7839, null, 40);

Houd er rekening mee dat als we een in-memory database zoals H2 gebruiken, we automatisch het databasescript moeten laden voordat de daadwerkelijke code wordt uitgevoerd om de gegevens op te halen. Gelukkig wordt H2 geleverd met een IN HET parameter die het databasescript tijdens runtime uit het klassenpad kan laden. De JDBC-URL zou er als volgt uit moeten zien:

jdbc: h2: mem: test; DB_CLOSE_DELAY = -1; INIT = runscript van 'classpath: /db.sql'

We moeten een methode maken om deze gegevens uit de database op te halen:

openbare statische lijst fetchData () genereert SQLException {String SQL_QUERY = "select * from emp"; Lijst werknemers = null; probeer (Connection con = DataSource.getConnection (); PreparedStatement pst = con.prepareStatement (SQL_QUERY); ResultSet rs = pst.executeQuery ();) {werknemers = nieuwe ArrayList (); Medewerker medewerker; while (rs.next ()) {medewerker = nieuwe medewerker (); werknemer.setEmpNo (rs.getInt ("empno")); employee.setEname (rs.getString ("ename")); employee.setJob (rs.getString ("job")); werknemer.setMgr (rs.getInt ("mgr")); employee.setHiredate (rs.getDate ("hiredate")); werknemer.setSal (rs.getInt ("sal")); employee.setComm (rs.getInt ("comm")); employee.setDeptno (rs.getInt ("deptno")); medewerkers.add (medewerker); }} terugkerende werknemers; }

Nu moeten we een JUnit-methode maken om deze te testen. Omdat we het aantal rijen in de tabel kennen emp, kunnen we verwachten dat de grootte van de geretourneerde lijst gelijk moet zijn aan het aantal rijen:

@Test openbare leegte gegevenConnection_thenFetchDbData () gooit SQLException {HikariCPDemo.fetchData (); assertEquals (4, workers.size ()); }

5. Conclusie

In deze korte tutorial hebben we geleerd over de voordelen van het gebruik van HikariCP en de configuratie ervan.

Zoals altijd is de volledige broncode beschikbaar op GitHub.