imxiangzi
imxiangzi

基于libevent的多线程通信框架实现

  很久没有写博客了，这半年多时间一直很忙，一直没有更新博客，今天心血来潮准备做一篇，刚好把最近的新研究东西拿出来给大家分享一下！自己以前的一个后台程序框架（应用于了很多应用项目，运营商***拦截系统，国内某视频聊天应用的后台系统等），里面的网络部分基于ACE来实现的，最近准备淘汰ACE，大部分组件功能打算重写，所以基于网络这块打算用libevent来实现，在做的过程中发现了一些问题，就是能找到的例子都是单线程实现的，有多线的例子也没有写得那么详细，都是很简单的实现，经过一周时间对源码和api的分析，自己做了实现，经过测试还没有发现问题，效率上比之前的框架做了很大的提升，今天给大家贴出来，做分享交流。

NetFrame.h

[cpp]   view plain  copy
  1. //  
  2. //  NetFrame.h  
  3. //  Frame  
  4. //  
  5. //  Created by chenjianjun on 15/9/7.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #ifndef __Frame__NetFrame__  
  10. #define __Frame__NetFrame__  
  11.   
  12. #include   
  13. #include   
  14. #include "Common.h"  
  15. #include "Thread.h"  
  16.   
  17. namespace NAME_SPACE {  
  18.       
  19.     class NetFrame {  
  20.           
  21.     public:  
  22.         static NetFrame* Instance();  
  23.         int NetWorkInit();  
  24.         int NetWorkExit();  
  25.           
  26.     protected:  
  27.         NetFrame();  
  28.         ~NetFrame();  
  29.           
  30.     private:  
  31.         class NetRunnable:public Runnable {  
  32.               
  33.         public:  
  34.             NetRunnable();  
  35.             ~NetRunnable();  
  36.               
  37.         protected:  
  38.             virtual void Run(void*);  
  39.         };  
  40.           
  41.         friend class NetRunnable;  
  42.         DISALLOW_EVIL_CONSTRUCTORS(NetFrame);  
  43.       
  44.     public:  
  45.         static struct event_base* _base;  
  46.           
  47.     private:  
  48.         Thread _main_loop_thread;  
  49.         volatile bool _run_flg;  
  50.         NetRunnable _runnable;  
  51.     };  
  52.       
  53. }  
  54.   
  55. #endif /* defined(__Frame__NetFrame__) */  

NetFrame.cpp
[cpp]   view plain  copy
  1. //  
  2. //  NetFrame.cpp  
  3. //  Frame  
  4. //  
  5. //  Created by chenjianjun on 15/9/7.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8. #include "NetFrame.h"  
  9. #include   
  10.   
  11. namespace NAME_SPACE {  
  12.       
  13.     struct event_base* NetFrame::_base = nullptr;  
  14.       
  15.     NetFrame* NetFrame::Instance() {  
  16.         LIBJINGLE_DEFINE_STATIC_LOCAL(NetFrame, manager, ());  
  17.         return &manager;  
  18.     }  
  19.       
  20.     NetFrame::NetFrame():_run_flg(false){}  
  21.       
  22.     NetFrame::~NetFrame(){  
  23.         NetWorkExit();  
  24.     }  
  25.       
  26.     NetFrame::NetRunnable::NetRunnable() {}  
  27.     NetFrame::NetRunnable::~NetRunnable() {}  
  28.       
  29.     void NetFrame::NetRunnable::Run(void* arg) {  
  30.           
  31.         NetFrame* pNetFrame = (NetFrame*)arg;  
  32.         while (pNetFrame->_run_flg) {  
  33.             Thread::SleepMs(2000);  
  34.             event_base_dispatch(NetFrame::_base);  
  35.         }  
  36.     }  
  37.       
  38.     int NetFrame::NetWorkInit() {  
  39.           
  40.         if (_run_flg) {  
  41.             return FUNC_SUCCESS;  
  42.         }  
  43.           
  44.         evthread_use_pthreads();  
  45.         _base = event_base_new();  
  46.         evthread_make_base_notifiable(_base);  
  47.   
  48.         // 开启事件监听主线程  
  49.         _run_flg = true;  
  50.         if (_main_loop_thread.Start(&_runnable, this)) {  
  51.             return FUNC_SUCCESS;  
  52.         }  
  53.           
  54.         // 开始线程失败置运行标志  
  55.         _run_flg = false;  
  56.           
  57.         return FUNC_FAILED;  
  58.     }  
  59.       
  60.     int NetFrame::NetWorkExit() {  
  61.           
  62.         if (!_run_flg) {  
  63.             return FUNC_SUCCESS;  
  64.         }  
  65.           
  66.         _run_flg = false;  
  67.         event_base_loopexit(NetFrame::_base, nullptr);  
  68.         _main_loop_thread.Stop();  
  69.         event_base_free(_base);  
  70.         _base = nullptr;  
  71.           
  72.         return FUNC_SUCCESS;  
  73.     }  
  74. }  

服务器对象类

ServerWorker.h

[cpp]   view plain  copy
  1. //  
  2. //  ServerWorker.h  
  3. //  服务器对象类  
  4. //  
  5. //  Created by chenjianjun on 15/9/7.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #ifndef __ServerWorker_H_  
  10. #define __ServerWorker_H_  
  11.   
  12. #include   
  13. #include   
  14. #include "NetSignal.h"  
  15.   
  16. namespace NAME_SPACE {  
  17.       
  18.     class ServerWorker {  
  19.           
  20.     public:  
  21.         /** 
  22.          *  @brief  服务器构造函数 
  23.          * 
  24.          *  @param  listen_ip   监听的本地IP 
  25.          *  @param  listen_port 监听的本地端口 
  26.          * 
  27.          *  @return 
  28.          */  
  29.         ServerWorker(std::string listen_ip, int listen_port);  
  30.         ServerWorker(int listen_port);  
  31.           
  32.         ~ServerWorker();  
  33.           
  34.         /** 
  35.          *  @brief  启动工作 
  36.          * 
  37.          *  @param 
  38.          * 
  39.          *  @return 
  40.          */  
  41.         bool StartWork(TCPServerSignal* pTCPServerSignal);  
  42.           
  43.         /** 
  44.          *  @brief  停止工作 
  45.          * 
  46.          *  @param 
  47.          * 
  48.          *  @return 
  49.          */  
  50.         void StopWork();  
  51.           
  52.         // 获取监听套接字  
  53.         SOCKET GetFd() { return _listen_fd; }  
  54.           
  55.     public:  
  56.           
  57.         /** 
  58.          *  @brief  新连接处理，此函数外部禁止调用，用于event事件回调函数调用 
  59.          * 
  60.          *  @param  int 套接字句柄 
  61.          *  @param  struct sockaddr_in * 客户端地址 
  62.          */  
  63.         void Accept(int fd, struct sockaddr_in *sa);  
  64.           
  65.         /** 
  66.          *  @brief  监听失败事件处理，此函数外部禁止调用，用于event事件回调函数调用 
  67.          * 
  68.          *  @param  int 套接字句柄 
  69.          *  @param  EM_NET_EVENT 错误码 
  70.          */  
  71.         void AcceptError(int fd, EM_NET_EVENT msg);  
  72.           
  73.     private:  
  74.         // 事件监听器  
  75.         evconnlistener* _listener;  
  76.         // 监听的IP  
  77.         std::string _listen_ip;  
  78.         // 监听的端口  
  79.         unsigned short _listen_port;  
  80.         // 监听的套接字  
  81.         SOCKET _listen_fd;  
  82.         // 连接器  
  83.         TCPServerSignal* _pTCPServerSignal;  
  84.     };  
  85.       
  86. }  
  87.   
  88. #endif /* defined(__ServerWorker_H_) */  

