ACE通信框架的一些例子(包括MFC)

一. ace的编译安装

环境：XP，VC6.0+SP6，ACE5.4

1. 解压缩ace源代码包，假设在D:\ACE_wrappers

2. 使用vc打开D:\ACE_wrappers\ace\ace.dsw

3. 工作区上有三个工程，在ACE工程的头文件中找到config.h

4. 双击打开这个文件，会有提示这个文件不存在是否创建，点是

5. 在config.h中写入#include "ace/config-win32.h"表示windos 32位操作系统

6. 在ACE工程上右键Settings... 选择c/c++ 在Caterory中选择 Code Generation 然后在 Use run-time library 中选择 Debug Multithreaded DLL

7. 在ACE工程上右键 build(selection only)

8. 编译后会在D:\ACE_wrappers\lib 目录中生成ACEd.lib ACEd.dll ACEd.exp ACEd.pdb等文件

9. D:\ACE_wrappers\ ACE-INSTALL.html有完整具体的安装指南

二. Ace的一些概念

网上找到描述，比较生动容易理解。

前摄器（Proactor）－异步的事件多路分离器、处理器，是核心处理类。启动后由3个线程组成（你不需要关心这三个线程，我只是让你知道一下有这回事存在）。

接受器（Acceptor）－用于服务端，监听在一个端口上，接受用户的请求。

连接器（Connector）－用于客户端，去连接远程的监听。当然，如果远程是ACE写的，就是Acceptor。

异步模式－即非阻塞模式。网络的传输速度一般来讲为10Mbps、100Mbps、1000Mbps。拿千兆网来说，实际的传输速度为1000Mbps/8大概为128KB左右。我们的CPU一般为P4 3.0GHZ，如果是32位的处理器，一秒钟大概可以处理6G的字节，那么，128KB的网络速度是远远及不上处理器的速度的。网络发送数据是一位一位发送出去的，如果CPU等在这里，发送完成函数才结束，那么，处理器浪费了大量时间在网络传输上。

操作系统提供了异步的模式来传输网络数据，工作模式即：应用程序把要发送的数据交给操作系统，操作系统把数据放在系统缓冲区后就告诉应用程序OK了，我帮你发，应用程序该干嘛干嘛去。操作系统发送完成后，会给应用系统一个回执，告诉应用程序：刚才那个包发送完成了！

举个例子：你有几封邮件和包裹要发，最有效率的办法是什么？你把邮件和包裹及交给总台，总台MM说，好了，你帮你发，你忙去吧！然后你去工作了。过了一会，总台MM打电话告诉你：“刚才我叫快递公司的人来了，把你的包裹发出去了。邮局的人也来了，取走了邮件，放心好了”。同样，如果你知道今天会有包裹来，比如你在淘宝上购物了，你能成天等在总台？你应该告诉总台MM：“今天可能有我的一个快递，你帮我收一下，晚上请你肯德基！”。MM：“看在肯得基的面子上，帮你收了”。某个时间，MM打电话来了：“帅哥，你的包裹到了，我帮你签收了，快来拿吧。”

因为操作系统是很有效率的，所有，他在后台收发是很快的。应用程序也很简单。Proactor就是这种异步模式的。Proactor就是总台MM；ACE_Service_Handle就是总台代为收发邮件的公司流程。

三. 配置ace的工程

在使用到ace的工程中都要进行的一些设置

1. 选择Project->Settings...

2. 选择c/c++ 在Caterory中选择 Code Generation 然后在 Use run-time library 中选择 Debug Multithreaded DLL

3. 在Caterory中选择Preprocessor 在Preprocessor definitions 中添加ACE_AS_STATIC_LIBS 使用逗号与前面的内容隔开 在Additional include directories 中写入ACE的根目录D:\ACE_wrappers

4. 选择 Link 在Caterory中选择Input 在Additional library path 中加入D:\ACE_wrappers\lib 在Object/library modules 后追加aced.lib 用空格与前面的内容隔开

5. 设置完整以后重启vc

四. 基于Console的服务器端

