poco SocketReactor 是什么 ，并给出完整 的例子

Poco SocketReactor是Poco网络编程库中的一个类，用于实现异步事件驱动的网络编程。通过SocketReactor，我们可以将套接字的读写、连接和关闭等事件注册到Reactor中，当这些事件发生时，Reactor会自动调用相应的回调函数来处理这些事件。

以下是一个Poco SocketReactor的完整示例代码，该示例创建了一个TCP服务器，通过SocketReactor监听客户端连接，并在收到客户端连接后向客户端发送一条欢迎消息。

#include "Poco/Net/ServerSocket.h"
#include "Poco/Net/SocketReactor.h"
#include "Poco/Net/SocketAcceptor.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/NObserver.h"
#include "Poco/Delegate.h"
#include <iostream>

using Poco::Net::ServerSocket;
using Poco::Net::SocketReactor;
using Poco::Net::SocketAcceptor;
using Poco::Net::StreamSocket;
using Poco::NObserver;
using Poco::delegate;

class MySocketHandler
{
public:
    MySocketHandler(StreamSocket& socket, SocketReactor& reactor):
        _socket(socket),
        _reactor(reactor)
    {
        _reactor.addEventHandler(_socket, NObserver<MySocketHandler, ReadableNotification>(*this, &MySocketHandler::onReadable));
    }

    void onReadable(const N::ReadableNotification& notification)
    {
        char buffer[1024];
        int n = _socket.receiveBytes(buffer, sizeof(buffer));
        if (n > 0)
        {
            std::string message(buffer, n);
            std::cout << "Received message: " << message << std::endl;
            _socket.sendBytes(message.c_str(), message.length());
        }
        else
        {
            _reactor.removeEventHandler(_socket, NObserver<MySocketHandler, ReadableNotification>(*this, &MySocketHandler::onReadable));
            delete this;
        }
    }

private:
    StreamSocket _socket;
    SocketReactor& _reactor;
};

class MyAcceptorHandler
{
public:
    MyAcceptorHandler(ServerSocket& socket, SocketReactor& reactor):
        _socket(socket),
        _reactor(reactor),
        _acceptor(socket, _reactor)
    {
        _reactor.addEventHandler(_socket, NObserver<MyAcceptorHandler, ReadableNotification>(*this, &MyAcceptorHandler::onReadable));
    }

    void onReadable(const N::ReadableNotification& notification)
    {
        StreamSocket socket = _acceptor.acceptConnection();
        std::cout << "Accepted connection from: " << socket.peerAddress().toString() << std::endl;
        std::string message = "Welcome to the server!";
        socket.sendBytes(message.c_str(), message.length());
        new MySocketHandler(socket, _reactor);
    }

private:
    ServerSocket _socket;
    SocketReactor& _reactor;
    SocketAcceptor<MySocketHandler> _acceptor;
};

int main(int argc, char** argv)
{
    unsigned int serverPort = 12345; // 服务器端口

    // 创建服务器套接字并绑定到指定端口
    ServerSocket serverSocket(serverPort);
    SocketReactor reactor;

    // 注册连接事件到Reactor中
    MyAcceptorHandler acceptorHandler(serverSocket, reactor);

    // 运行Reactor事件循环
    reactor.run();

    return 0;
}

在上述代码中，我们首先创建了一个ServerSocket对象，并将其绑定到指定的端口。然后创建了一个SocketReactor对象，并将连接事件注册到Reactor中。当有客户端连接时，SocketReactor会自动调用MyAcceptorHandler::onReadable函数来处理连接事件，并创建一个MySocketHandler对象来处理客户端的读写事件。当客户端断开连接时，MySocketHandler会自动从Reactor中删除，并释放相关资源。

需要注意的是，该示例中的所有网络操作都是异步的，即程序不会在读写数据时阻塞，而是通过回调函数来处理数据。如果需要同步操作，可以使用Poco提供的同步网络编程接口。