C/C++编程：连接客户端类connect_client

ゝ一纸荒年。 2022-09-04 02:55 129阅读 0赞

# 版本【一个小知识点】 #

namespace oceanstar{
        
        class  connect_client : public noncopyable{
        
        public:
            virtual ~connect_client() {
        }
        public:
            /**
             * 虚函数，该函数设置网络连接超时时间及网络 IO 超时时间，子类可以重载该虚函数，
             * 以便于设置内部的对象超时时间(如果子类由自己的conn_timeout_，rw_timeout_就必须实现自己的set_timeout函数，否则出错 )
             * @param conn_timeout {int} 网络连接超时时间(秒)
             * @param rw_timeout {int} 网络 IO 超时时间(秒)
             */
            virtual void set_timeout(int conn_timeout, int rw_timeout)
            {
        
                conn_timeout_ = conn_timeout;
                rw_timeout_ = rw_timeout;
            }
        protected:
            int   conn_timeout_;   //网络连接超时时间(秒)
            int   rw_timeout_;    // 网络 IO 超时时间(秒)
        };
    }

## 错误的写法 ##

class connect_client : public oceanstar::connect_client
    {
        
    public:
        connect_client( int conn_timeout, int rw_timeout) :
                  conn_timeout_(conn_timeout)
                , rw_timeout_(rw_timeout) {
        }
    
        virtual ~connect_client(){
        }
    public:
        int   conn_timeout_;
        int   rw_timeout_;
    };
    
    
    
    int main(void){
        
        connect_client client( 10, 10);
    
        client.set_timeout(1, 2);
    
        printf("error : %d\n", client.conn_timeout_);
    
        return 0;
    }

![在这里插入图片描述][fe0038202b3549b78d131b25bda1550f.png]

## 正确的写法 ##

class connect_client : public oceanstar::connect_client
    {
        
    public:
        connect_client( int conn_timeout, int rw_timeout) :
                  conn_timeout_(conn_timeout)
                , rw_timeout_(rw_timeout) {
        }
    
        virtual ~connect_client(){
        }
    
        void set_timeout(int conn_timeout, int rw_timeout)
        {
        
            conn_timeout_ = conn_timeout;
            rw_timeout_ = rw_timeout;
        }
    public:
        int   conn_timeout_;
        int   rw_timeout_;
    };
    
    
    
    int main(void){
        
        connect_client client( 10, 10);
    
        client.set_timeout(1, 2);
    
        printf("ok : %d\n", client.conn_timeout_);
    
        return 0;
    }

![在这里插入图片描述][d44e0067c77c46fa8bc9d00515ce558b.png]

# 版本1 #

## 源码 ##

//
    // Created by oceanstar on 2021/8/10.
    //
    
    #ifndef OCEANSTAR_HTTP_CONNECT_CLIENT_H
    #define OCEANSTAR_HTTP_CONNECT_CLIENT_H
    
    #include <noncopyable.h>
    #include <ctime>
    
    namespace oceanstar{
        
        class  connect_client : public noncopyable{
        
        public:
            connect_client() : when_(0) {
        }
            virtual ~connect_client() {
        }
        public:
            /**
             * 纯虚函数，子类必须实现此函数用于连接服务器
             * @return {bool} 是否连接成功
             */
            virtual bool open() = 0;
        public:
            /**
             * 虚函数，该函数设置网络连接超时时间及网络 IO 超时时间，子类可以重载该虚函数，
             * 以便于设置内部的对象超时时间
             * @param conn_timeout {int} 网络连接超时时间(秒)
             * @param rw_timeout {int} 网络 IO 超时时间(秒)
             */
            virtual void set_timeout(int conn_timeout, int rw_timeout)
            {
        
                conn_timeout_ = conn_timeout;
                rw_timeout_ = rw_timeout;
            }
        public:
            /**
             * 获得该连接对象最近一次被使用的时间截
             * @return {time_t}
             */
            time_t get_when()
            {
        
                return when_;
            }
    
            /**
             * 设置该连接对象当前被使用的时间截
             */
            void set_when(time_t when)
            {
        
                when_ = when;
            }
    
    
        protected:
            time_t when_;  // 该连接对象最近一次被使用的时间截
    
            int   conn_timeout_;   //网络连接超时时间(秒)
            int   rw_timeout_;    // 网络 IO 超时时间(秒)
        };
    }
    
    
    #endif //OCEANSTAR_HTTP_CONNECT_CLIENT_H

## 使用 ##

### 例子1 ###

