ACE之使用Acceptor-Connector框架

最新推荐文章于 2017-05-03 09:56:00 发布
最新推荐文章于 2017-05-03 09:56:00 发布
阅读量8.2k 收藏 6
点赞数
文章标签： 框架 output stream input buffer null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jacklam200/article/details/3478375
版权
本文深入探讨Reactor模式在ACE框架中的应用，通过具体的服务端和客户端示例代码，讲解了如何利用ACE_Svc_Handler和ACE_Connector简化网络编程任务。重点介绍了ACE_Svc_Handler的特性及其对连接管理的支持，同时展示了ACE_Connector如何用于建立连接。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

我们先看一个服务小例子，并比较Reactor框架

 

 

  1. #include <iostream>
  2. #include "ace/auto_ptr.h"
  3. #include "ace/log_msg.h"
  4. #include "ace/inet_addr.h"
  5. #include "ace/sock_acceptor.h"
  6. #include "ace/reactor.h"
  7. #include "ace/acceptor.h"
  9. #include "ace/Connector.h"
  10. #include "ace/Reactor_Notification_Strategy.h"
  11. #include "ace/Select_Reactor.h"
  12. #include "ace/Singleton.h"
  14. #include "ace/svc_handler.h"
  16. #include "ace/Message_Block.h"
  17. #include "ace/Message_Queue.h"
  18. #include "ace/SOCK_Stream.h"
  20. #include "ace/Null_Mutex.h"
  21. #include "ace/Null_Condition.h"
  24. using namespace std;
  26. //服务客户
  27. class ClientService:public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH>
  28. {
  29. public:
  30.     int open(void *p);
  31.     virtual int handle_input(ACE_HANDLE fd=ACE_INVALID_HANDLE);
  32.     virtual int handle_output(ACE_HANDLE fd=ACE_INVALID_HANDLE);
  33.     virtual int handle_close(ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
  35. protected:
  36.     ACE_SOCK_Stream sock_;
  37.     ACE_Message_Queue<ACE_NULL_SYNCH> output_queue_;
  38. };
  39. int ClientService::open(void *p)
  40. {
  41.     if(ACE_Svc_Handler::open(p)==-1)
  42.         return -1;
  43.     ACE_TCHAR peer_name[512];
  44.     ACE_INET_Addr peer_addr;
  45.     if(this->peer().get_remote_addr(peer_addr)==0&&peer_addr.addr_to_string(peer_name,512)==0)
  46.         cout<<" connection from "<<peer_name<<endl;
  47.     return 0;
  48. }
  49. int ClientService::handle_input(ACE_HANDLE)
  50. {
  51.     const size_t INPUT_SIZE=4096;
  52.     char buffer[INPUT_SIZE];
  53.     ssize_t recv_cnt,send_cnt;
  54.     if((recv_cnt=this->peer().recv(buffer,sizeof(buffer)))<=0)
  55.     {
  56.         ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) connection closed/n")));
  57.         return -1;
  58.     }
  59.     send_cnt=this->peer().send(buffer,ACE_static_cast(size_t,recv_cnt));
  60.     if(send_cnt==recv_cnt)
  61.         return 0;
  62.     if(send_cnt==-1&&ACE_OS::last_error()!=EWOULDBLOCK)
  63.         ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("%P|%t) %p/n"),ACE_TEXT("send")),0);
  64.     if(send_cnt==-1)
  65.         send_cnt=0;
  66.     ACE_Message_Block *mb;
  67.     size_t remaining=ACE_static_cast(size_t,(recv_cnt-send_cnt));
  68.     ACE_NEW_RETURN(mb,ACE_Message_Block(&buffer[send_cnt],remaining),-1);
  69.     int output_off=this->msg_queue()->is_empty();
  70.     ACE_Time_Value nowait(ACE_OS::gettimeofday());
  71.     if(this->putq(mb,&nowait)==-1)
  72.     {   
  73.         ACE_ERROR((LM_ERROR,ACE_TEXT("(%P|%t)%P;discarding data/n"),ACE_TEXT("enqueue failed ")));
  74.         mb->release();
  75.         return 0;
  76.     }
  77.     if(output_off)
  78.         return this->reactor()->register_handler(this,ACE_Event_Handler::WRITE_MASK);
  79.     return 0;
  82. }
  83. int ClientService::handle_output(ACE_HANDLE)
  84. {
  85.     ACE_Message_Block *mb;
  86.     ACE_Time_Value nowait(ACE_OS::gettimeofday());
  87.     while(0==this->getq(mb,&nowait))
  88.     {
  89.         ssize_t send_cnt=this->peer().send(mb->rd_ptr(),mb->length());
  90.         if(send_cnt==-1)
  91.             ACE_ERROR((LM_ERROR,ACE_TEXT("(%P|%t)%p/n"),ACE_TEXT("send")));
  92.         else
  93.             mb->rd_ptr(ACE_static_cast(size_t,send_cnt));
  94.         if(mb->length()>0)
  95.         {
  96.             this->ungetq(mb);
  97.             break;
  98.         }
  99.         mb->release();
  100.     }
  101.     return (this->msg_queue()->is_empty())?-1:0;
  102. }
  103. int ClientService::handle_close(ACE_HANDLE h,ACE_Reactor_Mask mask)
  104. {
  105.     if(mask==ACE_Event_Handler::WRITE_MASK)
  106.         return 0;
  107.     return ACE_Svc_Handler::handle_close(h,mask);
  108. }
  110. typedef ACE_Acceptor<ClientService,ACE_SOCK_ACCEPTOR> ClientAcceptor;
  111. int main(int argc,char *argv[])
  112. {
  113.     ACE_INET_Addr port_to_listen("HAStatus");
  114.     cout<<"waiting....."<<endl;
  115.     ClientAcceptor acceptor;
  116.     if(acceptor.open(port_to_listen)==-1)
  117.         return 1;
  118.     cout<<"waiting....."<<endl;
  119.     ACE_Reactor::instance()->run_reactor_event_loop();
  120.     cout<<"waiting....."<<endl;
  121.     return 0;
  124. }

