क्या मैं का उपयोग कर समाप्त हो गया एक अलग दृष्टिकोण है के रूप में TCPServer एक अलग जानवर पूरी तरह है। उदाहरण here पोस्ट के बाद मैं एक वर्ग ServerApplication से इनहेरिट, और एक वर्ग जो अनिवार्य रूप से कनेक्शन हैंडलर एक SocketReactor से हो जाता है के साथ समाप्त हो गया।
Deamonizer हैडर:
class Daemon : public ServerApplication
{
public:
Daemon();
/// @Brief The main loop of the daemon, everything must take place here
int main();
};
Deamonizer कार्यान्वयन:
int Daemon::main()
{
// Server Socket
ServerSocket svs(2222);
// Reactor-Notifier
SocketReactor reactor;
Poco::Timespan timeout(2000000); // 2Sec
reactor.setTimeout(timeout);
// Server-Acceptor
SocketAcceptor<ConnectionHandler> acceptor(svs, reactor);
// Threaded Reactor
Thread thread;
thread.start(reactor);
// Wait for CTRL+C
waitForTerminationRequest();
// Stop Reactor
reactor.stop();
thread.join();
return Application::EXIT_OK;
}
हैंडलर वर्ग के रूप में लंबे समय के रूप में यह एक अनुरूप निर्माता है कुछ भी हो सकता है (इस के लिए पोको :: नेट दस्तावेज़ देखें)। मेरे मामले में हेडर कुछ इस तरह दिखता है:
:
class ConnectionHandler
{
public:
/**
* @Brief Constructor of the Connection Handler
* @Note Each object is unique to an accepted connection
* @Param SteamSocket is the socket accepting the connections
* @See SocketAcceptor http://pocoproject.org/docs/Poco.Net.SocketAcceptor.html
* @Param SocketReactor is the reacting engine (threaded) which creates notifications about the socket
*/
ConnectionHandler(StreamSocket &, SocketReactor &);
/**
* @Brief Destructor
*/
~ConnectionHandler();
/**
* @Brief Event Handler when Socket becomes Readable, i.e: there is data waiting to be read
*/
void onSocketReadable(const AutoPtr<ReadableNotification>& pNf);
/**
* @Brief Event Handler when Socket was written, i.e: confirmation of data sent away (not received by client)
*/
void onSocketWritable(const AutoPtr<WritableNotification>& pNf);
/**
* @Brief Event Handler when Socket was shutdown on the remote/peer side
*/
void onSocketShutdown(const AutoPtr<ShutdownNotification>& pNf);
/**
* @Brief Event Handler when Socket throws an error
*/
void onSocketError(const AutoPtr<ErrorNotification>& pNf);
/**
* @Brief Event Handler when Socket times-out
*/
void onSocketTimeout(const AutoPtr<TimeoutNotification>& pNf);
private:
/**
* @Brief Read bytes from the socket, depending on available bytes on socket
*/
void readBytes();
/**
* @Brief Send message to the socket
* @Param std::string is the message (null terminated)
*/
void sendMessage(std::string);
/// Stream Socket
StreamSocket _socket;
/// Socket Reactor-Notifier
SocketReactor& _reactor;
/// Received Data Buffer
std::vector<char *> in_buffer;
};
आप हैंडलर कैसे लागू आप पर निर्भर है, केवल एक चीज है कि आप क्या करने की जरूरत रजिस्टर है वर्ग तरीकों जो इतनी तरह की घटनाओं को संभाल प्रदान की
_reactor.addEventHandler(_socket,NObserver<ConnectionHandler, ReadableNotification>(*this, &ConnectionHandler::onSocketReadable));
_reactor.addEventHandler(_socket,NObserver<ConnectionHandler, ShutdownNotification>(*this, &ConnectionHandler::onSocketShutdown));
_reactor.addEventHandler(_socket,NObserver<ConnectionHandler, ErrorNotification>(*this, &ConnectionHandler::onSocketError));
_reactor.addEventHandler(_socket,NObserver<ConnectionHandler, TimeoutNotification>(*this, &ConnectionHandler::onSocketTimeout));
सब कुछ, दो वर्ग, कोड की कुछ पंक्तियां, सरल और साफ। बिल्कुल पोको पुस्तकालय प्यार करना शुरू कर दिया! :)
अच्छा रिएक्टर :) धन्यवाद Alex –