Hikari CP es un Framework que permite crear pools de conexiones desarrollado en 2012, su particularidad es que si comparamos su performance con sus competidores c3p0, dbcp2, tomcat y vibur veremos los siguientes resultados:

Esto nos da una idea de porque debemos aprender a usarlo y su impacto en nuestras aplicaciones.

Paso 1 Crear base de datos

Antes de empezar a utilizar hikaricp crearemos una pequeña base de datos de prueba, en este ejemplo utilizaremos Mysql

Paso 2 Configuración de hikaricp

El primer paso será configurarlo, para esto agregaremos las siguiente dependencias :

Puedes copiar la dependencia de aquí.

Paso 3 Crear un datasource

Para crear un datasource debemos hacer lo siguiente:

import java.sql.Connection;
import java.sql.SQLException;

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

/**
 * @author maagapi
 *
 */
public class Devs4jDatasource {

	private static final HikariConfig config;
	private static final HikariDataSource ds;

	static {
		config = new HikariConfig();
		config.setJdbcUrl("jdbc:mysql://localhost:3306/information_schema");
		config.setUsername("root");
		config.setPassword("root");
		config.addDataSourceProperty("cachePrepStmts", "true");
		config.addDataSourceProperty("prepStmtCacheSize", "250");
		config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
		ds = new HikariDataSource(config);
	}

	private Devs4jDatasource() {
	}

	public static final Connection getConnection() throws SQLException {
		return ds.getConnection();
	}
}

Analicemos los siguientes puntos:

• Solo crearemos una instancia del tipo HikariDataSource ya que esta nos ayudará a generar muchas conexiones.
• Inicializamos nuestras configuraciones en un bloque estático ya que necesitaremos un objeto de tipo HikariConfig para crear nuestro HikariDataSource.
• El método ds.getConnection() devolverá una conexión a nuestra base de datos.
• En nuestro ejemplo nos conectaremos a la base de datos information_schema que ya viene por default con nuestra instalación de MySQL.

Es necesario que entendamos que podemos definir las siguientes configuraciones en nuestro HikariConfig:

• autoCommit
• connectionTimeout
• idleTimeout
• maxLifetime
• connectionTestQuery
• connectionInitSql
• validationTimeout
• maximumPoolSize
• poolName
• allowPoolSuspension
• readOnly
• transactionIsolation
• leakDetectionThreshold

Es posible crear un objeto de tipo HikariConfig leyendo las properties de un archivo externo como se muestra a continuación:

private static HikariConfig config = new HikariConfig(
    "datasource.properties" );

El archivo datasource.properties contendrá todas las propiedades necesarias para inicializar nuestro pool.

Paso 4: Utilizando nuestro Datasource

El siguiente paso será utilizar nuestro DataSource, veamos el siguiente código:

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * @author raidentrance
 *
 */
public class Devs4jApplication {
	public static void main(String[] args) throws SQLException {
		Connection connection = Devs4jDatasource.getConnection();

		PreparedStatement statement = connection.prepareStatement("SELECT TABLE_NAME FROM TABLES");
		ResultSet resultSet = statement.executeQuery();
		while(resultSet.next()){
			System.out.println(resultSet.getString("TABLE_NAME"));
		}
	}
}

En el código anterior podemos ver como obtener una conexión del pool de conexiones y utilizarla para obtener el nombre de las tablas que tenemos e imprimirlas.

Puedes encontrar el código completo en el siguiente repositorio https://github.com/raidentrance/hikaricp-example.

Síguenos en nuestras redes sociales para enterarte sobre nuevo contenido https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Autor: Alejandro Agapito Bautista

Twitter: @raidentrance

Contacto:raidentrance@gmail.com