服务器端的功能：在指定端口进行监听，在后台打印客户端发来的信息，然后向客户端返回“serer say hello”信息。

ACE_Service_Handle主要就是定义了一些回调函数。

当有客户端连接上来，连接建立成功后Proactor会调用这个方法。

1、virtual void open (ACE_HANDLE handle, ACE_Message_Block&message_block);

当用户要读的数据读好了后，调用这个方法

2、 virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);

当用户要写的数据在网卡上发送成功后，Proactor会回调这个方法

3、virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);

4、 virtual void handle_time_out (const ACE_Time_Value &tv, const void *act=0);

建立一个基于Console的服务器工程

下面是服务器的代码，不是很难，结合注释看，很容易看懂

Cpp代码

1. #include "stdafx.h"  
2. #include "ace/Addr.cpp"  
3. #include "ace/Time_Value.cpp"  
4. #include "ace/Message_Queue.h"  
5. #include "ace/Asynch_IO.h"  
6. #include "ace/OS.h"  
7. #include "ace/Proactor.h"  
8. #include "ace/Asynch_Acceptor.h"  
9. #include "ace/SOCK_SEQPACK_Association.h"  
10. class Proactive_Service : public ACE_Service_Handler  
11. {  
12. public:  
13.     ~Proactive_Service ()  
14.     {  
15.         if (this->handle () != ACE_INVALID_HANDLE)  
16.             ACE_OS::closesocket (this->handle ());  
17.     }  
18.     /******************************************************/  
19. /*每当客户端连接到服务器就会调用此函数                 */  
20.     /******************************************************/  
21.     virtual void open (ACE_HANDLE h, ACE_Message_Block&)  
22.     {  
23.         this->handle (h);  
24.         //打开与客户端的读取流  
25.         if (this->reader_.open (*this) != 0 )  
26.         {  
27.             delete this;  
28.             return;  
29.         }  
30.         //开打与客户端的写出流  
31.         if (this->writer_.open (*this) != 0 )  
32.         {  
33.             delete this;  
34.             return;  
35.         }  
36.           
37.         ACE_Message_Block *mb = new ACE_Message_Block(buffer,1024);  
38.         if (this->reader_.read (*mb, mb->space ()) != 0)  
39.         {  
40.             ACE_OS::printf("Begin read fail\n");  
41.             delete this;  
42.             return;  
43.         }  
44.           
45.         return;  
46.     }  
47.       
48.     //异步读完成后会调用此函数  
49.     virtual void handle_read_stream  
50.         (const ACE_Asynch_Read_Stream::Result &result){  
51.         ACE_Message_Block &mb = result.message_block ();  
52.         //如果读取失败说明客户端关闭，在这里删除客户端连接资源  
53.         if (!result.success () || result.bytes_transferred () == 0)  
54.         {  
55.             mb.release ();  
56.             delete this;  
57.             return;  
58.         }  
59.           
60.         mb.copy("");    //为字符串添加结束标记'\0'  
61.         ACE_OS::printf("rev:\t%s\n",mb.rd_ptr());  
62.         mb.release();  
63.         ACE_Message_Block *mbb = new ACE_Message_Block(100);  
64.         mbb->copy("serer say hello");  
65.         if (this->writer_.write(*mbb,mbb->length()) !=0)  
66.         {  
67.             delete this;  
68.             return;  
69.         }  
70.         ACE_Message_Block *nmb = new ACE_Message_Block(buffer,1024);  
71.         if (this->reader_.read (*nmb, nmb->space ()) != 0)  
72.               
73.             return;  
74.     }  
75.   
76.     //异步写完成后会调用此函数  
77.     virtual void handle_write_dgram  
78.         (const ACE_Asynch_Write_Stream::Result &result)  
79.     {  
80.         ACE_Message_Block &mb = result.message_block ();  
81.         mb.release();  
82.         return;  
83.     }  
84.       
85. private:  
86.     ACE_Asynch_Read_Stream reader_;  
87.     ACE_Asynch_Write_Stream writer_;  
88.     char buffer[1024];  
89. };  
90.   
91.   
92. int main(int argc, char *argv[])   
93. {  
94.     ACE::init();//初始化dll资源  
95.     int port=20002;//指定监听端口  
96.     ACE_Asynch_Acceptor<Proactive_Service> acceptor;  
97.       
98.     //在指定的端口上进行监听  
99.     if (acceptor.open (ACE_INET_Addr (port)) == -1)  
100.         return -1;  
101.     //开始等待客户端的连接  
102.     ACE_Proactor::instance ()->proactor_run_event_loop();  
103.     ACE::fini();//释放dll资源  
104.     return 0;   
105. }  

