स्वचालित प्रोग्रामिंग में डिज़ाइन पैटर्न

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

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

प्रेरणा

स्वचालित प्रोग्रामिंग एक बहुत ही सुविधाजनक और लचीला उपकरण है जो आपको विषय क्षेत्र की अवधारणाओं के करीब समस्या को हल करने की अनुमति देता है। उदाहरण के लिए, एक बहु-मंजिला इमारत में लिफ्ट के व्यवहार को प्रोग्रामिंग करने का कार्य निम्नलिखित राज्यों के साथ मशीन के एक बहुत ही औपचारिक मॉडल में बदल जाता है: "लिफ्ट ऊपर जाती है", "लिफ्ट नीचे जाती है", "लिफ्ट फर्श N पर खड़ी होती है" और घर के निवासियों से आने वाली घटनाएं: "डाउन बटन दबाया जाता है। N-th फ्लोर पर "और" Up बटन को N-th फ्लोर पर दबाया जाता है।

हालांकि, इस दृष्टिकोण के स्पष्ट लाभों के साथ, एक छोटी सी खामी है - ऐसी प्रणाली का कोडिंग एक बहुत ही अप्रिय प्रक्रिया है, जिसमें बड़ी संख्या में शाखाओं और संक्रमणों का उपयोग होता है।

इस समस्या को हल करने के लिए, OOP और टेम्पलेट्स आगंतुक और राज्य हैं।

उदाहरण

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

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

switch( state ) { case RADIO: switch(event) { case mode: /* Change the state */ state = CD; break; case next: /* Increase the station number */ stationNumber++; break; } break; case CD: switch(event) { case mode: /* Change the state */ state = RADIO; break; case next: /* Go to the next track */ trackNumber++; break; } break; } 

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

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

इस प्रकार, सिस्टम में एक नए प्रकार के ईवेंट या हैंडलर को जोड़ने के लिए, यह आवश्यक वर्ग को लागू करने के लिए पर्याप्त है, क्रमशः "इवेंट" या "हैंडलर" वर्गों के वारिस।

वर्ग आरेख

सिस्टम की मुख्य इकाइयाँ:

• ग्रामोफोन - रेडियो, जो चालू कर सकता है - सक्षम (), बंद करें - अक्षम करें () और ईवेंट प्राप्त करें - प्रेषण (ईवेंट);
• ग्रामोफोनइवेंट - एक एकल विधि के साथ संभावित घटनाओं का इंटरफ़ेस - हैंडलर को "लागू करें" घटना के लिए;
• ग्रामोफोनहैंडलर - एक हैंडलर इंटरफ़ेस जिसमें सिस्टम में मौजूद सभी घटनाओं को संसाधित करने के लिए पॉलीमॉर्फिक तरीके (हैंडल) होते हैं;

इस आरेख में सबसे बड़ी रुचि ग्रामोफोनहैंडलर इंटरफ़ेस है, जो विज़िटर संरचना (आगंतुक के रूप में) और स्व-निहित राज्य संरचना (ग्रामोफोन के लिए राज्य के रूप में) का हिस्सा है। यानी हम मान सकते हैं कि उदाहरण में दो पैटर्न की एक तरह की रचना का उपयोग किया जाता है।

कार्यान्वयन

