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

本文链接：https://blog.youkuaiyun.com/springcsc1982/article/details/8830337

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

该包所有的类与接口不多，也就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;
}
}

}