Jakarta Commons项目研究--pool

Jakarta Commons项目研究--pool
一.pool项目
到底什么是 pool, 简单来说, 就是先建立一些存在的 object, 放在 pool 之中, 当你有需要的时候,
可以从 pool 中直接获取, 不需要重新建立.. 最常听到的就是 database connection pooling,
因为建立数据库连结是一件耗时的工作, 如果我们先把连结建立好, 就可以节省这一些时间。database
connection pooling 即DBCP。
1.基础类结构
pool的基础类:
public interface ObjectPool {
    Object borrowObject();
    void returnObject(Object borrowed);
}
主要扩展类:
public interface KeyedObjectPool {
    Object borrowObject(Object key);
    void returnObject(Object key, Object borrowed);
}按照key来索引pool的对象

基础类仅提供了最基本的两个函数,用来创建和返回pool对象。
2.实现的基本类
BaseObjectPool--PoolableObjectFactory--BasePoolableObjectFactory
KeyedObjectPool--KeyedPoolableObjectFactory--BaseKeyedPoolableObjectFactory
StackObjectPool--StackKeyedObjectPool--可以在初始化创建实例，提供有限的 idle 数量
GenericObjectPool--GenericKeyedObjectPool--包含了设定 idle, active
的数量以及回收到pool中的设置
SoftReferenceObjectPool--可以随需要进行增加,他的回收是由垃圾回收站进行的
总的来说,它提供了 Pool 的 API 主要有三个方面:
提供一般性的对象 pool 接口, 可以简单地去使用和实现. 比如BaseObjectPool和KeyedObjectPool.
提供小工具可以建立模块化的 pool. 比如StackObjectPool.
实现出一些通用性的 pool. 比如GenericObjectPool.
3.实现

ObjectPool

 Object obj = null;
 
 try {
 //创建对象
    obj = pool.borrowObject();
//捕获异常
 } catch(Exception e) {
 } finally {
//确认对象是否已经返回
    if(null != obj) {
       pool.returnObject(obj);
    }
 }

KeyedObjectPool

 Object obj = null;
 Object key = "Key";

 try {
 //创建对象
    obj = pool.borrowObject(key);
 //捕获异常
 } catch(Exception e) {
 } finally {
 //确认返回
    if(null != obj) {
       pool.returnObject(key,obj);
    }
 }
其它的类型继承开发就可以了
4.范例(取自apache的commons组)
ReaderUtil.java

import java.io.Reader;
import java.io.IOException;

public class ReaderUtil {

 public ReaderUtil() {
    }

    /**
     * Dumps the contents of the {@link Reader} to a
     * String, closing the {@link Reader} when done.
     */
 public String readToString(Reader in)
  throws IOException {
  StringBuffer buf = new StringBuffer();
  try {

   for( int c = in.read(); c != -1; c = in.read()) {
    buf.append((char)c);
   }
   return buf.toString();
  } catch(IOException e) {
   throw e;
  } finally {
   try {
    in.close();
   } catch (Exception e) {    
        // ignored
   }
  }
 }
}

改换一下顺序，先取得pool，再由pool取值（推荐使用）

import org.apache.commons.pool.ObjectPool;
import java.io.Reader;
import java.io.IOException;
 
public class ReaderUtil {
    private ObjectPool pool;
 
    public ReaderUtil(ObjectPool pool) {
        this.pool = pool;
    }
 
    /**
     * Dumps the contents of the {@link Reader} to a
     * String, closing the {@link Reader} when done.
     */
    public String readToString(Reader in) throws IOException {
        StringBuffer buf = null;
        try {
            buf = (StringBuffer)(pool.borrowObject());
            for(int c = in.read(); c != -1; c = in.read()) {
                buf.append((char)c);
            }
            return buf.toString();
        } catch(IOException e) {
            throw e;
        } catch(Exception e) {
            throw new RuntimeException("Unable to borrow buffer from pool" +
                    e.toString());
        } finally {
            try {
                in.close();
            } catch(Exception e) {
                // ignored
            }
            try {
                if(null != buf) {
                    pool.returnObject(buf);
                }
            } catch(Exception e) {
                // ignored
            }
        }
    }
}

用StringBuffer做pool的例子(不推荐使用，仅供熟悉知识)

StringBufferFactory.java

import org.apache.commons.pool.BasePoolableObjectFactory;
 
public class StringBufferFactory extends BasePoolableObjectFactory {
    // for makeObject we'll simply return a new buffer
    public Object makeObject() {
        return new StringBuffer();
    }
    
    // when an object is returned to the pool, 
    // we'll clear it out
    public void passivateObject(Object obj) {
        StringBuffer buf = (StringBuffer)obj;
        buf.setLength(0);
    }
    
    // for all other methods, the no-op 
    // implementation in BasePoolableObjectFactory
    // will suffice
}

修改 ReaderUtil 由 StringBufferFactory Pool 得到 StringBuffer.

new  ReaderUtil(
 new StackObjectPool(
  new StringBufferFactory()
 )
)
5.总结
我们通常会在 io 的部分采用 pool 机制, 减少一些建立存取的时间, 对于最耗时的数据库存取,
更是相对的重要,我将会在commons-DBCP专题进行介绍，本篇是本系列的第二篇，以后将陆续推出，下期主题就是DBCP,请继续关注.
6.参考 -- 相关书目或相关文章
*Jakarta Commons:
http://jakarta.apache.org/commons/
*Jakarta Commons Pool
http://jakarta.apache.org/commons/pool/
*Jakarta Commons Pool API:
http://jakarta.apache.org/commons/pool/apidocs/index.html
*Oreilly: Using the Jakarta Commons, Part 3: #3
http://www.onjava.com/pub/a/onjava/2003/07/23/commons.html?page=3

本文版权所有，未经允许，不得转载，如许转载，请联系：topojuly@tom.com