Configuration

/**
 * Configuration class for HikariCP connection pool
 * Implements HikariConfigMXBean for JMX management
 */
public class HikariConfig implements HikariConfigMXBean {
    
    /**
     * Default constructor - loads from system property hikaricp.configurationFile if set
     */
    public HikariConfig();
    
    /**
     * Constructor from Properties object
     * @param properties Properties containing configuration
     */
    public HikariConfig(Properties properties);
    
    /**
     * Constructor from property file path
     * @param propertyFileName Path to properties file (filesystem or classpath)
     */
    public HikariConfig(String propertyFileName);
    
    /**
     * Validate the configuration and apply defaults
     * @throws IllegalArgumentException if configuration is invalid
     */
    public void validate();
    
    /**
     * Copy configuration state to another HikariConfig instance
     * @param other Target configuration instance
     */
    public void copyStateTo(HikariConfig other);
}

/**
 * JDBC URL for database connection
 */
public String getJdbcUrl();
public void setJdbcUrl(String jdbcUrl);

/**
 * Database username and password
 */
public String getUsername();
public void setUsername(String username);
public String getPassword();
public void setPassword(String password);

/**
 * Set username and password atomically
 */
public Credentials getCredentials();
public void setCredentials(Credentials credentials);

/**
 * JDBC driver class name (optional if using DataSource)
 */
public String getDriverClassName();
public void setDriverClassName(String driverClassName);

/**
 * DataSource class name for DataSource-based configuration
 */
public String getDataSourceClassName();
public void setDataSourceClassName(String className);

/**
 * Direct DataSource instance
 */
public DataSource getDataSource();
public void setDataSource(DataSource dataSource);

/**
 * JNDI name for DataSource lookup
 */
public String getDataSourceJNDI();
public void setDataSourceJNDI(String jndiDataSource);

// JDBC URL approach
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb?useSSL=false");
config.setUsername("dbuser");
config.setPassword("dbpass");
config.setDriverClassName("com.mysql.cj.jdbc.Driver");

// DataSource class approach
config.setDataSourceClassName("com.mysql.cj.jdbc.MysqlDataSource");
config.addDataSourceProperty("serverName", "localhost");
config.addDataSourceProperty("port", "3306");
config.addDataSourceProperty("databaseName", "mydb");
config.addDataSourceProperty("user", "dbuser");
config.addDataSourceProperty("password", "dbpass");

// JNDI approach
config.setDataSourceJNDI("java:comp/env/jdbc/MyDataSource");

// Direct DataSource
DataSource customDataSource = new MyCustomDataSource();
config.setDataSource(customDataSource);

/**
 * Maximum number of connections in the pool (default: 10)
 */
public int getMaximumPoolSize();
public void setMaximumPoolSize(int maxPoolSize);

/**
 * Minimum number of idle connections to maintain (default: same as maximumPoolSize)
 */
public int getMinimumIdle();
public void setMinimumIdle(int minIdle);

// Fixed pool size (all connections always available)
config.setMaximumPoolSize(20);
config.setMinimumIdle(20);

// Variable pool size (scales based on demand)
config.setMaximumPoolSize(20);
config.setMinimumIdle(5);

// Default behavior (fixed pool of 10)
// Uses defaults: maxPoolSize=10, minIdle=10

/**
 * Maximum time to wait for connection from pool (default: 30 seconds)
 */
public long getConnectionTimeout();
public void setConnectionTimeout(long connectionTimeoutMs);

/**
 * Maximum time for connection validation (default: 5 seconds)
 */
public long getValidationTimeout();
public void setValidationTimeout(long validationTimeoutMs);

/**
 * Maximum idle time before connection is retired (default: 10 minutes, 0=disabled)
 */
public long getIdleTimeout();
public void setIdleTimeout(long idleTimeoutMs);

/**
 * Maximum lifetime of connection in pool (default: 30 minutes, 0=infinite)
 */
public long getMaxLifetime();
public void setMaxLifetime(long maxLifetimeMs);

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

/**
 * Keepalive interval for idle connections (default: 0=disabled)
 */
public long getKeepaliveTime();
public void setKeepaliveTime(long keepaliveTimeMs);

// Production settings
config.setConnectionTimeout(20000);      // 20 seconds
config.setValidationTimeout(3000);       // 3 seconds  
config.setIdleTimeout(600000);           // 10 minutes
config.setMaxLifetime(1800000);          // 30 minutes
config.setLeakDetectionThreshold(60000); // 1 minute

// Development settings (more lenient)
config.setConnectionTimeout(30000);      // 30 seconds
config.setLeakDetectionThreshold(300000); // 5 minutes
config.setIdleTimeout(0);                // Disabled

/**
 * Default auto-commit mode for connections (default: true)
 */
public boolean isAutoCommit();
public void setAutoCommit(boolean isAutoCommit);

/**
 * Default read-only mode for connections (default: false)
 */
public boolean isReadOnly();
public void setReadOnly(boolean readOnly);