五. 基于Console的客户端

客户端实现的功能是在连接上服务器的时候给服务器发送当前的系统的时间，接收到服务器信息的时候，把信息打印找后台输出屏幕上

建立一个基于Console的客户端工程

把下面的代码贴到工程里面

Cpp代码

1. #include "stdafx.h"  
2. #include "ace/SOCK_Connector.h"  
3. #include "ace/OS_NS_string.h"  
4. #include "ace/OS_NS_stdio.h"  
5. #include "ace/Addr.cpp"  
6. #include "ace/Time_Value.cpp"  
7. #include "ace/Message_Queue.h"  
8. #include "ace/Asynch_IO.h"  
9. #include "ace/OS.h"  
10. #include "ace/Proactor.h"  
11. #include "ace/Asynch_Connector.h"  
12.   
13. class Proactive_Client : public ACE_Service_Handler  
14. {  
15. public:  
16.     ~Proactive_Client ()  
17.     {  
18.         if (this->handle () != ACE_INVALID_HANDLE)  
19.             ACE_OS::closesocket (this->handle ());  
20.     }  
21.       
22.     virtual void open (ACE_HANDLE h, ACE_Message_Block&)  
23.     {  
24.         this->handle (h);  
25.         if (this->reader_.open (*this) != 0 )  
26.         {  
27.             delete this;  
28.             return;  
29.         }  
30.         if (this->writer_.open (*this) != 0 )  
31.         {  
32.             delete this;  
33.             return;  
34.         }  
35.           
36.         ACE_Message_Block *mb = new ACE_Message_Block(buffer,1024);  
37.         if (this->reader_.read (*mb, mb->space ()) != 0)  
38.         {  
39.             delete this;  
40.             return;  
41.         }  
42.           
43.         ACE_OS::printf("connceted\n");  
44.         time_t now = ACE_OS::gettimeofday().sec();  
45.         char *time = ctime(&now);        //获取当前时间的字符串格式  
46.         ACE_Message_Block *mbb = new ACE_Message_Block(100);  
47.         mbb->copy(time);  
48.           
49.         if (this->writer_.write(*mbb,mbb->length()) !=0)  
50.         {  
51.             delete this;  
52.             return;  
53.         }  
54.       
55.         return;  
56.     }  
57.       
58.     //异步读完成后会调用此函数  
59.     virtual void handle_read_stream  
60.         (const ACE_Asynch_Read_Stream::Result &result)  
61.     {  
62.         ACE_Message_Block &mb = result.message_block ();  
63.         if (!result.success () || result.bytes_transferred () == 0)  
64.         {  
65.             mb.release ();  
66.             delete this;  
67.             return;  
68.         }  
69.           
70.         mb.copy("");    //为字符串添加结束标记'\0'  
71.         ACE_OS::printf("rev:\t%s\n",mb.rd_ptr());  
72.         mb.release();  
73.           
74.         ACE_Message_Block *nmb = new ACE_Message_Block(buffer,1024);  
75.         if (this->reader_.read (*nmb, nmb->space ()) != 0)  
76.               
77.             return;  
78.     }  
79.       
80.     //异步写完成后会调用此函数  
81.     virtual void handle_write_dgram  
82.         (const ACE_Asynch_Write_Stream::Result &result)  
83.     {  
84.         ACE_Message_Block &mb = result.message_block ();  
85.         mb.release();  
86.         return;  
87.     }  
88.       
89. private:  
90.     ACE_Asynch_Write_Stream writer_;  
91.     ACE_Asynch_Read_Stream reader_;  
92.     char buffer[1024];  
93. };  
94.   
95. int main(int argc, char *argv[])   
96. {  
97.     ACE::init();  
98.     ACE_INET_Addr addr(20002,"127.0.0.1");//服务器地址和端口  
99.     ACE_Asynch_Connector<Proactive_Client> connector;  
100.     connector.open();  
101.     if (connector.connect(addr) == -1)  
102.         return -1;  
103.     ACE_Proactor::instance()->proactor_run_event_loop();  
104.     ACE::fini();  
105.     return 0;   
106. }  

