Field Detail

• MSG_NULL_KEY

  public static final String MSG_NULL_KEY

  See Also:

  Constant Field Values

• MSG_NULL_KEYS

  public static final String MSG_NULL_KEYS

  See Also:

  Constant Field Values

Constructor Detail

• PoolUtils

  public PoolUtils()

  PoolUtils instances should NOT be constructed in standard programming. Instead, the class should be used procedurally: PoolUtils.adapt(aPool);. This constructor is public to permit tools that require a JavaBean instance to operate.

Method Detail

• checkRethrow

  public static void checkRethrow(Throwable t)

  Should the supplied Throwable be re-thrown (eg if it is an instance of one of the Throwables that should never be swallowed). Used by the pool error handling for operations that throw exceptions that normally need to be ignored.

  Parameters:

  t - The Throwable to check

  Throws:

  ThreadDeath - if that is passed in

  VirtualMachineError - if that is passed in

• checkMinIdle

  public static <T> TimerTask checkMinIdle(ObjectPool<T> pool,
                           int minIdle,
                           long period)
                                throws IllegalArgumentException

  Periodically check the idle object count for the pool. At most one idle object will be added per period. If there is an exception when calling ObjectPool.addObject() then no more checks will be performed.

  Type Parameters:

  T - the type of objects in the pool

  Parameters:

  pool - the pool to check periodically.

  minIdle - if the ObjectPool.getNumIdle() is less than this then add an idle object.

  period - the frequency to check the number of idle objects in a pool, see Timer.schedule(TimerTask, long, long).

  Returns:

  the TimerTask that will periodically check the pools idle object count.

  Throws:

  IllegalArgumentException - when pool is null or when minIdle is negative or when period isn't valid for Timer.schedule(TimerTask, long, long)

• checkMinIdle

  public static <K,V> TimerTask checkMinIdle(KeyedObjectPool<K,V> keyedPool,
                             K key,
                             int minIdle,
                             long period)
                                throws IllegalArgumentException

  Periodically check the idle object count for the key in the keyedPool. At most one idle object will be added per period. If there is an exception when calling KeyedObjectPool.addObject(Object) then no more checks for that key will be performed.

  Type Parameters:

  K - the type of the pool key

  V - the type of pool entries

  Parameters:

  keyedPool - the keyedPool to check periodically.

  key - the key to check the idle count of.

  minIdle - if the KeyedObjectPool.getNumIdle(Object) is less than this then add an idle object.

  period - the frequency to check the number of idle objects in a keyedPool, see Timer.schedule(TimerTask, long, long).

  Returns:

  the TimerTask that will periodically check the pools idle object count.

  Throws:

  IllegalArgumentException - when keyedPool, key is null or when minIdle is negative or when period isn't valid for Timer.schedule(TimerTask, long, long).

• checkMinIdle

  public static <K,V> Map<K,TimerTask> checkMinIdle(KeyedObjectPool<K,V> keyedPool,
                                    Collection<K> keys,
                                    int minIdle,
                                    long period)
                                       throws IllegalArgumentException

  Periodically check the idle object count for each key in the Collection keys in the keyedPool. At most one idle object will be added per period.

  Type Parameters:

  K - the type of the pool key

  V - the type of pool entries

  Parameters:

  keyedPool - the keyedPool to check periodically.

  keys - a collection of keys to check the idle object count.

  minIdle - if the KeyedObjectPool.getNumIdle(Object) is less than this then add an idle object.

  period - the frequency to check the number of idle objects in a keyedPool, see Timer.schedule(TimerTask, long, long).

  Returns:

  a Map of key and TimerTask pairs that will periodically check the pools idle object count.

  Throws:

  IllegalArgumentException - when keyedPool, keys, or any of the values in the collection is null or when minIdle is negative or when period isn't valid for Timer.schedule(TimerTask, long, long).

  See Also:

  checkMinIdle(KeyedObjectPool, Object, int, long)

• prefill

  @Deprecated
  public static <T> void prefill(ObjectPool<T> pool,
                            int count)
                      throws Exception,
                             IllegalArgumentException

  Deprecated. Use ObjectPool.addObjects(int).
  Calls ObjectPool.addObject() on pool count number of times.

  Type Parameters:

  T - the type of objects in the pool

  Parameters:

  pool - the pool to prefill.

  count - the number of idle objects to add.

  Throws:

  Exception - when ObjectPool.addObject() fails.

  IllegalArgumentException - when pool is null.

• prefill

  @Deprecated
  public static <K,V> void prefill(KeyedObjectPool<K,V> keyedPool,
                              K key,
                              int count)
                      throws Exception,
                             IllegalArgumentException

  Deprecated. Use KeyedObjectPool.addObjects(Object, int).
  Calls KeyedObjectPool.addObject(Object) on keyedPool with key count number of times.

  Type Parameters:

  K - the type of the pool key

  V - the type of pool entries

  Parameters:

  keyedPool - the keyedPool to prefill.

  key - the key to add objects for.

  count - the number of idle objects to add for key.

  Throws:

  Exception - when KeyedObjectPool.addObject(Object) fails.

  IllegalArgumentException - when keyedPool or key is null.

• prefill

  @Deprecated
  public static <K,V> void prefill(KeyedObjectPool<K,V> keyedPool,
                              Collection<K> keys,
                              int count)
                      throws Exception,
                             IllegalArgumentException

  Deprecated. Use KeyedObjectPool.addObjects(Collection, int).
  Calls KeyedObjectPool.addObject(Object) on keyedPool with each key in keys for count number of times. This has the same effect as calling prefill(KeyedObjectPool, Object, int) for each key in the keys collection.

  Type Parameters:

  K - the type of the pool key

  V - the type of pool entries

  Parameters:

  keyedPool - the keyedPool to prefill.

  keys - Collection of keys to add objects for.

  count - the number of idle objects to add for each key.

  Throws:

  Exception - when KeyedObjectPool.addObject(Object) fails.

  IllegalArgumentException - when keyedPool, keys, or any value in keys is null.

  See Also:

  prefill(KeyedObjectPool, Object, int)

• synchronizedPooledFactory

  public static <T> PooledObjectFactory<T> synchronizedPooledFactory(PooledObjectFactory<T> factory)

  Returns a synchronized (thread-safe) PooledObjectFactory backed by the specified PooledObjectFactory.

  Type Parameters:

  T - the type of objects in the pool

  Parameters:

  factory - the PooledObjectFactory to be "wrapped" in a synchronized PooledObjectFactory.

  Returns:

  a synchronized view of the specified PooledObjectFactory.

• synchronizedKeyedPooledFactory

  public static <K,V> KeyedPooledObjectFactory<K,V> synchronizedKeyedPooledFactory(KeyedPooledObjectFactory<K,V> keyedFactory)

  Returns a synchronized (thread-safe) KeyedPooledObjectFactory backed by the specified KeyedPoolableObjectFactory.

  Type Parameters:

  K - the type of the pool key

  V - the type of pool entries

  Parameters:

  keyedFactory - the KeyedPooledObjectFactory to be "wrapped" in a synchronized KeyedPooledObjectFactory.

  Returns:

  a synchronized view of the specified KeyedPooledObjectFactory.