基于ACE快速搭建轻量级应用程序编程框架（第二版）

ACE框架实现轻量级应用编程模型进阶

最新推荐文章于 2025-07-07 10:32:29 发布

ishow99

最新推荐文章于 2025-07-07 10:32:29 发布

阅读量1.8k

点赞数

CC 4.0 BY-SA版权

分类专栏： ACE应用文章标签：框架编程 buffer server exception file

本文链接：https://blog.youkuaiyun.com/ishow99/article/details/5935227

ACE应用专栏收录该内容

8 篇文章

订阅专栏

本文是基于《基于ACE快速搭建轻量级应用程序编程框架（第一版）》的延续，深入探讨如何利用ACE库的Acceptor & Connector设计模式构建适用于Socket应用的双工单路服务端和客户端。文章详细介绍了TaskSend和TaskRecv任务类，用于处理发送和接收数据队列，并展示了TaskServer和TaskClient如何通过ACE_Acceptor和ACE_Connector进行连接和通信。此外，还提供了一个简单的App1应用示例，展示如何整合这些组件并配置定时任务。

本篇基于上一篇《基于ACE快速搭建轻量级应用程序编程框架（第一版）》的基础，进一步完善早期实现的ACE Acceptor & Connector设计模式，比较适用于各种基于Socket的应用程序搭建；

文章中涉及的通用类请参考《基于ACE快速搭建轻量级应用程序编程框架（第一版）》中的快速链接，这里不再重复贴出来了；

TaskDefined.h

#ifndef _ACCEPTOR_CONNECTOR_h #define _ACCEPTOR_CONNECTOR_h #include <stdio.h> #include <stdlib.h> #include <string> #include <list> #include <vector> #include <ace/OS.h> #include <ace/Synch.h> #include <ace/Task.h> #include <ace/Reactor.h> #include <ace/Svc_Handler.h> #include <ace/Message_Block.h> #include <ace/INET_Addr.h> #include <ace/SOCK_Stream.h> #include <ace/SOCK_Connector.h> #include <ace/Connector.h> #include <ace/SOCK_Acceptor.h> #include <ace/Acceptor.h> #include "ffcs_common.h" #include "ffcs_logger.h" #define INPUT_SIZE (4 KB) /*接收数据缓冲区大小*/ #define RECV_HIGHT_MARK (2 MB) /*接收队列高水位标*/ #define SEND_HIGHT_MARK (2 MB) /*发送队列高水位标*/ #define MSG_HEAD_MODE 0 /*表示是否采用消息头模式，0:表示不使用，1:表示使用*/ #define MSG_HEAD_SIZE 12 /**********************************************************************************************************************************/ class TaskSend; class TaskRecv; class TaskServer; class TaskClient; typedef ACE_Acceptor <TaskServer, ACE_SOCK_ACCEPTOR> ServerAcceptor; typedef ACE_Connector<TaskClient, ACE_SOCK_CONNECTOR> ClientConnector; /**********************************************************************************************************************************/ /******************************************************************************************** * 采用ACE_Task任务或主动对象处理模式，处理服务器向客户端发送的数据队列 ********************************************************************************************/ class TaskSend: public ACE_Task<ACE_MT_SYNCH> { public: TaskSend() : active_(false), task_peer_(NULL) { this->active_ = false; this->msg_queue()->high_water_mark(SEND_HIGHT_MARK); } virtual ~TaskSend() { this->active_ = false; this->msg_queue()->close(); } virtual int svc(void); bool run_active(); void run_active(bool b); private: bool active_; void process_send(ACE_Message_Block *mb = NULL); ACE_Task<ACE_MT_SYNCH> * task_peer_; public: ACE_Task<ACE_MT_SYNCH> * task_peer(); void task_peer(ACE_Task<ACE_MT_SYNCH> *_task_peer_); int send_msg(const char * _buf, size_t _size); }; /******************************************************************************************** * 采用ACE_Task任务或主动对象处理模式，处理服务器接收到的客户端数据队列 ********************************************************************************************/ class TaskRecv: public ACE_Task<ACE_MT_SYNCH> { public: TaskRecv() : active_(false), task_send_(NULL) { this->active_ = false; this->msg_queue()->high_water_mark(RECV_HIGHT_MARK); } virtual ~TaskRecv() { this->active_ = false; this->msg_queue()->close(); } virtual int svc(void); bool run_active(); void run_active(bool b); private: bool active_; void process_recv(ACE_Message_Block *mb = NULL); TaskSend * task_send_; public: TaskSend * task_send(); void task_send(TaskSend *_task_send); int send_msg(const char * _buf, size_t _size); }; /******************************************************************************************** * 采用ACE接受器（Acceptor）连接建立模式，实现双工单路服务端 ********************************************************************************************/ class TaskServer : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_MT_SYNCH> { typedef ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_MT_SYNCH> super; public: TaskServer(void); private: virtual ~TaskServer(void); public: // 在连接建立后被自动回调 virtual int open (void * = 0); // Called when input is available from the client. virtual int handle_input(ACE_HANDLE fd = ACE_INVALID_HANDLE); // Called when output is possible. virtual int handle_output(ACE_HANDLE fd = ACE_INVALID_HANDLE); // Called when a timer expires. virtual int handle_timeout (const ACE_Time_Value ¤t_time, const void *act = 0); // Called when this handler is removed from the ACE_Reactor. virtual int handle_close(ACE_HANDLE handle, ACE_Reactor_Mask close_mask); bool run_active(); void run_active(bool b); private: bool active_; TaskRecv task_recv; TaskSend task_send; /*回调函数，使用者在此实现对应功能*/ void start_0(); /*对等端接入后回调*/ void stop_0(); /*对等端关闭后回调*/ void timeout_0(); /*定时任务*/ public: int g_iServerInterval; /*定时任务间隔时间，单位：秒*/ int g_iServerRecvPoolSize; /*接收线程数*/ int g_iServerSendPoolSize; /*发送线程数*/ }; /******************************************************************************************** * 采用ACE连接器（Connector）连接建立模式，实现双工单路客户端 ********************************************************************************************/ class TaskClient : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_MT_SYNCH> { typedef ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_MT_SYNCH> super; public: TaskClient(void); private: virtual ~TaskClient(void); public: // 在连接建立后被自动回调 virtual int open (void * = 0); // Called when input is available from the client. virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE); // Called when output is possible. virtual int handle_output (ACE_HANDLE fd = ACE_INVALID_HANDLE); // Called when a timer expires. virtual int handle_timeout (const ACE_Time_Value ¤t_time, const void *act = 0); // Called when this handler is removed from the ACE_Reactor. virtual int handle_close(ACE_HANDLE handle, ACE_Reactor_Mask close_mask); bool run_active(); void run_active(bool b); private: bool active_; TaskRecv task_recv; TaskSend task_send; /*回调函数，使用者在此实现对应功能*/ void start_0(); /*对等端接入后回调*/ void stop_0(); /*对等端关闭后回调*/ void timeout_0(); /*定时任务*/ public: int g_iClientInterval; /*定时任务间隔时间，单位：秒*/ int g_iClientRecvPoolSize; /*接收线程数*/ int g_iClientSendPoolSize; /*发送线程数*/ }; /**********************************************************************************************************************************/ #endif