ServerWorker.cpp
[cpp]   view plain  copy
  1. //  
  2. //  ServerWorker.cpp  
  3. //  Frame  
  4. //  
  5. //  Created by chenjianjun on 15/9/7.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #include "ServerWorker.h"  
  10. #include "NetFrame.h"  
  11.   
  12. namespace NAME_SPACE {  
  13.       
  14.     // 客户端连接事件回调处理函数  
  15.     static void ListenerEventCb(evconnlistener *listener, evutil_socket_t fd,  
  16.                                 sockaddr *sa, int socklen, void *user_data) {  
  17.         ServerWorker *pServerWorker = (ServerWorker*)user_data;  
  18.         struct linger l;  
  19.         l.l_onoff = 1;  
  20.         l.l_linger = 0;  
  21.         setsockopt(fd, SOL_SOCKET, SO_LINGER, (void*)&l, sizeof(l));  
  22.         pServerWorker->Accept(fd, (struct sockaddr_in *)sa);  
  23.     }  
  24.       
  25.     // 监听失败回调处理函数  
  26.     static void ListenerErrorCb(struct evconnlistener *listener, void *user_data) {  
  27.         ServerWorker* pServerWorker = (ServerWorker*)user_data;  
  28.         pServerWorker->AcceptError(pServerWorker->GetFd(),ENE_ACCEPT_ERROR);  
  29.                                    //evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR()));  
  30.     }  
  31.       
  32.     ServerWorker::ServerWorker(std::string listen_ip, int listen_port)  
  33.     :_listen_ip(listen_ip),  
  34.     _listen_port(listen_port),  
  35.     _listener(nullptr),  
  36.     _pTCPServerSignal(nullptr) {}  
  37.       
  38.     ServerWorker::ServerWorker(int listen_port)  
  39.     :_listen_port(listen_port),  
  40.     _listener(nullptr),  
  41.     _pTCPServerSignal(nullptr) {  
  42.         _listen_ip.clear();  
  43.     }  
  44.       
  45.     bool ServerWorker::StartWork(TCPServerSignal* pTCPServerSignal) {  
  46.           
  47.         if (_listener) {  
  48.             return false;  
  49.         }  
  50.           
  51.         sockaddr_in sin;  
  52.         memset(&sin, 0, sizeof(sin));  
  53.         sin.sin_family = AF_INET;  
  54.         if (!_listen_ip.empty()) { sin.sin_addr.s_addr = ::inet_addr(_listen_ip.c_str()); }  
  55.         sin.sin_port = htons(_listen_port);  
  56.           
  57.         _listener = evconnlistener_new_bind(NetFrame::_base,  
  58.                                             ListenerEventCb,  
  59.                                             (void*)this,  
  60.                                             LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,  
  61.                                             -1,  
  62.                                             (sockaddr*)&sin,  
  63.                                             sizeof(sockaddr_in));  
  64.         if( nullptr == _listener ) {  
  65.             LOG(ERROR)<<"创建监听器失败,IP["<<_listen_ip<<":"<<_listen_port<<"]";  
  66.             return false;  
  67.         }  
  68.           
  69.         _pTCPServerSignal = pTCPServerSignal;  
  70.           
  71.         // 设置监听失败回调  
  72.         evconnlistener_set_error_cb(_listener, ListenerErrorCb);  
  73.           
  74.         // 获取监听的套接字句柄  
  75.         _listen_fd = evconnlistener_get_fd(_listener);  
  76.           
  77.         return true;  
  78.     }  
  79.       
  80.     void ServerWorker::StopWork()  
  81.     {  
  82.         if (_listener) {  
  83.             evconnlistener_free(_listener);  
  84.             _listener = nullptr;  
  85.         }  
  86.     }  
  87.       
  88.     void ServerWorker::Accept(int fd, struct sockaddr_in *sa) {  
  89.         if (_pTCPServerSignal) {  
  90.             _pTCPServerSignal->SignalAccept(fd, sa);  
  91.         }  
  92.     }  
  93.       
  94.     void ServerWorker::AcceptError(int fd, EM_NET_EVENT msg) {  
  95.         if (_pTCPServerSignal) {  
  96.             _pTCPServerSignal->SignalAcceptError(fd, msg);  
  97.         }  
  98.     }  
  99.       
  100. }  

被动客户端连接类

PassiveTCPClient.h

[cpp]   view plain  copy
  1. //  
  2. //  PassiveTCPClient.h  
  3. //  Frame  
  4. //  
  5. //  Created by chenjianjun on 15/9/7.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #ifndef __PassiveTCPClient_H_  
  10. #define __PassiveTCPClient_H_  
  11.   
  12. #include   
  13. #include   
  14. #include   
  15. #include "NetSignal.h"  
  16.   
  17. namespace NAME_SPACE {  
  18.       
  19.     class PassiveTCPClient {  
  20.           
  21.     public:  
  22.         /** 
  23.          *  @brief  构造函数 
  24.          * 
  25.          *  @param  SOCKET 套接字句柄 
  26.          *  @param  sockaddr_in* 客户端地址 
  27.          *  @param  short 心跳时间 
  28.          * 
  29.          *  @return 
  30.          */  
  31.         PassiveTCPClient(SOCKET fd, struct sockaddr_in* sa, short heart_time = 10);  
  32.         ~PassiveTCPClient();  
  33.           
  34.         /** 
  35.          *  @brief  启动工作 
  36.          * 
  37.          *  @param 
  38.          * 
  39.          *  @return 
  40.          */  
  41.         bool StartWork(TCPClientSignal*);  
  42.           
  43.         /** 
  44.          *  @brief  停止工作 
  45.          * 
  46.          *  @param 
  47.          * 
  48.          *  @return 
  49.          */  
  50.         void StopWork();  
  51.           
  52.         /** 
  53.          *  @brief  发送数据 
  54.          * 
  55.          *  @paramv char* 数据 
  56.          *  @paramv size_t 数据长度 
  57.          * 
  58.          *  @return 
  59.          */  
  60.         int SendData(void* pdata, size_t len);  
  61.           
  62.         SOCKET GetFd() { return _fd; }  
  63.         void SetHeartFlg(bool flg) { _heart_flg = flg; }  
  64.         bool GetHeartFlg() { return _heart_flg; }  
  65.           
  66.     public:  
  67.           
  68.         /** 
  69.          *  @brief  接收数据，此函数外部禁止调用，用于event事件回调函数调用 
  70.          * 
  71.          *  @param  void* 数据 
  72.          *  @param  size_t 数据长度 
  73.          */  
  74.         void PutRecvData(void*, size_t);  
  75.   
  76.         /** 
  77.          *  @brief  事件处理，此函数外部禁止调用，用于event事件回调函数调用 
  78.          * 
  79.          *  @param  short 事件集合 
  80.          */  
  81.         void ProcEvent(short events);  
  82.           
  83.     public:  
  84.         /* 
  85.          连接器类,这个分离很重要,如果不分离会出现小概率崩溃现象,主要是连接函数在调用的时候回调函数里面， 
  86.          如果外部删除这个对象会出现内存访问异常，具体看实现（那里是一个自动锁实现,崩溃也在自动锁释放那里） 
  87.          */  
  88.         TCPClientSignal* _pTCPClientSignal;  
  89.   
  90.     private:  
  91.         // 客户端IP  
  92.         std::string _client_ip;  
  93.         // 客户端端口  
  94.         unsigned short _client_port;  
  95.         // 套接字句柄  
  96.         SOCKET _fd;  
  97.         // 心跳时间  
  98.         short _heart_time;  
  99.         // bufferevent  
  100.         struct bufferevent *_bev;  
  101.         // 心跳事件器  
  102.         struct event *_event;  
  103.         // 心跳标志  
  104.         volatile bool _heart_flg;  
  105.     };  
  106.       
  107. }  
  108.   
  109. #endif /* defined(__PassiveTCPClient_H_) */  