这里可以发现客户端和服务器端的代码基本上一样的，就是建立连接后一个函数负责发送数据，一个函数负责接收数据。作为客户端使用这样的方式去接受服务器随时发过来的数据，是不合理ACE_Proactor::instance()-> proactor_run_event_loop(); 这个语句使得这个程序进入一个死循环，从而无法做其他事情了。下面介绍客户端实现的另一种方式。

六. 基于FMC的客户端

建立一个基于对话框的FMC程序，在窗体上放置三个按钮，一个“连接”按钮，一个“发送”按钮，一个“退出”按钮。在放一个文本输入框，然后在文本输入框上右键选择ClassWizard->Member Variables 为文本输入框建立一个变量为m_send如下图

在工程中加入下面的文件

RecvTask.h

Cpp代码

1. #ifndef RECVTASK_H  
2. #define RECVTASK_H  
3.   
4. #include "ace/Task.h"  
5. #include "ace/OS.h"  
6. #include "ace/INET_Addr.h"  
7. #include "ace/SOCK_Connector.h"  
8. #define MSG_LEN_BYTES 128  
9. #define TIME_OUT_VALUE 1000000    
10.   
11. class RecvTask: public ACE_Task<ACE_MT_SYNCH>  
12. {  
13. public:  
14.     RecvTask();  
15.     int open(void* p);  
16.     int close(u_long);  
17.     //接收服务器的信息  
18.     int svc(void);  
19. };  
20. #endif  

RecvTask.cpp

Cpp代码

1. #include "stdafx.h"  
2. #include "RecvTask.h"  
3. #include "ace/ACE.h"  
4. #include "ace/OS.h"  
5. #include "ace/SOCK_Connector.h"  
6. #include "ace/INET_Addr.h"  
7. #include "ace/Task.h"  
8. #include "Client.h"  
9. int RecvTask::svc(void)  
10. {  
11.     while(true)  
12.     {  
13.         Client::getInstance()->recvMessage();  
14.         ACE_OS::sleep(ACE_Time_Value( 0, 5000 ));  
15.     }  
16. }  
17.   
18. int RecvTask::open(void* p)  
19. {  
20.     activate();  
21.     return 0;  
22. }  
23.   
24. int RecvTask::close(u_long)  
25. {  
26.     return 0;  
27. }  
28.   
29. RecvTask::RecvTask(){}  

Client.h

Cpp代码

1. #ifndef CLIENR_H  
2. #define CLIENR_H  
3. #include "stdafx.h"  
4. #include "ace/ACE.h"  
5. #include "ace/OS.h"  
6. #include "ace/SOCK_Connector.h"  
7. #include "ace/INET_Addr.h"  
8. #include "ace/Task.h"  
9. #include "RecvTask.h"  
10.   
11.   
12. class Client  
13. {  
14. public:  
15.     ~Client();  
16.     /***************************************************************/  
17.     /* 根据ip地址和端口号,连接服务器,如果连接成功返回0，失败返回-1 */  
18.     /***************************************************************/  
19.   
20.     int connect(int port,char * localhost);  
21.   
22.     /***************************************************************/  
23.     /* 获取客户端实例                                              */  
24.     /***************************************************************/  
25.   
26.     static Client * getInstance();  
27.   
28.     /***************************************************************/  
29.     /* 给服务器发送数据信息，返回发的字节数                        */  
30.     /***************************************************************/  
31.     int sendMessage(char * msg);  
32.       
33.     /**************************************************************/  
34.     /* 关闭与远程服务器的连接，成功返回0,失败返回-1              */  
35.     /**************************************************************/  
36.     int close();  
37.       
38.     void recvMessage();  
39.   
40. private:  
41.     Client();  
42.     ACE_SOCK_Connector connector;  
43.     ACE_Thread_Mutex mutex;  
44.     RecvTask * recvTask;  
45.     static Client * instance;  
46.     static BOOL hasInstance;  
47.     ACE_SOCK_Stream stream;  
48. };  
49. #endif  

