C/C++编程：连接池类connect_pool

￡神魔★判官ぃ 2022-09-04 02:57 445阅读 0赞

前置准备

  • C/C++编程：连接客户端类connect_client
  • 连接池指的是针对某一个服务器地址可以有多个连接

知识点：

1：纯虚类：不能创建实例，只能继承，而且子类必须实现其纯虚函数

  1. class  connect_pool : public noncopyable{
  3.  protected:
  4.         /**
  5.          * 纯虚函数，需要子类实现
  6.          * @return {connect_client*}
  7.          */
  8.         virtual connect_client* create_connect() = 0;
  9. }
  11. class connect_pool : public oceanstar::connect_pool{
  13. // 基类纯虚函数的实现
  14.     oceanstar::connect_client* create_connect(){
  16.         return new connect_client(addr_.c_str(), conn_timeout_, conn_timeout_);
  17.     }
  18. }

2. 如果父类没有默认构造函数，那么子类必须显式调用其父类的构造函数

  1. class  connect_pool : public noncopyable{
  3.     public:
  4.         /**
  5.          * 构造函数(因为这里显式写了一个构造函数，所以编译器不会默认生成无参构造函数)
  6.          * @param addr {const char*} 服务器监听地址，格式：ip:port(domain:port)
  7.          * @param max {size_t} 连接池最大连接个数限制，如果该值设为 0，则不设置连接池的连接上限
  8.          */
  9.         connect_pool(const char* addr, size_t max):  max_(max){
  11.             strncpy(addr_, addr, sizeof(addr_));
  12.         }
  14. class connect_pool : public oceanstar::connect_pool{
  16. public:
  17.     connect_pool(const char* addr, size_t count)
  18.        : oceanstar::connect_pool(addr, count){
  19.      //必须实现这种构造函数，否则：使用了被删除的函数‘connect_pool::connect_pool()’
  21.     }

版本1

源码（纯虚类）

  1. //
  2. // Created by oceanstar on 2021/8/10.
  3. //
  5. #ifndef OCEANSTAR_HTTP_CONNECT_POOL_H
  6. #define OCEANSTAR_HTTP_CONNECT_POOL_H
  7. #include <list>
  8. #include <noncopyable.h>
  9. #include "connect_client.h"
  10. #include <cstring>
  11. namespace oceanstar{
  13.     class connect_client;
  14.     /**
  15.      * 客户端连接池类，实现对连接池的动态管理，该类为纯虚类，需要子类实现
  16.      * 纯虚函数 create_connect 用于创建与服务端的一个连接
  17.      */
  18.     class  connect_pool : public noncopyable{
  20.     public:
  21.         /**
  22.          * 构造函数
  23.          * @param addr {const char*} 服务器监听地址，格式：ip:port(domain:port)
  24.          * @param max {size_t} 连接池最大连接个数限制，如果该值设为 0，则不设置连接池的连接上限
  25.          */
  26.         connect_pool(const char* addr, size_t max):  max_(max){
  28.             strncpy(addr_, addr, sizeof(addr_));
  29.         }
  31.         ~connect_pool(void)
  32.         {
  34.             std::list<connect_client*>::iterator it = pool_.begin();
  35.             for (; it != pool_.end(); ++it) {
  37.                 delete *it;
  38.             }
  39.         }
  40.     protected:
  41.         /**
  42.          * 纯虚函数，需要子类实现
  43.          * @return {connect_client*}
  44.          */
  45.         virtual connect_client* create_connect() = 0;
  47.     protected:
  48.         char  addr_[256];            // 连接池对应的服务器地址，IP:PORT
  49.         size_t max_;                // 最大连接数
  50.         std::list<connect_client*> pool_;    // 连接池集合
  51.     };
  52. }
  54. #endif //OCEANSTAR_HTTP_CONNECT_POOL_H

使用

  1. class connect_pool : public oceanstar::connect_pool{
  3. public:
  4.     connect_pool(const char* addr, size_t max)
  5.        : oceanstar::connect_pool(addr, max){
  6.      //必须实现这种构造函数，否则：使用了被删除的函数‘connect_pool::connect_pool()’
  8.     }
  11. protected:
  12.     // 基类纯虚函数的实现
  13.     oceanstar::connect_client* create_connect(){
  15.         return new connect_client(addr_.c_str(), conn_timeout_, rw_timeout_);
  16.     }
  18. protected:
  19.     std::string addr_;
  20.     int   conn_timeout_;
  21.     int   rw_timeout_;
  22. };

版本：添加key

因为连接池总是绑定到某一个地址【1V1】，所以可以为这个连接池设置一个key，用来标识其身份。最好的key是addr

  1. //
  2. // Created by oceanstar on 2021/8/10.
  3. //
  5. #ifndef OCEANSTAR_HTTP_CONNECT_POOL_H
  6. #define OCEANSTAR_HTTP_CONNECT_POOL_H
  7. #include <list>
  8. #include <noncopyable.h>
  9. #include "connect_client.h"
  10. #include "acl_mystring.h"
  11. #include <cstring>
  12. namespace oceanstar{
  14.     class connect_client;
  15.     /**
  16.      * 客户端连接池类，实现对连接池的动态管理，该类为纯虚类，需要子类实现
  17.      * 纯虚函数 create_connect 用于创建与服务端的一个连接
  18.      */
  19.     class  connect_pool : public noncopyable{
  21.     public:
  22.         /**
  23.          * 构造函数
  24.          * @param addr {const char*} 服务器监听地址，格式：ip:port(domain:port)
  25.          * @param max {size_t} 连接池最大连接个数限制，如果该值设为 0，则不设置连接池的连接上限
  26.          */
  27.         connect_pool(const char* addr, size_t max):  max_(max){
  29.             strncpy(addr_, addr, sizeof(addr_));
  30.             strncpy(key_, addr_, sizeof(key_));
  31.             acl_lowercase(key_);
  32.         }
  34.         ~connect_pool(void)
  35.         {
  37.             std::list<connect_client*>::iterator it = pool_.begin();
  38.             for (; it != pool_.end(); ++it) {
  40.                 delete *it;
  41.             }
  42.         }
  43.     public:
  44.         void set_key(const char* key){
  46.             strncpy(key_, key, sizeof(key_));
  47.             acl_lowercase(key_);
  48.         }
  49.         const char* get_key(void) const
  50.         {
  52.             return key_;
  53.         }
  54.     protected:
  55.         /**
  56.          * 纯虚函数，需要子类实现
  57.          * @return {connect_client*}
  58.          */
  59.         virtual connect_client* create_connect() = 0;
  61.     protected:
  62.         char  key_[256];            // 与该连接池相关的 key
  63.         char  addr_[256];            // 连接池对应的服务器地址，IP:PORT
  64.         size_t max_;                // 最大连接数
  65.         std::list<connect_client*> pool_;    // 连接池集合
  66.     };
  67. }
  69. #endif //OCEANSTAR_HTTP_CONNECT_POOL_H

版本：设置连接池是否可用

  1. //
  2. // Created by oceanstar on 2021/8/10.
  3. //
  5. #ifndef OCEANSTAR_HTTP_CONNECT_POOL_H
  6. #define OCEANSTAR_HTTP_CONNECT_POOL_H
  7. #include <list>
  8. #include <noncopyable.h>
  9. #include "connect_client.h"
  10. #include "acl_mystring.h"
  11. #include "thread_mutex.h"
  12. #include <cstring>
  13. namespace oceanstar{
  15.     class connect_client;
  16.     /**
  17.      * 客户端连接池类，实现对连接池的动态管理，该类为纯虚类，需要子类实现
  18.      * 纯虚函数 create_connect 用于创建与服务端的一个连接
  19.      */
  20.     class  connect_pool : public noncopyable{
  22.     public:
  23.         /**
  24.          * 构造函数
  25.          * @param addr {const char*} 服务器监听地址，格式：ip:port(domain:port)
  26.          * @param max {size_t} 连接池最大连接个数限制，如果该值设为 0，则不设置连接池的连接上限
  27.          */
  28.         connect_pool(const char* addr, size_t max):  max_(max), alive_(true), last_dead_(0){
  30.             strncpy(addr_, addr, sizeof(addr_));
  31.             strncpy(key_, addr_, sizeof(key_));
  32.             acl_lowercase(key_);
  33.         }
  35.         ~connect_pool(void)
  36.         {
  38.             std::list<connect_client*>::iterator it = pool_.begin();
  39.             for (; it != pool_.end(); ++it) {
  41.                 delete *it;
  42.             }
  43.         }
  44.     public:
  45.         void set_key(const char* key){
  47.             strncpy(key_, key, sizeof(key_));
  48.             acl_lowercase(key_);
  49.         }
  50.         const char* get_key(void) const
  51.         {
  53.             return key_;
  54.         }
  55.         /**
  56.          * 设置连接池的存活状态
  57.          */
  58.         void set_alive(bool yes /* true | false */){
  60.             lock_.lock();
  61.             alive_ = yes;
  62.             if (yes == false) {
  64.                 time(&last_dead_);
  65.             }
  66.             lock_.unlock();
  67.         }
  68.         /**
  69.          * 检查连接池是否正常
  70.          * @return {bool} 返回 true 表示当前连接池处于正常状态，否则表示当前
  71.          *  连接池不可用
  72.          */
  73.         bool aliving(){
  75.             return alive_;
  76.         }
  78.     protected:
  79.         /**
  80.          * 纯虚函数，需要子类实现
  81.          * @return {connect_client*}
  82.          */
  83.         virtual connect_client* create_connect() = 0;
  85.     protected:
  86.         char  key_[256];            // 与该连接池相关的 key
  87.         char  addr_[256];            // 连接池对应的服务器地址，IP:PORT
  88.         size_t max_;                // 最大连接数
  89.         std::list<connect_client*> pool_;    // 连接池集合
  90.         bool  alive_;                // 是否属正常
  91.         time_t last_dead_;            // 该连接池对象上次不可用时的时间截
  92.         thread_mutex lock_;        // 访问 pool_ 时的互斥锁
  93.     };
  94. }
  96. #endif //OCEANSTAR_HTTP_CONNECT_POOL_H

版本：添加超时时间

  1. //
  2. // Created by oceanstar on 2021/8/10.
  3. //
  5. #ifndef OCEANSTAR_HTTP_CONNECT_POOL_H
  6. #define OCEANSTAR_HTTP_CONNECT_POOL_H
  7. #include <list>
  8. #include <noncopyable.h>
  9. #include "connect_client.h"
  10. #include "acl_mystring.h"
  11. #include "thread_mutex.h"
  12. #include <cstring>
  13. namespace oceanstar{
  15.     class connect_client;
  16.     /**
  17.      * 客户端连接池类，实现对连接池的动态管理，该类为纯虚类，需要子类实现
  18.      * 纯虚函数 create_connect 用于创建与服务端的一个连接
  19.      */
  20.     class  connect_pool : public noncopyable{
  22.     public:
  23.         /**
  24.          * 构造函数
  25.          * @param addr {const char*} 服务器监听地址，格式：ip:port(domain:port)
  26.          * @param max {size_t} 连接池最大连接个数限制，如果该值设为 0，则不设置连接池的连接上限
  27.          */
  28.         connect_pool(const char* addr, size_t max):  max_(max), alive_(true), last_dead_(0){
  30.             strncpy(addr_, addr, sizeof(addr_));
  31.             strncpy(key_, addr_, sizeof(key_));
  32.             acl_lowercase(key_);
  33.         }
  35.         ~connect_pool(void)
  36.         {
  38.             std::list<connect_client*>::iterator it = pool_.begin();
  39.             for (; it != pool_.end(); ++it) {
  41.                 delete *it;
  42.             }
  43.         }
  45.         /**
  46.      * 此接口用来设置超时时间
  47.      * @param conn_timeout {int} 网络连接超时时间(秒)
  48.      * @param rw_timeout {int} 网络 IO 超时时间(秒)
  49.      */
  50.         connect_pool& set_timeout(int conn_timeout, int rw_timeout){
  52.             conn_timeout_ = conn_timeout;
  53.             rw_timeout_ = rw_timeout;
  54.             return *this;
  55.         }
  56.     public:
  57.         void set_key(const char* key){
  59.             strncpy(key_, key, sizeof(key_));
  60.             acl_lowercase(key_);
  61.         }
  62.         const char* get_key(void) const
  63.         {
  65.             return key_;
  66.         }
  67.         /**
  68.          * 设置连接池的存活状态
  69.          */
  70.         void set_alive(bool yes /* true | false */){
  72.             lock_.lock();
  73.             alive_ = yes;
  74.             if (yes == false) {
  76.                 time(&last_dead_);
  77.             }
  78.             lock_.unlock();
  79.         }
  80.         /**
  81.          * 检查连接池是否正常
  82.          * @return {bool} 返回 true 表示当前连接池处于正常状态，否则表示当前
  83.          *  连接池不可用
  84.          */
  85.         bool aliving(){
  87.             return alive_;
  88.         }
  90.     protected:
  91.         /**
  92.          * 纯虚函数，需要子类实现
  93.          * @return {connect_client*}
  94.          */
  95.         virtual connect_client* create_connect() = 0;
  97.     protected:
  98.         char  key_[256];            // 与该连接池相关的 key
  99.         char  addr_[256];            // 连接池对应的服务器地址，IP:PORT
  100.         size_t max_;                // 最大连接数
  101.         std::list<connect_client*> pool_;    // 连接池集合
  102.         bool  alive_;                // 是否属正常
  103.         time_t last_dead_;            // 该连接池对象上次不可用时的时间截
  104.         thread_mutex lock_;        // 访问 pool_ 时的互斥锁
  105.         int   conn_timeout_ = 30;            // 网络连接超时时间(秒)
  106.         int   rw_timeout_ = 30;            // 网络 IO 超时时间(秒)
  107.     };
  108. }
  110. #endif //OCEANSTAR_HTTP_CONNECT_POOL_H

使用

  1. //
  2. // Created by oceanstar on 2021/8/18.
  3. //
  5. #ifndef OCEANSTAR_HTTP_HTTP_REQUEST_POOL_H
  6. #define OCEANSTAR_HTTP_HTTP_REQUEST_POOL_H
  9. #include <connpool/connect_pool.h>
  10. #include "http_request.h"
  12. namespace oceanstar{
  14.     class  http_request_pool : public connect_pool{
  16.     public:
  17.         /**
  18.      * 构造函数
  19.      * @param addr {const char*} 服务器监听地址，格式：ip:port(domain:port)
  20.      * @param count {size_t} 连接池最大连接个数限制，当该值为 0 时则没有限制
  21.      * @param idx {size_t} 该连接池对象在集合中的下标位置(从 0 开始)
  22.      */
  23.         http_request_pool(const char* addr, size_t count) : connect_pool(addr, count){
  26.         }
  27.         ~http_request_pool() = default;;
  29.     protected:
  30.         // 基类纯虚函数，该函数返回后由基类设置该连接池的网络连接及网络 IO 超时时间
  31.         virtual connect_client* create_connect(){
  33.             http_request* req = new http_request(addr_, conn_timeout_, rw_timeout_);
  34.             return req;
  35.         }
  36.     };
  37. }
  39. #endif //OCEANSTAR_HTTP_HTTP_REQUEST_POOL_H

发表评论

表情：
评论列表 （有 0 条评论，445人围观）

还没有评论，来说两句吧...

相关阅读

    相关 druid连接池_工具类

    Druid连接池 Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。 在功能、性能、扩展性方面，都超过其他数据库

    青旅半醒青旅半醒/ 0 赞/ 160 阅读