PassiveTCPClient.cpp
[cpp]   view plain  copy
  1. //  
  2. //  PassiveTCPClient.cpp  
  3. //  被动TCP客户端  
  4. //  
  5. //  Created by chenjianjun on 15/9/7.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #include "PassiveTCPClient.h"  
  10. #include "NetFrame.h"  
  11.   
  12. namespace NAME_SPACE {  
  13.       
  14.     void PassiveTCPTimeOutEventCb(evutil_socket_t fd, short, void *data) {  
  15.           
  16.         PassiveTCPClient *pPassiveTCPClient = (PassiveTCPClient*)data;  
  17.         if (pPassiveTCPClient->GetHeartFlg()) {  
  18.             // 超时清除标志  
  19.             pPassiveTCPClient->SetHeartFlg(false);  
  20.         } else {  
  21.             // 心跳超时回调  
  22.             pPassiveTCPClient->ProcEvent(BEV_EVENT_TIMEOUT);  
  23.         }  
  24.     }  
  25.       
  26.     void PassiveTCPReadEventCb(struct bufferevent *bev, void *data) {  
  27.           
  28.         PassiveTCPClient* pPassiveTCPClient = (PassiveTCPClient*)data;  
  29.           
  30.         static char databuf[40960];  
  31.         size_t datalen = 0;  
  32.         size_t nbytes;  
  33.           
  34.         while ((nbytes = evbuffer_get_length(bev->input)) > 0) {  
  35.             evbuffer_remove(bev->input, databuf+datalen, sizeof(databuf)-datalen);  
  36.             datalen += nbytes;  
  37.         }  
  38.           
  39.         // 有数据往来，设置标志  
  40.         pPassiveTCPClient->SetHeartFlg(true);  
  41.           
  42.         // 数据接收回调  
  43.         pPassiveTCPClient->PutRecvData(databuf, datalen);  
  44.     }  
  45.       
  46.     void PassiveTCPEventCb(struct bufferevent *bev, short events, void *data) {  
  47.           
  48.         PassiveTCPClient* pPassiveTCPClient = (PassiveTCPClient*)data;  
  49.           
  50.         // 处理事件  
  51.         pPassiveTCPClient->ProcEvent(events);  
  52.     }  
  53.       
  54.     PassiveTCPClient::PassiveTCPClient(SOCKET fd, struct sockaddr_in* sa, short heart_time)  
  55.     :_fd(fd),  
  56.     _client_ip(inet_ntoa(sa->sin_addr)),  
  57.     _client_port(ntohs(sa->sin_port)),  
  58.     _bev(nullptr),  
  59.     _heart_flg(false),  
  60.     _heart_time(heart_time),  
  61.     _pTCPClientSignal(nullptr)  
  62.     {}  
  63.       
  64.     PassiveTCPClient::~PassiveTCPClient() {  
  65.         StopWork();  
  66.         _pTCPClientSignal = nullptr;  
  67.     }  
  68.       
  69.     bool PassiveTCPClient::StartWork(TCPClientSignal* pTCPClientSignal) {  
  70.           
  71.         if (_bev) {  
  72.             return false;  
  73.         }  
  74.           
  75.         _bev = bufferevent_socket_new(NetFrame::_base,  
  76.                                       _fd,  
  77.                                       BEV_OPT_CLOSE_ON_FREE|BEV_OPT_THREADSAFE);  
  78.         if (_bev == nullptr) {  
  79.             return false;  
  80.         }  
  81.           
  82.         _event = event_new(NetFrame::_base,  
  83.                            _fd,  
  84.                            EV_TIMEOUT|EV_PERSIST,  
  85.                            PassiveTCPTimeOutEventCb, this);  
  86.         if (_event == nullptr) {  
  87.             bufferevent_free(_bev);  
  88.             _bev = nullptr;  
  89.             return false;  
  90.         }  
  91.           
  92.         _pTCPClientSignal = pTCPClientSignal;  
  93.         // 设置心跳检测时间  
  94.         struct timeval timeout = {_heart_time, 0};  
  95.         event_add(_event, &timeout);  
  96.           
  97.         bufferevent_setcb(_bev, PassiveTCPReadEventCb, nullptr, PassiveTCPEventCb, this);  
  98.         bufferevent_enable(_bev, EV_READ);  
  99.           
  100.         return true;  
  101.     }  
  102.       
  103.     void PassiveTCPClient::StopWork() {  
  104.           
  105.         if (_bev) {  
  106.             bufferevent_disable(_bev, EV_READ);  
  107.             bufferevent_free(_bev);  
  108.             _bev = nullptr;  
  109.         }  
  110.           
  111.         if (_event) {  
  112.             event_del(_event);  
  113.             event_free(_event);  
  114.             _event = nullptr;  
  115.         }  
  116.           
  117.         // 不要对_pPassiveTCPClientSignal置null，释放由外部传入者负责  
  118.     }  
  119.       
  120.     int PassiveTCPClient::SendData(void* pdata, size_t len) {  
  121.           
  122.         if (_bev == nullptr) {  
  123.             return FUNC_FAILED;  
  124.         }  
  125.   
  126.         if (bufferevent_write(_bev, pdata, len) < 0) {  
  127.             return FUNC_FAILED;  
  128.         }  
  129.           
  130.         return FUNC_SUCCESS;  
  131.     }  
  132.       
  133.     void PassiveTCPClient::PutRecvData(void* data, size_t len) {  
  134.           
  135.         if (_pTCPClientSignal) {  
  136.             _pTCPClientSignal->SignalRecvData(_fd, data, len);  
  137.         }  
  138.     }  
  139.       
  140.     void PassiveTCPClient::ProcEvent(short events) {  
  141.           
  142.         if (!_pTCPClientSignal) {  
  143.             return;  
  144.         }  
  145.           
  146.         if (events & BEV_EVENT_CONNECTED) {  
  147.             _pTCPClientSignal->SignalEvent(_fd, ENE_CONNECTED);  
  148.         }  
  149.           
  150.         if(events & (BEV_EVENT_READING | BEV_EVENT_WRITING | BEV_EVENT_EOF | BEV_EVENT_ERROR | BEV_EVENT_TIMEOUT))  
  151.         {  
  152.              _pTCPClientSignal->SignalEvent(_fd, ENE_CLOSE);  
  153.         }  
  154.           
  155.     }  
  156. }  

主动客户端连接类

ActiveTCPClient.h

