An interface defining life-cycle methods for instances to be served by a {@link KeyedObjectPool}. <p> By contract, when an {@link KeyedObjectPool} delegates to a {@link KeyedPooledObjectFactory}, </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 KeyedObjectPool#borrowObject borrowed} from the pool. </li> <li> {@link #validateObject} may be invoked on {@link #activateObject activated} instances to make sure they can be {@link KeyedObjectPool#borrowObject borrowed} from the pool. <code>validateObject</code> may also be used to test an instance being {@link KeyedObjectPool#returnObject returned} to the pool before it is {@link #passivateObject passivated}. It will only be invoked on an activated instance. </li> <li> {@link #passivateObject passivateObject} is invoked on every instance when it is returned to the pool. </li> <li> {@link #destroyObject destroyObject} is invoked on every instance when it is being "dropped" from the pool (whether due to the response from <code>validateObject</code>, 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 KeyedPooledObjectFactory} must be thread-safe. The only promise an {@link KeyedObjectPool} makes is that the same instance of an object will not be passed to more than one method of a <code>KeyedPoolableObjectFactory</code> at a time. <p> While clients of a {@link KeyedObjectPool} borrow and return instances of the underlying value type 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 informations about the objects that they manage. </p>