基于ACE_Event_Handler的异步UDP通信

1、创建基于ACE_Event_Handler的异步服务端

AsyncUDPServer.h

 1 #include <ace/Event_Handler.h>
 2 #include <ace/Reactor.h>
 3 #include <ace/SOCK_Dgram.h>
 4 #include <ace/INET_Addr.h>
 5 #include <ace/Log_Msg.h>
 6 #include <ace/OS.h>
 7 class AsyncUDPServer :public ACE_Event_Handler
 8 {
 9 public:
10     AsyncUDPServer(ACE_SOCK_Dgram& sock);
11 
12 protected:
13     virtual int handle_input(ACE_HANDLE fd);
14 
15 private:
16     ACE_SOCK_Dgram& sock_;
17 };

AsyncUDPServer.cpp

 1 #include "AsyncUDPServer.h"
 2 #include <iostream>
 3 AsyncUDPServer::AsyncUDPServer(ACE_SOCK_Dgram& sock):sock_(sock)
 4 {
 5 }
 6 
 7 int AsyncUDPServer::handle_input(ACE_HANDLE fd)
 8 {
 9     char buffer[4096];
10     ACE_INET_Addr client_addr;
11     ssize_t bytes = sock_.recv(buffer, sizeof(buffer),client_addr);  // 异步接收
12     
13     if (bytes > 0) {
14         ACE_DEBUG((LM_DEBUG, "收到来自客户端 %s:%d 的数据: %s\n",
15             client_addr.get_host_addr(),
16             client_addr.get_port_number(),
17             buffer));
18         // 异步回显（非必须）
19         sock_.send(buffer, bytes, client_addr);
20     }
21     else
22         std::cout << ACE_OS::last_error();
23     return 0;
24 }

2、创建基于ACE_Event_Handler的异步客户端

AsyncUDPClient.h

 1 class AsyncUDPClient : public ACE_Event_Handler 
 2 {
 3 public:
 4     AsyncUDPClient(ACE_INET_Addr server_addr);
 5 
 6     int init_env(ACE_SOCK_Dgram sock);
 7     void send_data(const char* data);
 8     void start();
 9 protected:
10 
11     virtual int handle_input(ACE_HANDLE fd);
12 private:
13     ACE_SOCK_Dgram sock_;
14     ACE_INET_Addr server_addr_;
15     ACE_Reactor reactor;
16 };

 AsyncUDPClient.cpp

AsyncUDPClient::AsyncUDPClient(ACE_INET_Addr server_addr) : server_addr_(server_addr)
{
}

int AsyncUDPClient::init_env(ACE_SOCK_Dgram sock)
{
    sock_ = sock;
    ACE_INET_Addr server_addr(6000);
    if (sock_.open(server_addr) == -1) {  // 绑定随机端口
        ACE_ERROR((LM_ERROR, "客户端套接字初始化失败\n"));
        return -1;
    }
}

void AsyncUDPClient::send_data(const char * data)
{
    sock_.send(data, ACE_OS::strlen(data),server_addr_);
}

void AsyncUDPClient::start()
{
    reactor.register_handler(sock_.get_handle(),this, ACE_Event_Handler::READ_MASK);
    reactor.run_reactor_event_loop();
    sock_.close();
}

int AsyncUDPClient::handle_input(ACE_HANDLE fd)
{
    char buffer[4096];
    ACE_INET_Addr sender_addr;
    ssize_t bytes = sock_.recv(buffer, sizeof(buffer),sender_addr);
    if (bytes > 0) {
        ACE_DEBUG((LM_DEBUG, "收到服务器响应: %s\n", buffer));
    }
    else
        std::cout << ACE_OS::last_error();
    return 0;
}

3、创建服务端接收-发送方法启动事件循环

 1 int run_server()
 2 {
 3     ACE::init();
 4     ACE_Reactor reactor;
 5 
 6     // 创建 UDP 套接字并绑定端口
 7     ACE_INET_Addr server_addr(5000);
 8     ACE_SOCK_Dgram sock;
 9 
10     if (sock.open(server_addr) == -1) {
11         ACE_ERROR((LM_ERROR, "绑定失败: %p\n", ACE_OS::last_error()));
12         return 1;
13     }
14 
15     // 注册事件处理器
16     AsyncUDPServer handler(sock);
17     reactor.register_handler(sock.get_handle(),&handler, ACE_Event_Handler::READ_MASK);
18 
19     ACE_DEBUG((LM_DEBUG, "异步 UDP 服务器已启动，监听端口 5000...\n"));
20     reactor.run_reactor_event_loop();  // 启动事件循环
21 
22     sock.close();
23     ACE::fini();
24     return 1;
25 }

4、创建客户端接收-发送方法并启动事件循环

1 ACE_INET_Addr server_addr(5000, "127.0.0.1");
2 AsyncUDPClient client(server_addr);
3 void run_client()
4 {
5     ACE_SOCK_Dgram sock;
6     client.init_env(sock);
7     client.start();
8 }

5、启动服务端、客户端异步事件循环

 1 int main(int argc, char* argv[])
 2 {
 3     //异步通信
 4     std::thread tr(run_server);
 5     tr.detach();
 6 
 7     std::thread tr1(run_client);
 8     tr1.detach();
 9 
10     char a;
11 等待输入:    std::cin >> a;
12     if (a == 'a')
13     {
14         client.send_data("7788990000000000000000000000000");
15         goto 等待输入;
16     }
17     //异步通信
18     return 0;
19 }

6、测试过程演示

 

posted @ 2025-03-20 10:46  左边的翼  阅读(23)  评论(0)    收藏  举报