[cpp]   view plain  copy
  1. //  
  2. //  ActiveTCPClient.h  
  3. //  Frame 主动TCP客户端连接类  
  4. //  
  5. //  Created by chenjianjun on 15/9/8.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #ifndef __ActiveTCPClient_H_  
  10. #define __ActiveTCPClient_H_  
  11.   
  12. #include   
  13. #include   
  14. #include "NetSignal.h"  
  15. #include "RWLock.h"  
  16.   
  17. namespace NAME_SPACE {  
  18.       
  19.     class ActiveTCPClient {  
  20.           
  21.     public:  
  22.         explicit ActiveTCPClient(std::string host_name,  
  23.                                  unsigned short host_port,  
  24.                                  short heart_time = 10);  
  25.           
  26.         ~ActiveTCPClient();  
  27.           
  28.         void SetTCPClientSignal(TCPClientSignal* pTCPClientSignal) { _pTCPClientSignal = pTCPClientSignal;}  
  29.         /** 
  30.          *  @brief  启动工作 
  31.          * 
  32.          *  @param 
  33.          * 
  34.          *  @return 
  35.          */  
  36.         bool StartWork();  
  37.           
  38.         /** 
  39.          *  @brief  停止工作 
  40.          * 
  41.          *  @param 
  42.          * 
  43.          *  @return 
  44.          */  
  45.         void StopWork();  
  46.           
  47.         /** 
  48.          *  @brief  发送数据 
  49.          * 
  50.          *  @paramv char* 数据 
  51.          *  @paramv size_t 数据长度 
  52.          * 
  53.          *  @return 
  54.          */  
  55.         int SendData(void* pdata, size_t len);  
  56.           
  57.         SOCKET GetFd() { return _fd; }  
  58.         void SetHeartFlg(bool flg) { _heart_flg = flg; }  
  59.         bool GetHeartFlg() { return _heart_flg; }  
  60.         bool IsConnect() { return _connect_flg == 2;}  
  61.           
  62.     public:  
  63.         /** 
  64.          *  @brief  接收数据，此函数外部禁止调用，用于event事件回调函数调用 
  65.          * 
  66.          *  @param  void* 数据 
  67.          *  @param  size_t 数据长度 
  68.          */  
  69.         void PutRecvData(void*, size_t);  
  70.           
  71.         /** 
  72.          *  @brief  事件处理，此函数外部禁止调用，用于event事件回调函数调用 
  73.          * 
  74.          *  @param  short 事件集合 
  75.          */  
  76.         void ProcEvent(short events);  
  77.           
  78.     public:  
  79.         /* 
  80.          连接器类,这个分离很重要,如果不分离会出现小概率崩溃现象,主要是连接函数在调用的时候回调函数里面， 
  81.          如果外部删除这个对象会出现内存访问异常，具体看实现（那里是一个自动锁实现,崩溃也在自动锁释放那里） 
  82.          */  
  83.         TCPClientSignal* _pTCPClientSignal;  
  84.           
  85.     private:  
  86.         // 服务器监听地址  
  87.         std::string _host_name;  
  88.         // 服务器监听端口  
  89.         unsigned short _host_port;  
  90.         // bufferevent  
  91.         struct bufferevent *_bev;  
  92.         // 心跳检测时间  
  93.         short _heart_time;  
  94.         // socket连接句柄  
  95.         SOCKET _fd;  
  96.         // 心跳事件器  
  97.         struct event *_event;  
  98.         // 心跳标志  
  99.         volatile bool _heart_flg;  
  100.         // 读写锁  
  101.         RWLock* _m_rw_loacl;  
  102.         // 连接标志 0:未连接 1:连接中 2:已连接  
  103.         volatile unsigned char _connect_flg;  
  104.     };  
  105.       
  106. }  
  107.   
  108. #endif /* defined(__ActiveTCPClient_H_) */  