Client.cpp

Cpp代码

1. #include "stdafx.h"  
2. #include "RecvTask.h"  
3. #include "ace/ACE.h"  
4. #include "ace/OS.h"  
5. #include "ace/SOCK_Connector.h"  
6. #include "ace/INET_Addr.h"  
7. #include "ace/Task.h"  
8. #include "Client.h"  
9. #include "ace/OS_NS_string.h"  
10. Client * Client::instance=NULL;  
11. BOOL Client::hasInstance=false;  
12. Client::~Client()  
13. {  
14.     if (recvTask!=NULL)  
15.     {  
16.         delete recvTask;  
17.         recvTask=NULL;  
18.     }  
19.   
20. }  
21. Client * Client::getInstance()  
22. {  
23.     if (!hasInstance)  
24.     {  
25.         instance= new Client();  
26.         hasInstance=true;  
27.     }  
28.     return instance;  
29. }  
30. int Client::connect(int port,char * localhost)  
31. {  
32.     recvTask = new RecvTask();  
33.     //stream = new ACE_SOCK_Stream();  
34.     ACE_INET_Addr  remote_addr(port,localhost);  
35.     int result=connector.connect(stream, remote_addr);  
36.     if (result==0)  
37.     {  
38.         recvTask->open(0);   
39.     }else{  
40.         recvTask->close(0);  
41.         delete recvTask;  
42.     }  
43.     return result;  
44. }  
45. int Client::sendMessage(char * msg)  
46. {  
47.     return stream.send_n(msg,ACE_OS::strlen(msg));  
48.     //return recvTask->getStream().send_n(msg,ACE_OS::strlen(msg));  
49. }  
50. void Client::recvMessage()  
51. {  
52.     size_t recv_len;  
53.     char sLen[MSG_LEN_BYTES + 1];  
54.       
55.     ACE_Time_Value t(0, TIME_OUT_VALUE / 2);  
56.     stream.recv_n(sLen, MSG_LEN_BYTES, &t, &recv_len);  
57.     if (recv_len!=0)  
58.     {  
59.         sLen[recv_len]=0;  
60.         AfxMessageBox(sLen);  
61.           
62.     }  
63. }  
64. int Client::close()  
65. {  
66.     recvTask->close(0);  
67.     stream.close();  
68.     return 0;  
69. }  
70.   
71. Client::Client()  
72. {  
73.   
74. }  

双击“连接”按钮，贴入连接服务器的代码

Cpp代码

1. ACE::init();  
2.     if(Client::getInstance()->connect(20002,"127.0.0.1")==0)  
3.     {  
4.         AfxMessageBox("连接成功");  
5.     }else{  
6.         AfxMessageBox("连接失败");  
7.           
8.     }  

并在这个文件头部引入

#include "ace/Addr.cpp"

#include "Client.h"

双击“发送”按钮，写下发送的代码

Cpp代码

1. UpdateData(true);  
2. Client::getInstance()->sendMessage(m_send.GetBuffer(m_send.GetLength()));  

双击“退出”按钮，写下退出的代码

Cpp代码

1. Client::getInstance()->close();  
2. ACE::fini();  
3. CDialog::OnCancel();  

首先运行前面的服务器程序，然后再运行FMC程序，先连接服务器，然后再发生数据。

下面是运行的效果

注：运行的时候把ACEd.dll拷贝的exe 所在的目录