采用C++的ACE库实现的一个通用的C/S架构通信程序(最终版)

最新推荐文章于 2019-04-29 20:27:31 发布
最新推荐文章于 2019-04-29 20:27:31 发布
阅读量7.2k 收藏 12
点赞数
文章标签： c++ server constants manager thread stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenruichuan/article/details/384476
版权

ACE自适配通信环境（ADAPTIVE Communication Environment）是可以自由使用、开放源码的面向对象（OO）框架（Framework），在其中实现了许多用于并发通信软件的核心模式。ACE提供了一组丰富的可复用C++ Wrapper Facade（包装外观）和框架组件，可跨越多种平台完成通用的通信软件任务，其中包括：事件多路分离和事件处理器分派、信号处理、服务初始化、进程间通信、共享内存管理、消息路由、分布式服务动态（重）配置、并发执行和同步，等等。

ACE的目标用户是高性能和实时通信服务和应用的开发者。它简化了使用进程间通信、事件多路分离、显式动态链接和并发的OO网络应用和服务的开发。此外，通过服务在运行时与应用的动态链接，ACE还使系统的配置和重配置得以自动化。

 

我最近采用ACE实现了一个通用的C/S架构通信程序，具体实现简述如下：

 

1．  服务器端：一个采用领导者/跟随者模型的线程池不断地接受从多个客户端发来的消息，并放入一个消息队列，然后又有一个采用半同步/半异步模型的线程池不断地从这个消息队列中取出消息进行处理。

 

服务器端代码如下：（共10个文件）

 

ACE_Server.cpp

 

#include "ace/SOCK_Acceptor.h"

#include "ace/Acceptor.h"

#include "ace/Thread_Manager.h"

#include "ace/TP_Reactor.h"

#include "ace/Reactor.h"

#include "ace/INET_Addr.h"

#include "ace/OS.h"

 

#include "Request_Handler.h"

#include "Server.h"

#include "Constants.h"

 

using namespace ACE_Server;

 

int main(int argc, char *argv[])

{

     ACE_TP_Reactor tp_reactor;

     ACE_Reactor reactor(&tp_reactor, 1);

     ACE_Reactor::instance(&reactor, 1);

 

     ACE_Acceptor<Request_Handler, ACE_SOCK_ACCEPTOR> acceptor;

     ACE_INET_Addr addr(SERVER_PORT_NUM);

     if(acceptor.open(addr) == -1)

         return -1;

 

     Server server_tp;

     server_tp.activate(THR_NEW_LWP | THR_JOINABLE, SERVER_THREAD_POOL_SIZE);

     ACE_Thread_Manager::instance()->wait();

 

     return 0;

}

 

Constants.h

 

#ifndef __CONSTANTS_H_

#define __CONSTANTS_H_

 

namespace ACE_Server

{

     static const size_t SERVER_THREAD_POOL_SIZE = 5;   //进行数据接收的线程池大小

     static const size_t TASK_THREAD_POOL_SIZE = 5; //进行数据处理的线程池大小

     static const size_t BUFFER_SIZE = 4096;   //数据缓冲区大小

     static const size_t SERVER_PORT_NUM = 10101;   //服务器的通信端口号

}

 

#endif

 

Server.h

 

#ifndef __SERVER_H_

#define __SERVER_H_

 

#include "ace/Task.h"

 

namespace ACE_Server

{

     class Server: public ACE_Task_Base

     {

     public:

         virtual int svc(void);

     };

}

 

#endif

 

Server.cpp

 

#include "ace/Reactor.h"

 

#include "Server.h"

 

namespace ACE_Server

{

     int Server::svc(void)

     {

         int result = ACE_Reactor::instance()->run_reactor_event_loop();

         if(result == -1)

              return -1;

 

         return 0;

     }

}

 

Request_Handler.h

 

#ifndef __REQUEST_HANDLER_H_

#define __REQUEST_HANDLER_H_

 

#include "ace/Svc_Handler.h"

#include "ace/SOCK_Stream.h"

#include "ace/Synch.h"

#include "ace/Thread_Manager.h"

 

#include "Task_Manager.h"

 

namespace ACE_Server

{

     class Request_Handler: public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_MT_SYNCH>

     {

     public:

         Request_Handler(ACE_Thread_Manager *thr_mgr = 0);

 

     protected:

         virtual int handle_input(ACE_HANDLE fd = ACE_INVALID_HANDLE);

 

     private:

         static Task_Manager task_mgr;

     };

}

 

#endif

 

Request_Handler.cpp

 

#include "ace/OS.h"

#include "ace/Message_Block.h"

#include "ace/Thread_Manager.h"

#include "ace/Svc_Handler.h"