ActiveTCPClient.cpp
[cpp]   view plain  copy
  1. //  
  2. //  ActiveTCPClient.cpp  
  3. //  Frame  
  4. //  
  5. //  Created by chenjianjun on 15/9/8.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #include "ActiveTCPClient.h"  
  10. #include "NetFrame.h"  
  11.   
  12. namespace NAME_SPACE {  
  13.       
  14.     void ActiveTCPTimeOutEventCb(evutil_socket_t fd, short, void *data) {  
  15.         ActiveTCPClient* pActiveTCPClient = (ActiveTCPClient*)data;  
  16.         pActiveTCPClient->ProcEvent(BEV_EVENT_TIMEOUT);  
  17.     }  
  18.       
  19.     void ActiveTCPEventCb(struct bufferevent *bev, short events, void *data) {  
  20.         ActiveTCPClient* pActiveTCPClient = (ActiveTCPClient*)data;  
  21.         pActiveTCPClient->ProcEvent(events);  
  22.     }  
  23.       
  24.     void ActiveTCPReadEventCb(struct bufferevent *bev, void *data) {  
  25.           
  26.         ActiveTCPClient* pActiveTCPClient = (ActiveTCPClient*)data;  
  27.           
  28.         static char databuf[40960];  
  29.         size_t datalen = 0;  
  30.         size_t nbytes;  
  31.           
  32.         while ((nbytes = evbuffer_get_length(bev->input)) > 0) {  
  33.             evbuffer_remove(bev->input, databuf+datalen, sizeof(databuf)-datalen);  
  34.             datalen += nbytes;  
  35.         }  
  36.           
  37.         // 有数据往来，设置标志  
  38.         pActiveTCPClient->SetHeartFlg(true);  
  39.           
  40.         // 数据接收回调  
  41.         pActiveTCPClient->PutRecvData(databuf, datalen);  
  42.           
  43.     }  
  44.       
  45.     ActiveTCPClient::ActiveTCPClient(std::string host_name, unsigned short host_port, short heart_time)  
  46.     :_host_name(host_name),  
  47.     _host_port(host_port),  
  48.     _heart_time(heart_time),  
  49.     _bev(nullptr),  
  50.     _pTCPClientSignal(nullptr),  
  51.     _heart_flg(false),  
  52.     _event(nullptr),  
  53.     _connect_flg(0),  
  54.     _m_rw_loacl(RWLock::Create()) {  
  55.     }  
  56.       
  57.     ActiveTCPClient::~ActiveTCPClient() {  
  58.         StopWork();  
  59.         _pTCPClientSignal = nullptr;  
  60.         delete _m_rw_loacl;  
  61.     }  
  62.       
  63.     bool ActiveTCPClient::StartWork() {  
  64.           
  65.         WriteLockScoped wLock(*_m_rw_loacl);  
  66.           
  67.         if (_bev) {  
  68.             return false;  
  69.         }  
  70.           
  71.         _fd = socket(AF_INET, SOCK_STREAM, 0);  
  72.         evutil_make_socket_nonblocking(_fd);  
  73.         if (_fd < 0) {  
  74.             return false;  
  75.         }  
  76.           
  77.         _bev = bufferevent_socket_new(NetFrame::_base, _fd, BEV_OPT_CLOSE_ON_FREE|BEV_OPT_THREADSAFE);  
  78.         if (_bev == nullptr) {  
  79.             close(_fd);  
  80.             return false;  
  81.         }  
  82.           
  83.         struct sockaddr_in sSvrAddr;  
  84.         memset(&sSvrAddr, 0, sizeof(sSvrAddr));  
  85.         sSvrAddr.sin_family = AF_INET;  
  86.         sSvrAddr.sin_addr.s_addr = inet_addr(_host_name.c_str());  
  87.         sSvrAddr.sin_port = htons(_host_port);  
  88.         int addrlen = sizeof(struct sockaddr_in);  
  89.           
  90.         // 置为连接中状态  
  91.         _connect_flg = 1;  
  92.         if (bufferevent_socket_connect(_bev, (struct sockaddr*)&sSvrAddr, addrlen) < 0) {  
  93.             _connect_flg = 0;  
  94.             StopWork();  
  95.             return false;  
  96.         }  
  97.           
  98.         bufferevent_setcb(_bev, ActiveTCPReadEventCb, nullptr, ActiveTCPEventCb, this);  
  99.         bufferevent_enable(_bev, EV_READ);  
  100.           
  101.         return true;  
  102.     }  
  103.       
  104.     void ActiveTCPClient::StopWork() {  
  105.           
  106.         WriteLockScoped wLock(*_m_rw_loacl);  
  107.           
  108.         _connect_flg = 0;  
  109.         if (_event) {  
  110.             event_del(_event);  
  111.             event_free(_event);  
  112.             _event = nullptr;  
  113.         }  
  114.           
  115.         if (_bev) {  
  116.             bufferevent_disable(_bev, EV_READ);  
  117.             bufferevent_free(_bev);  
  118.             _bev = nullptr;  
  119.             _fd = -1;  
  120.         }  
  121.     }  
  122.       
  123.     int ActiveTCPClient::SendData(void* pdata, size_t len) {  
  124.           
  125.         LOG(INFO)<<"发送数据1..........";  
  126.         ReadLockScoped rLock(*_m_rw_loacl);  
  127.           
  128.         if (_bev == nullptr || _connect_flg != 2) {  
  129.             return FUNC_FAILED;  
  130.         }  
  131.   
  132.         if (bufferevent_write(_bev, pdata, len) < 0) {  
  133.             return FUNC_FAILED;  
  134.         }  
  135.           
  136. //        if (send(_fd, pdata, len, 0) < 0) {  
  137. //            return FUNC_FAILED;  
  138. //        }  
  139.           
  140.         LOG(INFO)<<"发送数据32..........";  
  141.           
  142.         return FUNC_SUCCESS;  
  143.           
  144.     }  
  145.       
  146.     void ActiveTCPClient::ProcEvent(short events) {  
  147.           
  148.         if (!_pTCPClientSignal) {  
  149.             return;  
  150.         }  
  151.           
  152.         if (events & BEV_EVENT_CONNECTED) {  
  153.               
  154.             // 已连接状态  
  155.             _connect_flg = 2;  
  156.             // 连接建立，开启心跳计数  
  157.             _event = event_new(NetFrame::_base,  
  158.                                _fd,  
  159.                                EV_TIMEOUT|EV_PERSIST,  
  160.                                ActiveTCPTimeOutEventCb,  
  161.                                this);  
  162.               
  163.             // 设置心跳检测时间  
  164.             struct timeval timeout = {_heart_time, 0};  
  165.             event_add(_event, &timeout);  
  166.               
  167.             _pTCPClientSignal->SignalEvent(_fd, ENE_CONNECTED);  
  168.               
  169.         } else if (events & (BEV_EVENT_READING|BEV_EVENT_WRITING|BEV_EVENT_EOF|BEV_EVENT_TIMEOUT)) {  
  170.             _pTCPClientSignal->SignalEvent(_fd, ENE_CLOSE);  
  171.         } else {  
  172.             _pTCPClientSignal->SignalEvent(_fd, EVE_UNKNOWN);  
  173.         }  
  174.           
  175.     }  
  176.       
  177.     void ActiveTCPClient::PutRecvData(void* data, size_t len) {  
  178.           
  179.         if (_pTCPClientSignal) {  
  180.             _pTCPClientSignal->SignalRecvData(_fd, data, len);  
  181.         }  
  182.           
  183.     }  
  184. }  

NetSignal.h
[html]   view plain  copy
  1. //  
  2. //  NetSignal.h  
  3. //  Frame  
  4. //  
  5. //  Created by chenjianjun on 15/9/8.  
  6. //  Copyright (c) 2015年 jsbn. All rights reserved.  
  7. //  
  8.   
  9. #ifndef __NetSignal_H_  
  10. #define __NetSignal_H_  
  11.   
  12. #include "Sigslot.h"  
  13. #include "Common.h"  
  14.   
  15. namespace NAME_SPACE {  
  16.       
  17.     class TCPServerSignal {  
  18.           
  19.     public:  
  20.         TCPServerSignal() {}  
  21.         ~TCPServerSignal() {}  
  22.           
  23.         // 客户端连接触发器  
  24.         sigslot::signal2<SOCKET , struct sockaddr_in*> SignalAccept;  
  25.         // 监听失败触发器  
  26.         sigslot::signal2<SOCKET , EM_NET_EVENT> SignalAcceptError;  
  27.     };  
  28.       
  29.     class TCPClientSignal {  
  30.           
  31.     public:  
  32.         TCPClientSignal() {}  
  33.         ~TCPClientSignal() {}  
  34.           
  35.         // 数据接收连接器  
  36.         sigslot::signal3<SOCKET, void*, size_t> SignalRecvData;  
  37.         // 套接字事件处理器  
  38.         sigslot::signal2<SOCKET, EM_NET_EVENT> SignalEvent;  
  39.     };  
  40.       
  41. }  
  42.   
  43. #endif /* defined(__NetSignal_H_) */  