सिस्टम का उपयोग करने के लिए विकल्पों में से एक इस तरह दिखाई देगा:

 public static void main(String args[]) { Gramophone gramophone = new Gramophone(); // it's CD by default gramophone.enable(); // start event loop gramophone.dispatch(new ToogleEvent()); // toogle to radio gramophone.dispatch(new NextEvent()); // next station gramophone.dispatch(new ToogleEvent()); // toogle to CD player gramophone.dispatch(new NextEvent()); // next CD track gramophone.disable(); // stop event loop } 

हम सिस्टम पर आने वाली बाहरी घटनाओं के लिए संभावित विकल्पों का वर्णन करते हैं।

 /** * Events */ interface GramophoneEvent { void apply(GramophoneHandler handler); } class ToogleEvent implements GramophoneEvent { @Override public void apply(GramophoneHandler handler) { handler.handle(this); } } class NextEvent implements GramophoneEvent { @Override public void apply(GramophoneHandler handler) { handler.handle(this); } } 

ऊपर दिए गए कोड में, लागू () विधि में सभी वंशजों में समान कार्यान्वयन है। यह टेम्पलेट का मुख्य विचार है - कोड निष्पादन की प्रक्रिया में घटना के प्रकार की एक बहुरूपी परिभाषा। यानी हैंडल () विधि को हैंडलर पर बुलाया जाएगा, यह घटना के प्रकार पर निर्भर करता है (जैसे कि यह लिंक)।

ऐसी भाषाएं जो बहुदेववाद का समर्थन नहीं करती हैं (उदाहरण के लिए, जावास्क्रिप्ट में), आप विधि नाम में संसाधित होने वाली घटना के प्रकार के बारे में जानकारी संलग्न कर सकते हैं। फिर हमारे मामले में, तरीके handleNext (इवेंट) और handleToogle (ईवेंट) और कॉलिंग कोड जैसे दिखेंगे:

 var NextEvent = function() { this.apply = function(handler) { handler.handleNext(this); } } 

प्रणाली के संभावित राज्यों का कार्यान्वयन निम्नलिखित कोड है। हमारे मामले में, राज्य = हैंडलर।

 /** * Visitor */ interface GramophoneHandler { void handle(ToogleEvent event); void handle(NextEvent event); } class RadioHandler implements GramophoneHandler { private Gramophone gramophone; public RadioHandler(Gramophone gramophone) { this.gramophone = gramophone; } @Override public void handle(ToogleEvent event) { gramophone.toogle(new CDHandler(gramophone)); } @Override public void handle(NextEvent event) { gramophone.nextStation(); } } class CDHandler implements GramophoneHandler { private Gramophone gramophone; public CDHandler(Gramophone gramophone) { this.gramophone = gramophone; } @Override public void handle(ToogleEvent event) { gramophone.toogle(new RadioHandler(gramophone)); } @Override public void handle(NextEvent event) { gramophone.nextTrack(); } } 

अंत में, हम सिस्टम के मुख्य वर्ग के कार्यान्वयन पर विचार करते हैं - रेडियो (ग्रामोफोन)।

 /** * FSM (Finit-State-Machine) implementation */ class Gramophone implements Runnable { private GramophoneHandler handler = new CDHandler(this); private Queue<GramophoneEvent> pool = new LinkedList<GramophoneEvent>(); private Thread self = new Thread(this); private int track = 0, station = 0; private boolean started = false; public void enable() { started = true; self.start(); } public void disable() { started = false; self.interrupt(); try { self.join(); } catch (InterruptedException ignored) { } } public synchronized void dispatch(GramophoneEvent event) { pool.offer(event); notify(); } @Override public void run() { for (;!pool.isEmpty() || started;) { for (;!pool.isEmpty();) { GramophoneEvent event = pool.poll(); event.apply(handler); } synchronized (this) { try { wait(); } catch (InterruptedException ignored) { } } } } void toogle(GramophoneHandler handler) { this.handler = handler; System.out.println("State changed: " + handler.getClass().getSimpleName()); } void nextTrack() { track++; System.out.println("Track changed: " + track); } void nextStation() { station++; System.out.println("Station changed: " + station); } } 

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

 void nextTrack() { if (Thread.currentThread() != self) { throw new RuntimeException(“Illegal thread”); } track++; System.out.println("Track changed: " + track); } 

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

निष्कर्ष

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

इस उदाहरण के लिए कोड GitHub पर उपलब्ध है । वहां आप अन्य पैटर्नों के उदाहरण पा सकते हैं, जिनके बारे में हैबरहाब पर पहले ही कई लेख लिखे जा चुके हैं।