不同Reactor框架，此框架无需写ClientAcceptor类,即无需设置acceptor对象的ACE_Reactor实例，只需typedef

typedef ACE_Acceptor<ClientService,ACE_SOCK_ACCEPTOR> ClientAcceptor;

我们继续考察ClientService类

class ClientService:public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH>

 

ACE_Svc_Handler允许你指定流类型和加锁类型，与ACE_Acceptor一样，ACE_Svc_Handler需要使用流的地址trait,所以我们使用了ACE_SOCK_STREAM宏，使这些代码在支持或不支持模板trait类型的系统上都能编译

之所以要加锁类型，是因为ACE_Svc_Handler是派生自ACE_Task的，后者含有一个ACE_Message_Queue成员，你必须为这个成员提供同步类型。

在此我们不会使用ACE_Task提供的线程能力，但我们要使用继承而得的ACE_Message_Queue成员，所以我们移除了先前例子的ACE_Message_Queue成员。

另外，我们只使用一个线程，所以用ACE_NULL_SYNCH

注意：ACE_Svc_Handler按照我们通常所需的方式实现了get()_handle（）方法，所以此方法也不见了

接着，再看handle_input(ACE_HANDLE)方法，与前一个版本不同的是：

1.我们使用ACE_Svc_Handler::peer()方法是访问底层的ACE_SOCK_Stream

2.我们通过继承的ACE_Task::msg_queue()方法访问继承的ACE_Message_Queue

3.为了把数据块放入队列中，我们可以继承而得的ACE_Task::putq()方法。同样，我们新的handle_output也类似的，但他利用了继承而得的方法

 

最后，默认的handle_close()方法会移除所有的反应器登记信息，取消所有的定时器，并删除该处理器

 

ACE_Svc_Handler的使用极大地简化了我们的服务处理器，使得我们能完全专注于需要的解决的问题，而不需要为所有那些连接管理问题而分心

 