借鉴了google的一个开源项目里面的sigslot机制，这里就不贴出来了，最后上一个测试代码
[cpp]   view plain  copy
  1. #include   
  2. #include   
  3. #include "NetFrame.h"  
  4. #include "ServerWorker.h"  
  5. #include "PassiveTCPClient.h"  
  6. #include "ActiveTCPClient.h"  
  7. #include "NetSignal.h"  
  8. #include "RWLock.h"  
  9.   
  10. using namespace NAME_SPACE;  
  11.   
  12. // 测试服务器  
  13. class TestServer : public sigslot::has_slots<>, public TCPClientSignal, public TCPServerSignal {  
  14.       
  15. public:  
  16.     TestServer() {  
  17.         pthread_mutex_init(&_work_mutex, nullptr);  
  18.     }  
  19.     ~TestServer() {  
  20.         pthread_mutex_destroy(&_work_mutex);  
  21.     }  
  22.       
  23.     int Start() {  
  24.           
  25.         _pServerWorker = new ServerWorker("192.168.1.74",8088);  
  26.           
  27.         SignalAccept.connect(this, &TestServer::Accept);  
  28.         SignalAcceptError.connect(this, &TestServer::Event);  
  29.         SignalRecvData.connect(this, &TestServer::RecvData);  
  30.         SignalEvent.connect(this, &TestServer::Event);  
  31.           
  32.         if (!_pServerWorker->StartWork(this)) {  
  33.             LOG(ERROR)<<"服务器监听启动失败";  
  34.             return FUNC_FAILED;  
  35.         }  
  36.           
  37.         return FUNC_SUCCESS;  
  38.     }  
  39.       
  40.     void Stop() {  
  41.           
  42.         _pServerWorker->StopWork();  
  43.           
  44.         pthread_mutex_lock(&_work_mutex);  
  45.         std::map::iterator it = _map_clients.begin();  
  46.         while (it != _map_clients.end()) {  
  47.             it->second->StopWork();  
  48.             delete it->second;  
  49.             _map_clients.erase(it++);  
  50.         }  
  51.         pthread_mutex_unlock(&_work_mutex);  
  52.           
  53.     }  
  54.       
  55.     int SendData(SOCKET fd, void* data, size_t len) {  
  56.           
  57.         pthread_mutex_lock(&_work_mutex);  
  58.         std::map::iterator it = _map_clients.find(fd);  
  59.         if (it != _map_clients.end()) {  
  60.             it->second->SendData(data, len);  
  61.         }  
  62.         pthread_mutex_unlock(&_work_mutex);  
  63.           
  64.         return 0;  
  65.     }  
  66.       
  67. public:  
  68.     // 数据接收  
  69.     void RecvData(SOCKET fd, void* data, size_t len) {  
  70.         // 接收到数据就回显，正常的程序师丢到队列里面去，让其他线程来处理  
  71.         SendData(fd, data, len);  
  72.     }  
  73.   
  74.     // 套接字事件处理器  
  75.     void Event(SOCKET fd, EM_NET_EVENT msg) {  
  76.           
  77.         LOG(ERROR)<<"收到事件通知."<< msg;  
  78.           
  79.         pthread_mutex_lock(&_work_mutex);  
  80.         std::map::iterator it = _map_clients.find(fd);  
  81.         if (it != _map_clients.end()) {  
  82.             it->second->StopWork();  
  83.             delete it->second;  
  84.             _map_clients.erase(it);  
  85.         }  
  86.         pthread_mutex_unlock(&_work_mutex);  
  87.           
  88.     }  
  89.   
  90.     // 客户端连接触发器  
  91.     void Accept(SOCKET fd, struct sockaddr_in* sa) {  
  92.           
  93.         LOG(ERROR)<<"收到客户端连接.";  
  94.           
  95.         pthread_mutex_lock(&_work_mutex);  
  96.           
  97.         std::map::iterator it = _map_clients.find(fd);  
  98.         if (it != _map_clients.end()) {  
  99.             it->second->StartWork(this);  
  100.             delete it->second;  
  101.             _map_clients.erase(it);  
  102.         }  
  103.           
  104.         PassiveTCPClient* pPassiveTCPClient = new PassiveTCPClient(fd, sa, 15);  
  105.         if (!pPassiveTCPClient->StartWork(this)) {  
  106.             LOG(ERROR)<<"启动客户端失败";  
  107.         } else {  
  108.             _map_clients[fd] = pPassiveTCPClient;  
  109.         }  
  110.           
  111.         pthread_mutex_unlock(&_work_mutex);  
  112.     }  
  113.       
  114. private:  
  115.     ServerWorker* _pServerWorker;  
  116.       
  117.     pthread_mutex_t _work_mutex;  
  118.     std::map _map_clients;  
  119. };  
  120.   
  121.   
  122. // 测试客户端  
  123. class TestClient : public sigslot::has_slots<>, public TCPClientSignal, public Runnable {  
  124.       
  125. public:  
  126.     TestClient():_is_run_flg(false) {  
  127.     }  
  128.       
  129.     ~TestClient() {  
  130.     }  
  131.       
  132.     int Start() {  
  133.         _pActiveTCPClient = new ActiveTCPClient("192.168.1.5", 8088, 15);  
  134.         _pActiveTCPClient->SetTCPClientSignal(this);  
  135.   
  136.         SignalEvent.connect(this, &TestClient::Event);  
  137.         SignalRecvData.connect(this, &TestClient::RecvData);  
  138.           
  139.         _is_run_flg = true;  
  140.         if (!_connect_thread.Start(this)) {  
  141.             _is_run_flg = false;  
  142.             delete _pActiveTCPClient;  
  143.             return FUNC_FAILED;  
  144.         }  
  145.           
  146.         return FUNC_SUCCESS;  
  147.     }  
  148.       
  149.     void Stop() {  
  150.           
  151.         if (_pActiveTCPClient) {  
  152.               
  153.             _is_run_flg = false;  
  154.             _connect_thread.Stop();  
  155.               
  156.             SignalEvent.disconnect(this);  
  157.             SignalRecvData.disconnect(this);  
  158.               
  159.             _pActiveTCPClient->StopWork();  
  160.               
  161.             delete _pActiveTCPClient;  
  162.             _pActiveTCPClient = nullptr;  
  163.         }  
  164.     }  
  165.       
  166.     int SendData(void* data,size_t len) {  
  167.           
  168.         if (_pActiveTCPClient) {  
  169.             _pActiveTCPClient->SendData(data, len);  
  170.         }  
  171.         return FUNC_SUCCESS;  
  172.     }  
  173.       
  174.     // 数据接收  
  175.     void RecvData(SOCKET fd, void* data, size_t len) {  
  176.         // 接收到数据就回显，正常的程序师丢到队列里面去，让其他线程来处理  
  177.         SendData(data, len);  
  178.     }  
  179.       
  180.     // 套接字事件处理器  
  181.     void Event(SOCKET fd, EM_NET_EVENT msg) {  
  182.           
  183.         if (msg == ENE_CONNECTED) {  
  184.         } else {  
  185.             _pActiveTCPClient->StopWork();  
  186.         }  
  187.           
  188.     }  
  189.       
  190. protected:  
  191.     virtual void Run(void* arg) {  
  192.           
  193.         //TestClient* p = (TestClient*)arg;  
  194.           
  195.         while (_is_run_flg) {  
  196.               
  197.             if (!_pActiveTCPClient->IsConnect()) {  
  198.                 _pActiveTCPClient->StartWork();  
  199.             }  
  200.               
  201.             Thread::SleepMs(2000);  
  202.         }  
  203.     }  
  204.       
  205. private:  
  206.     ActiveTCPClient* _pActiveTCPClient;  
  207.     // 运行标志  
  208.     volatile bool _is_run_flg;  
  209.     // 连接检测线程  
  210.     Thread _connect_thread;  
  211.       
  212. };  
  213.   
  214. int main(int argc,char* argv[]) {  
  215.       
  216.     // 初期化网络  
  217.     if (NetFrame::Instance()->NetWorkInit() != FUNC_SUCCESS) {  
  218.         LOG(ERROR)<<"网络初期化失败....";  
  219.         return -1;  
  220.     }  
  221.       
  222. //    {  
  223. //        // 测试服务器  
  224. //        TestServer mTestServer;  
  225. //        mTestServer.Start();  
  226. //        sleep(200);// 模拟测试，休眠10分钟时间来测试整个网络库  
  227. //        mTestServer.Stop();  
  228. //    }  
  229.       
  230. //    {  
  231. //        // 测试客户端  
  232. //        TestClient mTestClient;  
  233. //        mTestClient.Start();  
  234. //        char buf[4] = "bye";  
  235. //        for (int i = 0; i < 200; ++i) {  
  236. //            memset(buf, 0x00, sizeof(buf));  
  237. //            sprintf(buf, "%03d", i);  
  238. //            sleep(1);  
  239. //            mTestClient.SendData(buf, 3);  
  240. //        }  
  241. //          
  242. //        mTestClient.Stop();  
  243. //    }  
  244.       
  245.     // 关闭网络  
  246.     NetFrame::Instance()->NetWorkExit();  
  247.       
  248.     return 0;  
  249. }  

测试代码被注释了，打开就可以测试.