#include "ace/SOCK_Stream.h"

#include "ace/Synch.h"

#include "ace/Reactor.h"

 

#include "Request_Handler.h"

#include "Task_Manager.h"

#include "Constants.h"

 

namespace ACE_Server

{

     Task_Manager Request_Handler::task_mgr;

 

     Request_Handler::Request_Handler(ACE_Thread_Manager *thr_mgr): ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_MT_SYNCH> (thr_mgr)

     {

         this->reactor(ACE_Reactor::instance());

         task_mgr.activate();

     }

 

     int Request_Handler::handle_input(ACE_HANDLE fd)

     {

         char length[4] = {0};

         if(this->peer().recv_n(length, 4) == 4)

         {

              size_t msg_len = 0;

              for(int i = 0; i < 4; i++)

              {

                   msg_len |= (size_t)length[i] << (8 * i);

              }

 

              char msg[BUFFER_SIZE] = {0};

              if(this->peer().recv_n(msg, msg_len) == msg_len)

              {

                   ACE_Message_Block *mb = NULL;

                   ACE_NEW_RETURN(mb, ACE_Message_Block(msg_len, ACE_Message_Block::MB_DATA, 0, msg), -1);

                   mb->wr_ptr(msg_len);

                   task_mgr.putq(mb);

 

                   return 0;

              }

         }

         return -1;

     }

}

 

Task_Manager.h

 

#ifndef __TASK_MANAGER_H_

#define __TASK_MANAGER_H_

 

#include "ace/Task.h"

#include "ace/Synch.h"

 

namespace ACE_Server

{

     class Task_Manager: public ACE_Task<ACE_MT_SYNCH>

     {

     public:

         virtual int svc(void);

     };

}

 

#endif

 

Task_Manager.cpp

 

#include "ace/Message_Block.h"

 

#include "Task_Manager.h"

#include "Task_Worker.h"

#include "Constants.h"

 

namespace ACE_Server

{

     int Task_Manager::svc(void)

     {

         Task_Worker task_tp;

         task_tp.activate(THR_NEW_LWP | THR_JOINABLE, TASK_THREAD_POOL_SIZE);

 

         while(1)

         {

              ACE_Message_Block *mb = NULL;

              if(this->getq(mb) < 0)

              {

                   task_tp.msg_queue()->deactivate();

                   task_tp.wait();

              }

              task_tp.putq(mb);

         }

 

         return 0;

     }

}

 

Task_Worker.h

 

#ifndef __TASK_WORKER_H_

#define __TASK_WORKER_H_

 

#include "ace/Task.h"

#include "ace/Synch.h"

#include "ace/Message_Block.h"

 

namespace ACE_Server

{

     class Task_Worker: public ACE_Task<ACE_MT_SYNCH>

     {

     public:

         virtual int svc(void);

 

     private:

         void process_task(ACE_Message_Block *mb);

     };

}

 

#endif

 

Task_Worker.cpp

 

#include "ace/OS.h"

#include "ace/Message_Block.h"

 

#include "Task_Worker.h"

 

namespace ACE_Server

{

     int Task_Worker::svc(void)

     {

         while(1)

         {

              ACE_Message_Block *mb = NULL;

              if(this->getq(mb) == -1)

              {

                   continue;

              }

              process_task(mb);

         }

         return 0;

     }

 

     void Task_Worker::process_task(ACE_Message_Block *mb)

     {

         //进行数据处理,数据的起始地址为mb->rd_ptr(),长度为mb->length()

         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t) Processing task: %s length %d/n"), mb->rd_ptr(), mb->length()));

         ACE_OS::sleep(3);  //模拟数据处理过程

 

         mb->release();

     }

}

 

2．  客户端：应用程序将需要发送的若干消息放入一个消息队列，然后激活一个线程来发送所有消息到服务器端。

 

客户端代码如下：（共4个文件）

 

ACE_Client.cpp

 

#include "Client.h"

 

using namespace ACE_Client;

 

int main(int argc, char *argv[])

{

     Client client("localhost"); //服务器的IP地址或者服务器名称

 

     for(int i = 0; i < 5; i++)

     {

         char *task1 = "Is it a good day?";   //第1个task的数据

         size_t task1_len = 18; //第1个task的数据长度

         char *task1_t;     //无需修改

         ACE_NEW_RETURN(task1_t, char[task1_len + 4], -1);  //无需修改

         client.put_task(task1_t, task1, task1_len);    //无需修改

 

         char *task2 = "Yeah, it really is."; //第2个task的数据

         size_t task2_len = 20; //第2个task的数据长度

         char *task2_t;     //无需修改

         ACE_NEW_RETURN(task2_t, char[task2_len + 4], -1);  //无需修改

         client.put_task(task2_t, task2, task2_len);    //无需修改

 

         client.send_tasks();   //将上面的task全部发到服务器

 

         delete [] task1_t; //释放task1的内存

         delete [] task2_t; //释放task2的内存

     }

 

     return 0;

}

 

