You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by Phil Steitz <ph...@gmail.com> on 2011/06/13 19:41:56 UTC
Re: svn commit: r1135192 [1/2] - in /commons/proper/pool/trunk/src:
java/org/apache/commons/pool2/impl/ test/org/apache/commons/pool2/ test/org/apache/commons/pool2/impl/
test/org/apache/commons/pool2/performance/
On 6/13/11 10:37 AM, markt@apache.org wrote:
> Author: markt
> Date: Mon Jun 13 17:37:02 2011
> New Revision: 1135192
>
> URL: http://svn.apache.org/viewvc?rev=1135192&view=rev
> Log:
> Reduce the number of constructors for GenericObjectPool
Oh no! No more counting parameters :-( No more horizontal
scrolling :-(
Thanks, Mark!!
Phil
> Modified:
> commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/BaseObjectPoolConfig.java
> commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericKeyedObjectPoolConfig.java
> commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPool.java
> commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolConfig.java
> commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java
> commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java
> commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPool.java
> commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPoolFactory.java
> commons/proper/pool/trunk/src/test/org/apache/commons/pool2/performance/PerformanceTest.java
>
> Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/BaseObjectPoolConfig.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/BaseObjectPoolConfig.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/BaseObjectPoolConfig.java (original)
> +++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/BaseObjectPoolConfig.java Mon Jun 13 17:37:02 2011
> @@ -20,7 +20,7 @@ package org.apache.commons.pool2.impl;
> * Provides the common configuration attributes used by object pool
> * configurations.
> */
> -public abstract class BaseObjectPoolConfig {
> +public abstract class BaseObjectPoolConfig implements Cloneable {
>
> /**
> * The default LIFO status. True means that borrowObject returns the most
>
> Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericKeyedObjectPoolConfig.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericKeyedObjectPoolConfig.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericKeyedObjectPoolConfig.java (original)
> +++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericKeyedObjectPoolConfig.java Mon Jun 13 17:37:02 2011
> @@ -24,8 +24,7 @@ import org.apache.commons.pool2.KeyedPoo
> *
> * @since Pool 2.0
> */
> -public class GenericKeyedObjectPoolConfig<K,T> extends BaseObjectPoolConfig
> - implements Cloneable {
> +public class GenericKeyedObjectPoolConfig<K,T> extends BaseObjectPoolConfig {
>
> public static final int DEFAULT_MAX_TOTAL_PER_KEY = 8;
>
>
> Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPool.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPool.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPool.java (original)
> +++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPool.java Mon Jun 13 17:37:02 2011
> @@ -291,475 +291,32 @@ public class GenericObjectPool<T> extend
> * Create a new <tt>GenericObjectPool</tt> with default properties.
> */
> public GenericObjectPool() {
> - this(null, DEFAULT_MAX_ACTIVE, DEFAULT_WHEN_EXHAUSTED_ACTION,
> - DEFAULT_MAX_WAIT, DEFAULT_MAX_IDLE, DEFAULT_MIN_IDLE,
> - DEFAULT_TEST_ON_BORROW, DEFAULT_TEST_ON_RETURN,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> + this(new GenericObjectPoolConfig<T>());
> }
>
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified factory.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory) {
> - this(factory, DEFAULT_MAX_ACTIVE, DEFAULT_WHEN_EXHAUSTED_ACTION,
> - DEFAULT_MAX_WAIT, DEFAULT_MAX_IDLE, DEFAULT_MIN_IDLE,
> - DEFAULT_TEST_ON_BORROW, DEFAULT_TEST_ON_RETURN,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param config
> - * a non-<tt>null</tt> {@link GenericObjectPool.Config}
> - * describing my configuration
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory,
> - GenericObjectPool.Config config) {
> - this(factory, config.maxActive, config.whenExhaustedAction,
> - config.maxWait, config.maxIdle, config.minIdle,
> - config.testOnBorrow, config.testOnReturn,
> - config.timeBetweenEvictionRunsMillis,
> - config.numTestsPerEvictionRun,
> - config.minEvictableIdleTimeMillis, config.testWhileIdle,
> - config.softMinEvictableIdleTimeMillis, config.lifo);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed from me at
> - * one time (see {@link #setMaxActive})
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive) {
> - this(factory, maxActive, DEFAULT_WHEN_EXHAUSTED_ACTION,
> - DEFAULT_MAX_WAIT, DEFAULT_MAX_IDLE, DEFAULT_MIN_IDLE,
> - DEFAULT_TEST_ON_BORROW, DEFAULT_TEST_ON_RETURN,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed from me at
> - * one time (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #getWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted an and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #getMaxWait})
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait) {
> - this(factory, maxActive, whenExhaustedAction, maxWait,
> - DEFAULT_MAX_IDLE, DEFAULT_MIN_IDLE, DEFAULT_TEST_ON_BORROW,
> - DEFAULT_TEST_ON_RETURN,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #getWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted an and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #getMaxWait})
> - * @param testOnBorrow
> - * whether or not to validate objects before they are returned by
> - * the {@link #borrowObject} method (see {@link #getTestOnBorrow}
> - * )
> - * @param testOnReturn
> - * whether or not to validate objects after they are returned to
> - * the {@link #returnObject} method (see {@link #getTestOnReturn}
> - * )
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait,
> - boolean testOnBorrow, boolean testOnReturn) {
> - this(factory, maxActive, whenExhaustedAction, maxWait,
> - DEFAULT_MAX_IDLE, DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #getWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #getMaxWait})
> - * @param maxIdle
> - * the maximum number of idle objects in my pool (see
> - * {@link #getMaxIdle})
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait,
> - int maxIdle) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - DEFAULT_MIN_IDLE, DEFAULT_TEST_ON_BORROW,
> - DEFAULT_TEST_ON_RETURN,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #getWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #getMaxWait})
> - * @param maxIdle
> - * the maximum number of idle objects in my pool (see
> - * {@link #getMaxIdle})
> - * @param testOnBorrow
> - * whether or not to validate objects before they are returned by
> - * the {@link #borrowObject} method (see {@link #getTestOnBorrow}
> - * )
> - * @param testOnReturn
> - * whether or not to validate objects after they are returned to
> - * the {@link #returnObject} method (see {@link #getTestOnReturn}
> - * )
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait, int maxIdle,
> - boolean testOnBorrow, boolean testOnReturn) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
> - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #setWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #setMaxWait})
> - * @param maxIdle
> - * the maximum number of idle objects in my pool (see
> - * {@link #setMaxIdle})
> - * @param testOnBorrow
> - * whether or not to validate objects before they are returned by
> - * the {@link #borrowObject} method (see {@link #setTestOnBorrow}
> - * )
> - * @param testOnReturn
> - * whether or not to validate objects after they are returned to
> - * the {@link #returnObject} method (see {@link #setTestOnReturn}
> - * )
> - * @param timeBetweenEvictionRunsMillis
> - * the amount of time (in milliseconds) to sleep between
> - * examining idle objects for eviction (see
> - * {@link #setTimeBetweenEvictionRunsMillis})
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread (if any) (see
> - * {@link #setNumTestsPerEvictionRun})
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction (see
> - * {@link #setMinEvictableIdleTimeMillis})
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread, if any (see {@link #setTestWhileIdle})
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait, int maxIdle,
> - boolean testOnBorrow, boolean testOnReturn,
> - long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
> - long minEvictableIdleTimeMillis, boolean testWhileIdle) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
> - timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
> - minEvictableIdleTimeMillis, testWhileIdle);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #setWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #setMaxWait})
> - * @param maxIdle
> - * the maximum number of idle objects in my pool (see
> - * {@link #setMaxIdle})
> - * @param minIdle
> - * the minimum number of idle objects in my pool (see
> - * {@link #setMinIdle})
> - * @param testOnBorrow
> - * whether or not to validate objects before they are returned by
> - * the {@link #borrowObject} method (see {@link #setTestOnBorrow}
> - * )
> - * @param testOnReturn
> - * whether or not to validate objects after they are returned to
> - * the {@link #returnObject} method (see {@link #setTestOnReturn}
> - * )
> - * @param timeBetweenEvictionRunsMillis
> - * the amount of time (in milliseconds) to sleep between
> - * examining idle objects for eviction (see
> - * {@link #setTimeBetweenEvictionRunsMillis})
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread (if any) (see
> - * {@link #setNumTestsPerEvictionRun})
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction (see
> - * {@link #setMinEvictableIdleTimeMillis})
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread, if any (see {@link #setTestWhileIdle})
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait, int maxIdle,
> - int minIdle, boolean testOnBorrow, boolean testOnReturn,
> - long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
> - long minEvictableIdleTimeMillis, boolean testWhileIdle) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - minIdle, testOnBorrow, testOnReturn,
> - timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
> - minEvictableIdleTimeMillis, testWhileIdle,
> - DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #setWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #setMaxWait})
> - * @param maxIdle
> - * the maximum number of idle objects in my pool (see
> - * {@link #setMaxIdle})
> - * @param minIdle
> - * the minimum number of idle objects in my pool (see
> - * {@link #setMinIdle})
> - * @param testOnBorrow
> - * whether or not to validate objects before they are returned by
> - * the {@link #borrowObject} method (see {@link #setTestOnBorrow}
> - * )
> - * @param testOnReturn
> - * whether or not to validate objects after they are returned to
> - * the {@link #returnObject} method (see {@link #setTestOnReturn}
> - * )
> - * @param timeBetweenEvictionRunsMillis
> - * the amount of time (in milliseconds) to sleep between
> - * examining idle objects for eviction (see
> - * {@link #setTimeBetweenEvictionRunsMillis})
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread (if any) (see
> - * {@link #setNumTestsPerEvictionRun})
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction (see
> - * {@link #setMinEvictableIdleTimeMillis})
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread, if any (see {@link #setTestWhileIdle})
> - * @param softMinEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction with the extra
> - * condition that at least "minIdle" amount of object remain in
> - * the pool. (see {@link #setSoftMinEvictableIdleTimeMillis})
> - * @since Pool 1.3
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait, int maxIdle,
> - int minIdle, boolean testOnBorrow, boolean testOnReturn,
> - long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
> - long minEvictableIdleTimeMillis, boolean testWhileIdle,
> - long softMinEvictableIdleTimeMillis) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - minIdle, testOnBorrow, testOnReturn,
> - timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
> - minEvictableIdleTimeMillis, testWhileIdle,
> - softMinEvictableIdleTimeMillis, DEFAULT_LIFO);
> - }
> -
> - /**
> - * Create a new <tt>GenericObjectPool</tt> using the specified values.
> - *
> - * @param factory
> - * the (possibly <tt>null</tt>)PoolableObjectFactory to use to
> - * create, validate and destroy objects
> - * @param maxActive
> - * the maximum number of objects that can be borrowed at one time
> - * (see {@link #setMaxActive})
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted (see
> - * {@link #setWhenExhaustedAction})
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted and <i>whenExhaustedAction</i> is
> - * {@link WhenExhaustedAction#BLOCK} (otherwise ignored) (see
> - * {@link #setMaxWait})
> - * @param maxIdle
> - * the maximum number of idle objects in my pool (see
> - * {@link #setMaxIdle})
> - * @param minIdle
> - * the minimum number of idle objects in my pool (see
> - * {@link #setMinIdle})
> - * @param testOnBorrow
> - * whether or not to validate objects before they are returned by
> - * the {@link #borrowObject} method (see {@link #setTestOnBorrow}
> - * )
> - * @param testOnReturn
> - * whether or not to validate objects after they are returned to
> - * the {@link #returnObject} method (see {@link #setTestOnReturn}
> - * )
> - * @param timeBetweenEvictionRunsMillis
> - * the amount of time (in milliseconds) to sleep between
> - * examining idle objects for eviction (see
> - * {@link #setTimeBetweenEvictionRunsMillis})
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread (if any) (see
> - * {@link #setNumTestsPerEvictionRun})
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction (see
> - * {@link #setMinEvictableIdleTimeMillis})
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread, if any (see {@link #setTestWhileIdle})
> - * @param softMinEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction with the extra
> - * condition that at least "minIdle" amount of object remain in
> - * the pool. (see {@link #setSoftMinEvictableIdleTimeMillis})
> - * @param lifo
> - * whether or not objects are returned in last-in-first-out order
> - * from the idle object pool (see {@link #setLifo})
> - * @since Pool 1.4
> - */
> - public GenericObjectPool(PoolableObjectFactory<T> factory, int maxActive,
> - WhenExhaustedAction whenExhaustedAction, long maxWait, int maxIdle,
> - int minIdle, boolean testOnBorrow, boolean testOnReturn,
> - long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
> - long minEvictableIdleTimeMillis, boolean testWhileIdle,
> - long softMinEvictableIdleTimeMillis, boolean lifo) {
> - _factory = factory;
> - _maxActive = maxActive;
> - _lifo = lifo;
> - _whenExhaustedAction = whenExhaustedAction;
> - _maxWait = maxWait;
> - _maxIdle = maxIdle;
> - _minIdle = minIdle;
> - _testOnBorrow = testOnBorrow;
> - _testOnReturn = testOnReturn;
> - _timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
> - _numTestsPerEvictionRun = numTestsPerEvictionRun;
> - _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
> - _softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
> - _testWhileIdle = testWhileIdle;
> -
> - _idleObjects = new LinkedBlockingDeque<PooledObject<T>>();
> - _allObjects = new ConcurrentHashMap<T, PooledObject<T>>();
> + public GenericObjectPool(GenericObjectPoolConfig<T> config) {
> + this._factory = config.getFactory();
> + this._lifo = config.getLifo();
> + this._maxActive = config.getMaxTotal();
> + this._maxIdle = config.getMaxIdle();
> + this._maxWait = config.getMaxWait();
> + this._minEvictableIdleTimeMillis =
> + config.getMinEvictableIdleTimeMillis();
> + this._minIdle = config.getMinIdle();
> + this._numTestsPerEvictionRun = config.getNumTestsPerEvictionRun();
> + this._softMinEvictableIdleTimeMillis =
> + config.getSoftMinEvictableIdleTimeMillis();
> + this._testOnBorrow = config.getTestOnBorrow();
> + this._testOnReturn = config.getTestOnReturn();
> + this._testWhileIdle = config.getTestWhileIdle();
> + this._timeBetweenEvictionRunsMillis =
> + config.getTimeBetweenEvictionRunsMillis();
> + this._whenExhaustedAction = config.getWhenExhaustedAction();
>
> startEvictor(_timeBetweenEvictionRunsMillis);
> }
>
> +
> // --- public methods ---------------------------------------------
>
> // --- configuration methods --------------------------------------
> @@ -2011,7 +1568,8 @@ public class GenericObjectPool<T> extend
> * {@link #_allObjects} will always be less than or equal to {@link
> * #_maxActive}.
> */
> - private Map<T, PooledObject<T>> _allObjects = null;
> + private final Map<T, PooledObject<T>> _allObjects =
> + new ConcurrentHashMap<T, PooledObject<T>>();
>
> /**
> * The combined count of the currently created objects and those in the
> @@ -2020,10 +1578,11 @@ public class GenericObjectPool<T> extend
> * {@link #create(boolean)} will ensure that there are never more than
> * {@link #_maxActive} objects created at any one time.
> */
> - private AtomicLong createCount = new AtomicLong(0);
> + private final AtomicLong createCount = new AtomicLong(0);
>
> /** The queue of idle objects */
> - private LinkedBlockingDeque<PooledObject<T>> _idleObjects = null;
> + private final LinkedBlockingDeque<PooledObject<T>> _idleObjects =
> + new LinkedBlockingDeque<PooledObject<T>>();
>
> /** An iterator for {@link #_idleObjects} that is used by the evictor. */
> private Iterator<PooledObject<T>> _evictionIterator = null;
>
> Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolConfig.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolConfig.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolConfig.java (original)
> +++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolConfig.java Mon Jun 13 17:37:02 2011
> @@ -24,7 +24,7 @@ import org.apache.commons.pool2.Poolable
> *
> * @since Pool 2.0
> */
> -public class GenericObjectPoolConfig extends BaseObjectPoolConfig {
> +public class GenericObjectPoolConfig<T> extends BaseObjectPoolConfig {
>
> /**
> * The default value for {@link #getSoftMinEvictableIdleTimeMillis}.
> @@ -37,20 +37,35 @@ public class GenericObjectPoolConfig ext
> */
> public static final int DEFAULT_MAX_TOTAL = 8;
>
> + /**
> + * The default cap on the number of "sleeping" instances in the pool.
> + */
> + public static final int DEFAULT_MAX_IDLE = 8;
> +
> + /**
> + * The default minimum number of "sleeping" instances in the pool before
> + * before the evictor thread (if active) spawns new objects.
> + */
> + public static final int DEFAULT_MIN_IDLE = 0;
>
> - private PoolableObjectFactory<?> factory = null;
> +
> + private PoolableObjectFactory<T> factory = null;
>
> private long softMinEvictableIdleTimeMillis =
> DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
>
> private int maxTotal = DEFAULT_MAX_TOTAL;
>
> + private int maxIdle = DEFAULT_MAX_IDLE;
> +
> + private int minIdle = DEFAULT_MIN_IDLE;
>
> - public PoolableObjectFactory<?> getFactory() {
> +
> + public PoolableObjectFactory<T> getFactory() {
> return factory;
> }
>
> - public void setFactory(PoolableObjectFactory<?> factory) {
> + public void setFactory(PoolableObjectFactory<T> factory) {
> this.factory = factory;
> }
>
> @@ -72,4 +87,32 @@ public class GenericObjectPoolConfig ext
> public void setMaxTotal(int maxTotal) {
> this.maxTotal = maxTotal;
> }
> +
> +
> + public int getMaxIdle() {
> + return maxIdle;
> + }
> +
> + public void setMaxIdle(int maxIdle) {
> + this.maxIdle = maxIdle;
> + }
> +
> +
> + public int getMinIdle() {
> + return minIdle;
> + }
> +
> + public void setMinIdle(int minIdle) {
> + this.minIdle = minIdle;
> + }
> +
> + @SuppressWarnings("unchecked")
> + @Override
> + public GenericObjectPoolConfig<T> clone() {
> + try {
> + return (GenericObjectPoolConfig<T>) super.clone();
> + } catch (CloneNotSupportedException e) {
> + throw new AssertionError(); // Can't happen
> + }
> + }
> }
>
> Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java (original)
> +++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java Mon Jun 13 17:37:02 2011
> @@ -19,678 +19,62 @@ package org.apache.commons.pool2.impl;
>
> import org.apache.commons.pool2.ObjectPool;
> import org.apache.commons.pool2.ObjectPoolFactory;
> -import org.apache.commons.pool2.PoolableObjectFactory;
>
> /**
> - * A factory for creating {@link GenericObjectPool} instances.
> - *
> - * @see GenericObjectPool
> - * @see ObjectPoolFactory
> - * @param <T>
> - * Type of element pooled in the built pool.
> - * @author Rodney Waldhoff
> - * @version $Revision$ $Date: 2011-05-11 14:56:24 +0100 (Wed, 11 May
> - * 2011) $
> + * A factory for creating {@link GenericObjectPool} instances from a provided
> + * {@link GenericObjectPoolConfig configuration}.
> + *
> + * @param <T> Type of element pooled in the built pool.
> + *
> * @since Pool 1.0
> */
> -public class GenericObjectPoolFactory<T> implements ObjectPoolFactory<T> {
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory) {
> - this(factory, GenericObjectPool.DEFAULT_MAX_ACTIVE,
> - GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,
> - GenericObjectPool.DEFAULT_MAX_WAIT,
> - GenericObjectPool.DEFAULT_MAX_IDLE,
> - GenericObjectPool.DEFAULT_MIN_IDLE,
> - GenericObjectPool.DEFAULT_TEST_ON_BORROW,
> - GenericObjectPool.DEFAULT_TEST_ON_RETURN,
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
> - }
>
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param config
> - * a non-<code>null</code> GenericObjectPool.Config describing
> - * the configuration.
> - * @throws NullPointerException
> - * when config is <code>null</code>.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory,
> - * GenericObjectPool.Config)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - GenericObjectPool.Config config) throws NullPointerException {
> - this(factory, config.maxActive, config.whenExhaustedAction,
> - config.maxWait, config.maxIdle, config.minIdle,
> - config.testOnBorrow, config.testOnReturn,
> - config.timeBetweenEvictionRunsMillis,
> - config.numTestsPerEvictionRun,
> - config.minEvictableIdleTimeMillis, config.testWhileIdle,
> - config.softMinEvictableIdleTimeMillis, config.lifo);
> - }
> -
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive) {
> - this(factory, maxActive,
> - GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,
> - GenericObjectPool.DEFAULT_MAX_WAIT,
> - GenericObjectPool.DEFAULT_MAX_IDLE,
> - GenericObjectPool.DEFAULT_MIN_IDLE,
> - GenericObjectPool.DEFAULT_TEST_ON_BORROW,
> - GenericObjectPool.DEFAULT_TEST_ON_RETURN,
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
> - }
> -
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait) {
> - this(factory, maxActive, whenExhaustedAction, maxWait,
> - GenericObjectPool.DEFAULT_MAX_IDLE,
> - GenericObjectPool.DEFAULT_MIN_IDLE,
> - GenericObjectPool.DEFAULT_TEST_ON_BORROW,
> - GenericObjectPool.DEFAULT_TEST_ON_RETURN,
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
> - }
> +public class GenericObjectPoolFactory<T> implements ObjectPoolFactory<T> {
>
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param testOnBorrow
> - * whether to validate objects before they are returned by the
> - * borrowObject.
> - * @param testOnReturn
> - * whether to validate objects after they are returned to the
> - * returnObject.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, boolean, boolean)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, boolean testOnBorrow, boolean testOnReturn) {
> - this(factory, maxActive, whenExhaustedAction, maxWait,
> - GenericObjectPool.DEFAULT_MAX_IDLE,
> - GenericObjectPool.DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
> - }
> + private GenericObjectPoolConfig<T> config;
>
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param maxIdle
> - * the maximum number of idle objects in my pool.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, int)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, int maxIdle) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - GenericObjectPool.DEFAULT_MIN_IDLE,
> - GenericObjectPool.DEFAULT_TEST_ON_BORROW,
> - GenericObjectPool.DEFAULT_TEST_ON_RETURN,
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
> - }
>
> /**
> * Create a new GenericObjectPoolFactory.
> *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param maxIdle
> - * the maximum number of idle objects in my pool.
> - * @param testOnBorrow
> - * whether to validate objects before they are returned by the
> - * borrowObject.
> - * @param testOnReturn
> - * whether to validate objects after they are returned to the
> - * returnObject.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, int, boolean, boolean)
> + * @param config The configuration that will be used for all pools
> + * created by this factory. Note that the configuration is
> + * passed by value. Subsequent changes to config will not
> + * be reflected in this factory or the pools it creates.
> */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, int maxIdle, boolean testOnBorrow,
> - boolean testOnReturn) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - GenericObjectPool.DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
> - GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
> + public GenericObjectPoolFactory(GenericObjectPoolConfig<T> config) {
> + this.config = config.clone();
> }
>
> +
> /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param maxIdle
> - * the maximum number of idle objects in my pool.
> - * @param testOnBorrow
> - * whether to validate objects before they are returned by the
> - * borrowObject.
> - * @param testOnReturn
> - * whether to validate objects after they are returned to the
> - * returnObject.
> - * @param timeBetweenEvictionRunsMillis
> - * the number of milliseconds to sleep between examining idle
> - * objects for eviction.
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread.
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction.
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, int, boolean, boolean, long, int, long, boolean)
> + * Obtain the configuration currently used by the factory allowing the
> + * current settings to be viewed and changed.
> + *
> + * @return The config object currently used by the factory
> */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, int maxIdle, boolean testOnBorrow,
> - boolean testOnReturn, long timeBetweenEvictionRunsMillis,
> - int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
> - boolean testWhileIdle) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - GenericObjectPool.DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
> - timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
> - minEvictableIdleTimeMillis, testWhileIdle,
> - GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
> + public GenericObjectPoolConfig<T> getConfig() {
> + return config;
> }
>
> - /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param maxIdle
> - * the maximum number of idle objects in my pool.
> - * @param minIdle
> - * the minimum number of idle objects in my pool.
> - * @param testOnBorrow
> - * whether to validate objects before they are returned by the
> - * borrowObject.
> - * @param testOnReturn
> - * whether to validate objects after they are returned to the
> - * returnObject.
> - * @param timeBetweenEvictionRunsMillis
> - * the number of milliseconds to sleep between examining idle
> - * objects for eviction.
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread.
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction.
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread.
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, int, int, boolean, boolean, long, int, long, boolean)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, int maxIdle, int minIdle, boolean testOnBorrow,
> - boolean testOnReturn, long timeBetweenEvictionRunsMillis,
> - int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
> - boolean testWhileIdle) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - minIdle, testOnBorrow, testOnReturn,
> - timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
> - minEvictableIdleTimeMillis, testWhileIdle,
> - GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
> - }
>
> /**
> - * Create a new GenericObjectPoolFactory.
> - *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param maxIdle
> - * the maximum number of idle objects in my pool.
> - * @param minIdle
> - * the minimum number of idle objects in my pool.
> - * @param testOnBorrow
> - * whether to validate objects before they are returned by the
> - * borrowObject.
> - * @param testOnReturn
> - * whether to validate objects after they are returned to the
> - * returnObject.
> - * @param timeBetweenEvictionRunsMillis
> - * the number of milliseconds to sleep between examining idle
> - * objects for eviction.
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread.
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction.
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread.
> - * @param softMinEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction with the extra
> - * condition that at least "minIdle" amount of object remain in
> - * the pool.
> - * @since Pool 1.3
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, int, int, boolean, boolean, long, int, long, boolean,
> - * long)
> + * Replace the configuration settings used by this factory.
> + *
> + * @param config The new settings which will be passed by value
> */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, int maxIdle, int minIdle, boolean testOnBorrow,
> - boolean testOnReturn, long timeBetweenEvictionRunsMillis,
> - int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
> - boolean testWhileIdle, long softMinEvictableIdleTimeMillis) {
> - this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
> - minIdle, testOnBorrow, testOnReturn,
> - timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
> - minEvictableIdleTimeMillis, testWhileIdle,
> - softMinEvictableIdleTimeMillis, GenericObjectPool.DEFAULT_LIFO);
> + public void setConfig(GenericObjectPoolConfig<T> config) {
> + this.config = config.clone();
> }
>
> +
> /**
> - * Create a new GenericObjectPoolFactory.
> + * Create a new GenericKeyedObjectPool with the currently configured
> + * properties.
> *
> - * @param factory
> - * the PoolableObjectFactory used by created pools.
> - * @param maxActive
> - * maximum number of objects that can be borrowed from created
> - * pools at one time.
> - * @param whenExhaustedAction
> - * the action to take when the pool is exhausted.
> - * @param maxWait
> - * the maximum amount of time to wait for an idle object when the
> - * pool is exhausted.
> - * @param maxIdle
> - * the maximum number of idle objects in my pool.
> - * @param minIdle
> - * the minimum number of idle objects in my pool.
> - * @param testOnBorrow
> - * whether to validate objects before they are returned by the
> - * borrowObject.
> - * @param testOnReturn
> - * whether to validate objects after they are returned to the
> - * returnObject.
> - * @param timeBetweenEvictionRunsMillis
> - * the number of milliseconds to sleep between examining idle
> - * objects for eviction.
> - * @param numTestsPerEvictionRun
> - * the number of idle objects to examine per run within the idle
> - * object eviction thread.
> - * @param minEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction.
> - * @param testWhileIdle
> - * whether or not to validate objects in the idle object eviction
> - * thread.
> - * @param softMinEvictableIdleTimeMillis
> - * the minimum number of milliseconds an object can sit idle in
> - * the pool before it is eligible for eviction with the extra
> - * condition that at least "minIdle" amount of object remain in
> - * the pool.
> - * @param lifo
> - * whether or not objects are returned in last-in-first-out order
> - * from the idle object pool.
> - * @since Pool 1.4
> - * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
> - * byte, long, int, int, boolean, boolean, long, int, long, boolean,
> - * long, boolean)
> - */
> - public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
> - int maxActive, WhenExhaustedAction whenExhaustedAction,
> - long maxWait, int maxIdle, int minIdle, boolean testOnBorrow,
> - boolean testOnReturn, long timeBetweenEvictionRunsMillis,
> - int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
> - boolean testWhileIdle, long softMinEvictableIdleTimeMillis,
> - boolean lifo) {
> - _maxIdle = maxIdle;
> - _minIdle = minIdle;
> - _maxActive = maxActive;
> - _maxWait = maxWait;
> - _whenExhaustedAction = whenExhaustedAction;
> - _testOnBorrow = testOnBorrow;
> - _testOnReturn = testOnReturn;
> - _testWhileIdle = testWhileIdle;
> - _timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
> - _numTestsPerEvictionRun = numTestsPerEvictionRun;
> - _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
> - _softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
> - _lifo = lifo;
> - _factory = factory;
> - }
> -
> - /**
> - * {@inheritDoc}
> + * @return A pool configured with the current property settings
> */
> public ObjectPool<T> createPool() {
> - return new GenericObjectPool<T>(_factory, _maxActive,
> - _whenExhaustedAction, _maxWait, _maxIdle, _minIdle,
> - _testOnBorrow, _testOnReturn, _timeBetweenEvictionRunsMillis,
> - _numTestsPerEvictionRun, _minEvictableIdleTimeMillis,
> - _testWhileIdle, _softMinEvictableIdleTimeMillis, _lifo);
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getMaxIdle() maxIdle} setting for
> - * pools created by this factory.
> - * @since 1.5.5
> - */
> - public int getMaxIdle() {
> - return _maxIdle;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getMinIdle() minIdle} setting for
> - * pools created by this factory.
> - * @since 1.5.5
> - */
> - public int getMinIdle() {
> - return _minIdle;
> + return new GenericObjectPool<T>(config);
> }
> -
> - /**
> - * @return the {@link GenericObjectPool#getMaxActive() maxActive} setting
> - * for pools created by this factory.
> - * @since 1.5.5
> - */
> - public int getMaxActive() {
> - return _maxActive;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getMaxWait() maxWait} setting for
> - * pools created by this factory.
> - * @since 1.5.5
> - */
> - public long getMaxWait() {
> - return _maxWait;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getWhenExhaustedAction()
> - * whenExhaustedAction} setting for pools created by this factory.
> - * @since 1.5.5
> - */
> - public WhenExhaustedAction getWhenExhaustedAction() {
> - return _whenExhaustedAction;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getTestOnBorrow() testOnBorrow}
> - * setting for pools created by this factory.
> - * @since 1.5.5
> - */
> - public boolean getTestOnBorrow() {
> - return _testOnBorrow;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getTestOnReturn() testOnReturn}
> - * setting for pools created by this factory.
> - * @since 1.5.5
> - */
> - public boolean getTestOnReturn() {
> - return _testOnReturn;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getTestWhileIdle() testWhileIdle}
> - * setting for pools created by this factory.
> - * @since 1.5.5
> - */
> - public boolean getTestWhileIdle() {
> - return _testWhileIdle;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis()
> - * timeBetweenEvictionRunsMillis} setting for pools created by this
> - * factory.
> - * @since 1.5.5
> - */
> - public long getTimeBetweenEvictionRunsMillis() {
> - return _timeBetweenEvictionRunsMillis;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getNumTestsPerEvictionRun()
> - * numTestsPerEvictionRun} setting for pools created by this
> - * factory.
> - * @since 1.5.5
> - */
> - public int getNumTestsPerEvictionRun() {
> - return _numTestsPerEvictionRun;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getMinEvictableIdleTimeMillis()
> - * minEvictableIdleTimeMillis} setting for pools created by this
> - * factory.
> - * @since 1.5.5
> - */
> - public long getMinEvictableIdleTimeMillis() {
> - return _minEvictableIdleTimeMillis;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()
> - * softMinEvicatableIdleTimeMillis} setting for pools created by
> - * this factory.
> - * @since 1.5.5
> - */
> - public long getSoftMinEvictableIdleTimeMillis() {
> - return _softMinEvictableIdleTimeMillis;
> - }
> -
> - /**
> - * @return the {@link GenericObjectPool#getLifo() lifo} setting for pools
> - * created by this factory.
> - * @since 1.5.5
> - */
> - public boolean getLifo() {
> - return _lifo;
> - }
> -
> - /**
> - * @return the {@link PoolableObjectFactory} used by pools created by this
> - * factory
> - */
> - public PoolableObjectFactory<T> getFactory() {
> - return _factory;
> - }
> -
> - /**
> - * The {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools
> - * created by this factory.
> - */
> - private int _maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;
> -
> - /**
> - * The {@link GenericObjectPool#getMinIdle() minIdle} setting for pools
> - * created by this factory.
> - */
> - private int _minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;
> -
> - /**
> - * The {@link GenericObjectPool#getMaxActive() maxActive} setting for pools
> - * created by this factory.
> - */
> - private int _maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
> -
> - /**
> - * The {@link GenericObjectPool#getMaxWait() maxWait} setting for pools
> - * created by this factory.
> - */
> - private long _maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;
> -
> - /**
> - * The {@link GenericObjectPool#getWhenExhaustedAction()
> - * whenExhaustedAction} setting for pools created by this factory.
> - */
> - private WhenExhaustedAction _whenExhaustedAction =
> - GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
> -
> - /**
> - * The {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for
> - * pools created by this factory.
> - */
> - private boolean _testOnBorrow = GenericObjectPool.DEFAULT_TEST_ON_BORROW;
> -
> - /**
> - * The {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for
> - * pools created by this factory.
> - */
> - private boolean _testOnReturn = GenericObjectPool.DEFAULT_TEST_ON_RETURN;
> -
> - /**
> - * The {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting
> - * for pools created by this factory.
> - */
> - private boolean _testWhileIdle = GenericObjectPool.DEFAULT_TEST_WHILE_IDLE;
> -
> - /**
> - * The {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis()
> - * timeBetweenEvictionRunsMillis} setting for pools created by this factory.
> - */
> - private long _timeBetweenEvictionRunsMillis =
> - GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
> -
> - /**
> - * The {@link GenericObjectPool#getNumTestsPerEvictionRun()
> - * numTestsPerEvictionRun} setting for pools created by this factory.
> - */
> - private int _numTestsPerEvictionRun =
> - GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
> -
> - /**
> - * The {@link GenericObjectPool#getMinEvictableIdleTimeMillis()
> - * minEvictableIdleTimeMillis} setting for pools created by this factory.
> - */
> - private long _minEvictableIdleTimeMillis =
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
> -
> - /**
> - * The {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()
> - * softMinEvictableIdleTimeMillis} setting for pools created by this
> - * factory.
> - */
> - private long _softMinEvictableIdleTimeMillis =
> - GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
> -
> - /**
> - * The {@link GenericObjectPool#getLifo() lifo} setting for pools created by
> - * this factory.
> - */
> - private boolean _lifo = GenericObjectPool.DEFAULT_LIFO;
> -
> - /**
> - * The {@link PoolableObjectFactory} used by pools created by this factory.
> - */
> - private PoolableObjectFactory<T> _factory = null;
> -
> }
>
> Modified: commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java (original)
> +++ commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java Mon Jun 13 17:37:02 2011
> @@ -80,7 +80,8 @@ public class TestPoolUtils {
>
> // Test that the minIdle check doesn't add too many idle objects
> final PoolableObjectFactory<Object> pof = createProxy(PoolableObjectFactory.class, calledMethods);
> - final ObjectPool<Object> op = new GenericObjectPool(pof);
> + final ObjectPool<Object> op = new GenericObjectPool();
> + op.setFactory(pof);
> PoolUtils.checkMinIdle(op, 2, 100);
> Thread.sleep(400);
> assertEquals(2, op.getNumIdle());
>
> Modified: commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPool.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPool.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPool.java (original)
> +++ commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPool.java Mon Jun 13 17:37:02 2011
> @@ -47,7 +47,8 @@ public class TestGenericObjectPool exten
>
> @Override
> protected ObjectPool<Object> makeEmptyPool(int mincap) {
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(new SimpleFactory());
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(new SimpleFactory());
> pool.setMaxActive(mincap);
> pool.setMaxIdle(mincap);
> return pool;
> @@ -55,7 +56,9 @@ public class TestGenericObjectPool exten
>
> @Override
> protected ObjectPool<Object> makeEmptyPool(final PoolableObjectFactory<Object> factory) {
> - return new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> + return pool;
> }
>
> @Override
> @@ -65,7 +68,8 @@ public class TestGenericObjectPool exten
>
> @Before
> public void setUp() throws Exception {
> - pool = new GenericObjectPool<Object>(new SimpleFactory());
> + pool = new GenericObjectPool<Object>();
> + pool.setFactory(new SimpleFactory());
> }
>
> @After
> @@ -166,7 +170,8 @@ public class TestGenericObjectPool exten
> SimpleFactory factory = new SimpleFactory();
> factory.setMakeLatency(300);
> factory.setMaxActive(2);
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setMaxActive(2);
> pool.setMinIdle(1);
> pool.borrowObject(); // numActive = 1, numIdle = 0
> @@ -195,7 +200,8 @@ public class TestGenericObjectPool exten
> public void checkEvict(boolean lifo) throws Exception {
> // yea this is hairy but it tests all the code paths in GOP.evict()
> final SimpleFactory factory = new SimpleFactory();
> - final GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + final GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setSoftMinEvictableIdleTimeMillis(10);
> pool.setMinIdle(2);
> pool.setTestWhileIdle(true);
> @@ -232,7 +238,8 @@ public class TestGenericObjectPool exten
>
> private void checkEvictionOrder(boolean lifo) throws Exception {
> SimpleFactory factory = new SimpleFactory();
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setNumTestsPerEvictionRun(2);
> pool.setMinEvictableIdleTimeMillis(100);
> pool.setLifo(lifo);
> @@ -250,7 +257,8 @@ public class TestGenericObjectPool exten
>
> // Two eviction runs in sequence
> factory = new SimpleFactory();
> - pool = new GenericObjectPool<Object>(factory);
> + pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setNumTestsPerEvictionRun(2);
> pool.setMinEvictableIdleTimeMillis(100);
> pool.setLifo(lifo);
> @@ -275,7 +283,8 @@ public class TestGenericObjectPool exten
>
> private void checkEvictorVisiting(boolean lifo) throws Exception {
> VisitTrackerFactory<Object> factory = new VisitTrackerFactory<Object>();
> - GenericObjectPool<VisitTracker<Object>> pool = new GenericObjectPool<VisitTracker<Object>>(factory);
> + GenericObjectPool<VisitTracker<Object>> pool = new GenericObjectPool<VisitTracker<Object>>();
> + pool.setFactory(factory);
> pool.setNumTestsPerEvictionRun(2);
> pool.setMinEvictableIdleTimeMillis(-1);
> pool.setTestWhileIdle(true);
> @@ -307,7 +316,8 @@ public class TestGenericObjectPool exten
> }
>
> factory = new VisitTrackerFactory<Object>();
> - pool = new GenericObjectPool<VisitTracker<Object>>(factory);
> + pool = new GenericObjectPool<VisitTracker<Object>>();
> + pool.setFactory(factory);
> pool.setNumTestsPerEvictionRun(3);
> pool.setMinEvictableIdleTimeMillis(-1);
> pool.setTestWhileIdle(true);
> @@ -351,7 +361,8 @@ public class TestGenericObjectPool exten
> for (int i = 0; i < 4; i++) {
> pool.setNumTestsPerEvictionRun(smallPrimes[i]);
> for (int j = 0; j < 5; j++) {
> - pool = new GenericObjectPool<VisitTracker<Object>>(factory);
> + pool = new GenericObjectPool<VisitTracker<Object>>();
> + pool.setFactory(factory);
> pool.setNumTestsPerEvictionRun(3);
> pool.setMinEvictableIdleTimeMillis(-1);
> pool.setTestWhileIdle(true);
> @@ -393,7 +404,8 @@ public class TestGenericObjectPool exten
> @Test
> public void testExceptionOnPassivateDuringReturn() throws Exception {
> SimpleFactory factory = new SimpleFactory();
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> Object obj = pool.borrowObject();
> factory.setThrowExceptionOnPassivate(true);
> pool.returnObject(obj);
> @@ -405,7 +417,8 @@ public class TestGenericObjectPool exten
> public void testExceptionOnDestroyDuringBorrow() throws Exception {
> SimpleFactory factory = new SimpleFactory();
> factory.setThrowExceptionOnDestroy(true);
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setTestOnBorrow(true);
> pool.borrowObject();
> factory.setValid(false); // Make validation fail on next borrow attempt
> @@ -423,7 +436,8 @@ public class TestGenericObjectPool exten
> public void testExceptionOnDestroyDuringReturn() throws Exception {
> SimpleFactory factory = new SimpleFactory();
> factory.setThrowExceptionOnDestroy(true);
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setTestOnReturn(true);
> Object obj1 = pool.borrowObject();
> pool.borrowObject();
> @@ -436,7 +450,8 @@ public class TestGenericObjectPool exten
> @Test
> public void testExceptionOnActivateDuringBorrow() throws Exception {
> SimpleFactory factory = new SimpleFactory();
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> Object obj1 = pool.borrowObject();
> Object obj2 = pool.borrowObject();
> pool.returnObject(obj1);
> @@ -740,99 +755,10 @@ public class TestGenericObjectPool exten
> assertConfiguration(new GenericObjectPool.Config(),pool);
> }
> {
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(new SimpleFactory());
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(new SimpleFactory());
> assertConfiguration(new GenericObjectPool.Config(),pool);
> }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxIdle = 3;
> - expected.maxWait = 5L;
> - expected.minEvictableIdleTimeMillis = 7L;
> - expected.numTestsPerEvictionRun = 9;
> - expected.testOnBorrow = true;
> - expected.testOnReturn = true;
> - expected.testWhileIdle = true;
> - expected.timeBetweenEvictionRunsMillis = 11L;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxWait = 5L;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive,expected.whenExhaustedAction,expected.maxWait);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxWait = 5L;
> - expected.testOnBorrow = true;
> - expected.testOnReturn = true;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive,expected.whenExhaustedAction,expected.maxWait,expected.testOnBorrow,expected.testOnReturn);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxIdle = 3;
> - expected.maxWait = 5L;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive,expected.whenExhaustedAction,expected.maxWait,expected.maxIdle);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxIdle = 3;
> - expected.maxWait = 5L;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - expected.testOnBorrow = true;
> - expected.testOnReturn = true;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive,expected.whenExhaustedAction,expected.maxWait,expected.maxIdle,expected.testOnBorrow,expected.testOnReturn);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxIdle = 3;
> - expected.maxWait = 5L;
> - expected.minEvictableIdleTimeMillis = 7L;
> - expected.numTestsPerEvictionRun = 9;
> - expected.testOnBorrow = true;
> - expected.testOnReturn = true;
> - expected.testWhileIdle = true;
> - expected.timeBetweenEvictionRunsMillis = 11L;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive, expected.whenExhaustedAction, expected.maxWait, expected.maxIdle, expected.testOnBorrow, expected.testOnReturn, expected.timeBetweenEvictionRunsMillis, expected.numTestsPerEvictionRun, expected.minEvictableIdleTimeMillis, expected.testWhileIdle);
> - assertConfiguration(expected,pool);
> - }
> - {
> - GenericObjectPool.Config expected = new GenericObjectPool.Config();
> - expected.maxActive = 2;
> - expected.maxIdle = 3;
> - expected.minIdle = 1;
> - expected.maxWait = 5L;
> - expected.minEvictableIdleTimeMillis = 7L;
> - expected.numTestsPerEvictionRun = 9;
> - expected.testOnBorrow = true;
> - expected.testOnReturn = true;
> - expected.testWhileIdle = true;
> - expected.timeBetweenEvictionRunsMillis = 11L;
> - expected.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(null,expected.maxActive, expected.whenExhaustedAction, expected.maxWait, expected.maxIdle, expected.minIdle, expected.testOnBorrow, expected.testOnReturn, expected.timeBetweenEvictionRunsMillis, expected.numTestsPerEvictionRun, expected.minEvictableIdleTimeMillis, expected.testWhileIdle);
> - assertConfiguration(expected,pool);
> - }
> }
>
> @Test
> @@ -856,7 +782,8 @@ public class TestGenericObjectPool exten
>
> @Test
> public void testDebugInfo() throws Exception {
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(new SimpleFactory());
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(new SimpleFactory());
> pool.setMaxIdle(3);
> assertNotNull(pool.debugInfo());
> Object obj = pool.borrowObject();
> @@ -996,7 +923,8 @@ public class TestGenericObjectPool exten
> }
> }
>
> - GenericObjectPool<TimeTest> pool = new GenericObjectPool<TimeTest>(new TimeTest());
> + GenericObjectPool<TimeTest> pool = new GenericObjectPool<TimeTest>();
> + pool.setFactory(new TimeTest());
>
> pool.setMaxIdle(5);
> pool.setMaxActive(5);
> @@ -1155,7 +1083,8 @@ public class TestGenericObjectPool exten
> factory.setDestroyLatency(100); // Destroy takes 100 ms
> factory.setMaxActive(maxActive); // (makes - destroys) bound
> factory.setValidationEnabled(true);
> - pool = new GenericObjectPool(factory);
> + pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setMaxActive(maxActive);
> pool.setMaxIdle(-1);
> pool.setTestOnReturn(true);
> @@ -1710,7 +1639,8 @@ public class TestGenericObjectPool exten
> final long holdTime = 2 * maxWait; // how long to hold connection
> final int threads = 10; // number of threads to grab the object initially
> SimpleFactory factory = new SimpleFactory();
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setWhenExhaustedAction(WhenExhaustedAction.BLOCK);
> pool.setMaxWait(maxWait);
> pool.setMaxActive(threads);
> @@ -1763,7 +1693,8 @@ public class TestGenericObjectPool exten
> @Test
> public void testMakeConcurrentWithReturn() throws Exception {
> SimpleFactory factory = new SimpleFactory();
> - GenericObjectPool<Object> pool = new GenericObjectPool<Object>(factory);
> + GenericObjectPool<Object> pool = new GenericObjectPool<Object>();
> + pool.setFactory(factory);
> pool.setTestOnBorrow(true);
> factory.setValid(true);
> // Borrow and return an instance, with a short wait
>
> Modified: commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPoolFactory.java
> URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPoolFactory.java?rev=1135192&r1=1135191&r2=1135192&view=diff
> ==============================================================================
> --- commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPoolFactory.java (original)
> +++ commons/proper/pool/trunk/src/test/org/apache/commons/pool2/impl/TestGenericObjectPoolFactory.java Mon Jun 13 17:37:02 2011
> @@ -19,8 +19,6 @@ package org.apache.commons.pool2.impl;
>
> import static junit.framework.Assert.*;
>
> -import java.util.NoSuchElementException;
> -
> import org.apache.commons.pool2.MethodCallPoolableObjectFactory;
> import org.apache.commons.pool2.ObjectPoolFactory;
> import org.apache.commons.pool2.PoolableObjectFactory;
> @@ -38,32 +36,40 @@ import org.junit.Test;
> public class TestGenericObjectPoolFactory extends TestObjectPoolFactory {
>
> @Override
> - protected ObjectPoolFactory<Object> makeFactory(final PoolableObjectFactory<Object> objectFactory) throws UnsupportedOperationException {
> - return new GenericObjectPoolFactory<Object>(objectFactory);
> + protected ObjectPoolFactory<Object> makeFactory(
> + final PoolableObjectFactory<Object> objectFactory)
> + throws UnsupportedOperationException {
> +
> + GenericObjectPoolConfig<Object> config =
> + new GenericObjectPoolConfig<Object>();
> + config.setFactory(objectFactory);
> + return new GenericObjectPoolFactory<Object>(config);
> }
>
> @Test
> public void testConstructors() throws Exception {
> - GenericObjectPoolFactory<Object> factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory());
> - GenericObjectPool<Object> pool;
> - factory.createPool().close();
> -
> - final GenericObjectPool.Config config = new GenericObjectPool.Config();
> - config.maxActive = 1;
> - config.maxIdle = 2;
> - config.maxWait = 3;
> - config.minIdle = 4;
> - config.minEvictableIdleTimeMillis = 5;
> - config.numTestsPerEvictionRun = 6;
> - config.softMinEvictableIdleTimeMillis = 7;
> - config.testOnBorrow = true;
> - config.testOnReturn = false;
> - config.testWhileIdle = true;
> - config.lifo = false;
> - config.timeBetweenEvictionRunsMillis = 8;
> - config.whenExhaustedAction = WhenExhaustedAction.FAIL;
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), config);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> + final GenericObjectPoolConfig<Object> config =
> + new GenericObjectPoolConfig<Object>();
> + config.setMaxTotal(1);
> + config.setMaxIdle(2);
> + config.setMaxWait(3);
> + config.setMinIdle(4);
> + config.setMinEvictableIdleTimeMillis(5);
> + config.setNumTestsPerEvictionRun(6);
> + config.setSoftMinEvictableIdleTimeMillis(7);
> + config.setTestOnBorrow(true);
> + config.setTestOnReturn(false);
> + config.setTestWhileIdle(true);
> + config.setLifo(false);
> + config.setTimeBetweenEvictionRunsMillis(8);
> + config.setWhenExhaustedAction(WhenExhaustedAction.FAIL);
> + config.setFactory(new MethodCallPoolableObjectFactory());
> +
> + GenericObjectPoolFactory<Object> factory =
> + new GenericObjectPoolFactory<Object>(config);
> + GenericObjectPool<Object> pool =
> + (GenericObjectPool<Object>) factory.createPool();
> +
> assertEquals(1, pool.getMaxActive());
> assertEquals(2, pool.getMaxIdle());
> assertEquals(3, pool.getMaxWait());
> @@ -79,115 +85,5 @@ public class TestGenericObjectPoolFactor
> assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> pool.borrowObject();
> pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - pool.borrowObject();
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.BLOCK, 125);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(WhenExhaustedAction.BLOCK, pool.getWhenExhaustedAction());
> - assertEquals(125, pool.getMaxWait());
> - pool.borrowObject();
> - long startTime = System.currentTimeMillis();
> - try {
> - pool.borrowObject();
> - fail();
> - } catch (NoSuchElementException nsee) {
> - // expected
> - }
> - long delay = System.currentTimeMillis() - startTime;
> - assertTrue("delay: " + delay, delay > 100);
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.FAIL, 2, true, false);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(2, pool.getMaxWait());
> - assertEquals(true, pool.getTestOnBorrow());
> - assertEquals(false, pool.getTestOnReturn());
> - assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> - pool.borrowObject();
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.FAIL, 2, 3);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(2, pool.getMaxWait());
> - assertEquals(3, pool.getMaxIdle());
> - assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> - pool.borrowObject();
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.FAIL, 2, 3, true, false);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(2, pool.getMaxWait());
> - assertEquals(3, pool.getMaxIdle());
> - assertEquals(true, pool.getTestOnBorrow());
> - assertEquals(false, pool.getTestOnReturn());
> - assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> - pool.borrowObject();
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.FAIL, 2, 3, true, false, 4, 5, 6, false);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(2, pool.getMaxWait());
> - assertEquals(3, pool.getMaxIdle());
> - assertEquals(4, pool.getTimeBetweenEvictionRunsMillis());
> - assertEquals(5, pool.getNumTestsPerEvictionRun());
> - assertEquals(6, pool.getMinEvictableIdleTimeMillis());
> - assertEquals(true, pool.getTestOnBorrow());
> - assertEquals(false, pool.getTestOnReturn());
> - assertEquals(false, pool.getTestWhileIdle());
> - assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> - pool.borrowObject();
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.FAIL, 2, 3, 4, true, false, 5, 6, 7, true);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(2, pool.getMaxWait());
> - assertEquals(3, pool.getMaxIdle());
> - assertEquals(4, pool.getMinIdle());
> - assertEquals(5, pool.getTimeBetweenEvictionRunsMillis());
> - assertEquals(6, pool.getNumTestsPerEvictionRun());
> - assertEquals(7, pool.getMinEvictableIdleTimeMillis());
> - assertEquals(true, pool.getTestOnBorrow());
> - assertEquals(false, pool.getTestOnReturn());
> - assertEquals(true, pool.getTestWhileIdle());
> - assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> - pool.borrowObject();
> - pool.close();
> -
> -
> - factory = new GenericObjectPoolFactory<Object>(new MethodCallPoolableObjectFactory(), 1, WhenExhaustedAction.FAIL, 2, 3, 4, true, false, 5, 6, 7, true, 8, false);
> - pool = (GenericObjectPool<Object>)factory.createPool();
> - assertEquals(1, pool.getMaxActive());
> - assertEquals(2, pool.getMaxWait());
> - assertEquals(3, pool.getMaxIdle());
> - assertEquals(4, pool.getMinIdle());
> - assertEquals(5, pool.getTimeBetweenEvictionRunsMillis());
> - assertEquals(6, pool.getNumTestsPerEvictionRun());
> - assertEquals(7, pool.getMinEvictableIdleTimeMillis());
> - assertEquals(8, pool.getSoftMinEvictableIdleTimeMillis());
> - assertEquals(true, pool.getTestOnBorrow());
> - assertEquals(false, pool.getTestOnReturn());
> - assertEquals(true, pool.getTestWhileIdle());
> - assertEquals(false, pool.getLifo());
> - assertEquals(WhenExhaustedAction.FAIL, pool.getWhenExhaustedAction());
> - pool.borrowObject();
> - pool.close();
> }
> }
>
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org