HikariConfig (HikariCP 2.0.0 API)

java.lang.Object
- com.zaxxer.hikari.HikariConfig

All Implemented Interfaces:

HikariConfigMBean

Direct Known Subclasses:

HikariDataSource
```
public class HikariConfig
extends java.lang.Object
implements HikariConfigMBean
```

Constructor Summary

Constructors
Constructor and Description
`HikariConfig()` Default constructor
`HikariConfig(java.util.Properties properties)` Construct a HikariConfig from the specified properties object.
`HikariConfig(java.lang.String propertyFileName)` Construct a HikariConfig from the specified property file name.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addDataSourceProperty(java.lang.String propertyName, java.lang.Object value)`
`java.lang.String`	`getCatalog()` Get the default catalog name to be set on connections.
`IConnectionCustomizer`	`getConnectionCustomizer()` Get the customizer instance specified by the user.
`java.lang.String`	`getConnectionCustomizerClassName()` Get the name of the connection customizer class to instantiate and execute on all new connections.
`java.lang.String`	`getConnectionInitSql()` Get the SQL string that will be executed on all new connections when they are created, before they are added to the pool.
`java.lang.String`	`getConnectionTestQuery()` Get the SQL query to be executed to test the validity of connections.
`long`	`getConnectionTimeout()` Get the maximum number of milliseconds that a client will wait for a connection from the pool.
`javax.sql.DataSource`	`getDataSource()` Get the `DataSource` that has been explicitly specified to be wrapped by the pool.
`java.lang.String`	`getDataSourceClassName()`
`java.lang.String`	`getDataSourceJNDI()`
`java.util.Properties`	`getDataSourceProperties()`
`long`	`getIdleTimeout()` This property controls the maximum amount of time (in milliseconds) that a connection is allowed to sit idle in the pool.
`java.lang.String`	`getJdbcUrl()`
`long`	`getLeakDetectionThreshold()` This property controls the amount of time that a connection can be out of the pool before a message is logged indicating a possible connection leak.
`int`	`getMaximumPoolSize()` The property controls the maximum number of connections that HikariCP will keep in the pool, including both idle and in-use connections.
`long`	`getMaxLifetime()` This property controls the maximum lifetime of a connection in the pool.
`java.lang.String`	`getMetricsTrackerClassName()` Get the name of the class that implements the IMetricsTracker interface to be used for metrics tracking.
`int`	`getMinimumIdle()` The property controls the maximum size that the pool is allowed to reach, including both idle and in-use connections.
`java.lang.String`	`getPassword()` Get the default password to use for DataSource.getConnection(username, password) calls.
`java.lang.String`	`getPoolName()` The name of the connection pool.
`java.util.concurrent.ThreadFactory`	`getThreadFactory()` Get the thread factory used to create threads.
`int`	`getTransactionIsolation()`
`java.lang.String`	`getUsername()` Get the default username used for DataSource.getConnection(username, password) calls.
`boolean`	`isAutoCommit()` Get the default auto-commit behavior of connections in the pool.
`boolean`	`isInitializationFailFast()` Get whether or not the construction of the pool should throw an exception if the minimum number of connections cannot be created.
`boolean`	`isIsolateInternalQueries()`
`boolean`	`isJdbc4ConnectionTest()`
`boolean`	`isReadOnly()`
`boolean`	`isRecordMetrics()`
`boolean`	`isRegisterMbeans()`
`void`	`setAutoCommit(boolean isAutoCommit)` Set the default auto-commit behavior of connections in the pool.
`void`	`setCatalog(java.lang.String catalog)` Set the default catalog name to be set on connections.
`void`	`setConnectionCustomizer(IConnectionCustomizer customizer)` Set the connection customizer to be used by the pool.
`void`	`setConnectionCustomizerClassName(java.lang.String connectionCustomizerClassName)` Set the name of the connection customizer class to instantiate and execute on all new connections.
`void`	`setConnectionInitSql(java.lang.String connectionInitSql)` Set the SQL string that will be executed on all new connections when they are created, before they are added to the pool.
`void`	`setConnectionTestQuery(java.lang.String connectionTestQuery)` Set the SQL query to be executed to test the validity of connections.
`void`	`setConnectionTimeout(long connectionTimeoutMs)` Set the maximum number of milliseconds that a client will wait for a connection from the pool.
`void`	`setDataSource(javax.sql.DataSource dataSource)` Set a `DataSource` for the pool to explicitly wrap.
`void`	`setDataSourceClassName(java.lang.String className)`
`void`	`setDataSourceJNDI(java.lang.String jndiDataSource)`
`void`	`setDataSourceProperties(java.util.Properties dsProperties)`
`void`	`setDriverClassName(java.lang.String driverClassName)`
`void`	`setIdleTimeout(long idleTimeoutMs)` This property controls the maximum amount of time (in milliseconds) that a connection is allowed to sit idle in the pool.
`void`	`setInitializationFailFast(boolean failFast)` Set whether or not the construction of the pool should throw an exception if the minimum number of connections cannot be created.
`void`	`setIsolateInternalQueries(boolean isolate)`
`void`	`setJdbc4ConnectionTest(boolean useIsValid)`
`void`	`setJdbcUrl(java.lang.String jdbcUrl)`
`void`	`setLeakDetectionThreshold(long leakDetectionThresholdMs)` This property controls the amount of time that a connection can be out of the pool before a message is logged indicating a possible connection leak.
`void`	`setMaximumPoolSize(int maxPoolSize)` The property controls the maximum size that the pool is allowed to reach, including both idle and in-use connections.
`void`	`setMaxLifetime(long maxLifetimeMs)` This property controls the maximum lifetime of a connection in the pool.
`void`	`setMetricsTrackerClassName(java.lang.String className)` Set the name of the class that implements the IMetricsTracker interface to be used for metrics tracking.
`void`	`setMinimumIdle(int minIdle)` The property controls the minimum number of idle connections that HikariCP tries to maintain in the pool, including both idle and in-use connections.
`void`	`setPassword(java.lang.String password)` Set the default password to use for DataSource.getConnection(username, password) calls.
`void`	`setPoolName(java.lang.String poolName)` Set the name of the connection pool.
`void`	`setReadOnly(boolean readOnly)`
`void`	`setRecordMetrics(boolean recordMetrics)` Deprecated.
`void`	`setRegisterMbeans(boolean register)`
`void`	`setThreadFactory(java.util.concurrent.ThreadFactory threadFactory)` Set the thread factory to be used to create threads.
`void`	`setTransactionIsolation(java.lang.String isolationLevel)` Set the default transaction isolation level.
`void`	`setUsername(java.lang.String username)` Set the default username used for DataSource.getConnection(username, password) calls.
`void`	`validate()`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - HikariConfig
```
public HikariConfig()
```
    Default constructor
  - HikariConfig
```
public HikariConfig(java.util.Properties properties)
```
    Construct a HikariConfig from the specified properties object.
    
    Parameters:
    
    properties - the name of the property file
  - HikariConfig
```
public HikariConfig(java.lang.String propertyFileName)
```
    Construct a HikariConfig from the specified property file name.
    
    Parameters:
    
    propertyFileName - the name of the property file
- Method Detail
  - getCatalog
```
public java.lang.String getCatalog()
```
    Get the default catalog name to be set on connections.
    
    Returns:
    
    the default catalog name
  - setCatalog
```
public void setCatalog(java.lang.String catalog)
```
    Set the default catalog name to be set on connections.
    
    Parameters:
    
    catalog - the catalog name, or null
  - getConnectionCustomizerClassName
```
public java.lang.String getConnectionCustomizerClassName()
```
    Get the name of the connection customizer class to instantiate and execute on all new connections.
    
    Returns:
    
    the name of the customizer class, or null
  - setConnectionCustomizerClassName
```
public void setConnectionCustomizerClassName(java.lang.String connectionCustomizerClassName)
```
    Set the name of the connection customizer class to instantiate and execute on all new connections.
    
    Parameters:
    
    connectionCustomizerClassName - the name of the customizer class
  - getConnectionCustomizer
```
public IConnectionCustomizer getConnectionCustomizer()
```
    Get the customizer instance specified by the user.
    
    Returns:
    
    an instance of IConnectionCustomizer
  - setConnectionCustomizer
```
public void setConnectionCustomizer(IConnectionCustomizer customizer)
```
    Set the connection customizer to be used by the pool.
    
    Parameters:
    
    customizer - an instance of IConnectionCustomizer
  - getConnectionTestQuery
```
public java.lang.String getConnectionTestQuery()
```
    Get the SQL query to be executed to test the validity of connections.
    
    Returns:
    
    the SQL query string, or null
  - setConnectionTestQuery
```
public void setConnectionTestQuery(java.lang.String connectionTestQuery)
```
    Set the SQL query to be executed to test the validity of connections. Using the JDBC4 Connection.isValid() method to test connection validity can be more efficient on some databases and is recommended. See setJdbc4ConnectionTest(boolean).
    
    Parameters:
    
    connectionTestQuery - a SQL query string
  - getConnectionInitSql
```
public java.lang.String getConnectionInitSql()
```
    Get the SQL string that will be executed on all new connections when they are created, before they are added to the pool.
    
    Returns:
    
    the SQL to execute on new connections, or null
  - setConnectionInitSql
```
public void setConnectionInitSql(java.lang.String connectionInitSql)
```
    Set the SQL string that will be executed on all new connections when they are created, before they are added to the pool. If this query fails, it will be treated as a failed connection attempt.
    
    Parameters:
    
    connectionInitSql - the SQL to execute on new connections
  - getConnectionTimeout
```
public long getConnectionTimeout()
```
    Get the maximum number of milliseconds that a client will wait for a connection from the pool. If this time is exceeded without a connection becoming available, a SQLException will be thrown from DataSource.getConnection().
    
    Specified by:
    
    getConnectionTimeout in interface HikariConfigMBean
    
    Returns:
    
    the connection timeout in milliseconds
  - setConnectionTimeout
```
public void setConnectionTimeout(long connectionTimeoutMs)
```
    Set the maximum number of milliseconds that a client will wait for a connection from the pool. If this time is exceeded without a connection becoming available, a SQLException will be thrown from DataSource.getConnection().
    
    Specified by:
    
    setConnectionTimeout in interface HikariConfigMBean
    
    Parameters:
    
    connectionTimeoutMs - the connection timeout in milliseconds
  - getDataSource
```
public javax.sql.DataSource getDataSource()
```
    Get the DataSource that has been explicitly specified to be wrapped by the pool.
    
    Returns:
    
    the DataSource instance, or null
  - setDataSource
```
public void setDataSource(javax.sql.DataSource dataSource)
```
    Set a DataSource for the pool to explicitly wrap. This setter is not available through property file based initialization.
    
    Parameters:
    
    dataSource - a specific DataSource to be wrapped by the pool
  - getDataSourceClassName
```
public java.lang.String getDataSourceClassName()
```
  - setDataSourceClassName
```
public void setDataSourceClassName(java.lang.String className)
```
  - addDataSourceProperty
```
public void addDataSourceProperty(java.lang.String propertyName,
                                  java.lang.Object value)