TaskRecv.cpp

/*================================================================================================== * 项目名称: 接收模式 * 功能: 接收数据并处理 * 作者: huangjf * 联系: huangjf@ffcs.cn * 最近修改: 2010-9-30 * 版本: v1.0.0 ==================================================================================================*/ #include <string> #include <ace/OS.h> #include <ace/Message_Block.h> #include "ffcs_common.h" #include "ffcs_logger.h" #include "TaskDefined.h" extern Logger g_logger; /*处理接收队列*/ int TaskRecv::svc(void) { g_logger.debug("TaskRecv::svc() start/n"); while (this->active_==true) { ACE_Message_Block *mb = NULL; if (this->getq(mb) == -1) { if (mb) mb->release(); continue; } if (this->active_ == true) { process_recv(mb); } mb->release(); } g_logger.debug("TaskRecv::svc() stop/n"); return 0; } /**********************************************************************************************************************************/ void TaskRecv::process_recv(ACE_Message_Block *mb) { char * data = mb->rd_ptr(); size_t data_size = mb->length(); g_logger.debug("TaskRecv Processing recv message, length %d/n", data_size); /**************************************************************** * TODO 处理接收到的对等端数据，数据的起始地址为data,长度为data_size *****************************************************************/ ACE_OS::sleep(3); /*如何发送的例子*/ send_msg(data, data_size); } /*向对等端发送数据，实际操作是向发送队列插入一条 ACE_Message_Block *返回 -1:失败 >=0:发送数据长度*/ int TaskRecv::send_msg(const char * _buf, size_t _size) { if (_size == 0) return 0; if (this->active_ != true) return -1; return this->task_send_->send_msg(_buf, _size); } /**********************************************************************************************************************************/ bool TaskRecv::run_active() { return this->active_; } void TaskRecv::run_active(bool b) { this->active_ = b; } TaskSend * TaskRecv::task_send() { return this->task_send_; } void TaskRecv::task_send(TaskSend *_task_send) { this->task_send_ = _task_send; }

TaskSend.cpp