/**
 * Default transaction isolation level
 */
public String getTransactionIsolation();
public void setTransactionIsolation(String isolationLevel);

/**
 * Default catalog for connections
 */
public String getCatalog();
public void setCatalog(String catalog);

/**
 * Default schema for connections
 */
public String getSchema();
public void setSchema(String schema);

/**
 * SQL to execute on new connections
 */
public String getConnectionInitSql();
public void setConnectionInitSql(String connectionInitSql);

/**
 * SQL query to test connection validity (JDBC4 Connection.isValid() preferred)
 */
public String getConnectionTestQuery();
public void setConnectionTestQuery(String connectionTestQuery);

// Read-only replica configuration
config.setReadOnly(true);
config.setTransactionIsolation("TRANSACTION_READ_COMMITTED");

// Connection initialization
config.setConnectionInitSql("SET SESSION sql_mode = 'STRICT_TRANS_TABLES'");

// Custom validation (prefer JDBC4 isValid() when possible)
config.setConnectionTestQuery("SELECT 1");

// Schema/catalog defaults
config.setSchema("myapp");
config.setCatalog("production");

/**
 * Pool name for logging and JMX (auto-generated if not set)
 */
public String getPoolName();
public void setPoolName(String poolName);

/**
 * Allow pool suspension for maintenance (default: false)
 */
public boolean isAllowPoolSuspension();
public void setAllowPoolSuspension(boolean isAllowPoolSuspension);

/**
 * Isolate internal queries in separate transactions (default: false)
 */
public boolean isIsolateInternalQueries();
public void setIsolateInternalQueries(boolean isolate);

/**
 * Register MXBeans with JMX (default: false)
 */
public boolean isRegisterMbeans();
public void setRegisterMbeans(boolean register);

/**
 * Pool initialization failure timeout (default: 1ms)
 */
public long getInitializationFailTimeout();
public void setInitializationFailTimeout(long initializationFailTimeout);

/**
 * Custom thread factory for pool threads
 */
public ThreadFactory getThreadFactory();
public void setThreadFactory(ThreadFactory threadFactory);

/**
 * Custom scheduled executor for housekeeping
 */
public ScheduledExecutorService getScheduledExecutor();
public void setScheduledExecutor(ScheduledExecutorService executor);

// Production monitoring setup
config.setPoolName("MyApp-DB-Pool");
config.setRegisterMbeans(true);
config.setAllowPoolSuspension(true);

// Custom exception handling
config.setExceptionOverrideClassName("com.myapp.CustomSQLExceptionOverride");

// Fail-fast initialization (good for health checks)
config.setInitializationFailTimeout(2000); // 2 seconds

// Background initialization (good for startup performance)
config.setInitializationFailTimeout(-1); // Skip validation

/**
 * Add property for DataSource or Driver configuration
 * @param propertyName Property name (converted to setter for DataSource)
 * @param value Property value
 */
public void addDataSourceProperty(String propertyName, Object value);

/**
 * Get all DataSource properties
 */
public Properties getDataSourceProperties();

/**
 * Set DataSource properties in bulk
 */
public void setDataSourceProperties(Properties dsProperties);

// MySQL DataSource properties
config.setDataSourceClassName("com.mysql.cj.jdbc.MysqlDataSource");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
config.addDataSourceProperty("useServerPrepStmts", "true");
config.addDataSourceProperty("useLocalSessionState", "true");
config.addDataSourceProperty("rewriteBatchedStatements", "true");

// PostgreSQL DataSource properties
config.setDataSourceClassName("org.postgresql.ds.PGSimpleDataSource");
config.addDataSourceProperty("applicationName", "MyApplication");
config.addDataSourceProperty("loggerLevel", "INFO");

// Connection properties via JDBC URL (alternative approach)
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb?cachePrepStmts=true&prepStmtCacheSize=250");

# Database connection
jdbcUrl=jdbc:mysql://localhost:3306/mydb
username=dbuser
password=dbpass

# Pool settings
maximumPoolSize=20
minimumIdle=5

# Timeouts
connectionTimeout=30000
idleTimeout=600000
maxLifetime=1800000

# Other settings
poolName=MyApp-Pool
registerMbeans=true
leakDetectionThreshold=60000

# DataSource properties (when using dataSourceClassName)
dataSource.cachePrepStmts=true
dataSource.prepStmtCacheSize=250

// Load from file
HikariConfig config = new HikariConfig("/path/to/hikari.properties");

// Or from classpath
HikariConfig config = new HikariConfig("hikari.properties");

// Or using system property
System.setProperty("hikaricp.configurationFile", "hikari.properties");
HikariConfig config = new HikariConfig(); // Automatically loads file

// Validation is automatically called by HikariDataSource constructor
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
// Missing username/password will cause validation error

// Explicit validation
try {
    config.validate();
    System.out.println("Configuration is valid");
} catch (IllegalArgumentException e) {
    System.err.println("Configuration error: " + e.getMessage());
}