对象池commons-pool框架的研究以及源代码分析（二）

通过上一节的例子，我们使用了一个简单的对象池应用，现在再来看看其内部是如何实现的。先看看主要包括了哪些类：

该包所有的类与接口不多，也就20个左右，虽然是一个小项目，其中接口与抽象类的数量，基本上与实现的类差不多，可以说明开发者是使用面向接口编程，而不是面向实现编程，对我们的开发工作有着指导意义，在开发中要尽量面向接口编程而非实现。把类整理一下，分成两类，一类是包括KEY的对象池，一类是不包括KEY的对象池，实际上，分析了其中一个，另外的不用分析都知道其实现，先画个简单的类图（没有一个好的画图工具，这图画得不够专业啊，大家将就着看）：

绿色部分的类与接口，就是我们前面使用过的类与接口，StackObjectPool就是对象池的具体实现，由图中我们可以看到，对象池的实现，主要包括4类：StackObjectPool,GenericObjectPool，SoftReferenceObjectPool,AbandoneObjectPool。，值得一提的是BaseObjectPool类，其中负责对对象池状态来维护，实际上主要是维护一个isClose属性，不过在设计上，还是可取的，将通用的属性在一个抽象类里面维护。

左边部分，就是我们使用的对象状态维护工厂，由对象池具体实现操作，对对象的状态进行维护。

右边是使用了工厂设计模式，生成利用对象池工厂生成对象池，由于我们的代码只是演示，所以直接在代码中硬编码了，没有使用工厂，在实际编程中是不可取的。

对核心的类、接口有一个整体印象后，我们就可以来看其具体实现了，先来看看StackObjectPool类：

public class StackObjectPool extends BaseObjectPool implements ObjectPool {

先看看属性：

    protected Stack _pool = null;//对象池，是一个Stack，后面可以想象，主要是围绕Stack做操作

    protected static final int DEFAULT_MAX_SLEEPING  = 8;//默认池中对象最大数量，注意是Static与final
    protected static final int DEFAULT_INIT_SLEEPING_CAPACITY = 4;//默认初始化对象的数量，注意是Static与final
值得学习的地方：设置一些默认对象时，尽量设置为final，避免认为的非法修改    

protected PoolableObjectFactory _factory = null;//对象状态维护工厂
  protected int _maxSleeping = DEFAULT_MAX_SLEEPING;//最大对象数量
    protected int _numActive = 0;//被借出对象数量

//设略构造函数5个，构造函数主要是对以上属性设置值

 

 
    public StackObjectPool(PoolableObjectFactory factory, int maxIdle, int initIdleCapacity) {
        _factory = factory;
        _maxSleeping = (maxIdle < 0 ? DEFAULT_MAX_SLEEPING : maxIdle);
        int initcapacity = (initIdleCapacity < 1 ? DEFAULT_INIT_SLEEPING_CAPACITY : initIdleCapacity);
        _pool = new Stack();
        _pool.ensureCapacity( initcapacity > _maxSleeping ? _maxSleeping : initcapacity);
//生成Stack对象，并对对象的大小做初始化   

 }

//借出对象
    public synchronized Object borrowObject() throws Exception {
        assertOpen();
        Object obj = null;
        while (null == obj) {
            if (!_pool.empty()) {//如果对象池非空，就取出对象
                obj = _pool.pop();
            } else {//如果对象池为空，就调用我们传递进来的对象状态维护类来创建对象
                if(null == _factory) {
                    throw new NoSuchElementException();
                } else {
                    obj = _factory.makeObject();
                }
            }
            if(null != _factory && null != obj) {//如果取出对象，就激活对象
                _factory.activateObject(obj);
            }
            if (null != _factory && null != obj && !_factory.validateObject(obj)) {//如果对象验证对象不可用，就销毁掉并返回NULL
                _factory.destroyObject(obj);
                obj = null;
            }
        }
        _numActive++;
        return obj;
    }

//返回对象
    public synchronized void returnObject(Object obj) throws Exception {
        assertOpen();
        boolean success = true;
        if(null != _factory) {
            if(!(_factory.validateObject(obj))) {//如果对象无效
                success = false;
            } else {
                try {
                    _factory.passivateObject(obj);//调用对象返回后的动作进行状态维护
                } catch(Exception e) {
                    success = false;
                }
            }
        }


        boolean shouldDestroy = !success;


        _numActive--;
        if (success) {//对象有效
            Object toBeDestroyed = null;
            if(_pool.size() >= _maxSleeping) {
                shouldDestroy = true;
                toBeDestroyed = _pool.remove(0); // remove the stalest object
            }
            _pool.push(obj);
            obj = toBeDestroyed; // swap returned obj with the stalest one so it can be destroyed
        }
        notifyAll(); // _numActive has changed
//这一段代码写得有点乱，原意是：如果对象数量超出最大限制，取出池中的对象，然后将有效对象放入，取出的对象就等着销毁

        if(shouldDestroy) { // by constructor, shouldDestroy is false when _factory is null
            try {
                _factory.destroyObject(obj);
            } catch(Exception e) {
                // ignored
            }
        }
    }

//将对象设置为无效
    public synchronized void invalidateObject(Object obj) throws Exception {
        assertOpen();
        _numActive--;
        if(null != _factory ) {
            _factory.destroyObject(obj);//实际上就是调用我们传递进来的状态维护类销毁对象
        }
        notifyAll(); // _numActive has changed
    }

//获取对象池空闲对象数量
    public synchronized int getNumIdle() {
        assertOpen();
        return _pool.size();
    }

//获取对象池已被使用的对象数量
    public synchronized int getNumActive() {
        assertOpen();
        return _numActive;
    }

//销毁对象池所有对象，并将对象池清空
    public synchronized void clear() {
        assertOpen();
        if(null != _factory) {
            Iterator it = _pool.iterator();
            while(it.hasNext()) {
                try {
                    _factory.destroyObject(it.next());
                } catch(Exception e) {
                    // ignore error, keep destroying the rest
                }
            }
        }
        _pool.clear();
    }

//清空对象池，并将对象池状态设置为关闭
    public synchronized void close() throws Exception {
        clear();
        _pool = null;
        _factory = null;
        super.close();
    }


     //添加对象
    public synchronized void addObject() throws Exception {
        assertOpen();
        Object obj = _factory.makeObject();//直接调用我们传递的类添加
        _numActive++;   // A little slimy - must do this because returnObject decrements it.
        this.returnObject(obj);
    }

//设置对象状态维护工厂
    public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException {
        assertOpen();
        if(0 < getNumActive()) {
            throw new IllegalStateException("Objects are already active");
        } else {
            clear();
            _factory = factory;
        }
    }


  
}

注意：上面每个方法都是声明为synchronized 的，所以在是线程安全的，在多线程中可以放心使用。