जिम्मेदारी डिजाइन पैटर्न की श्रृंखला

अन्य पैटर्न का वर्णन पढ़ें ।

समस्या

संभावित रूप से बड़ी संख्या में हैंडलर के साथ सिस्टम में घटनाओं / अनुरोधों / संदेशों के प्रवाह को संसाधित करने के लिए प्रभावी रूप से और तंत्र को लागू करें।

विवरण

इवेंट / हैंडलर मॉडल का विभिन्न क्षेत्रों के सॉफ्टवेयर सिस्टम में व्यापक रूप से उपयोग किया जाता है। मूल रूप से, यह एक ग्राफिकल यूजर इंटरफेस है जहां यूजर एक्शन द्वारा उत्पन्न घटनाओं को इंटरफेस तत्वों द्वारा विभिन्न तरीकों से नियंत्रित किया जाता है। हमें WinAPI के बारे में नहीं भूलना चाहिए, जो बहुत बार ऐसे मॉडल को लागू करता है। ज्यादातर स्रोतों में, इस मॉडल को इवेंट लूप कहा जाता है।


एक तरफ, सब कुछ काफी पारदर्शी है। कई प्रकार के संदेश हैं; इन संदेशों के लिए कई हैंडलर हैं। कार्य एक विशिष्ट प्रोसेसर के साथ स्ट्रीम में प्रत्येक संदेश को अपने विशिष्ट प्रकार के साथ संसाधित करना है। सीधे शब्दों में कहें, तो आपके पास संदेश प्रकार और हैंडलर को जोड़ने के लिए एक प्रभावी तंत्र होना चाहिए।

ज्यादातर मामलों में, सिस्टम में एक निश्चित और कम संख्या में हैंडलर के साथ, यह इस प्रणाली को लागू करने के लिए पर्याप्त है यदि तत्कालीन निर्माण पर आधारित है। हालांकि, यह हमेशा इतना आसान नहीं होता है। सबसे पहले, यह हमेशा अग्रिम में नहीं जाना जाता है कि कितने हैंडलर की आवश्यकता है। दूसरे, सिस्टम में एक नए प्रकार के संदेश को जोड़ना आमतौर पर एक नए हैंडलर की उपस्थिति की ओर जाता है, जिसका परिचय पहले से ही वास्तव में मुश्किल काम होता जा रहा है।

ऐसी समस्याओं को हल करने के लिए, एक टेम्पलेट है - "जिम्मेदारियों की श्रृंखला"।

टेम्पलेट का विचार हैंडलर की एक आवर्तक पाइपलाइन को व्यवस्थित करना है जिसमें प्रत्येक हैंडलर या तो एक आने वाले संदेश (उदाहरण के लिए, केवल एक निश्चित प्रकार के संदेश) को संसाधित कर सकता है या पाइपलाइन में अगले हैंडलर को संसाधित कर सकता है। प्रसंस्करण का एक और संस्करण और बाद में संचरण संभव है। उसी समय, किसी विशेष संदेश के प्रसंस्करण की शुरुआत करने के लिए, क्लाइंट को केवल इसे पाइप लाइन में पहले प्रोसेसर को पास करने की आवश्यकता होती है।

व्यावहारिक उदाहरण

एक कंप्यूटर नेटवर्क - शायद टेम्पलेट का सबसे स्पष्ट उदाहरण पर विचार करें। दरअसल - बड़ी संख्या में हैंडलर - नेटवर्क नोड (कंप्यूटर, सर्वर, राउटर) और बड़ी संख्या में नेटवर्क अनुरोध।

मान लीजिए कि एक सरलीकृत और काल्पनिक नेटवर्क मॉडल में 4 प्रकार के प्रोसेसर हैं - एक नेटवर्क, एक राउटर, एक फारवर्डर और एक सर्वर। इसलिए केवल एक प्रकार का अनुरोध है - सर्वर प्रोसेसिंग के लिए एक अनुरोध। हैंडलर्स का निम्नलिखित व्यवहार होता है: एक नेटवर्क बस अपने वातावरण में एक अनुरोध भेजता है, एक राउटर एक नेटवर्क से दूसरे नेटवर्क पर एक अनुरोध भेजता है, एक फारवर्डर एक विशिष्ट मेजबान को एक अनुरोध भेजता है, और सर्वर अनुरोध को संसाधित करता है।

