BaseObjectPool (Apache Tomcat 7.0.104 API Documentation)

org.apache.tomcat.dbcp.pool

## Class BaseObjectPool<T>

- java.lang.Object
- - org.apache.tomcat.dbcp.pool.BaseObjectPool<T>

- Type Parameters:
    `T` - the type of objects held in this pool
  All Implemented Interfaces:
    ObjectPool<T>
  Direct Known Subclasses:
    GenericObjectPool, SoftReferenceObjectPool, StackObjectPool

      public abstract class BaseObjectPool<T>
      extends Object
      implements ObjectPool<T>

  A simple base implementation of `ObjectPool`. Optional operations are implemented to either do nothing, return a value indicating it is unsupported or throw `UnsupportedOperationException`.
  Since:
    Pool 1.0
  Author:
    Rodney Waldhoff, Sandy McArthur

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `BaseObjectPool()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addObject()` Not supported in this base implementation.
    `protected void` | `assertOpen()` Throws an `IllegalStateException` when this pool has been closed.
    `abstract T` | `borrowObject()` Obtains an instance from the pool.
    `void` | `clear()` Not supported in this base implementation.
    `void` | `close()` Close this pool.
    `int` | `getNumActive()` Not supported in this base implementation.
    `int` | `getNumIdle()` Not supported in this base implementation.
    `abstract void` | `invalidateObject(T obj)` Invalidates an object from the pool.
    `boolean` | `isClosed()` Has this pool instance been closed.
    `abstract void` | `returnObject(T obj)` Returns an instance to the pool.
    `void` | `setFactory(PoolableObjectFactory<T> factory)` Deprecated. to be removed in pool 2.0

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### BaseObjectPool

          public BaseObjectPool()

  - ### Method Detail

    - #### borrowObject

          public abstract T borrowObject()
                                  throws Exception

      Obtains an instance from the pool.
      Specified by:
        `borrowObject` in interface `ObjectPool<T>`
      Returns:
        an instance from the pool
      Throws:
        `Exception` - if an instance cannot be obtained from the pool

    - #### returnObject

          public abstract void returnObject(T obj)
                                     throws Exception

      Returns an instance to the pool.
      Specified by:
        `returnObject` in interface `ObjectPool<T>`
      Parameters:
        `obj` - instance to return to the pool
      Throws:
        `Exception`

    - #### invalidateObject

          public abstract void invalidateObject(T obj)
                                         throws Exception

      Invalidates an object from the pool.

      By contract, `obj` must have been obtained using `borrowObject`.

      This method should be used when an object that has been borrowed is determined (due to an exception or other problem) to be invalid.

      Specified by:
        `invalidateObject` in interface `ObjectPool<T>`
      Parameters:
        `obj` - a `borrowed` instance to be disposed.
      Throws:
        `Exception`

    - #### getNumIdle

          public int getNumIdle()
                         throws UnsupportedOperationException

      Not supported in this base implementation.
      Specified by:
        `getNumIdle` in interface `ObjectPool<T>`
      Returns:
        a negative value.
      Throws:
        `UnsupportedOperationException`

    - #### getNumActive

          public int getNumActive()
                           throws UnsupportedOperationException

      Not supported in this base implementation.
      Specified by:
        `getNumActive` in interface `ObjectPool<T>`
      Returns:
        a negative value.
      Throws:
        `UnsupportedOperationException`

    - #### clear

          public void clear()
                     throws Exception,
                            UnsupportedOperationException

      Not supported in this base implementation.
      Specified by:
        `clear` in interface `ObjectPool<T>`
      Throws:
        `UnsupportedOperationException`
        `Exception`

    - #### addObject

          public void addObject()
                         throws Exception,
                                UnsupportedOperationException

      Not supported in this base implementation. Always throws an `UnsupportedOperationException`, subclasses should override this behavior.
      Specified by:
        `addObject` in interface `ObjectPool<T>`
      Throws:
        `UnsupportedOperationException`
        `Exception` - when `PoolableObjectFactory.makeObject()` fails.
        `IllegalStateException` - after `ObjectPool.close()` has been called on this pool.

    - #### close

          public void close()
                     throws Exception

      Close this pool. This affects the behavior of `isClosed` and `assertOpen`.
      Specified by:
        `close` in interface `ObjectPool<T>`
      Throws:
        `Exception` - deprecated: implementations should silently fail if not all resources can be freed.

    - #### setFactory

          @Deprecated
          public void setFactory(PoolableObjectFactory<T> factory)
                          throws IllegalStateException,
                                 UnsupportedOperationException

      Deprecated. to be removed in pool 2.0
      Not supported in this base implementation. Always throws an `UnsupportedOperationException`, subclasses should override this behavior.
      Specified by:
        `setFactory` in interface `ObjectPool<T>`
      Parameters:
        `factory` - the PoolableObjectFactory
      Throws:
        `UnsupportedOperationException`
        `IllegalStateException`

    - #### isClosed

          public final boolean isClosed()

      Has this pool instance been closed.
      Returns:
        `true` when this pool has been closed.

    - #### assertOpen

          protected final void assertOpen()
                                   throws IllegalStateException

      Throws an `IllegalStateException` when this pool has been closed.
      Throws:
        `IllegalStateException` - when this pool has been closed.
      See Also:
        `isClosed()`

Copyright © 2000-2020 Apache Software Foundation. All Rights Reserved.