接着，我们再看ACE_Connector

  1. #include <iostream>
  2. #include "ace/reactor.h"
  3. #include "ace/inet_addr.h"
  4. #include "ace/sock_stream.h"
  5. #include "ace/sock_connector.h"
  6. #include "ace/connector.h"
  7. #include "ace/svc_handler.h"
  8. #include "ace/reactor_notification_strategy.h"
  9. #include <conio.h>
  10. using namespace std;
  11. typedef ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH> super;
  12. class Client:public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH>
  13. {
  14.     
  16. public:
  17.     Client():notifier_(0,this,ACE_Event_Handler::WRITE_MASK)
  18.     {
  19.     }
  20.     virtual int open(void *p=0);
  21.     virtual int handle_input(ACE_HANDLE fd=ACE_INVALID_HANDLE);
  22.     virtual int handle_output(ACE_HANDLE fd=ACE_INVALID_HANDLE);
  23.     virtual int handle_timeout(const ACE_Time_Value ¤t_time,const void *act=0);
  24. private:
  25.     enum{ITERATIONS=5};
  26.     int iterations_;
  27.     ACE_Reactor_Notification_Strategy notifier_;
  28. };
  29. int Client::open(void *p)
  30. {
  31.     ACE_Time_Value iter_delay(2);
  32.     if(ACE_Svc_Handler::open(p)==-1)
  33.         return -1;
  34.     this->notifier_.reactor(this->reactor());
  35.     this->msg_queue()->notification_strategy(this->notifier_);
  36.     return this->reactor()->schedule_timer(this,0,ACE_Time_Value::zero,iter_delay);
  37. }
  38. int Client::handle_input(ACE_HANDLE)
  39. {
  40.     char buf[64];
  41.     ssize_t recv_cnt=this->peer().recv(buf,sizeof(buf)-1);
  42.     if(recv_cnt>0)
  43.     {
  44.     }
  45.     if(recv_cnt==0||ACE_OS::last_error()!=EWOULDBLOCK)
  46.     {
  47.         this->reactor()->end_reactor_event_loop();
  48.         return -1;
  49.     }
  50.     return 0;
  51. }
  52. int Client::handle_timeout(const ACE_Time_Value &,const void *)
  53. {
  54.     if(this->iterations_>=ITERATIONS)
  55.     {
  56.         this->peer().close_writer();
  57.         return 0;
  58.     }
  59.     ACE_Message_Block *mb;
  60.     char msg[128];
  61.     ACE_OS::sprintf(msg,"iteration %d/n",this->iterations_);
  62.     ACE_NEW_RETURN(mb,ACE_Message_Block(msg),-1);
  63.     this->putq(mb);
  64.     return 0;
  65. }
  66. int Client::handle_output(ACE_HANDLE)
  67. {
  68.     ACE_Message_Block *mb;
  69.     ACE_Time_Value nowait(ACE_OS::gettimeofday());
  70.     while(-1!=this->getq(mb,&nowait))
  71.     {
  72.         ssize_t send_cnt=this->peer().send(mb->rd_ptr(),mb->length());
  73.         if(send_cnt==-1)
  74.             ACE_ERROR((LM_ERROR,ACE_TEXT("(%P|%T)%P/n"),ACE_TEXT("send")));
  75.         else
  76.             mb->rd_ptr(ACE_static_cast(size_t,send_cnt));
  77.         if(mb->length()>0)
  78.         {
  79.             this->ungetq(mb);
  80.             break;
  81.         }
  82.         mb->release();
  83.     }
  84.     if(this->msg_queue()->is_empty())
  85.         this->reactor()->cancel_wakeup(this,ACE_Event_Handler::WRITE_MASK);
  86.     else
  87.         this->reactor()->schedule_wakeup(this,ACE_Event_Handler::WRITE_MASK);
  88.     return 0;
  89. }
  90. int ACE_TMAIN(int ,ACE_TCHAR *[])
  91. {
  92.     ACE_INET_Addr port_to_connect("HAStatus",ACE_LOCALHOST);
  93.     ACE_Connector<Client,ACE_SOCK_CONNECTOR> connector;
  94.     Client client;
  95.     Client *pc=&client;
  96.     if(connector.connect(pc,port_to_connect)==-1)
  97.     {
  98.         ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("%p/n"),ACE_TEXT("connect")),1);
  99.     }
  100.     ACE_Reactor::instance()->run_reactor_event_loop();
  101.     getch();
  102.     return 0;
  103. }

从程序中我们看到有一个新类，ACE_Reactor_Notification_Strategy是一个策略类，实现了Strategy模式，它允许你定制另一个类的行为，且无需改变受影响的类

在例子中也可以看到构造的时候先初始化了notifier_对象，设置正确的ACE_Reactor指针，目的是通过ACE_Reactor_Notification_Strategy这样的对象使ACE_Message_Queue策略化。如果ACE_Message_Queue拥有一个策略对象，无论何时有ACE_Message_Block对象进入队列，ACE_Message_Queue都会调用该策略对象的notify()方法。因为我们已经设置了notifier_,他会在Client的反应器上发出notify()调用，把一个通知放入队列，通知的目标是我们的client对象的handle_output()方法。要把ACE_Message_Queue的入队操作结合进反应器的事件循环

handle_timeout方法：如果我们把预定数目的串发给服务器，就是用close_writer()方法关闭我们这一端的TCP/IP socket。