मेजबान प्रोसेसर की एक पाइपलाइन हैं। अनुरोध एक विशिष्ट संदेश है। अनुरोध, श्रृंखला के साथ आगे बढ़ने (संसाधित, अग्रेषित) इसके प्रत्येक नोड द्वारा संसाधित किया जाता है और पारित किया जाता है। जब तक यह अंत में सर्वर द्वारा संसाधित नहीं होता है।

वर्ग आरेख

मुख्य बिंदु जिस पर आपको ध्यान देना चाहिए वह कन्वेयर प्रसंस्करण के आयोजन की विधि है। इस मामले में, निम्नलिखित दृष्टिकोण का उपयोग किया जाता है। सभी हैंडलर एक अमूर्त वर्ग को लागू करते हैं - RequestHandled, जिसमें पाइपलाइन में अगले हैंडलर को प्रसंस्करण जिम्मेदारियों को सौंपने के लिए स्वयं (उत्तराधिकारी) का संदर्भ होता है। ऐसे डेलिगेशन को डिफॉल्ट रूप से लागू करता है।

C ++ कार्यान्वयन

//  #ifndef REQUEST_H #define REQUEST_H #include <string> using namespace std; class Request { private: protected: public: string requestString; Request(string requestString) : requestString(requestString) { } }; #endif //  #ifndef REQUEST_HANDLER_H #define REQUEST_HANDLER_H #include "Request.h" class RequestHandler { protected: RequestHandler *successor; public: RequestHandler(); RequestHandler(RequestHandler *successor) : successor(successor) { } virtual void handleRequest(const Request& request) { successor->handleRequest(request); } }; RequestHandler::RequestHandler() { } #endif //  #ifndef HOST_H #define HOST_H #include "RequestHandler.h" class Host : public RequestHandler { private: protected: public: Host(); Host(Host *host); }; Host::Host() { } Host::Host(Host *host) : RequestHandler((RequestHandler*)host) { } #endif //  #ifndef NETWORK_H #define NETWORK_H #include "RequestHandler.h" #include "Router.h" class Network : public RequestHandler { private: protected: public: Network(Host *host); }; Network::Network(Host *host) : RequestHandler((RequestHandler*)host) { } #endif //  #ifndef ROUTER_H #define ROUTER_H #include "Host.h" #include "Network.h" #include "RequestHandler.h" #include "Request.h" #include <cstdlib> #include <iostream> using namespace std; class Router : public Host { private: void route(Network *network, const Request& request) { if (network != NULL) { ((RequestHandler*)network)->handleRequest(request); } else { cout << "ER: Network is unreachable. Request with string " << request.requestString << " was lost" << endl; } } protected: public: Router(Network *network); virtual void handleRequest(const Request& request) { route((Network*) successor, request); } }; Router::Router(Network *network) { successor = (RequestHandler*) network; } #endif //  #ifndef SERVER_H #define SERVER_H #include "Host.h" #include "Request.h" #include "string" using namespace std; class Server : public Host { private: void showMessage(const string& msg) { cout << msg << endl; } protected: public: Server() : Host(NULL) { } virtual ~Server(); virtual void handleRequest(const Request& request) { string messageStr = "Request received with string: " + request.requestString; showMessage(messageStr); } }; #endif //  #ifndef FORWARDER_H #define FORWARDER_H #include "Host.h" #include "Request.h" class Forwarder : public Host { private: protected: public: Forwarder(Host *host) : Host(host) { } virtual ~Forwarder(); }; #endif //  #include <iostream> #include <cstdlib> using namespace std; #include "Server.h" #include "Router.h" #include "Forwarder.h" #include "Network.h" int main(int argc, char *argv[]) { Server *webServer = new Server(); Forwarder *fw1 = new Forwarder(webServer); Forwarder *fw2 = new Forwarder(fw1); Network *network = new Network(fw2); Router *router = new Router(network); const Request *req = new Request("correct request"); router->handleRequest(*req); Router *router1 = new Router(NULL); Forwarder *fw3 = new Forwarder(router1); Forwarder *fw4 = new Forwarder(fw3); Network *network2 = new Network(fw4); Router *router2 = new Router(network2); const Request *req1 = new Request("incorrect request"); router2->handleRequest(*req1); system("pause"); } 

पुनश्च

चौकस पाठक कहेगा - “ओह! मैं इस आदमी के लेख को पहले ही पढ़ चुका हूँ! " यह सही है, मैंने डिजाइन पैटर्न पर लेखों की एक श्रृंखला जारी रखने का फैसला किया है और मुझे आपकी प्रतिक्रिया की उम्मीद है।