/*================================================================================================== * 项目名称: 发送模式 * 功能: 处理数据并发送 * 作者: huangjf * 联系: huangjf@ffcs.cn * 最近修改: 2010-9-30 * 版本: v1.0.0 ==================================================================================================*/ #include <string> #include <ace/OS.h> #include <ace/Message_Block.h> #include "ffcs_common.h" #include "ffcs_logger.h" #include "TaskDefined.h" extern Logger g_logger; /*处理发送队列*/ int TaskSend::svc(void) { g_logger.debug("TaskSend::svc() start/n"); while (this->active_==true) { ACE_Message_Block *mb = NULL; if (this->getq(mb) == -1) { if (mb) mb->release(); continue; } if (this->active_ == true) { process_send(mb); } mb->release(); } g_logger.debug("TaskSend::svc() stop/n"); return 0; } /**********************************************************************************************************************************/ void TaskSend::process_send(ACE_Message_Block *mb) { char * data = mb->rd_ptr(); size_t data_size = mb->length(); g_logger.debug("TaskSend Processing recv message, length %d/n", data_size); ACE_Message_Block *mb_0 = NULL; ACE_NEW_NORETURN(mb_0, ACE_Message_Block(data_size+1)); ACE_OS::memcpy(mb_0->wr_ptr(), data, data_size); mb_0->wr_ptr(data_size); if (this->task_peer_->putq(mb_0) == -1) { if (mb_0) mb_0->release(); g_logger.error("TaskSend enqueue to Svc_Handler failed；discarding data！/n"); } this->task_peer_->reactor()->notify(this->task_peer_, ACE_Event_Handler::WRITE_MASK); } /*可以调用此方法向对等端发送数据，实际操作是向发送队列插入一条 ACE_Message_Block *返回 -1:失败 >=0:发送数据长度*/ int TaskSend::send_msg(const char * _buf, size_t _size) { if (_size == 0) return 0; if (this->active_ != true) return -1; ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(_size+1), -1); ACE_OS::memcpy(mb->wr_ptr(), _buf, _size); mb->wr_ptr(_size); if (this->putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskSend enqueue failed；discarding data！/n"); return -1; } return mb->length(); } /**********************************************************************************************************************************/ bool TaskSend::run_active() { return this->active_; } void TaskSend::run_active(bool b) { this->active_ = b; } ACE_Task<ACE_MT_SYNCH> * TaskSend::task_peer() { return this->task_peer_; } void TaskSend::task_peer(ACE_Task<ACE_MT_SYNCH> * _task_peer_) { this->task_peer_ = _task_peer_; }

TaskServer.cpp