注意，对于我们想要发往服务器的每一个串，我们都把它插入一个ACE_Message_Block,并把这个块放入队列，这将使消息队列用notifier_对象把通知放入反应器的队列。当反应器处理该通知时，他会调用我们的handle_output方法，然后我们从队列中取出数据，直到队列变空。

在handle_output方法中，有cancel_wakeup()和schedule_wakeup(),前者是从这个处理器的反应器登记信息中移除指定的掩码位，而schedule_wakeup()则增加指定的掩码。也就是说不会造成handle_close()被调用。因此，这一次也无需实现handle_close(),以专门处理被取消的WRITE掩码，我们复用了ACE_Svc_Handler的默认handle_close()方法，所以无需编写代码

 

JackLam
关注
ACE中Connector-Acceptor架构
riding的专栏
02-16 8064
ACE作为通讯方面的开源架构，不但用c++实现，而且用JAVA实作的架构已经可以使用了，由此看来掌握ACE成为每个开发通讯程序的程序员的必备技能。ACE的库分为4个层次：l         OS适配层 该层将ACE的较高层和与OS机制相关联的平台特有的依赖屏蔽开来。l         OO包装层 封装并增强在像Win32和UNIX这样的现代操作系统上可用的并发、进程间通信（IPC）、以
ACE框架解读 - 源码篇
六神的博客
11-21 2406
最近研究了ACE框架的源码，先考虑选取最新版本ACE6.0来读，但是发现代码量有30多万行，规模太大了花的时间会比较多，所以考虑选取旧一些的版本，最后选取ACE4.5版本来阅读，代码量13万行比较适中。 下面是我读代码时的一些总结，把所有的目录和文件列出来，并针对每个文件里的主要类及其实现，根据自己的理解作了一些总结。 文件 总结 [CORBA] COBRA整体略过。 CORBA_Ha...
ACE的接受器（Acceptor）和连接器（Connector）：连接建立模式
demonzsmj12315的博客
03-25 429
ACE的接受器（Acceptor）和连接器（Connector）：连接建立模式 　　接受器/连接器模式设计用于降低连接建立与连接建立后所执行的服务之间的耦合。例如，在WWW浏览器中，所执行的服务或“实际工作”是解析和显示客户浏览器接收到的HTML页面。连接建立是次要的，可能通过BSD socket或其他一些等价的IPC机制来完成。使用这些模式允许程序员专注于“实际工作”，而最少限度地去...
Acceptor-Connector模式一（Acceptor的工作）V2.0
weixin_33717117的博客
05-03 116
 前言：ACE Acceptor-Connector模式 首先这样的模式肯定是面向连接的TCP/IP协议。 无论是什么场景。差点儿面向连接的通信程序总是由一端主动发起连接，一端监听等待对方的连接。 这就是接收器-连接器模式（server-client）。 模式思想 （1）此模式仅仅负责连接的建立。无论有多少连接上来，这个模式都能应对。 （2）至于连接建立之后怎样通信，那是通信处...