#include <fcntl.h>
    #include <connpool/connect_client.h>
    #include "acl_file.h"
    
    
    class connect_client : public oceanstar::connect_client
    {
        
    public:
        connect_client(const char* addr, int conn_timeout, int rw_timeout): addr_(addr)
                , conn_timeout_(conn_timeout)
                , rw_timeout_(rw_timeout) {
        }
    
        virtual ~connect_client(){
        }
    
        const char* get_addr() const
        {
        
            return addr_;
        }
    
        void reset() {
        }
        void set_timeout(int conn_timeout, int rw_timeout)
        {
        
            conn_timeout_ = conn_timeout;
            rw_timeout_ = rw_timeout;
        }
    protected:
        virtual bool open(){
        
            return true;
        }
    
    private:
        const char* addr_;
        int   conn_timeout_;
        int   rw_timeout_;
    };
    
    
    
    int main(void){
        
        connect_client client("127.0.0.1:8181", 10, 10);
    
        client.set_timeout(1, 2);
    
        printf("%s", client.get_addr());
    
        return 0;
    }

# 版本2：引入pool #

//
    // Created by oceanstar on 2021/8/10.
    //
    
    #ifndef OCEANSTAR_HTTP_CONNECT_CLIENT_H
    #define OCEANSTAR_HTTP_CONNECT_CLIENT_H
    
    #include <noncopyable.h>
    #include <ctime>
    #include "connect_pool.h"
    
    namespace oceanstar{
        
        class connect_pool;  //  必须的，否则 ---- 错误：‘connect_pool’不是一个类型名
        class  connect_client : public noncopyable{
        
        public:
            connect_client(void)
                    : conn_timeout_(5)
                    , rw_timeout_(5)
                    , when_(0)
                    , pool_(NULL) {
        }
    
            virtual ~connect_client() {
        }
        public:
            /**
             * 纯虚函数，子类必须实现此函数用于连接服务器
             * @return {bool} 是否连接成功
             */
            virtual bool open() = 0;
        public:
            /**
             * 虚函数，该函数设置网络连接超时时间及网络 IO 超时时间，子类可以重载该虚函数，
             * 以便于设置内部的对象超时时间
             * @param conn_timeout {int} 网络连接超时时间(秒)
             * @param rw_timeout {int} 网络 IO 超时时间(秒)
             */
            virtual void set_timeout(int conn_timeout, int rw_timeout)
            {
        
                conn_timeout_ = conn_timeout;
                rw_timeout_ = rw_timeout;
            }
        public:
            /**
             * 获得该连接对象最近一次被使用的时间截
             * @return {time_t}
             */
            time_t get_when()
            {
        
                return when_;
            }
    
            /**
             * 设置该连接对象当前被使用的时间截
             */
            void set_when(time_t when)
            {
        
                when_ = when;
            }
            /**
             * 获得连接池对象引用，在 connect_pool 内部创建
             * 连接对象会调用 set_pool 设置连接池对象句柄
             * @return {connect_pool*}
             */
            connect_pool* get_pool() const
            {
        
                return pool_;
            }
        protected:
            time_t when_;  // 该连接对象最近一次被使用的时间截
    
            int   conn_timeout_;   //网络连接超时时间(秒)
            int   rw_timeout_;    // 网络 IO 超时时间(秒)
    
            connect_pool* pool_;
    
            void set_pool(connect_pool* pool)
            {
        
                pool_ = pool;
            }
        };
    }
    
    
    #endif //OCEANSTAR_HTTP_CONNECT_CLIENT_H

## 使用 ##

//
    // Created by oceanstar on 2021/8/10.
    //
    
    #ifndef OCEANSTAR_HTTP_TCP_CLIENT_H
    #define OCEANSTAR_HTTP_TCP_CLIENT_H
    
    #include "stream/socket_stream.h"
    #include "connect_client.h"
    
    namespace oceanstar{
        
        class  tcp_client : public connect_client{
        
        public:
            tcp_client(const char* addr, int conn_timeout = 10, int rw_timeout = 10)
                   : conn_timeout_(conn_timeout) , rw_timeout_(rw_timeout){
        
                addr_   = strdup(addr);
                conn_ = new socket_stream;
            }
    
            virtual ~tcp_client(void){
        
                delete conn_;
                free(addr_);
            }
        protected:
            // @override
            virtual bool open(void){
        
                if (!conn_->open(addr_, conn_timeout_, rw_timeout_)) {
        
                    logger_error("connnect %s error %s", addr_, strerror(errno));
                    return false;
                }
    
                return true;
            }
        private:
            char* addr_;
    
            int   conn_timeout_;
            int   rw_timeout_;
            socket_stream* conn_;
        };
    }
    
    
    #endif //OCEANSTAR_HTTP_TCP_CLIENT_H

## 使用 ##

*  [用于连接池][Link 1]

[fe0038202b3549b78d131b25bda1550f.png]: /images/20220829/c9bcc5d4fd134fe5b7da3e8c13a44c87.png
[d44e0067c77c46fa8bc9d00515ce558b.png]: /images/20220829/817c75ca9ee64700a3eb8a668b24fc82.png
[Link 1]: https://blog.csdn.net/zhizhengguan/article/details/119573052