/*================================================================================================== * 项目名称: 实现ACE_Acceptor设计模式 * 功能: 实现ACE_Acceptor服务端连接及数据收发功能 * 作者: huangjf * 联系: huangjf@ffcs.cn * 最近修改: 2010-9-30 * 版本: v1.0.1 ==================================================================================================*/ #include <string> #include <list> #include <vector> #include <ace/OS.h> #include <ace/Synch.h> #include <ace/Reactor.h> #include <ace/Svc_Handler.h> #include <ace/Message_Block.h> #include <ace/INET_Addr.h> #include <ace/SOCK_Stream.h> #include <ace/SOCK_Acceptor.h> #include <ace/Acceptor.h> #include "ffcs_common.h" #include "ffcs_logger.h" #include "ffcs_config.h" #include "app_main.h" #include "TaskDefined.h" extern Logger g_logger; TaskServer::TaskServer(void) : active_(false) { this->active_ = false; this->msg_queue()->high_water_mark(SEND_HIGHT_MARK); return; } TaskServer::~TaskServer(void) { this->active_ = false; this->msg_queue()->close(); return; } /*在连接建立后被自动回调*/ int TaskServer::open(void *p) { ACE_TCHAR peer_name[MAXHOSTNAMELEN]; ACE_INET_Addr peer_addr; if (this->peer().get_remote_addr(peer_addr) == 0 && peer_addr.addr_to_string (peer_name, MAXHOSTNAMELEN) == 0) { g_logger.message("***** Connection from %s on fd %d/n", peer_name, this->peer().get_handle()); } ConfigParameter <int> p_1(CONFIG_FILE, "SERVER", "SERVER_INTERVAL", 30, this->g_iServerInterval); ConfigParameter <int> p_2(CONFIG_FILE, "SERVER", "SERVER_RECV_POOL_SIZE", 8, this->g_iServerRecvPoolSize); ConfigParameter <int> p_3(CONFIG_FILE, "SERVER", "SERVER_SEND_POOL_SIZE", 1, this->g_iServerSendPoolSize); this->active_ = true; this->task_recv.task_send(&task_send); this->task_recv.run_active(true); if (this->task_recv.activate(THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, this->g_iServerRecvPoolSize) == -1) { g_logger.error("Server TaskRecv activate failed/n"); return -1; } this->task_send.task_peer((ACE_Task<ACE_MT_SYNCH> *)this); this->task_send.run_active(true); if (this->task_send.activate(THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, this->g_iServerSendPoolSize) == -1) { g_logger.error("Server TaskSend activate failed/n"); return -1; } /*回调*/ this->start_0(); /*开启定时处理线程*/ ACE_Time_Value tvDelay(3, 0), tvInterval(this->g_iServerInterval); this->reactor()->schedule_timer(this, 0, tvDelay, tvInterval); return super::open(p); } /*服务端接收到客户端发送的数据后，回调此函数*/ int TaskServer::handle_input(ACE_HANDLE) { char buffer[INPUT_SIZE] = {0}; ssize_t recv_cnt = 0; #if (MSG_HEAD_MODE==1) /*接收消息头模式*/ /**************************************************************** * TODO 根据实际消息头格式修改解析方法 *****************************************************************/ ssize_t msg_len = 0; recv_cnt = 0; try { recv_cnt = this->peer().recv(buffer, MSG_HEAD_SIZE); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (recv_cnt > 0 && recv_cnt == MSG_HEAD_SIZE) { /************************* * TODO 注意这里的4个字节 **************************/ msg_len = SET_BYTE4(buffer[0]&0xFF) + SET_BYTE3(buffer[1]&0xFF) + SET_BYTE2(buffer[2]&0xFF) + SET_BYTE1(buffer[3]&0xFF); if (msg_len < INPUT_SIZE) { g_logger.debug("Server receive message，length (%d)；/n", msg_len); } else { g_logger.warn("Server receive message，length (%d)；warning!!! out of range/n", msg_len); } if (msg_len >= MSG_HEAD_SIZE && msg_len < INPUT_SIZE) { if (msg_len == MSG_HEAD_SIZE) { ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(msg_len+1), -1); ACE_OS::memcpy(mb->wr_ptr(), buffer, msg_len); mb->wr_ptr(msg_len); if (this->task_recv.putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskServer enqueue to TaskRecv failed；discarding data！/n"); return 0; } /*打印*/ g_logger.dump(buffer, msg_len, 1); return 0; } else { recv_cnt = 0; try { recv_cnt = this->peer().recv(buffer+MSG_HEAD_SIZE, (msg_len-MSG_HEAD_SIZE)); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (recv_cnt > 0 && recv_cnt == (msg_len-MSG_HEAD_SIZE)) { ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(msg_len+1), -1); ACE_OS::memcpy(mb->wr_ptr(), buffer, msg_len); mb->wr_ptr(msg_len); if (this->task_recv.putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskServer enqueue to TaskRecv failed；discarding data！/n"); return 0; } /*打印*/ g_logger.dump(buffer, msg_len, 1); return 0; } if (recv_cnt <= 0 || ACE_OS::last_error() != EWOULDBLOCK) { this->active_ = false; g_logger.warn("Server Connection closed.2 on fd %d/n", this->peer().get_handle()); /*表示客户端已断开*/ return -1; } } } return 0; } if (recv_cnt <= 0 || ACE_OS::last_error() != EWOULDBLOCK) { this->active_ = false; g_logger.warn("Server Connection closed.1 on fd %d/n", this->peer().get_handle()); /*表示客户端已断开*/ return -1; } #else /*不接收消息头模式*/ recv_cnt = 0; try { recv_cnt = this->peer().recv(buffer, sizeof(buffer)); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (recv_cnt > 0) { ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(recv_cnt+1), -1); ACE_OS::memcpy(mb->wr_ptr(), buffer, recv_cnt); mb->wr_ptr(recv_cnt); if (this->task_recv.putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskServer enqueue to TaskRecv failed；discarding data！/n"); return 0; } /*打印*/ g_logger.dump(buffer, recv_cnt, 1); return 0; } if (recv_cnt <= 0 || ACE_OS::last_error() != EWOULDBLOCK) { this->active_ = false; g_logger.warn("Server Connection closed on fd %d/n", this->peer().get_handle()); /*表示客户端已断开*/ return -1; } #endif return 0; } /*服务端向客户端发送数据时，回调此函数*/ int TaskServer::handle_output (ACE_HANDLE) { ACE_Message_Block *mb = NULL; ACE_Time_Value nowait(ACE_OS::gettimeofday()); if (this->getq(mb, &nowait) != -1) { ssize_t send_cnt = -1; try { send_cnt = this->peer().send(mb->rd_ptr(), mb->length()); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (send_cnt == -1) { g_logger.error("TaskServer send fail/n"); } else if (send_cnt == mb->length()) { /*打印*/ g_logger.dump(mb->rd_ptr(), send_cnt, 2); mb->rd_ptr(ACE_static_cast(size_t, send_cnt)); } else { g_logger.error("TaskServer send lost(%d:%d)/n", mb->length(), send_cnt); } mb->release (); mb = NULL; } if (mb) mb->release (); return 0; } /*定时处理函数*/ int TaskServer::handle_timeout(const ACE_Time_Value ¤t_time, const void *act) { if (this->active_ != true) return 0; this->timeout_0(); return 0; } /*客户端断开时，回调此函数*/ int TaskServer::handle_close (ACE_HANDLE h, ACE_Reactor_Mask mask) { if (mask == ACE_Event_Handler::WRITE_MASK) return 0; else { ACE_TCHAR peer_name[MAXHOSTNAMELEN] = {0}; ACE_INET_Addr peer_addr; if (this->peer().get_remote_addr(peer_addr) == 0 && peer_addr.addr_to_string (peer_name, MAXHOSTNAMELEN) == 0) g_logger.debug("Host %s Disconnected on fd %d/n", peer_name, this->peer().get_handle()); /*释放队列资源*/ this->task_send.run_active(false); this->task_recv.run_active(false); this->active_ = false; this->task_send.msg_queue()->close(); this->task_recv.msg_queue()->close(); this->msg_queue()->close(); this->task_send.wait(); this->task_recv.wait(); this->wait(); /*回调*/ this->stop_0(); /*关闭链路*/ this->peer().close_reader(); this->peer().close_writer(); this->peer().close(); return super::handle_close(h, mask); } } /**********************************************************************************************************************************/ bool TaskServer::run_active() { return this->active_; } void TaskServer::run_active(bool b) { this->active_ = b; } /**********************************************************************************************************************************/ void TaskServer::start_0() { /**************************************************************** * TODO 可以在此实现客户端接入后需要的初始化工作 - （已经实际接入） *****************************************************************/ } void TaskServer::stop_0() { /**************************************************************** * TODO 可以在此实现客户端断开后需要执行的工作 *****************************************************************/ } void TaskServer::timeout_0() { /**************************************************************** * TODO 实现服务端定时任务，如发送心跳等，(注：多客户端时，只对本连接有效) *****************************************************************/ g_logger.debug("TaskServer handle_timeout/n"); }

