Configuration and Setup

public class HikariDataSource extends HikariConfig implements DataSource, Closeable {
    /**
     * Default constructor with lazy initialization.
     * Pool creation is deferred until first getConnection() call.
     */
    public HikariDataSource();
    
    /**
     * Construct DataSource with specific configuration.
     * 
     * @param configuration HikariConfig instance with pool settings
     */
    public HikariDataSource(HikariConfig configuration);
    
    /**
     * Get a connection from the pool.
     * 
     * @return Connection from the pool
     * @throws SQLException if connection cannot be obtained
     */
    public Connection getConnection() throws SQLException;
    
    /**
     * Get connection with credentials (deprecated - credentials ignored).
     * 
     * @param username ignored parameter
     * @param password ignored parameter
     * @return Connection from the pool
     * @throws SQLException if connection cannot be obtained
     * @deprecated This method is deprecated in the underlying implementation
     */
    @Deprecated
    public Connection getConnection(String username, String password) throws SQLException;
    
    /**
     * Get the log writer for the DataSource.
     * 
     * @return PrintWriter for logging
     * @throws SQLException on error
     */
    public PrintWriter getLogWriter() throws SQLException;
    
    /**
     * Set the log writer for the DataSource.
     * 
     * @param out PrintWriter for logging
     * @throws SQLException on error
     */
    public void setLogWriter(PrintWriter out) throws SQLException;
    
    /**
     * Set login timeout in seconds.
     * 
     * @param seconds timeout in seconds
     * @throws SQLException on error
     */
    public void setLoginTimeout(int seconds) throws SQLException;
    
    /**
     * Get login timeout in seconds.
     * 
     * @return timeout in seconds
     * @throws SQLException on error
     */
    public int getLoginTimeout() throws SQLException;
    
    /**
     * Get parent logger (always throws SQLFeatureNotSupportedException).
     * 
     * @return never returns normally
     * @throws SQLFeatureNotSupportedException always thrown
     */
    public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException;
    
    /**
     * Unwrap to specified interface.
     * 
     * @param iface target interface class
     * @return unwrapped instance
     * @throws SQLException if unwrapping fails
     */
    public <T> T unwrap(Class<T> iface) throws SQLException;
    
    /**
     * Check if wrapper for specified interface.
     * 
     * @param iface target interface class
     * @return true if wrapper for interface
     * @throws SQLException on error
     */
    public boolean isWrapperFor(Class<?> iface) throws SQLException;
    
    /**
     * Set Codahale MetricRegistry for metrics collection.
     * 
     * @param metricRegistry MetricRegistry instance or null
     */
    public void setMetricRegistry(Object metricRegistry);
    
    /**
     * Set Codahale HealthCheckRegistry for health monitoring.
     * 
     * @param healthCheckRegistry HealthCheckRegistry instance or null
     */
    public void setHealthCheckRegistry(Object healthCheckRegistry);
    
    /**
     * Evict a specific connection from the pool.
     * 
     * @param connection connection to evict
     */
    public void evictConnection(Connection connection);
    
    /**
     * Suspend connection allocation from the pool.
     * Existing connections continue to work but no new connections are allocated.
     */
    public void suspendPool();
    
    /**
     * Resume connection allocation after suspension.
     */
    public void resumePool();
    
    /**
     * Close the DataSource and shutdown the connection pool.
     * Synonym for shutdown().
     */
    public void close();
    
    /**
     * Shutdown the DataSource and connection pool.
     * Waits for active connections to be returned.
     */
    public void shutdown();
    
    /**
     * String representation of the DataSource.
     * 
     * @return string describing the DataSource
     */
    public String toString();
}

public class HikariConfig extends AbstractHikariConfig {
    /**
     * Default constructor.
     */
    public HikariConfig();
    
    /**
     * Construct from Properties object.
     * Property keys should match configuration property names.
     * 
     * @param properties Properties containing configuration
     */
    public HikariConfig(Properties properties);
    
    /**
     * Construct from property file.
     * 
     * @param propertyFileName path to properties file
     */
    public HikariConfig(String propertyFileName);
    
    /**
     * Load properties from file (protected method for subclass use).
     * Attempts to load from filesystem first, then from classpath.
     * 
     * @param propertyFileName path to properties file
     * @throws IllegalArgumentException if property file not found
     * @throws RuntimeException if error loading properties
     */
    protected void loadProperties(String propertyFileName);
}

public abstract class AbstractHikariConfig implements HikariConfigMXBean {
    /**
     * Default constructor.
     */
    public AbstractHikariConfig();
    
    /**
     * Construct from Properties object.
     * 
     * @param properties Properties containing configuration
     */
    public AbstractHikariConfig(Properties properties);
    
    /**
     * Construct from property file.
     * 
     * @param propertyFileName path to properties file
     */
    public AbstractHikariConfig(String propertyFileName);
}

// JDBC URL configuration
public String getJdbcUrl();
public void setJdbcUrl(String jdbcUrl);

// Authentication
public String getUsername();
public void setUsername(String username);
public String getPassword();
public void setPassword(String password);

// Driver configuration
public String getDriverClassName();
public void setDriverClassName(String driverClassName);

// DataSource alternatives
public DataSource getDataSource();
public void setDataSource(DataSource dataSource);
public String getDataSourceClassName();
public void setDataSourceClassName(String className);
public String getDataSourceJNDI();
public void setDataSourceJNDI(String jndiDataSource);

