apache-common-pool2对象池的使用

一、概述

大多时候，我们获取对象的方法都是直接new一个。但是，对于大对象的构造，或者构造耗时比较久的对象，我们每次要使用都去new一个是很不科学的。比如数据库的连接对象、redis的连接对象、Http连接请求对象等等。在设计模式中有一个专门的模式来解决这种场景下的问题，即享元模式。

享元模式其实很好理解，也就是构造一个对象池，这个对象池中维护一定数量的对象，需要的时候就从这个对象池中获取对象，使用完后返还给对象池。这样就避免构造对象所带来的耗时，提升了系统的性能。

设计这样的一个对象池看起来好像并不难，甚至觉的只需要一个List就可以做到。但是，如果考虑到系统的伸缩性，比如在系统忙时可能需要对象池中有足够的对象可以被拿来使用，以保证系统大多时候应该等待对象而进入阻塞，同时，在系统闲时又不需要太多的对象存放在对象池中，这时候就需要释放一些对象。另外，还需要考虑对象何时构造，何时销毁，对象异常的处理等问题。

为了让大多java程序员不重复造轮子，apache开发了一个库，专门给需要对象池的程序提供一个底层的支持。这个库也就是apche-common-pool2，使用这个库，我们只需要关注对象的生成、销毁、校验等操作就可以了。对象池的具体实现细节都交给common-pool2中的具体对象池实现类来完成。

二、maven地址

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.4.2</version>
</dependency>

三、相关接口

common-pool2下有几个很重要的接口，common-pool2也是以这几个接口为基础进行开发的。
ObjectPool.java，抽象了对象池的一个整体的行为。

    //从对象池中获取对象的方法
    T borrowObject() throws Exception, NoSuchElementException,
            IllegalStateException;
    //将对象返还给对象池
    void returnObject(T obj) throws Exception;
    //让对象失效
    void invalidateObject(T obj) throws Exception;
    //往对象池中新增一个对象
    void addObject() throws Exception, IllegalStateException,
            UnsupportedOperationException;
    //获取当前闲置在对象池中的对象数量，即没有被拿走使用的对象数量
    int getNumIdle();
    //获取已经在使用中的对象数量，即被使用者从对象池中拿走使用的数量
    int getNumActive();
    //清空对象池中闲置的所有对象
    void clear() throws Exception, UnsupportedOperationException;
    //关闭对象池
    void close();

PooledObject,抽象了对象池中对象应该具备的一些属性。注意，这个对象并不是我们真正要存的对象，而是经过一层封装的对象。比如我们想往对象池存放String类型的对象，那么真正存放在对象池的其实都是经过封装过的对象，即PooledObject<String>对象。

public interface PooledObject<T> extends Comparable<PooledObject<T>> {
    T getObject();
    long getCreateTime();
    long getActiveTimeMillis();
    long getIdleTimeMillis();
    long getLastBorrowTime();
    long getLastReturnTime();
    long getLastUsedTime();
    @Override
    int compareTo(PooledObject<T> other);
    @Override
    boolean equals(Object obj);
    @Override
    int hashCode();
    String toString();
    boolean startEvictionTest();
    boolean endEvictionTest(Deque<PooledObject<T>> idleQueue);
    boolean allocate();
    boolean deallocate();
    void invalidate();
    void setLogAbandoned(boolean logAbandoned);
    void use();
    void printStackTrace(PrintWriter writer);
    PooledObjectState getState();
    void markAbandoned();
    void markReturning();
}

PooledObjectFactory.java，抽象了生成对象的工厂模型

public interface PooledObjectFactory<T> {
  //构造一个封装对象
  PooledObject<T> makeObject() throws Exception;
  //销毁对象
  void destroyObject(PooledObject<T> p) throws Exception;
  //验证对象是否可用
  boolean validateObject(PooledObject<T> p);
  //激活一个对象，使其可用用
  void activateObject(PooledObject<T> p) throws Exception;
   //钝化一个对象,也可以理解为反初始化
  void passivateObject(PooledObject<T> p) throws Exception;
}

同时还有KeyedObjectPool,KeyedPooledObjectFactory接口，主要提供了带有键的对象池模板。带有键的对象池可以理解为一个 Map<key,ObjectPool> 。也就是每个键都对应一个对象池。