TaskClient.cpp

/*================================================================================================== * 项目名称: 实现ACE_Connector设计模式 * 功能: 实现ACE_Connector客户端连接及数据收发功能 * 作者: huangjf * 联系: huangjf@ffcs.cn * 最近修改: 2010-9-30 * 版本: v1.0.1 ==================================================================================================*/ #include <string> #include <list> #include <vector> #include <ace/OS.h> #include <ace/Synch.h> #include <ace/Reactor.h> #include <ace/Svc_Handler.h> #include <ace/Message_Block.h> #include <ace/INET_Addr.h> #include <ace/SOCK_Stream.h> #include <ace/SOCK_Connector.h> #include <ace/Connector.h> #include "ffcs_common.h" #include "ffcs_logger.h" #include "ffcs_config.h" #include "app_main.h" #include "TaskDefined.h" extern Logger g_logger; TaskClient::TaskClient(void) : active_(false) { this->active_ = false; this->msg_queue()->high_water_mark(SEND_HIGHT_MARK); return; } TaskClient::~TaskClient(void) { this->active_ = false; this->msg_queue()->close(); return; } /*在连接建立后被自动回调*/ int TaskClient::open(void *p) { ACE_TCHAR peer_name[MAXHOSTNAMELEN]; ACE_INET_Addr peer_addr; if (this->peer().get_remote_addr(peer_addr) == 0 && peer_addr.addr_to_string (peer_name, MAXHOSTNAMELEN) == 0) { g_logger.message("***** Connection to %s on fd %d/n", peer_name, this->peer().get_handle()); } ConfigParameter <int> p_1(CONFIG_FILE, "CLIENT", "CLIENT_INTERVAL", 30, this->g_iClientInterval); ConfigParameter <int> p_2(CONFIG_FILE, "CLIENT", "CLIENT_RECV_POOL_SIZE", 8, this->g_iClientRecvPoolSize); ConfigParameter <int> p_3(CONFIG_FILE, "CLIENT", "CLIENT_SEND_POOL_SIZE", 1, this->g_iClientSendPoolSize); this->active_ = true; this->task_recv.task_send(&task_send); this->task_recv.run_active(true); if (this->task_recv.activate(THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, this->g_iClientRecvPoolSize) == -1) { g_logger.error("Client TaskRecv activate failed/n"); return -1; } this->task_send.task_peer((ACE_Task<ACE_MT_SYNCH> *)this); this->task_send.run_active(true); if (this->task_send.activate(THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, this->g_iClientSendPoolSize) == -1) { g_logger.error("Client TaskSend activate failed/n"); return -1; } /*回调*/ this->start_0(); /*开启定时处理线程*/ ACE_Time_Value tvDelay(3, 0), tvInterval(this->g_iClientInterval); this->reactor()->schedule_timer(this, 0, tvDelay, tvInterval); return super::open(p); } /*客户端接收到服务端发送的数据后，回调此函数*/ int TaskClient::handle_input(ACE_HANDLE) { char buffer[INPUT_SIZE] = {0}; ssize_t recv_cnt = 0; #if (MSG_HEAD_MODE==1) /*接收消息头模式*/ /**************************************************************** * TODO 根据实际消息头格式修改解析方法 *****************************************************************/ ssize_t msg_len = 0; recv_cnt = 0; try { recv_cnt = this->peer().recv(buffer, MSG_HEAD_SIZE); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (recv_cnt > 0 && recv_cnt == MSG_HEAD_SIZE) { /************************* * TODO 注意这里的4个字节 **************************/ msg_len = SET_BYTE4(buffer[0]&0xFF) + SET_BYTE3(buffer[1]&0xFF) + SET_BYTE2(buffer[2]&0xFF) + SET_BYTE1(buffer[3]&0xFF); if (msg_len < INPUT_SIZE) { g_logger.debug("Client receive message，length (%d)；/n", msg_len); } else { g_logger.warn("Client receive message，length (%d)；warning!!! out of range/n", msg_len); } if (msg_len >= MSG_HEAD_SIZE && msg_len < INPUT_SIZE) { if (msg_len == MSG_HEAD_SIZE) { ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(msg_len+1), -1); ACE_OS::memcpy(mb->wr_ptr(), buffer, msg_len); mb->wr_ptr(msg_len); if (this->task_recv.putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskClient enqueue to TaskRecv failed；discarding data！/n"); return 0; } /*打印*/ g_logger.dump(buffer, msg_len, 1); return 0; } else { recv_cnt = 0; try { recv_cnt = this->peer().recv(buffer+MSG_HEAD_SIZE, (msg_len-MSG_HEAD_SIZE)); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (recv_cnt > 0 && recv_cnt == (msg_len-MSG_HEAD_SIZE)) { ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(msg_len+1), -1); ACE_OS::memcpy(mb->wr_ptr(), buffer, msg_len); mb->wr_ptr(msg_len); if (this->task_recv.putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskClient enqueue to TaskRecv failed；discarding data！/n"); return 0; } /*打印*/ g_logger.dump(buffer, msg_len, 1); return 0; } if (recv_cnt <= 0 || ACE_OS::last_error() != EWOULDBLOCK) { this->active_ = false; g_logger.warn("Client Connection closed.2 on fd %d/n", this->peer().get_handle()); /*表示客户端已断开*/ return -1; } } } return 0; } if (recv_cnt <= 0 || ACE_OS::last_error() != EWOULDBLOCK) { this->active_ = false; g_logger.warn("Client Connection closed.1 on fd %d/n", this->peer().get_handle()); /*表示客户端已断开*/ return -1; } #else /*不接收消息头模式*/ recv_cnt = 0; try { recv_cnt = this->peer().recv(buffer, sizeof(buffer)); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (recv_cnt > 0) { ACE_Message_Block *mb = NULL; ACE_NEW_RETURN(mb, ACE_Message_Block(recv_cnt+1), -1); ACE_OS::memcpy(mb->wr_ptr(), buffer, recv_cnt); mb->wr_ptr(recv_cnt); if (this->task_recv.putq(mb) == -1) { if (mb) mb->release(); g_logger.error("TaskClient enqueue to TaskRecv failed；discarding data！/n"); return 0; } /*打印*/ g_logger.dump(buffer, recv_cnt, 1); return 0; } if (recv_cnt <= 0 || ACE_OS::last_error() != EWOULDBLOCK) { this->active_ = false; g_logger.warn("Client Connection closed on fd %d/n", this->peer().get_handle()); /*表示客户端已断开*/ return -1; } #endif return 0; } /*客户端向服务端发送数据时，回调此函数*/ int TaskClient::handle_output (ACE_HANDLE) { ACE_Message_Block *mb = NULL; ACE_Time_Value nowait(ACE_OS::gettimeofday()); if (this->getq(mb, &nowait) != -1) { ssize_t send_cnt = -1; try { send_cnt = this->peer().send(mb->rd_ptr(), mb->length()); } catch (std::exception& exc) { g_logger.error("[%d:%s]:%s/n", __LINE__, __FILE__, exc.what()); } if (send_cnt == -1) { g_logger.error("TaskClient send fail/n"); } else if (send_cnt == mb->length()) { /*打印*/ g_logger.dump(mb->rd_ptr(), send_cnt, 2); mb->rd_ptr(ACE_static_cast(size_t, send_cnt)); } else { g_logger.error("TaskClient send lost(%d:%d)/n", mb->length(), send_cnt); } mb->release (); mb = NULL; } if (mb) mb->release (); return 0; } /*定时处理函数*/ int TaskClient::handle_timeout(const ACE_Time_Value ¤t_time, const void *act) { if (this->active_ != true) return 0; this->timeout_0(); return 0; } /*服务端断开时，回调此函数*/ int TaskClient::handle_close (ACE_HANDLE h, ACE_Reactor_Mask mask) { if (mask == ACE_Event_Handler::WRITE_MASK) return 0; else { ACE_TCHAR peer_name[MAXHOSTNAMELEN] = {0}; ACE_INET_Addr peer_addr; if (this->peer().get_remote_addr(peer_addr) == 0 && peer_addr.addr_to_string (peer_name, MAXHOSTNAMELEN) == 0) g_logger.debug("Host %s Disconnected on fd %d/n", peer_name, this->peer().get_handle()); /*释放队列资源*/ this->task_send.run_active(false); this->task_recv.run_active(false); this->active_ = false; this->task_send.msg_queue()->close(); this->task_recv.msg_queue()->close(); this->msg_queue()->close(); this->task_send.wait(); this->task_recv.wait(); this->wait(); /*回调*/ this->stop_0(); /*关闭链路*/ this->peer().close_reader(); this->peer().close_writer(); this->peer().close(); return super::handle_close(h, mask); } } /**********************************************************************************************************************************/ bool TaskClient::run_active() { return this->active_; } void TaskClient::run_active(bool b) { this->active_ = b; } /**********************************************************************************************************************************/ void TaskClient::start_0() { /**************************************************************** * TODO 可以在此实现接入服务端后需要的初始化工作 - （已经实际接入） *****************************************************************/ } void TaskClient::stop_0() { /**************************************************************** * TODO 可以在此实现断开服务端后需要执行的工作 *****************************************************************/ } void TaskClient::timeout_0() { /**************************************************************** * TODO 实现客户端定时任务，如发送心跳等 *****************************************************************/ g_logger.debug("TaskClient handle_timeout/n"); std::string data = "hello world/n"; this->task_send.send_msg(data.c_str(), data.size()); }