Acceptor-Connector
qwidget的专栏
07-25 1493
This article is extracted from POSA2 as a reading note.Superserver implementations, for example Inetd, Listen, and the Service Configurator
ACE_SOCK_TCP.rar_ACE_ACE TCP C++_ACE tcp_ace-6
09-22
通过使用ACE_SOCK_Acceptor、ACE_SOCK_Connector和ACE_SOCK_Stream等类，开发者可以快速构建可靠、高性能的TCP服务，同时享受到ACE库带来的诸如异步I/O、异常处理等高级功能。对于需要在C++中进行网络编程的开发者而...
ACE框架详细讲解，包括ACE框架详解、用户指南、案例分析
最新发布
02-02
ACE框架包含了许多核心组件，如Acceptor-Connector设计模式、Reactor模式、Proactor模式，这些都是实现异步事件驱动编程的关键元素。 "用户指南"将引导你如何有效地使用ACE框架。它通常会涵盖安装步骤、配置环境、...
ACE_server.rar_ACE server_ACE tcp_ACE_SERVER_ACE框架_ace server cl
09-21
在“ACE_server.rar”这个压缩包中，包含的是使用ACE库搭建的一个TCP服务器和客户端框架。这个框架设计得简洁且易于扩展，适合开发者快速构建自己的网络服务。 首先，我们来了解一下ACE库的核心特性。ACE是一个开源...
ACE开发入门指南：初级版-事件与框架详解
该指南的目的是帮助读者快速理解和掌握ACE的基础概念和技术，包括如何获取、编译和配置ACE框架，以及其核心组件如Reactor（反应器）、Acceptor（接受器）-Connector（连接器）框架的使用。ACE_Reactor负责事件处理，...
ACE接受器－连接器设计模式Acceptor-Connector
Think && Discover && Share
11-19 3041
本贴转自http://www.cnblogs.com/TianFang/category/78013.html  作者:天方   接受器－连接器设计模式（Acceptor-Connector）使分布式系统中的连接建立及服务初始化与一旦服务初始化后所执行的处理去耦合 。  这样的去耦合通过三种组件来完成：acceptor 、connector  和 servicehandler （服务
[ACE程序员教程笔记]使用ACE_Acceptor建立连接并处理连接请求
程序点滴
01-10 2789
<br />本例中实现了Accept功能和输入事件处理功能。在与客户端连接建立成功之后，程序向Reactor注册输入回调事件处理函数。当客户端发送的数据到达时，此事件处理函数负责接收数据，并将其内容显示到输入设备。<br />由于ACE_Svc_Handle继承于ACE_Event_Handle，因此对事件处理只需要添加handle_input函数即可实现。<br />#include "stdafx.h" #include "ace/Reactor.h" #include "ace/Svc_Handl
Acceptor 和 Connector
weixin_33811961的博客
05-08 152
非阻塞Accept和Connect的封装器,WINDOWS版本 acceptor #ifndef _ACCEPTOR_H #define _ACCEPTOR_H typedef struct acceptor* acceptor_t; typedef void (*on_accept)(SOCKET); acceptor_t create_acceptor(const char...
ACE之旅——Acceptor-Connector框架实例
Mirage520的专栏
02-21 1097
ACE的Reactor框架非常方便，结合Acceptor-Connector更为方便。以下是一个使用Acceptor-Connector框架写的daytime实例C/S应用。 #include "ace/INET_Addr.h" #include "ace/SOCK_Stream.h" #include "ace/SOCK_Acceptor.h" #include "ace/Log_Msg.h"
[ACE程序员教程笔记]使用ACE_Acceptor分离连接和事件处理
程序点滴
01-10 2733
<br />ACE_Acceptor为一个抽象工厂，采用了客户端连接与服务处理程序分离的方式，开发人员可以分别关注两个不同的处理点，客户端连接处理与服务器处理程序都可以采用多种的方式，每一个客户端连接的处理与服务处理程序都可以实现适配。下文中的代码实现了服务器监听功能，当与客户端建立连接请求时，服务程序回调open方法，显示连接状态。<br />#include "stdafx.h" #include "ace/Reactor.h" #include "ace/Svc_Handler.h" #incl
ACE 的ACE_Acceptor类
努力在路上
02-15 1056
最近在看一个腾讯开源的框架， c++ 的， 网上的资料少之又少，开源word写的那个，说实话按照word上都不如自行百度。折腾了两天才跑起来了。    在看代码的过程中，对于 这个typedef ACE_Acceptor ISGW_ACCEPTOR 可以说是ACE的一个很重要的类。是Acceptor参与者的实现体。      Acceptor参与者位于网络连接的服务端，它有两个主要的功能，一是
小用ACE_Acceptor
weixin_30708329的博客
01-21 138
Ace_Acceptor是ACE的接收器之一，此次使用涉及了这个类的三个函数：open\accept_svc_handler\activate_svc_handler。 其中open函数的原型之一： /** * Open the contained @c PEER_ACCEPTOR object to begin listening, and * register wi...
ACE之Acceptor-Connector框架
飘羽随风
03-23 997
<br />我们先看一个服务小例子，并比较Reactor框架<br /> <br /> <br />#include <iostream> <br /> #include "ace/auto_ptr.h" <br /> #include "ace/log_msg.h" <br /> #include "ace/inet_addr.h" <br /> #include "ace/sock_acceptor.h" <br /> #include "ace/reactor.h" <br /> #inc
ACE_Acceptor类源码浅解析
FebruarySwallow的博客
11-16 2087
接受器/连接器模式设计用于降低连接建立与连接建立后所执行的服务之间的耦合。例如，在WWW浏览器中，所执行的服务或“实际工作”是解析和显示客户浏览器接收到的HTML页面。连接建立是次要的，可能通过BSDsocket或其他一些等价的IPC机制来完成。使用这些模式允许程序员专注于“实际工作”，而最少限度地去关心怎样在服务器和客户之间建立连接。而另外一方面，程序员也可以独立于他所编写的、或将要编写的服务例程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值