池化

　　对于那些创建耗时较长，或者资源占用较多的对象，比如网络连接，线程之类的资源，通常使用池化来管理这些对象，从而达到提高性能的目的。比如数据库连接池（c3p0, dbcp）, java的线程池 ExecutorService. Apache Commons Pool提供一套池化规范接口，以及实现通用逻辑，我们只需要要实现其抽象出来的方法就可以。Commons Pool主要有以下几个对象

　　PooledObject：这个就是前面所说需要池化的资源，被池化的对象可以抽离出共有属性，如，创建时间，状态，最近一次使用时间等

　　PooledObjectFactory： 对象工厂，负责对PooledOjbect的创建，状态验证，销毁之类的工作

　　ObjectPool： 对象池，它是负责和对象使用者直接打交道的, 对使用者提供获取对象，返还对象接口

　　英文不太好的同学可能被这几个对象的命名搞晕，其实世间万物的道理都是相通的。如果把图书馆的书比作PooledObject 的话，那么图书馆就是ObjectPool，图书馆为了管理书，对书添加了入库时间，书借存状态等用于管理的属性。图书馆（ObjectPool）对借书人提供借书，还书的服务（即接口）。而书（PooledObject ）的印刷，质量检验，回收（有点不现实）等实实在在的工作还是得交给印刷厂（PooledObjectFactory ）来做。其流程关系如下：

　　下面看看如何使用Commons Pool如何实现自己的对象池。创建自己的对象池大致需要以下工作，

　　1. 首先你已经编写好了你的资源对象（这部分不属于池化内容），之后编写实现apache的PooledObjectFactory<T>接口的Factory类，这是编写自己对象池最主要的工作。你的Factory可能需要添加一些用于池化对象的初始化 ，池化对象的验证等参数作为成员变量。

　　2. 编写自己的Pool类，让其继承或者内部引用apache的GenericObjectPool<T>，GenericObjectPool实现了ObjectPool接口，已经封装了对池化对象的生命周期管理逻辑

　　3. 可选部分，继承apache的GenericObjectPoolConfig，重写构造器，添加一些适合自己业务场景的初始化参数。

　　我们以Jedis的源码为例，学习它的实现。我们先看下使用JedisPool操作Redis的简单例子

package com.eg.test.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class TestPool {
     public static void main(String[] args) {
        //JedisPoolConfig继承apache的GenericObjectPoolConfig，配置Pool的相关参数如下：
        JedisPoolConfig config = new JedisPoolConfig(); 
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。 
        config.setMaxTotal(500); 
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。 
        config.setMaxIdle(5); 
        //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException； 
        config.setMaxWaitMillis(30000);; 
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的； 
        config.setTestOnBorrow(true); 
       
        JedisPool pool = new JedisPool(config, "192.168.2.191", 8888); 
        //从pool中获取对象
        Jedis jedis = pool.getResource(); 
        String value = jedis.get("someKey");
       
     }
}

　　首先看JedisFactory的实现：

class JedisFactory implements PooledObjectFactory<Jedis> {
     private final AtomicReference<HostAndPort> hostAndPort = new AtomicReference<HostAndPort>();
     private final int connectionTimeout;
     private final int soTimeout;

     //省略构造函数，都是一些初始化成员变量的操作

     @Override
     public void activateObject(PooledObject<Jedis> pooledJedis) throws Exception {
           final BinaryJedis jedis = pooledJedis.getObject();
           if (jedis.getDB() != database) {
                jedis.select(database);
           }
     }

     @Override
     public void destroyObject(PooledObject<Jedis> pooledJedis) throws Exception {
           final BinaryJedis jedis = pooledJedis.getObject();
           if (jedis.isConnected()) {
                try {
                     try {
                           jedis.quit();
                     } catch (Exception e) {
                     }
                     jedis.disconnect();
                } catch (Exception e) {
                }
           }
     }

