如何快速实现一个连接池？

在实际工作中，我们经常会用到各种连接池，例如：连接 FTP 服务器的连接数有限，需要建立一个连接池;连接数据库的连接数有限，需要建立一个连接池。那我们如何去快速实现一个连接池呢?

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、虚拟主机、营销软件、网站建设、东港网站维护、网站推广。

无论是 FTP 连接池，还是数据库连接池，我们会发现它们都有相同的地方，它们都需要：生命周期管理、连接创建管理等等。如果我们从零开始去实现这些功能，那我们要耗费的时间就很长了!那有没有一个通用的库可以快速实现一个线程池呢?

得益于 Java 完善的生态，前人们针对这种需要开发了一个通用库：Apache Commons Pool(下文简称 ACP)。本质上来说，ACP 库提供的是管理对象池的通用能力，当然也可以用来管理连接池了!

什么是 ACP?

ACP 库提供了一整套用于实现对象池化的 API，以及若干种各具特色的对象池实现。目前最常用的版本是 2.0 版本，相对于 1.x 版本而言，并不是简单升级。2.0 版本是对象池实现的完全重写，显著的提升了性能和可伸缩性，并且包含可靠的实例跟踪和池监控。

Apache Commons Pool 的官网地址为：Pool – Overview，想翻找相关文档资料，到这里去是最权威、最全面的。

如何使用 ACP?

要使用 ACP 实现一个线程池，首先需要先引入 ACP 的依赖包，这里以 Maven 为例。

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2.  org.apache.commons 
    3.   
  
  
  
  3.  commons-pool2 
    4.   
  
  
  
  4.  2.0 
    5.   
  
  
  
  5.  
    6.

要使用 ACP 实现一个对象池，大致可以分为三个步骤：

  • 创建对象工厂：告诉 ACP 如何创建你要的对象。
  • 创建对象池：告诉 ACP 你想创建一个怎样的对象池。
  • 使用对象池：ACP 告诉你如何使用你的对象。

创建对象工厂

对象工厂告诉 ACP，它应该如何去创建、激活、钝化、销毁你的对象。创建对象工厂非常简单，只需要实现 ACP 的 PooledObjectFactory 接口即可。PooledObjectFactory 接口的定义如下：

 
 
 
 
    
  
  
  
  
  1. public interface PooledObjectFactory { 
    2.   
  
  
  
  2.   PooledObject makeObject() throws Exception; 
    3.   
  
  
  
  3.   void destroyObject(PooledObject p) throws Exception; 
    4.   
  
  
  
  4.   boolean validateObject(PooledObject p); 
    5.   
  
  
  
  5.   void activateObject(PooledObject p) throws Exception; 
    6.   
  
  
  
  6.   void passivateObject(PooledObject p) throws Exception; 
    7.   
  
  
  
  7. } 
    8.

但更多情况下，我们会继承 BasePooledObjectFactory 类来实现对象工厂。因为 BasePooledObjectFactory 类是 PooledObjectFactory 的基础实现类，使用它可以帮我们省了很多麻烦。通过继承这个抽象类，我们只需要实现两个方法：create() 和 wrap() 方法。

 
 
 
 
    
  
  
  
  
  1. // 告诉 ACP 如何创建对象 
    2.   
  
  
  
  2. public abstract T create() throws Exception; 
    3.   
  
  
  
  3. // 定义你要返回的对象 
    4.   
  
  
  
  4. public abstract PooledObject wrap(T obj); 
    5.

create() 方法定义你的对象初始化过程，最后将初始化完成的对象返回。例如你想定义一个 SFTP 的连接，那么你首先需要定义一个 JSch 对象，之后设置账号密码，之后连接服务器，最后返回一个 ChannelSftp 对象。

 
 
 
 
    
  
  
  
  
  1. public ChannelSftp create() { 
    2.   
  
  
  
  2.     // SFTP 连接的创建过程 
    3.   
  
  
  
  3. } 
    4.