四、常规对象池的使用

下面举个例子，假设我们要做一个维护数据库连接的对象池。我们只需要定义两个类
DbConnection,用于连接数据库的对象。为了让代码不那么复杂，下面的类并没有连接数据库的代码，只有一个简单的属性，表示是否连接上数据库。

public class DbConnection {

    private Boolean isActive;

    public Boolean getActive() {
        return isActive;
    }

    public void setActive(Boolean active) {
        isActive = active;
    }
}

再定义一个构造DbConnection的工厂类DbConnectionFactory,然后实现一些方法

public class DbConnectionFactory implements PooledObjectFactory<DbConnection> {

    @Override
    public PooledObject<DbConnection> makeObject() throws Exception {
        DbConnection dbConnection = new DbConnection();
        //构造一个新的连接对象
        return new DefaultPooledObject<>(dbConnection);
    }

    @Override
    public void destroyObject(PooledObject<DbConnection> p) throws Exception {
        //断开连接
        p.getObject().setActive(false);
    }

    @Override
    public boolean validateObject(PooledObject<DbConnection> p) {
        //判断这个对象是否是保持连接状态
        return p.getObject().getActive();
    }

    @Override
    public void activateObject(PooledObject<DbConnection> p) throws Exception {
        //激活这个对象，让它连接上数据库
        p.getObject().setActive(true);
    }

    @Override
    public void passivateObject(PooledObject<DbConnection> p) throws Exception {
        //不处理
    }
}

到这里，我们就可以使用common-pool2自带的GenericObjectPool类了。

public static void main(String[] args) {
        DbConnectionFactory factory = new DbConnectionFactory();
        //设置对象池的相关参数
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxIdle(20);
        poolConfig.setMaxTotal(100);
        poolConfig.setMinIdle(5);
        //新建一个对象池,传入对象工厂和配置
        GenericObjectPool<DbConnection> objectPool = new GenericObjectPool<>(factory, poolConfig);
        DbConnection dbConnection = null;
        try {
            //从对象池获取对象，如果
            dbConnection = objectPool.borrowObject();
            System.out.println(dbConnection.getActive());
            //使用改对象
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dbConnection != null) {
                //返还对象
                objectPool.returnObject(dbConnection);
            }
        }
    }

这样，我们就已经完成的常规对象池的所有开发。

SoftReferenceObjectPool

common-pool2还提供了一个软引用对象池的实现类，原理和GenericObjectPool差不多，不过对象池中存放的封装对象是软引用对象。软引用对象主要是在堆空间不足会被GC回收，再具体的细节请读者自行百度。

五、带有键的对象池

目前我们看到的对象池的对象都是属于一个类型的，也就是说如果要求对象池中存放的对象类型不一样，常规对象池就做不到了。
比如现在有这样一个场景，项目中要连接的数据库比较多，每个数据库的地址账号密码都不一样，但是上面的常规对象池存放的连接对象好像没办法在取对象时指定获取哪个数据库的连接对象。这是，就需要带有键的对象池，也就是GenericKeyedObjectPool。

我们再定义个DbConnection2，多一个字段url，来表示属于哪个数据库的连接

public class DbConnection2 {

    private Boolean isActive;
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Boolean getActive() {
        return isActive;
    }

    public void setActive(Boolean active) {
        isActive = active;
    }
}

再实现一个KeyedPooledObjectFactory类

public class DbConnectionKeyFactory implements KeyedPooledObjectFactory<String, DbConnection2> {

    @Override
    public PooledObject<DbConnection2> makeObject(String key) throws Exception {
        DbConnection2 dbConnection2 = new DbConnection2();
        dbConnection2.setUrl(key);
        dbConnection2.setActive(true);
        return new DefaultPooledObject<>(dbConnection2);
    }

    @Override
    public void destroyObject(String key, PooledObject<DbConnection2> p) throws Exception {
        p.getObject().setActive(false);
    }

    @Override
    public boolean validateObject(String key, PooledObject<DbConnection2> p) {
        return p.getObject().getActive();
    }

