An interface defining life-cycle methods for instances to be served by an {@link ObjectPool}. <p> By contract, when an {@link ObjectPool} delegates to a {@link PooledObjectFactory}, </p> <ol> <li> {@link #makeObject} is called whenever a new instance is needed. </li> <li> {@link #activateObject} is invoked on every instance that has been {@link #passivateObject passivated} before it is {@link ObjectPool#borrowObject borrowed} from the pool. </li> <li> {@link #validateObject} may be invoked on {@link #activateObject activated} instances to make sure they can be {@link ObjectPool#borrowObject borrowed} from the pool. {@link #validateObject} may also be used to test an instance being {@link ObjectPool#returnObject returned} to the pool before it is {@link #passivateObject passivated}. It will only be invoked on an activated instance. </li> <li> {@link #passivateObject} is invoked on every instance when it is returned to the pool. </li> <li> {@link #destroyObject} is invoked on every instance when it is being "dropped" from the pool (whether due to the response from {@link #validateObject}, or for reasons specific to the pool implementation.) There is no guarantee that the instance being destroyed will be considered active, passive or in a generally consistent state. </li> </ol> {@link PooledObjectFactory} must be thread-safe. The only promise an {@link ObjectPool} makes is that the same instance of an object will not be passed to more than one method of a <code>PoolableObjectFactory</code> at a time. <p> While clients of a {@link KeyedObjectPool} borrow and return instances of the underlying value type {@code V}, the factory methods act on instances of {@link PooledObject PooledObject<V>}. These are the object wrappers that pools use to track and maintain state information about the objects that they manage. </p>