wrap() 方法定义你要返回的对象，对于一个 SFTP 的连接池来说，其实就是一个 ChannelSftp 对象。一般情况下可以使用类 DefaultPooledObject 替代，参考实现如下：

 
 
 
 
    
  
  
  
  
  1. @Override 
    2.   
  
  
  
  2. public PooledObject wrap(Foo foo) { 
    3.   
  
  
  
  3.     return new DefaultPooledObject(foo); 
    4.   
  
  
  
  4. } 
    5.

创建对象池

创建好对象工厂之后，ACP 已经知道你需要的对象如何创建了。那么接下来，你需要根据你的实际需要，去创建一个对象池。在 ACP 中，我们通过 GenericObjectPool 以及 GenericObjectPoolConfig 来创建一个对象池。

 
 
 
 
    
  
  
  
  
  1. // 声明一个对象池 
    2.   
  
  
  
  2. private GenericObjectPool sftpConnectPool; 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4. // 设置连接池配置 
    5.   
  
  
  
  5.         GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig(); 
    6.   
  
  
  
  6.         poolConfig.setEvictionPolicyClassName("tech.shuyi.javacodechip.acp.SftpEvictionPolicy"); 
    7.   
  
  
  
  7.         poolConfig.setBlockWhenExhausted(true); 
    8.   
  
  
  
  8.         poolConfig.setJmxEnabled(false); 
    9.   
  
  
  
  9.         poolConfig.setMaxWaitMillis(1000 * 10); 
    10.   
  
  
  
  10.         poolConfig.setTimeBetweenEvictionRunsMillis(60 * 1000); 
    11.   
  
  
  
  11.         poolConfig.setMinEvictableIdleTimeMillis(20 * 1000); 
    12.   
  
  
  
  12.         poolConfig.setTestWhileIdle(true); 
    13.   
  
  
  
  13.         poolConfig.setTestOnReturn(true); 
    14.   
  
  
  
  14.         poolConfig.setTestOnBorrow(true); 
    15.   
  
  
  
  15.         poolConfig.setMaxTotal(3); 
    16.   
  
  
  
  16.         // 设置抛弃策略 
    17.   
  
  
  
  17.         AbandonedConfig abandonedConfig = new AbandonedConfig(); 
    18.   
  
  
  
  18.         abandonedConfig.setRemoveAbandonedOnMaintenance(true); 
    19.   
  
  
  
  19.         abandonedConfig.setRemoveAbandonedOnBorrow(true); 
    20.   
  
  
  
  20.         this.sftpConnectPool = new GenericObjectPool<>(sftpConnectFactory, poolConfig, abandonedConfig); 
    21.