    @Override
    public void activateObject(String key, PooledObject<DbConnection2> p) throws Exception {
        p.getObject().setActive(true);
    }

    @Override
    public void passivateObject(String key, PooledObject<DbConnection2> p) throws Exception {

    }
}

之后就可以使用GenericKeyedObjectPool对象池了

public static void main(String[] args) {
        GenericKeyedObjectPoolConfig genericKeyedObjectPoolConfig = new GenericKeyedObjectPoolConfig();
        genericKeyedObjectPoolConfig.setMaxIdlePerKey(10);
        genericKeyedObjectPoolConfig.setMaxTotalPerKey(100);
        genericKeyedObjectPoolConfig.setMaxTotal(500);
        genericKeyedObjectPoolConfig.setMinIdlePerKey(10);

        DbConnectionKeyFactory dbConnectionKeyFactory = new DbConnectionKeyFactory();
        GenericKeyedObjectPool<String, DbConnection2> genericKeyedObjectPool = new GenericKeyedObjectPool<>
                (dbConnectionKeyFactory, genericKeyedObjectPoolConfig);
        DbConnection2 dbConnection1 = null;
        DbConnection2 dbConnection2 = null;
        try {
            dbConnection1 = genericKeyedObjectPool.borrowObject("192.168.0.1");
            dbConnection2 = genericKeyedObjectPool.borrowObject("192.168.0.2");
            System.out.println(dbConnection1.getUrl());
            System.out.println(dbConnection2.getUrl());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dbConnection1 != null) {
                genericKeyedObjectPool.returnObject(dbConnection1.getUrl(), dbConnection1);
            }
            if (dbConnection2 != null) {
                genericKeyedObjectPool.returnObject(dbConnection2.getUrl(), dbConnection2);
            }
        }
    }

六、存放代理对象的对象池

如果需要在对象池中存放代理对象，common-pool2也提供了两个现有的对象池实现类ProxiedObjectPool和ProxiedKeyedObjectPool,我们下面简单介绍下ProxiedObjectPool的使用。
我们要用到jdk的对象代理机制，所以需要定义一个代表连接对象的接口类DbConnectionInterface

public interface DbConnectionInterface {
    public Boolean getActive();
    public void setActive(Boolean active);
}

之后定义一个实现类DbConnection

public class DbConnection implements DbConnectionInterface {

    private Boolean isActive;

    public Boolean getActive() {
        return isActive;
    }

    public void setActive(Boolean active) {
        isActive = active;
    }
}

为了方便观察代理的效果，我们需要再定义一下封装对象MyDefaultPooledObject,直接继承DefaultPooledObject类就好了。重写一下use()方法

public class MyDefaultPooledObject extends DefaultPooledObject<DbConnectionInterface> {
    public MyDefaultPooledObject(DbConnectionInterface object) {
        super(object);
    }

    @Override
    //代理对象被调用时，会回调这个方法
    public void use() {
        super.use();
        DbConnectionInterface object = getObject();
        System.out.println("method get " + object.getActive());
    }
}

最后还要定义一个生产DbConnectionInterface对象的工厂类DbConnectionFactory

public class DbConnectionFactory implements PooledObjectFactory<DbConnectionInterface> {

    @Override
    public PooledObject<DbConnectionInterface> makeObject() throws Exception {
        DbConnectionInterface dbConnection = new DbConnection();
        return new MyDefaultPooledObject(dbConnection);
    }

    @Override
    public void destroyObject(PooledObject<DbConnectionInterface> p) throws Exception {
        p.getObject().setActive(false);
    }

    @Override
    public boolean validateObject(PooledObject<DbConnectionInterface> p) {
        return p.getObject().getActive();
    }

    @Override
    public void activateObject(PooledObject<DbConnectionInterface> p) throws Exception {
        p.getObject().setActive(true);
    }

    @Override
    public void passivateObject(PooledObject<DbConnectionInterface> p) throws Exception {
        //不处理
    }
}

然后就可以开始使用ProxiedObjectPool对象池了