这里把主要代码贴了出来，一些其他的代码可以看我的github项目:

https://github.com/chenjianjun571/cioforandroid.Git

https://github.com/chenjianjun571/cioforios.git


FROM: http://blog.csdn.net/cjj198561/article/details/48370933




你可能感兴趣的:(网络/libevent)

  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 2023-04-17|篮球女孩 长一木
    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • 《在战“疫”中成长致敬生活》观后感 梅子刘的刀
    （作者：周晨）今天上午，我看了“我是接班人”网络大课堂《在战役中成长致敬生活》。有很多人拿出自己攒下的钱，默默地捐给了武汉，有几千块钱的、有几万块钱的，也有十几万块钱的。连小朋友也把自己的压岁钱捐给了武汉。有名环卫工人把自己五年的积蓄全部捐给了武汉。有名外卖小哥为医护人员买鞋子送吃的。还有已经治愈出院的新型肺炎病人捐了400毫升的血浆。还有位叫大树的叔叔，虽然他没有钱，但是他地里有蔬菜，捐了几大卡
  • 中原焦点团队网络初中级30期阴丽丽坚持分享第三百八十八次2022.10.18分享 约练次数（74） 咨询师（6） 来访者（53） 观察者（15） 阴丽丽
    今天是忙碌的一天，一早起来，总想着找点把事情弄完，可总也弄不完。就这样弄着吧！孩子的事，自己的事都在那里搁置着，不想做，有点欧！今天总体还不错，只是在下午起床时走神了俩小时，也算是给自己的放松吧！今日难得1.儿子乖巧、听话，努力配合，一天下来也是忙忙碌碌，这真的很难得！2.儿子今天录的视频被班主任认可，这真的很难得3.我今天早上做核酸时，自己把教案整了一下，这真的很难得
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 多子女家庭问题 3e5c5362403c
    杨宁宁焦点解决网络初17中19坚持分享589天（2021.3.20）本周约练我1次，总计166次，读书打卡第256天案例督导收获：【家有老大篇】被爱与高期待下的独舞家里的第一个孩子往往集万千宠爱于一身。爸爸妈妈、爷爷奶奶、姥姥姥爷的目光都聚焦在他的身上。在这种光环下长大的孩子，就如小皇帝一般，衣来伸手、饭来张口。拥有爱的同时，也意味着拥有了更高的被期待，父母会花血本给你报各种各样的早教班，给你买各
  • 父母教育孩子的方式，将影响孩子一生 树英教育
    为什么有些孩子总是充满自信与快乐？独立、有主见又坚强？而有些孩子却自卑、胆怯，软弱又过度依赖父母？为什么有些孩子总是健康、阳光又富于创造力？而有些孩子却悲观、孤僻又思想空乏？一个孩子的行为取决于孩子的思想，思想取决于环境和自己的认知，认知取决于教育。父母是孩子人生中的第一位教育者，父母养育孩子的方式，将决定他们人生的高度，影响他们的一生。网络图，侵权即删优秀的父母就像园丁，既要浇水施肥，又要修剪杂
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • 戴容容 中原焦点团队.网络初级第33期,坚持分享第19天 2022年3月9日 TessDai
    《每个人眼中的世界都是不同的》“一千个人眼里有一千个哈姆雷特”世界是多元的,每个人都有自己的道理,人人按照自己的理解去看待这个世界的人和物.我们如此,其他人也是如此.因此,任何事情,我们要放下自己以为的真理,去理解他人认为的真理,只有同频方能共振.孩子在慢慢长大的过程中慢慢学会独立,甚至对抗.尤其当孩子处于青春期的时候,他们开始有很多自己独立的想法,和一些特立独行的做法,家长常常会觉得不可思议,觉
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • 网络通信流程 记得开心一点啊 服务器网络运维
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • 计算机木马详细编写思路 小熊同学哦 php开发语言木马木马思路
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
  • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 errorreactmongodb数据库
    背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
  • 高考后该不该给孩子买电脑，什么情况能买？什么情况不能买？ 寻求改变
    我知道家长们很担心，怕买了电脑小孩沉迷游戏，耽误了学业，也不利于身体健康。对于准大学生来说，基本上在18岁左右，也不算小了，但在很多父母眼里，依旧是个小孩子。数据显示，这种情况是有发生的，大学生约70%的电脑主要被用于玩网络游戏，如果没有养成一个用良好的习惯，对孩子影响是非常大的。我总结为三买，三不买。最近有看到群里很多家长再问，小孩上大学该不该给他买电脑，要买和不买两种观点的家长都有，那么哪种情
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • 中国广电永久9元流量套餐！性价比最高流量卡套餐介绍！ 优惠攻略官
    中国广电是中国最大的传媒集团之一，其推出的流量套餐备受消费者青睐。中国广电最实惠的流量套餐不仅价格亲民，而且提供了优质的网络体验。首先，中国广电的流量套餐价格实惠，适合不同消费者的需求。无论是短期的日租卡还是长期有效的月租卡，用户都可以根据自己的实际情况选择适合自己的套餐。而且，流量的价格相对于其他运营商的套餐来说更加合理，给用户提供了更大的选择空间。☞大流量卡套餐「→点这免费申请办理」或者截图扫
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 4 大低成本娱乐方式: 小说, 音乐, 视频, 电子游戏 穷人小水滴 娱乐音视频低成本小说游戏
    穷人如何获得快乐?小说,音乐,视频,游戏,本文简单盘点一下这4大低成本(安全)娱乐方式.这里是穷人小水滴,专注于穷人友好型低成本技术.(本文为58号作品.)目录1娱乐方式1.1小说(网络小说)1.2音乐1.3视频(b站)1.4游戏(电子游戏/计算机软件)2低成本:一只手机即可3总结与展望1娱乐方式这几种,也可以说是艺术的具体形式.更专业的说,(娱乐)是劳动力再生产的重要组成部分.使人放松,获得快乐
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • 计算机网络八股总结 Petrichorzncu 八股总结计算机网络笔记
    这里写目录标题网络模型划分（五层和七层）及每一层的功能五层网络模型七层网络模型（OSI模型）==三次握手和四次挥手具体过程及原因==三次握手四次挥手TCP/IP协议组成==UDP协议与TCP/IP协议的区别==Http协议相关知识网络地址，子网掩码等相关计算网络模型划分（五层和七层）及每一层的功能五层网络模型应用层：负责处理网络应用程序，如电子邮件、文件传输和网页浏览。主要协议包括HTTP、FTP
  • 每日头像|爱与时光，终年不遇 一宝先生
    小可爱们晚上好呀今天晚上来推送一期情侣头像~喜欢的小可爱可以点赞收藏评论哟~部分素材来自网络，版权归原创者，如有侵权请联系删除今天的头像结束啦喜欢的小可爱可以点下关注哟~如果喜欢本期的内容可以转发分享哦~那我们下期再见咯~拜了个拜~
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开 摸鱼小号 php
    可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
  • 年的味道~ 心理疗愈师英子
    小时候，最期盼过年，一想到过年有压岁钱拿、有新衣服穿、不用上学还有好东西吃，就兴奋不已。可是不知道从什么时候开始，很多人那种儿时满怀期待过年的感觉没有了，对年的期盼也越来越少。现在物质极大丰富，以前过年才有的丰盛年夜饭，现在几乎已成家常便饭，对过年有好东西吃的期盼没了。现在网络购物发达，服装店也遍布大街小巷，随时都可以添置新衣服，而不必非要等到过年，儿时那种大年初一从头新到脚的仪式感没有了。放鞭炮
  • 2021-07-09 2018心如止水
    张雲芳焦点解决网络课程学习坚持分享第816天20210709本周第2次（约练总291）渴了喝水；饿了吃饭；累了休息。看似简单的选择与行为，做起来却没那么容易。尤其是作为成年人，每天有工作需要完成，有孩子、家人需要陪伴，有时候各种事情赶在一起，忙的晕头转向、焦头烂额，即使自己特别累，也没有间隙去休息一下下，想象一下身体疲惫，精力耗竭是什么样的状态？对于孩子的哭闹你还会有更多的耐心吗？我想多数情况下都
  • 寓美于心 琴韵无声
    今天是“语文湿地2021网络年会”第一天。年会早上七点在尹东老师和王君老师的激情开幕致辞中开始。一天下来听了八节课，真是“八仙过海，各显神通。”精彩纷呈。愚笨如我，真的是找不出一个恰切的词来形容她们的美妙绝伦。今天一口气吃下了饕餮盛宴，留待日后慢慢反刍吧。今天的压轴大戏是王君老师的《若爱，深深爱；若写，深情写》——跟《土地的誓言》学意象铺排”艺术。又加上是最后一节听的，印象最为深刻。凭着印象先略记
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • ASM系列六 利用TreeApi 添加和移除类成员 lijingyao8206 jvm动态代理ASM字节码技术TreeAPI
        同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。   package asm.core; /** * Created by yunshen.ljy on 2015/6/
  • Springmvc-权限设计 bee1314 springWebjsp
    万丈高楼平地起。 权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 目标： 1.实现权限的管理（CRUD） 2.实现部门管理 （CRUD) 3.实现人员的管理 （CRUD） 4.实现部门和权限
  • 算法竞赛入门经典（第二版）第2章习题 CrazyMizzz c算法
    2.4.1 输出技巧 #include <stdio.h> int main() { int i, n; scanf("%d", &n); for (i = 1; i <= n; i++) printf("%d\n", i); return 0; } 习题2-2 水仙花数(daffodil
  • struts2中jsp自动跳转到Action 麦田的设计者 jspwebxmlstruts2自动跳转
    1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士）   2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
  • php 操作webservice实例 IT独行者 PHPwebservice
    首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; OK 现在我们来体验webservice //server端 serve
  • Windows下使用Vagrant安装linux系统 _wy_ windowsvagrant
    准备工作： 下载安装 VirtualBox ：https://www.virtualbox.org/ 下载安装 Vagrant ：http://www.vagrantup.com/ 下载需要使用的 box ： 官方提供的范例：http://files.vagrantup.com/precise32.box 还可以在 http://www.vagrantbox.es/ 
  • 更改linux的文件拥有者及用户组(chown和chgrp) 无量 clinuxchgrpchown
    本文（转） http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/ http://ydlmlh.iteye.com/blog/1435157 一、基本使用： 使用chown命令可以修改文件或目录所属的用户：        命令
  • linux下抓包工具 矮蛋蛋 linux
    原文地址： http://blog.chinaunix.net/uid-23670869-id-2610683.html tcpdump -nn -vv -X udp port 8888 上面命令是抓取udp包、端口为8888 netstat -tln 命令是用来查看linux的端口使用情况 13 . 列出所有的网络连接 lsof -i 14. 列出所有tcp 网络连接信息 l
  • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起” alafqq mybatis
    最近看了  每一个用mybatis的男纸，你伤不起 原文地址 ：http://www.iteye.com/topic/1073938 发表一下个人看法。欢迎大神拍砖； 个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 发现多了一个mapper层；个人感觉就是个dao；
  • 解决java数据交换之谜 百合不是茶 数据交换
    交换两个数字的方法有以下三种 ，其中第一种最常用   /* 输出最小的一个数 */ public class jiaohuan1 { public static void main(String[] args) { int a =4; int b = 3; if(a<b){ // 第一种交换方式 int tmep =
  • 渐变显示 bijian1013 JavaScript
    <style type="text/css"> #wxf { FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98); height: 25px; } </style>
  • 探索JUnit4扩展：断言语法assertThat bijian1013 java单元测试assertThat
    一.概述         JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
  • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}} bit1129 gson
      如何把如下简单的JSON字符串反序列化为Java的POJO对象? {"data":{"IM":["MSN","QQ","Gtalk"]}}   下面的POJO类Model无法完成正确的解析：   import com.google.gson.Gson;
  • 【Kafka九】Kafka High Level API vs. Low Level API bit1129 kafka
    1. Kafka提供了两种Consumer API High Level Consumer API Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题  
  • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua
    Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
  • java-归并排序 bylijinnan java
    import java.util.Arrays; public class MergeSort { public static void main(String[] args) { int[] a={20,1,3,8,5,9,4,25}; mergeSort(a,0,a.length-1); System.out.println(Arrays.to
  • Netty源码学习-CompositeChannelBuffer bylijinnan javanetty
    CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 查看API（ http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 可以看到，所谓“Transparent Zero Copy”是通
  • Android中给Activity添加返回键 hotsunshine Activity
    // this need android:minSdkVersion="11" getActionBar().setDisplayHomeAsUpEnabled(true); @Override public boolean onOptionsItemSelected(MenuItem item) {
  • 静态页面传参 ctrain 静态
    $(document).ready(function () { var request = { QueryString : function (val) { var uri = window.location.search; var re = new RegExp("" + val + "=([^&?]*)", &
  • Windows中查找某个目录下的所有文件中包含某个字符串的命令 daizj windows查找某个目录下的所有文件包含某个字符串
    findstr可以完成这个工作。   [html]  view plain copy   >findstr /s /i "string" *.*   上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
  • 改善程序代码质量的一些技巧 dcj3sjt126com 编程PHP重构
    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
  • SharedPreferences对数据的存储 dcj3sjt126com
    SharedPreferences简介：                                                   &nbs
  • linux复习笔记之bash shell (2) bash基础 eksliang bashbash shell
    转载请出自出处： http://eksliang.iteye.com/blog/2104329 1.影响显示结果的语系变量（locale）  1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： [root@localhost shell]# locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8"
  • Android零碎知识总结 gqdy365 android
    1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
  • HoverTree.Model.ArticleSelect类的作用 hvt Web.netC#hovertreeasp.net
    ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
  • PHP 判断是否使用代理 PHP Proxy Detector 天梯梦 proxy
    1. php 类 I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to
  • apache的math库中的回归——regression（翻译） lvdccyb Mathapache
    这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。   数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。   基本覆盖了：线代，统计，矩阵， 最优化理论 曲线拟合 常微分方程 遗传算法（GA）， 还有3维的运算。。。
  • 基础数据结构和算法十三：Undirected Graphs (2) sunwinner Algorithm
      Design pattern for graph processing. Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
  • 云计算平台最重要的五项技术 sumapp 云计算云平台智城云
    云计算平台最重要的五项技术 1、云服务器 云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 特性 机型丰富 通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 仅需要几分钟，根据CP
  • 《京东技术解密》有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  12月试读活动回顾： http://webmaster.iteye.com/blog/2164754 本次技术图书试读活动获奖名单及相应作品如下： 一等奖（两名） Microhardest：http://microhardest.ite
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他