apache-common-pool2对象池的使用

待我称王封你为后i 2022-05-20 06:56 287阅读 0赞

## 一、概述 ##

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

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

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

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

## 二、maven地址 ##

<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对象。

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

## 四、常规对象池的使用 ##

下面举个例子，假设我们要做一个维护数据库连接的对象池。我们只需要定义两个类  
`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实现一个。当然，也可能是我理解不够，如果有不同意见的读者欢迎指出。