```
  - getDataSourceJNDI
```
public java.lang.String getDataSourceJNDI()
```
  - setDataSourceJNDI
```
public void setDataSourceJNDI(java.lang.String jndiDataSource)
```
  - getDataSourceProperties
```
public java.util.Properties getDataSourceProperties()
```
  - setDataSourceProperties
```
public void setDataSourceProperties(java.util.Properties dsProperties)
```
  - setDriverClassName
```
public void setDriverClassName(java.lang.String driverClassName)
```
  - getIdleTimeout
```
public long getIdleTimeout()
```
    This property controls the maximum amount of time (in milliseconds) that a connection is allowed to sit idle in the pool. Whether a connection is retired as idle or not is subject to a maximum variation of +30 seconds, and average variation of +15 seconds. A connection will never be retired as idle before this timeout. A value of 0 means that idle connections are never removed from the pool.
    
    Specified by:
    
    getIdleTimeout in interface HikariConfigMBean
    
    Returns:
    
    the idle timeout in milliseconds
  - setIdleTimeout
```
public void setIdleTimeout(long idleTimeoutMs)
```
    This property controls the maximum amount of time (in milliseconds) that a connection is allowed to sit idle in the pool. Whether a connection is retired as idle or not is subject to a maximum variation of +30 seconds, and average variation of +15 seconds. A connection will never be retired as idle before this timeout. A value of 0 means that idle connections are never removed from the pool.
    
    Specified by:
    
    setIdleTimeout in interface HikariConfigMBean
    
    Parameters:
    
    idleTimeoutMs - the idle timeout in milliseconds
  - getJdbcUrl
```
public java.lang.String getJdbcUrl()
```
  - setJdbcUrl
```
public void setJdbcUrl(java.lang.String jdbcUrl)
```
  - isAutoCommit
```
public boolean isAutoCommit()
```
    Get the default auto-commit behavior of connections in the pool.
    
    Returns:
    
    the default auto-commit behavior of connections
  - setAutoCommit
```
public void setAutoCommit(boolean isAutoCommit)
```
    Set the default auto-commit behavior of connections in the pool.
    
    Parameters:
    
    isAutoCommit - the desired auto-commit default for connections
  - isInitializationFailFast
```
public boolean isInitializationFailFast()
```
    Get whether or not the construction of the pool should throw an exception if the minimum number of connections cannot be created.
    
    Returns:
    
    whether or not initialization should fail on error immediately
  - setInitializationFailFast
```
public void setInitializationFailFast(boolean failFast)
```
    Set whether or not the construction of the pool should throw an exception if the minimum number of connections cannot be created.
    
    Parameters:
    
    failFast - true if the pool should fail if the minimum connections cannot be created
  - isIsolateInternalQueries
```
public boolean isIsolateInternalQueries()
```
  - setIsolateInternalQueries
```
public void setIsolateInternalQueries(boolean isolate)
```
  - isJdbc4ConnectionTest
```
public boolean isJdbc4ConnectionTest()
```
  - setJdbc4ConnectionTest
```
public void setJdbc4ConnectionTest(boolean useIsValid)
```
  - isReadOnly
```
public boolean isReadOnly()
```
  - setReadOnly
```
public void setReadOnly(boolean readOnly)
```
  - isRecordMetrics
```
public boolean isRecordMetrics()
```
  - setRecordMetrics
```
@Deprecated
public void setRecordMetrics(boolean recordMetrics)
```
    Deprecated.
    
    Currently not supported.
    
    Parameters:
    
    recordMetrics - true if metrics should be recorded
  - isRegisterMbeans
```
public boolean isRegisterMbeans()
```
  - setRegisterMbeans
```
public void setRegisterMbeans(boolean register)
```
  - getLeakDetectionThreshold
```
public long getLeakDetectionThreshold()
```
    This property controls the amount of time that a connection can be out of the pool before a message is logged indicating a possible connection leak. A value of 0 means leak detection is disabled.
    
    Specified by:
    
    getLeakDetectionThreshold in interface HikariConfigMBean
    
    Returns:
    
    the connection leak detection threshold in milliseconds
  - setLeakDetectionThreshold
```
public void setLeakDetectionThreshold(long leakDetectionThresholdMs)
```
    This property controls the amount of time that a connection can be out of the pool before a message is logged indicating a possible connection leak. A value of 0 means leak detection is disabled.
    
    Specified by:
    
    setLeakDetectionThreshold in interface HikariConfigMBean
    
    Parameters:
    
    leakDetectionThresholdMs - the connection leak detection threshold in milliseconds
  - getMaxLifetime
```
public long getMaxLifetime()
```
    This property controls the maximum lifetime of a connection in the pool. When a connection reaches this timeout, even if recently used, it will be retired from the pool. An in-use connection will never be retired, only when it is idle will it be removed.
    
    Specified by:
    
    getMaxLifetime in interface HikariConfigMBean
    
    Returns:
    
    the maximum connection lifetime in milliseconds
  - setMaxLifetime
```
public void setMaxLifetime(long maxLifetimeMs)
```
    This property controls the maximum lifetime of a connection in the pool. When a connection reaches this timeout, even if recently used, it will be retired from the pool. An in-use connection will never be retired, only when it is idle will it be removed.
    
    Specified by:
    
    setMaxLifetime in interface HikariConfigMBean
    
    Parameters:
    
    maxLifetimeMs - the maximum connection lifetime in milliseconds
  - getMaximumPoolSize
```
public int getMaximumPoolSize()
```
    The property controls the maximum number of connections that HikariCP will keep in the pool, including both idle and in-use connections.
    
    Specified by:
    
    getMaximumPoolSize in interface HikariConfigMBean
    
    Returns:
    
    the maximum number of connections in the pool
  - setMaximumPoolSize
```
public void setMaximumPoolSize(int maxPoolSize)
```
    The property controls the maximum size that the pool is allowed to reach, including both idle and in-use connections. Basically this value will determine the maximum number of actual connections to the database backend.
    When the pool reaches this size, and no idle connections are available, calls to getConnection() will block for up to connectionTimeout milliseconds before timing out.
    
    Specified by:
    
    setMaximumPoolSize in interface HikariConfigMBean
    
    Parameters:
    
    maxPoolSize - the maximum number of connections in the pool
  - getMetricsTrackerClassName
```
public java.lang.String getMetricsTrackerClassName()
```
    Get the name of the class that implements the IMetricsTracker interface to be used for metrics tracking.
    
    Returns:
    
    the name of the class that implements the IMetricsTracker interface
  - setMetricsTrackerClassName
```
public void setMetricsTrackerClassName(java.lang.String className)
```
    Set the name of the class that implements the IMetricsTracker interface to be used for metrics tracking.
    
    Parameters:
    
    className - the name of the class that implements the IMetricsTracker interface
  - getMinimumIdle
```
public int getMinimumIdle()
```
    The property controls the maximum size that the pool is allowed to reach, including both idle and in-use connections. Basically this value will determine the maximum number of actual connections to the database backend.
    When the pool reaches this size, and no idle connections are available, calls to getConnection() will block for up to connectionTimeout milliseconds before timing out.
    
    Specified by:
    
    getMinimumIdle in interface HikariConfigMBean
    
    Returns:
    
    the minimum number of connections in the pool
  - setMinimumIdle
```
public void setMinimumIdle(int minIdle)
```
    The property controls the minimum number of idle connections that HikariCP tries to maintain in the pool, including both idle and in-use connections. If the idle connections dip below this value, HikariCP will make a best effort to restore them quickly and efficiently.
    
    Specified by:
    
    setMinimumIdle in interface HikariConfigMBean
    
    Parameters:
    
    minIdle - the minimum number of idle connections in the pool to maintain
  - getPassword
```
public java.lang.String getPassword()
```
    Get the default password to use for DataSource.getConnection(username, password) calls.
    
    Returns:
    
    the password
  - setPassword
```
public void setPassword(java.lang.String password)
```
    Set the default password to use for DataSource.getConnection(username, password) calls.
    
    Parameters:
    
    password - the password
  - getPoolName
```
public java.lang.String getPoolName()
```
    The name of the connection pool.
    
    Specified by:
    
    getPoolName in interface HikariConfigMBean
    
    Returns:
    
    the name of the connection pool
  - setPoolName
```
public void setPoolName(java.lang.String poolName)
```
    Set the name of the connection pool. This is primarily used for the MBean to uniquely identify the pool configuration.
    
    Parameters:
    
    poolName - the name of the connection pool to use
  - getTransactionIsolation
```
public int getTransactionIsolation()
```
  - setTransactionIsolation
```
public void setTransactionIsolation(java.lang.String isolationLevel)
```
    Set the default transaction isolation level. The specified value is the constant name from the Connection class, eg. TRANSACTION_REPEATABLE_READ.
    
    Parameters:
    
    isolationLevel - the name of the isolation level
  - getUsername
```
public java.lang.String getUsername()
```
    Get the default username used for DataSource.getConnection(username, password) calls.
    
    Returns:
    
    the username
  - setUsername
```
public void setUsername(java.lang.String username)
```
    Set the default username used for DataSource.getConnection(username, password) calls.
    
    Parameters:
    
    username - the username
  - getThreadFactory
```
public java.util.concurrent.ThreadFactory getThreadFactory()
```
    Get the thread factory used to create threads.
    
    Returns:
    
    the thread factory (may be null, in which case the default thread factory is used)
  - setThreadFactory
```
public void setThreadFactory(java.util.concurrent.ThreadFactory threadFactory)
```
    Set the thread factory to be used to create threads.
    
    Parameters:
    
    threadFactory - the thread factory (setting to null causes the default thread factory to be used)
  - validate
```
public void validate()
```

Class HikariConfig

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

HikariConfig

HikariConfig

HikariConfig

Method Detail

getCatalog

setCatalog

getConnectionCustomizerClassName

setConnectionCustomizerClassName

getConnectionCustomizer

setConnectionCustomizer

getConnectionTestQuery

setConnectionTestQuery

getConnectionInitSql

setConnectionInitSql

getConnectionTimeout

setConnectionTimeout

getDataSource

setDataSource

getDataSourceClassName

setDataSourceClassName

addDataSourceProperty

getDataSourceJNDI

setDataSourceJNDI

getDataSourceProperties

setDataSourceProperties

setDriverClassName

getIdleTimeout

setIdleTimeout

getJdbcUrl

setJdbcUrl

isAutoCommit

setAutoCommit

isInitializationFailFast

setInitializationFailFast

isIsolateInternalQueries

setIsolateInternalQueries

isJdbc4ConnectionTest

setJdbc4ConnectionTest

isReadOnly

setReadOnly

isRecordMetrics

setRecordMetrics

isRegisterMbeans

setRegisterMbeans

getLeakDetectionThreshold

setLeakDetectionThreshold

getMaxLifetime

setMaxLifetime

getMaximumPoolSize

setMaximumPoolSize

getMetricsTrackerClassName

setMetricsTrackerClassName

getMinimumIdle

setMinimumIdle

getPassword

setPassword

getPoolName

setPoolName

getTransactionIsolation

setTransactionIsolation

getUsername

setUsername

getThreadFactory

setThreadFactory

validate