Redis客戶端連接池

　　

使用場景

對於一些大對象，或者初始化過程較長的可復用的對象，我們如果每次都new對象出來，那么意味着會耗費大量的時間。

我們可以將這些對象緩存起來，當接口調用完畢后，不是銷毀對象，當下次使用的時候，直接從對象池中拿出來即可。

下面以redis客戶端舉例，說明下連接池的基礎實現。
commons-pool2，是常用的對象池工具包，實現了對象池中對象的整個生命周期的管理，同時還可以手動指定對象生命周期的調度閥值。
Jedis是java的redis客戶端的實現，能夠實現對redis單機以及切片集群的鏈接。使用起來還很方便。
下面使用Jedis和commons-pool實現客戶端連接池的管理。

首先定義生成Jedis鏈接的工廠

public class JedisPooledFactory extends BasePooledObjectFactory<Jedis> {

    //jedis server url
    private String url  = null;

    //redis server port
    private int    port = 6379;

    /**
     * @param url
     * @param port
     */
    public JedisPooledFactory(String url, int port) {
        super();
        this.url = url;
        this.port = port;
    }

    /** 
     * @see org.apache.commons.pool2.BasePooledObjectFactory#create()
     */
    @Override
    public Jedis create() throws Exception {
        Assert.notNull(url);
        return new Jedis(url, port);
    }

    @Override
    public boolean validateObject(PooledObject<Jedis> p) {
        //if closed,validate error
        if(!p.getObject().isConnected()){
            return false;
        }
        return super.validateObject(p);
    }

    @Override
    public void destroyObject(PooledObject<Jedis> p) throws Exception {
        // close the connection
        p.getObject().close();
        super.destroyObject(p);
    }

    /**
     * @see org.apache.commons.pool2.BasePooledObjectFactory#wrap(java.lang.Object)
     */
    @Override
    public PooledObject<Jedis> wrap(Jedis obj) {
        return new DefaultPooledObject<Jedis>(obj);
    }
}

我們可以看到，這個工廠主要是實現了對Jedis連接對象的生命周期的管理，結合Jedis來說明定義的行為：1.怎么創建Jedis連接（比如連接池中jedis連接不夠用的時候）。2.怎么銷毀對象(比如連接池中大量空閑連接)。3.每次borrow/return Jedis連接的時候，判斷jedis連接的有效性。，如果無效就將該對象銷毀，然后重新borrow。4.wrap,將任意對象池化的時候，需要讓對象支持一些對象池中的特定的一些特性，比如在對象池中，如果空閑對象超過了閥值並且超過了一定的時間，borrow的時候就清除掉對象，這個意味着池中的對象需要支持池化后的一些特性，主要是與生命狀態相關的特性。那么這個wrap就是對象的包裝類，有個默認的實現：

DefaultPooledObject

我們現在要開始使用Jedis連接工廠了

public class RedisClientImpl implements InitializingBean, RedisClient {

    private final static Logger      logger      = LoggerFactory.getLogger(RedisClientImpl.class);

    /** redis url */
    private String                   url         = null;
    private int                      port        = 6379;

    /**
     * The Max wait time.
     */
    private int                      maxWaitTime = 1000;

    /** jedis池化 */
    private GenericObjectPool<Jedis> jedisPool   = null;

    /**
     * Instantiates a new Redis client.
     */
    public RedisClientImpl() {
    }

    /**
     * Instantiates a new Redis client.
     *
     * @param url  the url
     * @param port the port
     */
    public RedisClientImpl(String url, int port){
        setPort(port);
        setUrl(url);
    }

    /**
     * 不帶異常的put數據
     * @param key
     * @param value
     */
    public void putobjWithExp(String key, Object value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.set(key, JSON.toJSONString(value));
        } catch (Exception e) {
            logger.error("獲取Jedis異常", e);
        } finally {
            if (jedis != null) {
                returnJedis(jedis);
            }
        }
    }

    /**
     * 獲取jedis
     * @return 從池中獲取jedis
     * @throws Exception
     */
    private Jedis getJedis() throws Exception {
        LoggerUtils.info(logger, "borrow jedis,borrowwed=", jedisPool.getNumActive(), ",maxTotal=",
            jedisPool.getMaxTotal());
        return jedisPool.borrowObject(maxWaitTime);
    }

    /**
     * 歸還jedis
     * @param jedis
     */
    private void returnJedis(Jedis jedis) {
        LoggerUtils.info(logger, "return jedis,borrowwed=", jedisPool.getNumActive(), ",maxTotal=",
            jedisPool.getMaxTotal());
        jedisPool.returnObject(jedis);
    }

    /**
     * Setter method for property <tt>port</tt>.
     * 
     * @param port value to be assigned to property port
     */
    public void setPort(int port) {
        this.port = port;
    }

    /**
     * Setter method for property <tt>url</tt>.
     * 
     * @param url value to be assigned to property url
     */
    public void setUrl(String url) {
        this.url = url;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        LoggerUtils.info(logger, "開始初始化jedis池,url=", url, ",port=", port);
        Assert.notNull(url);
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setMaxWaitMillis(100);
        poolConfig.setLifo(false);
        poolConfig.setMaxIdle(50);//// 最大空閑連接數
        poolConfig.setMinIdle(20);// 最小空閑連接數
        poolConfig.setMaxTotal(500);// 整個池的最大值,最大連接數
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnCreate(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(false);
        jedisPool = new GenericObjectPool<>(new JedisPooledFactory(url, port), poolConfig);
    }

這里jedis采用單機的形式。
首先是afterPropertiesSet方法，這里對jedis連接池做了一些配置，比如池的大小，borrow jedis連接的時候等待時間（borrow的時候采用的樂觀鎖），池中空閑對象超過多少的時候，return連接直接就銷毀。。。等等
然后是putobjWithExp方法，這里首先是從池中borrow一個鏈接，如果池中沒有的話，commons-pool會自動創建。然后獲取到連接了以后，調用下jedis的set方法，將數據保存。

這里采用的是fastJson來做序列化的，保存的內容也是String格式的。 而tair是支持自定義序列化工具的，而且它的序列化是

最后，將jedis連接歸還到pool去就好啦。
除了對象復用以外，其實還沒有提到一個很重要的使用對象池的原因：

對於連接池的場景而言，連接是有限的資源，不采用池化，那么無法對資源的分配進行管理。

打個比方，不采用連接池，每個請求進來生成一個連接，那么如果突然某個業務請求量遞增，直接導致連接數都被該系統占用了。但是采用了連接池，不僅僅可以對象復用，同時還能做資源的管控。

測試：

測試環境:10個線程，同時采用jedispool和非jedispool的方式向redis put數據，put的數據一樣，一共put 50000次，以下是測試結果。
帶jedis連接池的--->任務執行完畢,執行時間5055ms,共有50000個任務,執行異常0次
不帶連接池的--->任務執行完畢,執行時間14654ms,共有50000個任務,執行異常0次

效果還是很明顯的。后續還可以增加對連接池的定時任務監控等~~~