public static void main(String[] args) {
        DbConnectionFactory factory = new DbConnectionFactory();
        //这里必须定义一个AbandonedConfig配置，并且设置useUsageTracking属性为true
        //这样代理对象的方法被调用时，才会去调用DefaultPooledObject的use()方法
        AbandonedConfig abandonedConfig = new AbandonedConfig();
        abandonedConfig.setUseUsageTracking(true);
        //定义一个常规对象池
        GenericObjectPool<DbConnectionInterface> pool = new GenericObjectPool<>(factory, new GenericObjectPoolConfig()
                , abandonedConfig);
        pool.setMaxTotal(100); // 对象池中允许的最大对象数量
        pool.setMaxIdle(50);
        pool.setMaxWaitMillis(5000);
        pool.setTimeBetweenEvictionRunsMillis(10000);
        pool.setMinIdle(20);
        // 使用jdk自带的代理机制
        JdkProxySource<DbConnectionInterface> proxySource = new JdkProxySource<>(DbConnectionInterface.class
                .getClassLoader(), new
                Class[]{DbConnectionInterface.class});
        // 加装代理新对象池
        ProxiedObjectPool<DbConnectionInterface> proxiedPool = new ProxiedObjectPool<>(pool, proxySource);
        DbConnectionInterface connection = null;
        try {
            connection = proxiedPool.borrowObject();
            //每次代理对象被调用时，都会执行MyDefaultPooledObject里的use方法
            connection.getActive();
            //这里输出class com.sun.proxy.$Proxy0，说明这是一个代理对象
            System.out.println(connection.getClass());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    proxiedPool.returnObject(connection);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }

这样，通过代理对象池取出的所有对象在调用方法时，都会经过我们定义的MyDefaultPooledObject#use()方法。

其实代理对象池的原理很简单,就是通过jdk的代理机制为刚创建的封装对象再创建一个代理对象，这样放到对象池中的就是代理对象了。当代理对象的任一方法被调用时，都会触发JdkProxyHandler#invoke()执行，也就是下面这个方法

@Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        return doInvoke(method, args);
    }

Object doInvoke(Method method, Object[] args) throws Throwable {
        validateProxiedObject();
        T object = getPooledObject();
        if (usageTracking != null) {
          //这里的usageTracking其实就是我们的常规对象池GenericObjectPool
          //GenericObjectPool实现了UsageTracking接口
            usageTracking.use(object);
        }
        return method.invoke(object, args);
    }

所以每个代理对象的方法调用都会触发GenericObjectPool#use()方法，use()方法里面会判断useUsageTracking是否开启来决定是否调用poolObject#use()方法。

@Override
    public void use(T pooledObject) {
        AbandonedConfig ac = this.abandonedConfig;
        if (ac != null && ac.getUseUsageTracking()) {
            PooledObject<T> wrapper = allObjects.get(new IdentityWrapper<T>(pooledObject));
            wrapper.use();
        }
    }

ProxiedKeyedObjectPool的原理也差不多，就不多做介绍了。

七、总结

总的来说，common-pool2给我们提供了5种不同类型的对象池实现来给我们使用:

  1. GenericObjectPool
  2. SoftReferenceObjectPool
  3. GenericKeyedObjectPool
  4. ProxiedObjectPool
  5. ProxiedKeyedObjectPool

一般情况下，GenericObjectPool足够满足我们大部分的场景，而且用起来也很简单，我们只需要实现一个对象工厂类就可以了，可谓是开箱即用。另外SoftReferenceObjectPool和GenericKeyedObjectPool也有不少的使用场景，也很好用。

对于ProxiedObjectPool和ProxiedKeyedObjectPool，个人感觉并不太好用。因为代理对象只会在方法被调用前执行一些自定义方法，而没有在方法被调用后执行一些方法。另外，要开启代理对象池还需要专门设置AbandonedConfig，很是麻烦。可能还不如自己基于GenericObjectPool实现一个。当然，也可能是我理解不够，如果有不同意见的读者欢迎指出。

我的CSDN博客地址
https://blog.csdn.net/u013332124/article/details/81042375

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,098评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,213评论 2赞 380
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,960评论 0赞 336
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,519评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,512评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,533评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,914评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,574评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,804评论 1赞 296
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,563评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,644评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,350评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,933评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,908评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,146评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,847评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,361评论 2赞 342

推荐阅读更多精彩内容