or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration.mdconnection-pool.mdframework-integration.mdindex.mdjmx-management.mdmetrics.md
tile.json

tessl/maven-com-zaxxer--hikari-cp-java7

Ultimate JDBC Connection Pool

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.zaxxer/HikariCP-java7@2.4.x

To install, run

npx @tessl/cli install tessl/maven-com-zaxxer--hikari-cp-java7@2.4.0

index.mddocs/

HikariCP

HikariCP is a high-performance JDBC connection pool library designed for production environments. It provides a lightweight (approximately 90KB), zero-overhead connection pool that focuses on speed, simplicity, and reliability. HikariCP offers comprehensive connection management with features including connection timeout handling, pool size configuration, connection validation, metrics integration with Dropwizard and Prometheus, leak detection, and JMX monitoring capabilities.

Package Information

  • Package Name: HikariCP-java7
  • Package Type: maven
  • Language: Java
  • Installation: 
    <dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP-java7</artifactId>
    <version>2.4.13</version>
</dependency>

Core Imports

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

For JMX management:

import com.zaxxer.hikari.HikariConfigMXBean;
import com.zaxxer.hikari.HikariPoolMXBean;

For metrics integration:

import com.zaxxer.hikari.metrics.MetricsTracker;
import com.zaxxer.hikari.metrics.MetricsTrackerFactory;
import com.zaxxer.hikari.metrics.PoolStats;

For framework integration:

import com.zaxxer.hikari.hibernate.HikariConnectionProvider;
import com.zaxxer.hikari.HikariJNDIFactory;

Standard Java imports needed:

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.io.PrintWriter;
import java.io.Closeable;
import java.util.Properties;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import javax.sql.DataSource;

Basic Usage

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.SQLException;

// Configuration-based setup (recommended)
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
config.setUsername("user");
config.setPassword("password");
config.setMaximumPoolSize(20);
config.setMinimumIdle(5);
config.setConnectionTestQuery("SELECT 1");

HikariDataSource dataSource = new HikariDataSource(config);

// Get connections from the pool
try (Connection connection = dataSource.getConnection()) {
    // Use the connection for database operations
    // Connection is automatically returned to pool when closed
}

// Clean shutdown
dataSource.close();

Architecture

HikariCP is built around several key components:

  • HikariDataSource: Main pooled DataSource implementation extending standard JDBC DataSource
  • HikariConfig: Comprehensive configuration class with all pool settings and validation
  • Connection Pool Management: High-performance connection pool with configurable sizing and timeouts
  • JMX Integration: Runtime monitoring and management through HikariPoolMXBean and HikariConfigMXBean
  • Metrics Integration: Pluggable metrics system supporting Dropwizard Metrics and Prometheus
  • Leak Detection: Built-in connection leak detection and reporting
  • Framework Integration: Native integration with Hibernate and JNDI environments

Capabilities

Connection Pool Management

Core connection pooling functionality providing high-performance JDBC connection management with configurable pool sizing and connection lifecycle management.

public class HikariDataSource extends HikariConfig implements DataSource, Closeable {
    // Constructors
    public HikariDataSource();
    public HikariDataSource(HikariConfig configuration);
    
    // DataSource methods
    public Connection getConnection() throws SQLException;
    public Connection getConnection(String username, String password) throws SQLException;
    public PrintWriter getLogWriter() throws SQLException;
    public void setLogWriter(PrintWriter out) throws SQLException;
    public void setLoginTimeout(int seconds) throws SQLException;
    public int getLoginTimeout() throws SQLException;
    public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException;
    public <T> T unwrap(Class<T> iface) throws SQLException;
    public boolean isWrapperFor(Class<?> iface) throws SQLException;
    
    // Pool management and lifecycle
    public void close();
    public boolean isClosed();
    public void evictConnection(Connection connection);
    @Deprecated
    public void suspendPool();
    @Deprecated
    public void resumePool();
    @Deprecated
    public void shutdown();
    
    // JMX and monitoring
    public HikariPoolMXBean getHikariPoolMXBean();
    public HikariConfigMXBean getHikariConfigMXBean();
    
