Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.picocontainer.gems.behaviors
Class Pooled<T>

    java.lang.Object
      org.picocontainer.behaviors.AbstractBehavior<T>
          org.picocontainer.gems.behaviors.Pooled<T>

All Implemented Interfaces:
  Serializable, org.picocontainer.Behavior<T>, org.picocontainer.ComponentAdapter<T>, org.picocontainer.ComponentLifecycle<T>, org.picocontainer.ComponentMonitorStrategy, org.picocontainer.LifecycleStrategy

    public final class Pooled<T>

extends org.picocontainer.behaviors.AbstractBehavior<T>

`ComponentAdapter` implementation that pools components.

The implementation utilizes a delegated ComponentAdapter to create the instances of the pool. The pool can be configured to grow unlimited or to a maximum size. If a component is requested from this adapter, the implementation returns an available instance from the pool or will create a new one, if the maximum pool size is not reached yet. If none is available, the implementation can wait a defined time for a returned object before it throws a `Pooled.PoolException`.

This implementation uses the `Pool` toy from the ProxyToys project. This ensures, that any component, that is out of scope will be automatically returned to the pool by the garbage collector. Additionally will every component instance also implement `Poolable`, that can be used to return the instance manually. After returning an instance it should not be used in client code anymore.

Before a returning object is added to the available instances of the pool again, it should be reinitialized to a normalized state. By providing a proper Resetter implementation this can be done automatically. If the object cannot be reused anymore it can also be dropped and the pool may request a new instance.

The pool supports components with a lifecycle. If the delegated `ComponentAdapter` implements a `LifecycleStrategy`, any component retrieved form the pool will be started before and stopped again, when it returns back into the pool. Also if a component cannot be resetted it will automatically be disposed. If the container of the pool is disposed, that any returning object is also disposed and will not return to the pool anymore. Note, that current implementation cannot dispose pooled objects.

Author:
  Jörg Schaible, Aslak Hellesøy
See Also:
  Serialized Form

Nested Class Summary
`static interface` | `Pooled.Context` Context of the Pooled used to initialize it.
`static class` | `Pooled.DefaultContext` The default context for a Pooled.
`static class` | `Pooled.PoolException` Exception thrown from the Pooled.

Nested classes/interfaces inherited from interface org.picocontainer.ComponentAdapter
`org.picocontainer.ComponentAdapter.NOTHING`

Field Summary
`static int` | `BLOCK_ON_WAIT` `BLOCK_ON_WAIT` forces the pool to wait until an object of the pool is returning in case none is immediately available.
`static int` | `DEFAULT_MAX_SIZE` `DEFAULT_MAX_SIZE` is the default size of the pool.
`static Resetter` | `DEFAULT_RESETTER` `DEFAULT_RESETTER` is a `NoOperationResetter` that is used by default.
`static int` | `FAIL_ON_WAIT` `FAIL_ON_WAIT` forces the pool to fail none is immediately available.
`static int` | `UNLIMITED_SIZE` `UNLIMITED_SIZE` is the value to set the maximum size of the pool to unlimited (`Integer.MAX_VALUE` in fact).

Fields inherited from class org.picocontainer.behaviors.AbstractBehavior
`delegate`

Constructor Summary
`protected` | `Pooled()` Construct an empty ComponentAdapter, used for serialization with reflection only.
`` | `Pooled(org.picocontainer.ComponentAdapter delegate, Pooled.Context context)` Construct a Pooled.

Method Summary
`void` | `dispose(org.picocontainer.PicoContainer container)` Dispose of the container will dispose all returning objects.
`T` | `getComponentInstance(org.picocontainer.PicoContainer container, Type into)`
`String` | `getDescriptor()`
`int` | `size()` Retrieve the current size of the pool.
`void` | `start(org.picocontainer.PicoContainer container)` Start of the container ensures that at least one pooled component has been started.
`void` | `stop(org.picocontainer.PicoContainer container)` Stop of the container has no effect for the pool.

Methods inherited from class org.picocontainer.behaviors.AbstractBehavior
`accept, changeMonitor, componentHasLifecycle, currentMonitor, dispose, findAdapterOfType, getComponentImplementation, getComponentInstance, getComponentKey, getDelegate, hasLifecycle, isStarted, start, stop, toString, verify`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### UNLIMITED_SIZE

    public static final int UNLIMITED_SIZE

  `UNLIMITED_SIZE` is the value to set the maximum size of the pool to unlimited (`Integer.MAX_VALUE` in fact).

  See Also:
    Constant Field Values

