कमांड / कमांड डिजाइन पैटर्न

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

समस्या

एक निश्चित प्रणाली के लिए अनुरोधों का प्रभावी प्रतिनिधित्व होना आवश्यक है, जबकि उनकी प्रकृति या उनके प्रसंस्करण के तरीकों का ज्ञान न होना।

विवरण

"टीम" टेम्पलेट का उपयोग करने के लिए कम से कम तीन प्रेरणाएँ हैं:

• बाद के लॉगिंग / लॉगिंग, आदि के लिए ऑब्जेक्ट के रूप में अनुरोध को एनकैप्सुलेट करना
• एक स्वतंत्र वस्तु के गुणों के साथ "किसी वस्तु की पद्धति को कॉल करना" का सार;
• ऑब्जेक्ट ओरिएंटेड कॉलबैक (कॉलबैक);
  
  
  वास्तव में, उपरोक्त सभी प्रेरणाएँ एक बात पर आती हैं - "अनुरोध को एक वस्तु के रूप में बदलना" । बड़ी संख्या में सिस्टम ज्ञात हैं जहां इस तरह का दृष्टिकोण प्रभावी और न्यायसंगत है। सबसे पहले, यह उपयोगकर्ता के कार्यों (रद्द / फिर से करना) को रद्द करने और दोहराने की क्षमता वाला कोई कम गंभीर डेस्कटॉप अनुप्रयोग है। दूसरे, ये नेटवर्क वितरित सिस्टम हैं जो ऑब्जेक्ट के रूप में प्रश्नों का उपयोग करते हुए कुछ संचालन को शुरू करने के मुख्य आदिम के रूप में होते हैं। तीसरा, अतुल्यकालिक कॉल के लिए समर्थन वाले सिस्टम कॉलबैक ऑब्जेक्ट के रूप में कॉलबैक को एन्कैप्सुलेट करते हैं। आप अंतहीन रूप से सूचीबद्ध कर सकते हैं, यह समझना महत्वपूर्ण है कि कमांड टेम्प्लेट सबसे आम टेम्प्लेट में से एक है, जिसे आप कह सकते हैं, ओओपी के गठन के चरण में शाब्दिक रूप से प्रकट हुआ और केवल तब औपचारिक रूप से और गोफ पुस्तक में वर्णित किया गया था।
  
  टेम्पलेट का मौलिक विचार सभी प्रकार के संचालन का वर्णन करने के लिए एकल इंटरफ़ेस का उपयोग करना है जो सिस्टम के साथ किया जा सकता है। फिर, समर्थन प्रणाली में एक नया ऑपरेशन जोड़ने के लिए, यह प्रस्तावित इंटरफ़ेस को लागू करने के लिए पर्याप्त है। इस प्रकार, प्रत्येक ऑपरेशन एक स्वतंत्र वस्तु प्रतीत होता है जो अतिरिक्त गुणों के एक निश्चित समूह को घेरता है। प्रणाली, बदले में, अनुरोधों (ऑब्जेक्ट्स) पर अतिरिक्त कार्यों का प्रदर्शन करने की क्षमता प्राप्त करती है। यह पिछली कार्रवाई को दोहरा रहा है, अगले एक को दोहरा रहा है, आदि।
  
  

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

  
  टेम्पलेट का उपयोग करने के लिए सबसे स्पष्ट प्रेरणा पर विचार करें - लॉगिंग / पूर्ववत करें। इसके लिए, कल्पना कीजिए कि यह था,

    <ताना> 

  अगर स्टीफन बॉर्न (बैश के लेखक) ने GoF पुस्तक पढ़ी और पता था कि "टीम" डिजाइन पैटर्न क्या है

    </ ताना> 

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

  वर्ग आरेख

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

  पायथन कार्यान्वयन

  
  

  # -*- coding: cp1251 -*- from sys import stdout as console #   exit class SessionClosed(Exception): def __init__(self, value): self.value = value #   class Command: def execute(self): raise NotImplementedError() def cancel(self): raise NotImplementedError() def name(): raise NotImplementedError() #  rm class RmCommand(Command): def execute(self): console.write("You are executed \"rm\" command\n") def cancel(self): console.write("You are canceled \"rm\" command\n") def name(self): return "rm" #  uptime class UptimeCommand(Command): def execute(self): console.write("You are executed \"uptime\" command\n") def cancel(self): console.write("You are canceled \"uptime\" command\n") def name(self): return "uptime" #  undo class UndoCommand(Command): def execute(self): try: cmd = HISTORY.pop() TRASH.append(cmd) console.write("Undo command \"{0}\"\n".format(cmd.name())) cmd.cancel() except IndexError: console.write("ERROR: HISTORY is empty\n") def name(self): return "undo" #  redo class RedoCommand(Command): def execute(self): try: cmd = TRASH.pop() HISTORY.append(cmd) console.write("Redo command \"{0}\"\n".format(cmd.name())) cmd.execute() except IndexError: console.write("ERROR: TRASH is empty\n") def name(self): return "redo" #  history class HistoryCommand(Command): def execute(self): i = 0 for cmd in HISTORY: console.write("{0}: {1}\n".format(i, cmd.name())) i = i + 1 def name(self): print "history" #  exit class ExitCommand(Command): def execute(self): raise SessionClosed("Good bay!") def name(self): return "exit" #    COMMANDS = {'rm': RmCommand(), 'uptime': UptimeCommand(), 'undo': UndoCommand(), 'redo': RedoCommand(), 'history': HistoryCommand(), 'exit': ExitCommand()} HISTORY = list() TRASH = list() #  def main(): try: while True: console.flush() console.write("pysh >> ") cmd = raw_input() try: command = COMMANDS[cmd] command.execute() if not isinstance(command, UndoCommand) and not isinstance(command, RedoCommand) and not isinstance(command, HistoryCommand): TRASH = list() HISTORY.append(command) except KeyError: console.write("ERROR: Command \"%s\" not found\n" % cmd) except SessionClosed as e: console.write(e.value) if __name__ == "__main__": main() 

  
  
  

  के उपयोग

  
  

   $ python pysh.py pysh >> rm You are executed "rm" command pysh >> rm You are executed "rm" command pysh >> rm You are executed "rm" command pysh >> history 0: rm 1: rm 2: rm pysh >> undo Undo command "rm" You are canceled "rm" command pysh >> exit Good bay! 

  
  
  

  टिप्पणी

  
  कुछ स्रोतों में, टेम्पलेट को एक क्रिया या लेनदेन कहा जाता है।