对RAM做简单的池化实现

首先由于项目的关系需要使用IBM的Rational Assert Manager做ROA的资源存储。所以需要编写一个队RAM进行池化的东西。大致实现类似JDBC下DBCP的功能。当然这里记录下的只是利用pool进行简单池化，并没有添加其他额外的功能。后期在使用中可能会增强该方法的功能。

首先列出该池化实现的需要jar：
junit-4.8.2.jar
log4j-1.2.16.jar
commons-pool-1.6.jar
com.ibm.ram.common_7.5.1.v20110224.jar
ramclient-ant.jar
ramclient.jar

首先pool中主要有三个接口：ObjectPool，ObjectPoolFactory和PoolableObjectFactory。这一组接口是基于Object的，而相对的还有一组也是三个接口就是基于KeyObject，底层使用Map实现。这里我们不需要使用Map的这种数据结构，所以只选择了Object讲解。

而ObjectPool接口implement后，主要就是用于实现池存储的功能。
ObjectPoolFactory这个接口主要是用于池的创建。当需要批量创建配置相同的池时，可以实现该工厂接口去批量穿件ObjectPool。
PoolableObjectFactory这个接口主要就是对我们需要池化的对象的创建，销毁，挂起，和激活等操作的管理工厂。

而pool包中，已经implement了以上接口实现了部分类。我们只需要通过继承那些类，稍作添加一些功能和重写一些方法即可。这种方式也是最简单实用的方式。不用自己去实现一些存储的实现。

而这里对于Object的，有genericObject和stackObject。两者只是存储的方式不同而已。前者使用arraylist实现，后者使用stack实现。本人选择arraylist实现的genericObject系列。作为池子的父类。

public class RAMObjectPool extends GenericObjectPool<RAMSession> {

	public RAMObjectPool() {
		super();
	}

	public RAMObjectPool(PoolableRAMObjectFactory factory) {
		super(factory);
	}

	public RAMObjectPool(PoolableRAMObjectFactory factory,Config config) {
		super(factory, config);
	}

	@Override
	public RAMSession borrowObject() throws Exception {
		return borrowObject();
	}


	@Override
	public void invalidateObject(RAMSession obj) throws Exception {
		invalidateObject(obj);	
	}


	@Override
	public void returnObject(RAMSession obj) throws Exception {
		returnObject(obj);
	}

简简单单就可以对对象进行池化了。

由于这里我们只使用一个池子，所以不使用池子创建的工厂。就再实现一个对象的创建销毁工厂即可。因为这里我们需要使用的功能很简单，所以只是继承了BasePoolableObjectFactory类就可以了。

public class PoolableRAMObjectFactory extends BasePoolableObjectFactory<RAMSession> {

	private static Logger logger = Logger.getLogger(PoolableRAMObjectFactory.class);

	private String url = null;

	private String userId = null;

	private String userPwd = null;

	public PoolableRAMObjectFactory(String ramURL, String ramUserID, String ramPassword) {
		url = ramURL;
		userId = ramUserID;
		userPwd = ramPassword;
	}
	/**
	 * create a RAMSession
	 * @return 
	 * @throws Exception
	 */
	@Override
	public RAMSession makeObject() throws Exception {
		// Create a connection to Rational Asset Manager
        RAMSession session = new RAMSession(url,userId, userPwd);
        if(logger.isDebugEnabled())logger.debug("obj is created");
		return session;
	}
	/**
	 * 
	 * @param obj
	 * @return
	 */
	@Override
	public boolean validateObject(RAMSession obj) {
		return true;
	}

	@Override
	public void destroyObject(RAMSession obj) throws Exception {
		if(obj!=null) {
			if(logger.isDebugEnabled())logger.debug("obj is destroyed");
			obj.release();
			obj = null;
		}
	}

	@Override
	public void activateObject(RAMSession obj) throws Exception {

	}

	@Override
	public void passivateObject(RAMSession obj) throws Exception {
		if (obj!=null) {
			if(logger.isDebugEnabled())logger.debug("obj is cleared");
			obj.clear();
			obj = null;
		}
	}

}

而对象工厂如果每次都去创建的话，会比较麻烦，而如果写成单例的话，创建出来的RAMSession会不大好管理，所以创建了一个专门用于从池中获取RAMSession进行管理的对象。并用单例模式进行创建。单例模式使用的是bob lee的单例模式。

public class RAMSessionManager {

	private static Logger logger = Logger.getLogger(RAMSessionManager.class);

	private RAMObjectPool objectPool = null;

	private ThreadLocal<RAMSession> localSession = new ThreadLocal<RAMSession>();

	private RAMSessionManager() {
		GenericObjectPool.Config config = null;
		Properties properties = BaseConfig.load();
		String ramURL = properties.getProperty("ramURL");
		String ramUserID = properties.getProperty("ramUserID");
		String ramPassword = properties.getProperty("ramPassword");
		try {
			config = LoadObjectPoolConfig.load(properties.getProperty("poolConfigURL"));
		} catch (Exception e) {
			config = null;
		}
		if(config==null) {
			objectPool = new RAMObjectPool(new PoolableRAMObjectFactory(ramURL, ramUserID, ramPassword));
		} else {
			objectPool = new RAMObjectPool(new PoolableRAMObjectFactory(ramURL, ramUserID, ramPassword),config);
		}
		printDebugInfo();
	}

	static class RAMSessionHolder {
		public static RAMSessionManager instance = new RAMSessionManager();
	}

	public static RAMSessionManager getInstance() {
		return RAMSessionHolder.instance;
	}
	/**
	 * create session
	 * @return
	 * @throws Exception
	 */
	public RAMSession createSession() throws Exception {
		RAMSession obj = objectPool.borrowObject();
		if(obj!=null) {
			printDebugInfo();
			localSession.set(obj);
		} else {
			throw new NullPointerException("RAMSession is null from pool!");
		}
		return obj;
	}
	/**
	 * if created Session get it, else create Session
	 * @return
	 * @throws Exception
	 */
	public RAMSession openSession() throws Exception {
		RAMSession obj = localSession.get();
		if(obj==null) {
			obj = createSession();
		}
		return obj;
	}
	/**
	 * close Session 
	 * @param obj
	 * @throws Exception
	 */
	public void closeSession(RAMSession obj) throws Exception {
		if(obj!=null) {
			objectPool.returnObject(obj);
			printDebugInfo();
		}
	}

	private void printDebugInfo() {
		if (logger.isDebugEnabled()) {
			logger.debug("Active number : "+objectPool.getNumActive()+"\t Idle number : "+objectPool.getNumIdle());
		}
	}
}

最后就是BaseConfig和LoadObjectPoolConfig两个配置进行读取类的编写就可以了。这里就不附上代码了。详情请参考附件。