Constants.h

 

#ifndef __CONSTANTS_H_

#define __CONSTANTS_H_

 

#include "ace/Time_Value.h"

 

namespace ACE_Client

{

     static const size_t BUFFER_SIZE = 4096;   //数据缓冲区大小

     static const size_t SERVER_PORT_NUM = 10101;   //服务器的通信端口号

     static const ACE_Time_Value TIME_INTERVAL(0, 1000000);  //两次数据发送之间的时间间隔(0 s + 1000000 us = 1 s)

}

 

#endif

 

Client.h

 

#ifndef __CLIENT_H_

#define __CLIENT_H_

 

#include "ace/Task.h"

#include "ace/INET_Addr.h"

#include "ace/Synch.h"

 

namespace ACE_Client

{

     class Client: public ACE_Task<ACE_NULL_SYNCH>

     {

     public:

         Client(char *server);

         virtual int svc(void);

         char *put_task(char *msg_t, char *msg_s, size_t msg_len);

         void send_tasks(void);

 

     private:

         ACE_INET_Addr addr;

     };

}

 

#endif

 

Client.cpp

 

#include "ace/OS.h"

#include "ace/SOCK_Stream.h"

#include "ace/SOCK_Connector.h"

#include "ace/Message_Block.h"

#include "ace/Thread_Manager.h"

#include "ace/INET_Addr.h"

 

#include "Constants.h"

#include "Client.h"

 

namespace ACE_Client

{

     Client::Client(char *server)

     {

         addr = ACE_INET_Addr(SERVER_PORT_NUM, server);

     }

 

     int Client::svc(void)

     {

         ACE_SOCK_Stream stream;

         ACE_SOCK_Connector connector;

 

         if(connector.connect(stream, addr) < 0)

         {

              return -1;

         }

         else

         {

              while(1)

              {

                   ACE_Message_Block *mb = NULL;

                   if(this->getq(mb) == -1)

                   {

                       break;

                   }

 

                   ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t) Sending %s/n"), &(mb->rd_ptr()[4])));

 

                   stream.send_n(mb->rd_ptr(), mb->length());

                   mb->release();

 

                   ACE_OS::sleep(TIME_INTERVAL);

              }

         }

         stream.close();

 

          return 0;

     }

 

     char *Client::put_task(char *msg_t, char *msg_s, size_t msg_len)

     {

         for(int i = 0; i < 4; i++)

         {

              msg_t[i] = (char)((msg_len >> (8 * i)) & 0xff);

         }

         ACE_OS::memcpy(&msg_t[4], msg_s, msg_len);

 

         ACE_Message_Block *mb = NULL;

         ACE_NEW_RETURN(mb, ACE_Message_Block(msg_len + 4, ACE_Message_Block::MB_DATA, 0, msg_t), 0);

         mb->wr_ptr(msg_len + 4);

         this->putq(mb);

 

         return msg_t;

     }

 

     void Client::send_tasks(void)

     {

         this->activate();

         ACE_Thread_Manager::instance()->wait();

     }

}

 

全部完毕，希望大家能够喜欢：）