main.cpp

/*================================================================================================== * 项目名称: XX项目 * 功能: 封装Acceptor & Connector设计模式，简化服务器客户端应用开发 * 作者: huangjf * 联系: huangjf@ffcs.cn * 最近修改: 2010-9-20 * 版本: v1.0.0 ==================================================================================================*/ #include <stdio.h> #include <stdlib.h> #include <iostream> #include <fstream> #include <string> #include <vector> #include <ace/OS.h> #include <ace/Reactor.h> #include <ace/TP_Reactor.h> #include <ace/Time_Value.h> #include <ace/Event_Handler.h> #include <ace/Thread_Manager.h> #include <ace/Get_Opt.h> #include <Poco/Timespan.h> #include <Poco/DateTime.h> #include <Poco/LocalDateTime.h> #include <Poco/DateTimeFormatter.h> #include "ffcs_common.h" #include "ffcs_logger.h" #include "ffcs_config.h" #include "ffcs_ftp_client.h" #include "ffcs_db_proc.h" #include "app_main.h" #include "TaskDefined.h" class App1: public Application { public: App1(Logger& _logger, ConfigUpdate& _config) : Application(_logger, _config) { } virtual ~App1() { } public: /*初始化*/ void init(int argc, ACE_TCHAR* argv[]) { ACE_Time_Value tvDelay(3, 0), tvInterval; /************************************************************************/ ACE_TP_Reactor *tp_reactor = new ACE_TP_Reactor(); ACE_Reactor *reactor = new ACE_Reactor(tp_reactor, 1); ACE_Reactor::instance(reactor, 1); /************************************************************************/ Application::init(); /*参数配置*/ ConfigParameter <int> p_logger_1(CONFIG_FILE, "LOGGER", "LOGMEDIA", FFCS_LOGMEDIA_ALL, this->logger().media_); ConfigParameter <int> p_logger_2(CONFIG_FILE, "LOGGER", "LOGLEVEL", FFCS_LOGLEVEL_MESSAGE, this->logger().level_); ConfigParameter <int> p_logger_3(CONFIG_FILE, "LOGGER", "LOGCLEANER", FFCS_LOGCLEANER_OPEN, this->logger().cleaner_switch_); ConfigParameter <int> p_logger_4(CONFIG_FILE, "LOGGER", "LOGSAVEDMONTH", DEFAULT_SAVED_MONTH, this->logger().saved_month_); ConfigParameter <int> p_system_1(CONFIG_FILE, "SYSTEM", "SYS_INTERVAL", 15, this->g_iInterval); ConfigParameter <int> p_system_2(CONFIG_FILE, "SYSTEM", "SYS_NOTIFY_ITERATIONS", 10, this->g_iNotifyIterations); ConfigParameter<std::string> p_database_1(CONFIG_FILE, "DATABASE", "CONNSTR_0", "NULL", this->g_dbString); ConfigParameter<std::string> p_database_2(CONFIG_FILE, "DATABASE", "LINKNAME_0", "NULL", this->g_dbName); ConfigParameter<std::string> p_server_1(CONFIG_FILE, "SERVER", "SERVER_HOST", "127.0.0.1", this->g_serverHost); ConfigParameter <int> p_server_2(CONFIG_FILE, "SERVER", "SERVER_PORT", 30903, this->g_serverPort); ConfigParameter<std::string> p_client_1(CONFIG_FILE, "CLIENT", "CLIENT_HOST", "127.0.0.1", this->g_clientHost); ConfigParameter <int> p_client_2(CONFIG_FILE, "CLIENT", "CLIENT_PORT", 30903, this->g_clientPort); this->config().add(p_logger_1); this->config().add(p_logger_2); this->config().add(p_logger_3); this->config().add(p_logger_4); this->config().add(p_system_1); this->config().add(p_system_2); this->config().add(p_database_1); this->config().add(p_database_2); this->config().add(p_server_1); this->config().add(p_server_2); this->config().add(p_client_1); this->config().add(p_client_2); /*this->config().dump();*/ /*设置事件处理能力*//*一次handle_events()调用中处理的notify()最大数目*/ ACE_Reactor::instance()->max_notify_iterations(this->g_iNotifyIterations); /*任务调度*/ tvInterval.sec(this->g_iInterval); ACE_Reactor::instance()->schedule_timer(this, NULL, tvDelay, tvInterval); /*TODO*/ ACE_INET_Addr port_to_listen(this->g_serverPort, this->g_serverHost.c_str()); do { this->acceptor.reactor(ACE_Reactor::instance()); if (this->acceptor.open(port_to_listen) == -1) { this->logger().error("Listen %s:%d fail/n", port_to_listen.get_host_addr(), port_to_listen.get_port_number()); this->logger().debug("Auto re-listen 10 seconds later./n"); ACE_OS::sleep(10); continue; } this->logger().message("Listen at %s:%d .../n", port_to_listen.get_host_addr(), port_to_listen.get_port_number()); break; } while (true); ACE_INET_Addr port_to_connect(this->g_clientPort, this->g_clientHost.c_str()); do { TaskClient *pc = NULL; ACE_NEW_NORETURN(pc, TaskClient); /*如果指定了Reactor模式，必须在这里显性指派*/ this->connector.reactor(ACE_Reactor::instance()); if (pc == NULL || this->connector.connect(pc, port_to_connect) == -1) { this->logger().error("Connect to %s:%d fail/n", port_to_connect.get_host_addr(), port_to_connect.get_port_number()); this->logger().debug("Auto re-connect 10 seconds later./n"); ACE_OS::sleep(10); continue; } break; } while(true); return; } /*执行*/ int run() { ACE_Time_Value tv(0, 100*1000); struct timespec rqt; rqt.tv_sec = 0; rqt.tv_nsec = 100*1000*1000; while (this->active_ == true) { if (ACE_Reactor::instance()->handle_events(tv) == -1) break; ACE_OS::nanosleep(&rqt); } return 0; /*return Application::run();*/ } /*退出*/ void exit() { this->connector.close(); this->acceptor.close(); return Application::exit(); } /*参数处理，0:程序继续执行，1:程序中断退出*/ int usage(int argc, char* argv[]) { int c; ACE_Get_Opt get_opt(argc, argv, "hv"); while ((c = get_opt ()) != EOF) { switch (c) { case 'v': { Util::fun_copyright(); } return 1; case 'h': default: { ACE_OS::printf("/n/n"); ACE_OS::printf("Usage: ./app_main_ace [OPTIONS] /n"); ACE_OS::printf(" -h display this usage message/n"); ACE_OS::printf(" -v display version/n"); ACE_OS::printf("/n/n"); } return 1; } } return 0; } protected: /*定时任务*/ int handle_timeout(const ACE_Time_Value &_current_time, const void *act = 0) { Poco::LocalDateTime ldt_now; this->logger().debug("心跳正常，程序还活着! 下次看到心跳预计时间:[%s]/n/n", Poco::DateTimeFormatter::format(ldt_now+Poco::Timespan(this->g_iInterval, 0), "%Y-%m-%d %H:%M:%S").c_str()); return 0; } private: int g_iInterval; int g_iNotifyIterations; std::string g_dbString, g_dbName; std::string g_serverHost, g_clientHost; int g_serverPort, g_clientPort; ServerAcceptor acceptor; ClientConnector connector; }; FFCS_APP_MAIN(App1);