    // Metrics configuration
    public void setMetricRegistry(Object metricRegistry);
    public void setMetricsTrackerFactory(MetricsTrackerFactory metricsTrackerFactory);
    public void setHealthCheckRegistry(Object healthCheckRegistry);
}

Connection Pool Management

Configuration Management

Comprehensive configuration system with over 30 configuration properties for fine-tuning pool behavior, connection settings, and performance optimization.

public class HikariConfig implements HikariConfigMXBean {
    // Constructors
    public HikariConfig();
    public HikariConfig(Properties properties);
    public HikariConfig(String propertyFileName);
    
    // Essential configuration setters
    public void setJdbcUrl(String jdbcUrl);
    public void setDataSourceClassName(String className);
    public void setUsername(String username);
    public void setPassword(String password);
    public void setDataSource(DataSource dataSource);
    public void setDataSourceJNDI(String jndiDataSource);
    public void setDriverClassName(String driverClassName);
    
    // Essential configuration getters
    public String getJdbcUrl();
    public String getDataSourceClassName();
    public String getUsername();
    public String getPassword();
    public DataSource getDataSource();
    public String getDataSourceJNDI();
    public String getDriverClassName();
    
    // Pool sizing
    public void setMaximumPoolSize(int maxPoolSize);
    public void setMinimumIdle(int minIdle);
    public int getMaximumPoolSize();
    public int getMinimumIdle();
    
    // Timeouts
    public void setConnectionTimeout(long connectionTimeoutMs);
    public void setValidationTimeout(long validationTimeoutMs);
    public void setIdleTimeout(long idleTimeoutMs);
    public void setMaxLifetime(long maxLifetimeMs);
    public void setLeakDetectionThreshold(long leakDetectionThresholdMs);
    public void setInitializationFailTimeout(long initializationFailTimeout);
    public long getConnectionTimeout();
    public long getValidationTimeout();
    public long getIdleTimeout();
    public long getMaxLifetime();
    public long getLeakDetectionThreshold();
    public long getInitializationFailTimeout();
    
    // Connection settings
    public void setAutoCommit(boolean isAutoCommit);
    public void setReadOnly(boolean readOnly);
    public void setCatalog(String catalog);
    public void setTransactionIsolation(String isolationLevel);
    public void setConnectionTestQuery(String connectionTestQuery);
    public void setConnectionInitSql(String connectionInitSql);
    public boolean isAutoCommit();
    public boolean isReadOnly();
    public String getCatalog();
    public String getTransactionIsolation();
    public String getConnectionTestQuery();
    public String getConnectionInitSql();
    
    // Pool management
    public void setAllowPoolSuspension(boolean isAllowPoolSuspension);
    public void setIsolateInternalQueries(boolean isolate);
    public void setRegisterMbeans(boolean register);
    public void setPoolName(String poolName);
    public boolean isAllowPoolSuspension();
    public boolean isIsolateInternalQueries();
    public boolean isRegisterMbeans();
    public String getPoolName();
    
    // Threading and scheduling
    public void setThreadFactory(ThreadFactory threadFactory);
    public void setScheduledExecutor(ScheduledExecutorService executor);
    public ThreadFactory getThreadFactory();
    public ScheduledExecutorService getScheduledExecutor();
    
    // Metrics and monitoring
    public void setMetricsTrackerFactory(MetricsTrackerFactory metricsTrackerFactory);
    public void setMetricRegistry(Object metricRegistry);
    public void setHealthCheckRegistry(Object healthCheckRegistry);
    public void setHealthCheckProperties(Properties healthCheckProperties);
    public MetricsTrackerFactory getMetricsTrackerFactory();
    public Object getMetricRegistry();
    public Object getHealthCheckRegistry();
    public Properties getHealthCheckProperties();
    
    // DataSource properties
    public void setDataSourceProperties(Properties dsProperties);
    public void addDataSourceProperty(String propertyName, Object value);
    public void addHealthCheckProperty(String key, String value);
    public Properties getDataSourceProperties();
    
    // Validation and utility
    public void validate();
    public void copyState(HikariConfig other);
}

Configuration Management

JMX Management and Monitoring

Runtime monitoring and management capabilities through JMX beans, providing pool statistics and runtime configuration changes.