chenruichuan
关注
C/C++框架和第三方库汇总
编程与实战的博客
07-12 4522
根据读者反馈，发现此篇汇总获赞率异常的高，为了照顾一下新加入的粉丝，故重新发一遍，供粉丝查阅温习。值得学习的C语言开源项目- 1. WebbenchWebbench是一个在linux下使用...
C++网络编程ACE框架
05-02
网络编程关于ACE在Windows平台的下网络程序，它是基于平，非常多的网络编程小实例，特别有用
C++ ACE
weixin_34037977的博客
07-06 187
为什么80%的码农都做不了架构师？>>> ...
十五ACE编写简单的通信程序
07-17 140
该程序将演示如何将一个简单结构序列化后发送到网络上，如何从网络上接收到数据后反序列化回结构。 ACE的 C++ WRAPPER FACADE层将网络通信分成三种角色：连接者 (ACE_SOCK_Connector)、等待者 (ACE_SOCK_Acceptor)和传输者 (ACE_SOCK_Stream)。 ...
开源C/C++网络库比较：ACE、livevent和Boost
debugconsole的专栏
11-23 2924
ACE是一个大型的中间件产品，代码20万行左右，过于宏大，一堆的设计模式，架构了一层又一层，使用的时候， 要根据情况，看你从那一层来进行使用。支持跨平台。 Boost的ASIO是一个异步IO库，封装了对Socket的常用操作，简化了基于socket程序的开发。支持跨平台。 libevent是一个C语言写的网络库， 官方主要支持的是类linux 操作系统， 最新的版本添加了对window
采用C++的ACE库实现的一个通用的CS架构通信程序(VS2005源码)
02-04
1、服务器端：一个采用领导者/跟随者模型的线程池不断地接受从多个客户端发来的消息，并放入一个消息队列，然后又有一个采用半同步/半异步模型的线程池不断地从这个消息队列中取出消息进行处理。 2、客户端：应用...
ACE网络通信架构中文版
10-26
ACE是可以自由使用、开放源码的面向对象（OO）构架（Framework），提供了一组丰富的可复用C++包装外观（Wrapper Façade）和构架组件，可跨越多种平台完成通用的通信软件任务。本书详细描述了技术架构及编程实例，...
C++网络通信框架与XML解析库：ACE、StreamModule与Xerces详解
提到的是ACE（Adaptive Communication Environment），这是一个强大的C++库，专为并发通信软件设计，提供了事件多路分离、信号处理、进程间通信等多种核心模式，适用于各种平台的通用通信任务，适合在网络运维中实现...
C++ ACE 动态加载链接库
weixin_30654419的博客
06-24 290
添加头文件 #include <ace/DLL.h> #include <ace/DLL_Manager.h> 定义函数接口 typedef long (*PFN_TEST)(const char* szName); PFN_TEST g_pfnTest = NULL; 加载动态库(dll/so) ACE_TCHAR ...
C++网络编程 ACE
01-09
C++网络编程 卷1 运用ACE和模式消除复杂性.pdf C++网络编程 卷2 基于ACE和框架的系统化复用.pdf
C++ ACE 实现c/s通信demo
04-08
注：运行环境代码之前，先配置下ACE的环境，本系统基于ACE6.0编写。有兴趣研究的朋友可以看看，提出建设性问题。 代码是C/S结构，支持多客户端并发。 ACE环境搭建参考：http://blog.csdn.net/hireboy/article/details/8863458
C++ 网络编程套件ACE 资料
02-03
这些文档 有我下载整理的 也有我的学习笔记 主要是为了 初学ACE的人提供一点帮助，如果您在为Windows下部署ACE 有问题找不到好的解决办法。可以看看一下里面有一分ACE在Windows下vs2008的安装部署总结的文档。那个是一步一步操作后形成的文档，有贴图
C++实例(ACE模式简单分析)
技术资料库
12-10 1560
ACE将网络编程进行了模式化，以便你不必每次都重复相同的代码。　　网络编程需要处理的事情多括中断，并发，多线程等，程序格式相对固定，但是健壮的网络程序则相对复杂。为了处理这些情形，ACE内建了几个网络编程的模式。　　最基本的模式当然是直接使用sock进行单客户单服务器单线程的一对一模型，这种模式相对简单，也和ACE关系不大，但是这样编写的程序不能处理并发的情况，可用性很差或者说基本不具有可用性。　
采用C++的ACE库实现的一个通用的udp通信服务器程序
weixin_30468137的博客
03-01 121
觉得这个例子特别好，特此记录一下。 转载： 采用C++的ACE库实现的一个通用的udp通信服务器程序 - CSDN博客 http://blog.csdn.net/itclock/article/details/1036647 采用C++的ACE库实现的一个通用的C/S架构通信程序(最终版) - CSDN博客 http://blog.csdn.net/chenruichuan/ar...
【ACE】ACE 框架简单了解C++的C/S框架(ADAPTIVE Communication Environment)
bandaoyu的note
04-29 6921
1、ACE 是一个C/S框架(ACE自适配通信环境（ADAPTIVE Communication Environment）) 网络程序开发常遇见的问题： a) 跨平台。这一点相对比较容易，主要是针对类似多线程、socket通信等操作，定义统一的接口，使用define实现。基本上，只要定义良好，使用起来就很方便，也不需要多少改动。 b) Socket通信。在socket通信过程中，除了...
优秀的开源C＋＋库：ACE及其安装使用
知而后定
06-26 3809
开源C＋＋库：ACE及其安装使用什么是ACE？　　ACE自适配通信环境（ADAPTIVE Communication Environment）是可以自由使用、开放源码的面向对象（OO）框架（Framework），在其中实现了许多用于并发通信软件的核心模式。ACE提供了一组丰富的可复用C++ Wrapper Facade（包装外观）和框架组件，可跨越多种平台完成通用的通信软件任务。据推测在新的C
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值