在上面创建 SFTP 连接池的代码中，我们配置了一些线程池的参数以及设置了抛弃策略。抛弃策略是非常重要的，如果没有设置抛弃策略，那么会拿到失效的连接从而导致获取文件失败。抛弃策略是通过 poolConfig.setEvictionPolicyClassName 来设置的，我们这里设置的是 SftpEvictionPolicy 类，其代码内容如下：

 
 
 
 
    
  
  
  
  
  1. @Slf4j 
    2.   
  
  
  
  2. @Component 
    3.   
  
  
  
  3. public class SftpEvictionPolicy implements EvictionPolicy { 
    4.   
  
  
  
  4.     @Override 
    5.   
  
  
  
  5.     public boolean evict(EvictionConfig config, PooledObject underTest, int idleCount) { 
    6.   
  
  
  
  6.         try { 
    7.   
  
  
  
  7.             // 连接失效时进行驱逐 
    8.   
  
  
  
  8.             if (!underTest.getObject().isConnected()) { 
    9.   
  
  
  
  9.                 log.warn("connect time out, evict the connection. time={}",System.currentTimeMillis() - underTest.getLastReturnTime()); 
    10.   
  
  
  
  10.                 return true; 
    11.   
  
  
  
  11.             } 
    12.   
  
  
  
  12.         }catch (Exception e){ 
    13.   
  
  
  
  13.             return true; 
    14.   
  
  
  
  14.         } 
    15.   
  
  
  
  15.         return false; 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17. } 
    18.

看到这里，创建线程池的代码就结束了，SftpConnectPool 文件的全部内容如下：

 
 
 
 
    
  
  
  
  
  1. @Slf4j 
    2.   
  
  
  
  2. public class SftpConnectPool { 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4.     private GenericObjectPool sftpConnectPool; 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.     public SftpConnectPool(SftpConnectFactory sftpConnectFactory) { 
    7.   
  
  
  
  7.         // 设置连接池配置 
    8.   
  
  
  
  8.         GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig(); 
    9.   
  
  
  
  9.         poolConfig.setEvictionPolicyClassName("tech.shuyi.javacodechip.acp.SftpEvictionPolicy"); 
    10.   
  
  
  
  10.         poolConfig.setBlockWhenExhausted(true); 
    11.   
  
  
  
  11.         poolConfig.setJmxEnabled(false); 
    12.   
  
  
  
  12.         poolConfig.setMaxWaitMillis(1000 * 10); 
    13.   
  
  
  
  13.         poolConfig.setTimeBetweenEvictionRunsMillis(60 * 1000); 
    14.   
  
  
  
  14.         poolConfig.setMinEvictableIdleTimeMillis(20 * 1000); 
    15.   
  
  
  
  15.         poolConfig.setTestWhileIdle(true); 
    16.   
  
  
  
  16.         poolConfig.setTestOnReturn(true); 
    17.   
  
  
  
  17.         poolConfig.setTestOnBorrow(true); 
    18.   
  
  
  
  18.         poolConfig.setMaxTotal(3); 
    19.   
  
  
  
  19.         // 设置抛弃策略 
    20.   
  
  
  
  20.         AbandonedConfig abandonedConfig = new AbandonedConfig(); 
    21.   
  
  
  
  21.         abandonedConfig.setRemoveAbandonedOnMaintenance(true); 
    22.   
  
  
  
  22.         abandonedConfig.setRemoveAbandonedOnBorrow(true); 
    23.   
  
  
  
  23.         this.sftpConnectPool = new GenericObjectPool<>(sftpConnectFactory, poolConfig, abandonedConfig); 
    24.   
  
  
  
  24.     } 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26.     public ChannelSftp borrowObject() { 
    27.   
  
  
  
  27.         try { 
    28.   
  
  
  
  28.             return sftpConnectPool.borrowObject(); 
    29.   
  
  
  
  29.         } catch (Exception e) { 
    30.   
  
  
  
  30.             log.error("borrowObject error", e); 
    31.   
  
  
  
  31.             return null; 
    32.   
  
  
  
  32.         } 
    33.   
  
  
  
  33.     } 
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35.     public void returnObject(ChannelSftp channelSftp) { 
    36.   
  
  
  
  36.         if (channelSftp!=null) { 
    37.   
  
  
  
  37.             sftpConnectPool.returnObject(channelSftp); 
    38.   
  
  
  
  38.         } 
    39.   
  
  
  
  39.     } 
    40.   
  
  
  
  40. } 
    41.

为了方便使用，我还增加了 borrowObject 和 returnObject 方法，但这两个并不是必须的。在这两个方法中，我们分别调用了 GenericObjectPool 类的 borrowObject 方法和 returnObject 方法。这正是 ACP 提供的、使用线程池对象的方法，先借一个对象，之后归还对象。

注：其实在这一步，已经包含了对象池的使用了。但实际使用的时候，我们经常是将对象池的声明与使用放在同一个类中，因此为了讲解方便，这里没有分开。因此下文的使用对象池，本质上是对对象池做进一步封装。

使用对象池

到这里我们的 SFTP 对象池就已经创建完毕了，是不是非常简单呢!但在实际的工作中，我们通常会在这基础上，做一些封装。对于我们这次的 SFTP 连接池来说，我们会对外直接提供下载文件的服务，将 SFTP 对象池进一步封装起来，不需要关心怎么获取文件。

 
 
 
 
    
  
  
  
  
  1. public class SftpFileHelper { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     @Autowired 
    4.   
  
  
  
  4.     private SftpConnectPool sftpConnectPool; 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.     public void download(String dir, String file, String saveUrl)throws IOException { 
    7.   
  
  
  
  7.         ChannelSftp sftp = sftpConnectPool.borrowObject(); 
    8.   
  
  
  
  8.         log.info("begin to download file, dir={}, file={}, saveUrl={}", dir, file, saveUrl); 
    9.   
  
  
  
  9.         try { 
    10.   
  
  
  
  10.             if (!StringUtils.isEmpty(dir)) { 
    11.   
  
  
  
  11.                 sftp.cd(dir); 
    12.   
  
  
  
  12.             } 
    13.   
  
  
  
  13.             File downloadFile = new File(saveUrl); 
    14.   
  
  
  
  14.             sftp.get(file, new FileOutputStream(downloadFile)); 
    15.   
  
  
  
  15.         }catch (Exception e){ 
    16.   
  
  
  
  16.             log.warn("下载文件失败", e); 
    17.   
  
  
  
  17.         }finally { 
    18.   
  
  
  
  18.             sftpConnectPool.returnObject(sftp); 
    19.   
  
  
  
  19.         } 
    20.   
  
  
  
  20.         log.info("file:{} is download successful", file); 
    21.   
  
  
  
  21.     } 
    22.   
  
  
  
  22. } 
    23.

最后我们写一个测试用例来试一试，是否能正常下载文件。

 
 
 
 
    
  
  
  
  
  1. @RunWith(SpringRunner.class) 
    2.   
  
  
  
  2. @SpringBootTest 
    3.   
  
  
  
  3. @Slf4j 
    4.   
  
  
  
  4. public class SftpFileHelperTest { 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.     @Autowired 
    7.   
  
  
  
  7.     private SftpFileHelper sftpFileHelper; 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     @Test 
    10.   
  
  
  
  10.     public void testDownloadFtpFile() throws Exception { 
    11.   
  
  
  
  11.         sftpFileHelper.download("dir", "fileName", "fileName"); 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13. } 
    14.

没有意外的话，你会看到一条绿线，文件已经被成功下载了!

总结

本文针对 Apache Commons Pool 库最常用的对象池功能做了演示。看完这篇文章，我们知道创建一个线程池需要三个步骤，分别是：

创建对象工厂：告诉 ACP 如何创建你要的对象。

创建对象池：告诉 ACP 你想创建一个怎样的对象池、设置驱逐策略。

使用对象池：ACP 告诉你如何使用你的对象。

本文相关代码存放在博主 Github 项目：java-code-chip 中，可以点击地址获取：java-code-chip/src/main/java/tech/shuyi/javacodechip/acp at master · chenyurong/java-code-chip

ACP 库能够让读者朋友们快速地创建一个对象池，更加专注于业务内容。但事实上，ACP 提供的内容远不止如此，它还有更多更高级的功能。

例如当我们连接的 SFTP 服务器有多个时，我们需要通过不同地址来获得不同的连接对象。此时最笨的办法是每个不同的地址，都复制多一份代码，然后通过不同类的不同方法来实现。但这样的情况工作量相当可观，并且也会有很多重复代码。这种时候就可以使用 BaseKeyedPooledObjectFactory 来替代 BasePooledObjectFactory，从而实现通过 key 来实现不同地址的连接对象管理。

更多关于 ACP 的内容，感兴趣的同学可以自行探索，这里就不深入讲解了。

谢谢大家的阅读。如果文章对你有帮助，点个 「点赞」 ，或者分享到朋友圈 吧。

参考资料

  • Apache Commons 系列简介 之 Pool-阿里云开发者社区
  • Apache Common Pool2 对象池应用浅析 - 知乎
  • Pool – Project Information

 本文转载自微信公众号「陈树义」，可以通过以下二维码关注。转载本文请联系陈树义公众号。

分享名称：如何快速实现一个连接池？
网站网址：http://www.shufengxianlan.com/qtweb/news45/211395.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

行业网站建设

德阳电信机房　　 　手机网站制作　　 　成都微信二次开发公司　　 　护栏打桩机　　 　重庆电信五里店机房　　 　微信小程序　　 　高端网站设计推广　　 　成都网络推广　　 　混凝土搅拌罐车　　 　重庆电商网站定制　　 　成都艾瑞格　　 　盐亭网站建设　　 　成都模板网站　　 　汕尾凯敏网站　　 　成都微商城　　 　成都网站建设　　 　免备案虚拟主机　　 　成都温江机房　　 　绵阳服务器托管　　 　成都展柜制作