### DEFAULT_MAX_SIZE

    public static final int DEFAULT_MAX_SIZE

  `DEFAULT_MAX_SIZE` is the default size of the pool.

  See Also:
    Constant Field Values

### BLOCK_ON_WAIT

    public static final int BLOCK_ON_WAIT

  `BLOCK_ON_WAIT` forces the pool to wait until an object of the pool is returning in case none is immediately available.

  See Also:
    Constant Field Values

### FAIL_ON_WAIT

    public static final int FAIL_ON_WAIT

  `FAIL_ON_WAIT` forces the pool to fail none is immediately available.

  See Also:
    Constant Field Values

### DEFAULT_RESETTER

    public static final Resetter DEFAULT_RESETTER

  `DEFAULT_RESETTER` is a `NoOperationResetter` that is used by default.

Constructor Detail

### Pooled

    public Pooled(org.picocontainer.ComponentAdapter delegate,
                  Pooled.Context context)

  Construct a Pooled. Remember, that the implementation will request new components from the delegate as long as no component instance is available in the pool and the maximum pool size is not reached. Therefore the delegate may not return the same component instance twice. Ensure, that the used `ComponentAdapter` does not cache.

  Parameters:
    `delegate` - the delegated ComponentAdapter
    `context` - the `Pooled.Context` of the pool
  Throws:
    `IllegalArgumentException` - if the maximum pool size or the serialization mode is invalid

### Pooled

    protected Pooled()

  Construct an empty ComponentAdapter, used for serialization with reflection only.

Method Detail

### getComponentInstance

    public T getComponentInstance(org.picocontainer.PicoContainer container,
                                  Type into)

  As long as the maximum size of the pool is not reached and the pool is exhausted, the implementation will request its delegate for a new instance, that will be managed by the pool. Only if the maximum size of the pool is reached, the implementation may wait (depends on the initializing `Pooled.Context`) for a returning object.

  Specified by:
    `getComponentInstance` in interface `org.picocontainer.ComponentAdapter<T>`
  Overrides:
    `getComponentInstance` in class `org.picocontainer.behaviors.AbstractBehavior<T>`
  Throws:
    `Pooled.PoolException` - if the pool is exhausted or waiting for a returning object timed out or was interrupted

### getDescriptor

    public String getDescriptor()

### size

    public int size()

  Retrieve the current size of the pool. The returned value reflects the number of all managed components.

  Returns:
    the number of components.

### start

    public void start(org.picocontainer.PicoContainer container)

  Start of the container ensures that at least one pooled component has been started. Applies only if the delegated `ComponentAdapter` supports a lifecylce by implementing `LifecycleStrategy`.

  Specified by:
    `start` in interface `org.picocontainer.ComponentLifecycle<T>`
  Overrides:
    `start` in class `org.picocontainer.behaviors.AbstractBehavior<T>`
  Throws:
    `IllegalStateException` - if pool was already disposed

### stop

    public void stop(org.picocontainer.PicoContainer container)

  Stop of the container has no effect for the pool. Applies only if the delegated `ComponentAdapter` supports a lifecylce by implementing `LifecycleStrategy`.

  Specified by:
    `stop` in interface `org.picocontainer.ComponentLifecycle<T>`
  Overrides:
    `stop` in class `org.picocontainer.behaviors.AbstractBehavior<T>`
  Throws:
    `IllegalStateException` - if pool was already disposed

### dispose

    public void dispose(org.picocontainer.PicoContainer container)

  Dispose of the container will dispose all returning objects. They will not be added to the pool anymore. Applies only if the delegated `ComponentAdapter` supports a lifecylce by implementing `LifecycleStrategy`.

  Specified by:
    `dispose` in interface `org.picocontainer.ComponentLifecycle<T>`
  Overrides:
    `dispose` in class `org.picocontainer.behaviors.AbstractBehavior<T>`
  Throws:
    `IllegalStateException` - if pool was already disposed

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2009 Codehaus. All Rights Reserved.