org.springframework.aop.target

## Class AbstractPoolingTargetSource

- java.lang.Object
- - org.springframework.aop.target.AbstractBeanFactoryBasedTargetSource
  - - org.springframework.aop.target.AbstractPrototypeBasedTargetSource
    - - org.springframework.aop.target.AbstractPoolingTargetSource

All Implemented Interfaces:
  Serializable, PoolingConfig, TargetClassAware, TargetSource, Aware, BeanFactoryAware, DisposableBean

Direct Known Subclasses:
  CommonsPoolTargetSource

    public abstract class AbstractPoolingTargetSource
    extends AbstractPrototypeBasedTargetSource
    implements PoolingConfig, DisposableBean

Abstract base class for pooling `TargetSource` implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation. This abstract base class is independent of concrete pooling technology; see the subclass `CommonsPoolTargetSource` for a concrete example.

Subclasses must implement the `getTarget()` and `releaseTarget(java.lang.Object)` methods based on their chosen object pool. The `AbstractPrototypeBasedTargetSource.newPrototypeInstance()` method inherited from `AbstractPrototypeBasedTargetSource` can be used to create objects in order to put them into the pool.

Subclasses must also implement some of the monitoring methods from the `PoolingConfig` interface. The `getPoolingConfigMixin()` method makes these stats available on proxied objects through an IntroductionAdvisor.

This class implements the `DisposableBean` interface in order to force subclasses to implement a `DisposableBean.destroy()` method, closing down their object pool.

Author:
  Rod Johnson, Juergen Hoeller
See Also:
  `getTarget()`, `releaseTarget(java.lang.Object)`, `DisposableBean.destroy()`, Serialized Form

### Field Summary

### Fields inherited from class org.springframework.aop.target.AbstractBeanFactoryBasedTargetSource

`logger`

### Constructor Summary

Constructors
Constructor and Description
`AbstractPoolingTargetSource()`

### Method Summary

Methods
`protected abstract void` `createPool()` Create the pool.
`int` `getMaxSize()` Return the maximum size of the pool.
`DefaultIntroductionAdvisor` `getPoolingConfigMixin()` Return an IntroductionAdvisor that providing a mixin exposing statistics about the pool maintained by this object.
`abstract Object` `getTarget()` Acquire an object from the pool.
`abstract void` `releaseTarget(Object target)` Return the given object to the pool.
`void` `setBeanFactory(BeanFactory beanFactory)` Set the owning BeanFactory.
`void` `setMaxSize(int maxSize)` Set the maximum size of the pool.

### Methods inherited from class org.springframework.aop.target.AbstractPrototypeBasedTargetSource

`destroyPrototypeInstance, newPrototypeInstance, writeReplace`

### Methods inherited from class org.springframework.aop.target.AbstractBeanFactoryBasedTargetSource

`copyFrom, equals, getBeanFactory, getTargetBeanName, getTargetClass, hashCode, isStatic, setTargetBeanName, setTargetClass, toString`

### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface org.springframework.aop.target.PoolingConfig

`getActiveCount, getIdleCount`

### Methods inherited from interface org.springframework.beans.factory.DisposableBean

`destroy`

### Constructor Detail

#### AbstractPoolingTargetSource

    public AbstractPoolingTargetSource()

### Method Detail

#### setMaxSize

    public void setMaxSize(int maxSize)

Set the maximum size of the pool. Default is -1, indicating no size limit.

#### getMaxSize

    public int getMaxSize()

Return the maximum size of the pool.

Specified by:
  `getMaxSize` in interface `PoolingConfig`

#### setBeanFactory

    public final void setBeanFactory(BeanFactory beanFactory)
                              throws BeansException

Description copied from class: `AbstractBeanFactoryBasedTargetSource`
Set the owning BeanFactory. We need to save a reference so that we can use the `getBean` method on every invocation.

Specified by:
  `setBeanFactory` in interface `BeanFactoryAware`
Overrides:
  `setBeanFactory` in class `AbstractPrototypeBasedTargetSource`
Parameters:
  `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
Throws:
  `BeansException` - in case of initialization errors
See Also:
  `BeanInitializationException`

#### createPool

    protected abstract void createPool()
                                throws Exception

Create the pool.

Throws:
  `Exception` - to avoid placing constraints on pooling APIs

#### getTarget

    public abstract Object getTarget()
                              throws Exception

Acquire an object from the pool.

Specified by:
  `getTarget` in interface `TargetSource`
Returns:
  an object from the pool
Throws:
  `Exception` - we may need to deal with checked exceptions from pool APIs, so we're forgiving with our exception signature

#### releaseTarget

    public abstract void releaseTarget(Object target)
                                throws Exception

Return the given object to the pool.

Specified by:
  `releaseTarget` in interface `TargetSource`
Overrides:
  `releaseTarget` in class `AbstractBeanFactoryBasedTargetSource`
Parameters:
  `target` - object that must have been acquired from the pool via a call to `getTarget()`
Throws:
  `Exception` - to allow pooling APIs to throw exception
See Also:
  `getTarget()`

#### getPoolingConfigMixin

    public DefaultIntroductionAdvisor getPoolingConfigMixin()

Return an IntroductionAdvisor that providing a mixin exposing statistics about the pool maintained by this object.