     @Override
     public PooledObject<Jedis> makeObject() throws Exception {
           final HostAndPort hostAndPort = this.hostAndPort.get();
           final Jedis jedis = new Jedis(hostAndPort.getHost(), hostAndPort.getPort(), connectionTimeout, soTimeout, ssl,
                   sslSocketFactory, sslParameters, hostnameVerifier);
           try {
                jedis.connect();
                if (null != this.password) {
                     jedis.auth(this.password);
                }
                if (database != 0) {
                     jedis.select(database);
                }
                if (clientName != null) {
                     jedis.clientSetname(clientName);
                }
           } catch (JedisException je) {
                jedis.close();
                throw je;
           }
           return new DefaultPooledObject<Jedis>(jedis);
     }
     @Override
     public void passivateObject(PooledObject<Jedis> pooledJedis) throws Exception {
           // TODO maybe should select db 0? Not sure right now.
     }
     @Override
     public boolean validateObject(PooledObject<Jedis> pooledJedis) {
           final BinaryJedis jedis = pooledJedis.getObject();
           try {
                HostAndPort hostAndPort = this.hostAndPort.get();
                String connectionHost = jedis.getClient().getHost();
                int connectionPort = jedis.getClient().getPort();
                return hostAndPort.getHost().equals(connectionHost) && hostAndPort.getPort() == connectionPort
                        && jedis.isConnected() && jedis.ping().equals("PONG");
           } catch (final Exception e) {
                return false;
           }
     }
}

　　我们看到JedisFactory代码较少，但是逻辑很清晰。该Factory将作为ObjectPool的成员变量，其中四个重写的方法被ObjectPool管理对象生命周期的时候调用。makeobject()方法负责创建Jedis实例，成功调用connect()方法建立有状态的socket连接之后，返回一个包装了jedis的DefaultPooledObject对象，DefaultPooledObject实现了关于统计池化对象状态信息的PooledObject接口。validateObject()方法用于对对象状态的检验，Jedis对象的状态通过socket的ping-pong来验证连接是否正常。destroyObject()方法用来销毁对象，Jedis对象将会断开连接，回收资源。

　　再看JedisPool的实现，由于JedisPool继承Pool<T>，所以我们主要看Pool<T>的部分代码：

public abstract class Pool<T> implements Closeable {
     protected GenericObjectPool<T> internalPool;

     public Pool(final GenericObjectPoolConfig poolConfig, PooledObjectFactory<T> factory) {
           initPool(poolConfig, factory);
     }

     public boolean isClosed() {
           return this.internalPool.isClosed();
     }
     public void initPool(final GenericObjectPoolConfig poolConfig, PooledObjectFactory<T> factory) {
           if (this.internalPool != null) {
                try {
                     closeInternalPool();
                } catch (Exception e) {
                }
           }
           this.internalPool = new GenericObjectPool<T>(factory, poolConfig);
     }
     public T getResource() {
           try {
                return internalPool.borrowObject();
           } catch (NoSuchElementException nse) {
                throw new JedisException("Could not get a resource from the pool", nse);
           } catch (Exception e) {
                throw new JedisConnectionException("Could not get a resource from the pool", e);
           }
     }
     protected void returnResourceObject(final T resource) {
           if (resource == null) {
                return;
           }
           try {
                internalPool.returnObject(resource);
           } catch (Exception e) {
                throw new JedisException("Could not return the resource to the pool", e);
           }
     }

     public void addObjects(int count) {
           try {
                for (int i = 0; i < count; i++) {
                     this.internalPool.addObject();
                }
           } catch (Exception e) {
                throw new JedisException("Error trying to add idle objects", e);
           }
     }
}

　　JedisPool通过内部引用GenericObjectPool，包装其接口的装饰者模式，相比继承来说这种模式更加灵活。JedisPool的构造方法需要将JedisFactory以及JedisPoolConfig创建标准的ObjectPool作为自己的成员变量。所以pool.getResource()方法的背后还是调用PoolObject.borrowObject()。

 

　　最后我们稍微看下JedisPoolConfig，只是做了一些预初始化参数的工作。

public class JedisPoolConfig extends GenericObjectPoolConfig {
     public JedisPoolConfig() {
           // defaults to make your life with connection pool easier :)
           setTestWhileIdle(true);
           setMinEvictableIdleTimeMillis(60000);
           setTimeBetweenEvictionRunsMillis(30000);
           setNumTestsPerEvictionRun(-1);
     }
}