1.对象池化技术的基本思路

将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象所造成的开销。用于充当保存对象的“容器”的对象，被称为“对象池”（Object Pool，或简称Pool）。

2. Jakarta Commons Pool组件及其使用

Jakarta Commons Pool是一个用于在Java程序中实现对象池化的组件,它包含两个包（org.apache.commons.pool和org.apache.commons.pool.impl）。下载commons-dbcp，将commons-pool.jar和commons-collections.jar及commons-dbcp-1.2.2.jar放到所在工程的classpath中。

3. 对象池化的工作中用到的三类对象

l         PoolableObjectFactory用于管理被池化的对象的产生、激活、挂起、校验和销毁；

l         ObjectPool用于管理要被池化的对象的借出和归还，并通知PoolableObjectFactory完成相应的工作；

l         ObjectPoolFactory则用于大量生成相同类型和设置的ObjectPool。

3.1 创立PoolableObjectFactory

     PoolableObjectFactory是在org.apache.commons.pool包中定义的一个接口。实际使用的时候需要利用这个接口的一个具体实现。如下：

创建一个实现类PoolableObjectFactorySample.java

import org.apache.commons.pool.PoolableObjectFactory;

public class PoolableObjectFactorySample

        implements PoolableObjectFactory {

private static int counter = 0;

/* *

*这个方法用于在必要时产生新的对象。

     */

    public Object makeObject() throws Exception {

        Object obj = String.valueOf(counter++);

        System.err.println("Making Object " + obj);

        return obj;

}

/* *

* 这个方法用于将对象“激活”设置为适合开始使用的状态。

*/

    public void activateObject(Object obj) throws Exception {

        System.err.println("Activating Object " + obj);

}

/* *

*这个方法用于将对象“挂起”设置为适合开始休眠的状态。

*/

    public void passivateObject(Object obj) throws Exception {

        System.err.println("Passivating Object " + obj);

}

/* *

*这个方法用于校验一个具体的对象是否仍然有效，已失效的对象会被自动交

*给destroyObject方法销毁

*/

    public boolean validateObject(Object obj) {

        /* 以1/2的概率将对象判定为失效 */

        boolean result = (Math.random() > 0.5);

        System.err.println("Validating Object "

                + obj + " : " + result);

        return result;

}

/* *

*这个方法用于销毁被validateObject判定为已失效的对象。

*/

    public void destroyObject(Object obj) throws Exception {

        System.err.println("Destroying Object " + obj);

    }

}

3.2 使用ObjectPool

    ObjectPool是在org.apache.commons.pool包中定义的一个接口，实际使用的时候也需要利用这个接口的一个具体实现。如下：

    创建一个ObjectPoolSample.java类：

import org.apache.commons.pool.ObjectPool;

import org.apache.commons.pool.PoolableObjectFactory;

import org.apache.commons.pool.impl.StackObjectPool;

public class ObjectPoolSample {

    public static void main(String[] args) {

        Object obj = null;

 /*生成PoolableObjectFactory类的实例*/

        PoolableObjectFactory factory = new PoolableObjectFactorySample();

/*生成一个实现了ObjectPool接口的类（例如StackObjectPool）的实例*/

        ObjectPool pool = new StackObjectPool(factory);

        try {

            for(long i = 0; i < 100 ; i++) {

                System.out.println("== " + i + " ==");

                obj = pool.borrowObject(); //从对象池中取出对象

                System.out.println(obj);

                pool.returnObject(obj); //将对象放回对象池

            }

            obj = null;//明确地设为null，作为对象已归还的标志

        }

        catch (Exception e) {

            e.printStackTrace();

        }

        finally {

            try{

                if (obj != null) {//避免将一个对象归还两次

                    pool.returnObject(obj);

                }

                pool.close();

            }

            catch (Exception e){

                e.printStackTrace();

            }

        }

    }

}

3.3 利用ObjectPoolFactory

    要在多处生成类型和设置都相同的ObjectPool就要使用ObjectPoolFactory。ObjectPoolFactory是一个在org.apache.commons.pool中定义的接口，它定义了一个ObjectPool createPool()方法，可以用于大量生产类型和设置都相同的ObjectPool。实例如下：

 创建一个ObjectPoolFactorySample.java文件。

import org.apache.commons.pool.ObjectPool;

import org.apache.commons.pool.ObjectPoolFactory;

import org.apache.commons.pool.PoolableObjectFactory;

import org.apache.commons.pool.impl.StackObjectPoolFactory;

public class ObjectPoolFactorySample {

    public static void main(String[] args) {

        Object obj = null;

        PoolableObjectFactory factory

                = new PoolableObjectFactorySample();

        ObjectPoolFactory poolFactory

                = new StackObjectPoolFactory(factory);

        ObjectPool pool = poolFactory.createPool();

        try {

            for(long i = 0; i < 100 ; i++) {

                System.out.println("== " + i + " ==");

                obj = pool.borrowObject();

                System.out.println(obj);

                pool.returnObject(obj);

            }

            obj = null;

        }

        catch (Exception e) {

            e.printStackTrace();

        }

        finally {

            try{

                if (obj != null) {

                    pool.returnObject(obj);

                }

                pool.close();

            }

            catch (Exception e){

                e.printStackTrace();

            }

        }

    }

}

4.借助BasePoolableObjectFactory

   BasePoolableObjectFactory是org.apache.commons.pool包中的一个抽象类。它实现了PoolableObjectFactory接口，并且为makeObject方法提供了一个基本的实现，而activateObject、passivateObject和destroyObject方法不进行任何操作， validateObject始终返回true。通过继承这个类，而不是直接实现PoolableObjectFactory接口，就可以免去编写一些只起到让编译通过的作用的代码的麻烦了。实例如下：

创建一个BasePoolableObjectFactorySample.java 文件。

import org.apache.commons.pool.BasePoolableObjectFactory;

public class BasePoolableObjectFactorySample 

        extends BasePoolableObjectFactory {

    private int counter = 0;

    public Object makeObject() throws Exception {

        return String.valueOf(counter++);

    }

}

5. ObjectPool的分类

l         StackObjectPool   利用java.util.Stack对象来保存对象池里的对象。

l        SoftReferenceObjectPool 利用java.util.ArrayList对象来保存对象池里的对象。

l         GenericObjectPool利用一个org.apache.commons.collections.CursorableLinkedList对象来保存对象池里的对象。