// DataSource properties
public Properties getDataSourceProperties();
public void setDataSourceProperties(Properties dsProperties);
public void addDataSourceProperty(String propertyName, Object value);

// Pool sizing
public int getMaximumPoolSize();
public void setMaximumPoolSize(int maxPoolSize);
public int getMinimumIdle();
public void setMinimumIdle(int minIdle);

// Pool identification
public String getPoolName();
public void setPoolName(String poolName);

// Connection acquisition timeout (default: 30 seconds)
public long getConnectionTimeout();
public void setConnectionTimeout(long connectionTimeoutMs);

// Connection validation timeout (default: 5 seconds)
public long getValidationTimeout();
public void setValidationTimeout(long validationTimeoutMs);

// Idle connection timeout (default: 10 minutes)
public long getIdleTimeout();
public void setIdleTimeout(long idleTimeoutMs);

// Maximum connection lifetime (default: 30 minutes)
public long getMaxLifetime();
public void setMaxLifetime(long maxLifetimeMs);

// Connection leak detection threshold (default: 0 - disabled)
public long getLeakDetectionThreshold();
public void setLeakDetectionThreshold(long leakDetectionThresholdMs);

// Auto-commit behavior
public boolean isAutoCommit();
public void setAutoCommit(boolean isAutoCommit);

// Read-only mode
public boolean isReadOnly();
public void setReadOnly(boolean readOnly);

// Transaction isolation level
public String getTransactionIsolation();
public void setTransactionIsolation(String isolationLevel);

// Default catalog
public String getCatalog();
public void setCatalog(String catalog);

// Connection initialization SQL
public String getConnectionInitSql();
public void setConnectionInitSql(String connectionInitSql);

// Connection test query
public String getConnectionTestQuery();
public void setConnectionTestQuery(String connectionTestQuery);

// JDBC4 connection test (deprecated)
public boolean isJdbc4ConnectionTest();
public void setJdbc4ConnectionTest(boolean useIsValid);

// Internal query isolation
public boolean isIsolateInternalQueries();
public void setIsolateInternalQueries(boolean isolate);

// Pool suspension support
public boolean isAllowPoolSuspension();
public void setAllowPoolSuspension(boolean isAllowPoolSuspension);

// Fail-fast initialization
public boolean isInitializationFailFast();
public void setInitializationFailFast(boolean failFast);

// JMX MBean registration
public boolean isRegisterMbeans();
public void setRegisterMbeans(boolean register);

// Custom thread factory
public ThreadFactory getThreadFactory();
public void setThreadFactory(ThreadFactory threadFactory);

// Metrics integration
public Object getMetricRegistry();
public void setMetricRegistry(Object metricRegistry);

// Health check integration
public Object getHealthCheckRegistry();
public void setHealthCheckRegistry(Object healthCheckRegistry);
public Properties getHealthCheckProperties();
public void setHealthCheckProperties(Properties healthCheckProperties);
public void addHealthCheckProperty(String key, String value);

// Connection customization (deprecated)
@Deprecated
public String getConnectionCustomizerClassName();
@Deprecated
public void setConnectionCustomizerClassName(String connectionCustomizerClassName);
@Deprecated
public IConnectionCustomizer getConnectionCustomizer();
@Deprecated
public void setConnectionCustomizer(IConnectionCustomizer customizer);

/**
 * Validate the current configuration.
 * Throws IllegalArgumentException for invalid configurations.
 */
public void validate();

/**
 * Copy configuration state from another config instance.
 * 
 * @param other source configuration to copy from
 */
public void copyState(AbstractHikariConfig other);

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:postgresql://localhost/test");
config.setUsername("postgres");
config.setPassword("password");
config.setDriverClassName("org.postgresql.Driver");

HikariDataSource ds = new HikariDataSource(config);

Properties props = new Properties();
props.setProperty("jdbcUrl", "jdbc:mysql://localhost:3306/mydb");
props.setProperty("username", "user");
props.setProperty("password", "pass");
props.setProperty("maximumPoolSize", "20");
props.setProperty("connectionTimeout", "30000");

HikariConfig config = new HikariConfig(props);
HikariDataSource ds = new HikariDataSource(config);

// Load from hikari.properties file
HikariConfig config = new HikariConfig("hikari.properties");
HikariDataSource ds = new HikariDataSource(config);

// Using existing DataSource
HikariConfig config = new HikariConfig();
config.setDataSource(existingDataSource);
config.setMaximumPoolSize(15);

// Or by class name
config.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
config.addDataSourceProperty("url", "jdbc:mysql://localhost:3306/mydb");
config.addDataSourceProperty("user", "username");
config.addDataSourceProperty("password", "password");

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:postgresql://localhost/highload");
config.setUsername("postgres");
config.setPassword("password");

// Pool sizing for high-load application
config.setMaximumPoolSize(50);
config.setMinimumIdle(10);

// Optimize timeouts
config.setConnectionTimeout(20000);      // 20 seconds
config.setIdleTimeout(300000);          // 5 minutes
config.setMaxLifetime(1200000);         // 20 minutes

// Enable leak detection
config.setLeakDetectionThreshold(60000); // 1 minute

// Performance optimizations
config.setAutoCommit(true);
config.setTransactionIsolation("TRANSACTION_READ_COMMITTED");

HikariDataSource ds = new HikariDataSource(config);