config.cfg

##########日志输出配置信息###################################### [LOGGER] #日志输出根路径（不支持动态修改） LOGFILEDIR = "../logs" #日志输出媒体 0：屏幕 1：文件 2：屏幕+文件（支持动态修改） LOGMEDIA = 2 #日志打印级别 0：ERROR 1：WARN 2：MESSAGE 3：DEBUG（支持动态修改） LOGLEVEL = 3 #日志清理开关 1：开，0：关（支持动态修改） LOGCLEANER = 1 #日志保存月数，日志清理开时有效 0：表示不删除（支持动态修改） LOGSAVEDMONTH = 6 ################################################################ ################################################################ [SYSTEM] #设置事件处理能力，即一次handle_events()调用中处理的notify()最大数目（不支持动态修改） SYS_NOTIFY_ITERATIONS = 10 #定时任务间隔时间，单位：秒（不支持动态修改） SYS_INTERVAL = 30 ################################################################ [DATABASE] CONNSTR_0 = "huangjf/12345678@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=orcl)))" LINKNAME_0 = "local_svc0" ################################################################ [SERVER] #服务端IP（不支持动态修改） SERVER_HOST = "127.0.0.1" #服务端端口（不支持动态修改） SERVER_PORT = 5011 #定时任务间隔时间，单位：秒（不支持动态修改） SERVER_INTERVAL = 30 #接收线程数，即接收端并发处理能力（不支持动态修改） SERVER_RECV_POOL_SIZE = 10 #发送线程数（不支持动态修改） SERVER_SEND_POOL_SIZE = 1 [CLIENT] #客户端IP（不支持动态修改） CLIENT_HOST = "127.0.0.1" #客户端端口（不支持动态修改） CLIENT_PORT = 5011 #定时任务间隔时间，单位：秒（不支持动态修改） CLIENT_INTERVAL = 30 #接收线程数，即接收端并发处理能力（不支持动态修改） CLIENT_RECV_POOL_SIZE = 10 #发送线程数（不支持动态修改） CLIENT_SEND_POOL_SIZE = 1