public interface HikariPoolMXBean {
    // Pool statistics
    int getIdleConnections();
    int getActiveConnections();
    int getTotalConnections();
    int getThreadsAwaitingConnection();
    
    // Pool control
    void suspendPool();
    void resumePool();
    void softEvictConnections();
}

public interface HikariConfigMXBean {
    // Runtime configuration setters
    void setConnectionTimeout(long connectionTimeoutMs);
    void setValidationTimeout(long validationTimeoutMs);
    void setIdleTimeout(long idleTimeoutMs);
    void setMaximumPoolSize(int maxPoolSize);
    void setMinimumIdle(int minIdle);
    void setLeakDetectionThreshold(long leakDetectionThresholdMs);
    void setMaxLifetime(long maxLifetimeMs);
    void setPassword(String password);
    void setUsername(String username);
    
    // Runtime configuration getters
    long getConnectionTimeout();
    long getValidationTimeout();
    long getIdleTimeout();
    long getLeakDetectionThreshold();
    long getMaxLifetime();
    int getMinimumIdle();
    int getMaximumPoolSize();
    String getPoolName();
}

JMX Management

Metrics Integration

Pluggable metrics system supporting popular metrics frameworks including Dropwizard Metrics and Prometheus for comprehensive pool monitoring.

public class MetricsTracker implements AutoCloseable {
    // Constructor
    public MetricsTracker();
    
    // Metrics recording methods
    public void recordConnectionAcquiredNanos(long elapsedAcquiredNanos);
    public void recordConnectionUsageMillis(long elapsedBorrowedMillis);
    public void recordConnectionTimeout();
    
    // AutoCloseable implementation
    public void close();
}

public interface MetricsTrackerFactory {
    MetricsTracker create(String poolName, PoolStats poolStats);
}

// Configuration methods in HikariConfig/HikariDataSource
public void setMetricsTrackerFactory(MetricsTrackerFactory metricsTrackerFactory);
public void setMetricRegistry(Object metricRegistry);
public void setHealthCheckRegistry(Object healthCheckRegistry);
public MetricsTrackerFactory getMetricsTrackerFactory();
public Object getMetricRegistry();
public Object getHealthCheckRegistry();

Metrics Integration

Framework Integration

Native integration with popular Java frameworks including Hibernate ORM and JNDI environments for seamless adoption in enterprise applications.

// Hibernate Integration
public class HikariConnectionProvider implements ConnectionProvider, Configurable, Stoppable {
    // Constructor
    public HikariConnectionProvider();
    
    // ConnectionProvider methods
    public Connection getConnection() throws SQLException;
    public void closeConnection(Connection conn) throws SQLException;
    public boolean supportsAggressiveRelease();
    public boolean isUnwrappableAs(Class unwrapType);
    public <T> T unwrap(Class<T> unwrapType);
    
    // Configurable implementation
    public void configure(Map props) throws HibernateException;
    
    // Stoppable implementation
    public void stop();
}

// JNDI Integration  
public class HikariJNDIFactory implements ObjectFactory {
    public synchronized Object getObjectInstance(Object obj, Name name, Context nameCtx, 
                                               Hashtable<?, ?> environment) throws Exception;
}

Framework Integration

Types

// Core configuration properties interface
public interface HikariConfigMXBean {
    long getConnectionTimeout();
    long getValidationTimeout();
    long getIdleTimeout();
    long getLeakDetectionThreshold();
    long getMaxLifetime();
    int getMinimumIdle();
    int getMaximumPoolSize();
    String getPoolName();
}

// Pool statistics and control interface
public interface HikariPoolMXBean {
    int getIdleConnections();
    int getActiveConnections();
    int getTotalConnections();
    int getThreadsAwaitingConnection();
    void softEvictConnections();
    void suspendPool();
    void resumePool();
}

// Base class for metrics tracking
public abstract class PoolStats {
    protected PoolStats(long timeoutMs);
    public int getTotalConnections();
    public int getIdleConnections();
    public int getActiveConnections();
    public int getPendingThreads();
    
    // Abstract method to be implemented by subclasses
    protected abstract void update();
}