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

दुर्भाग्य से, पायथन समुदाय में "अच्छी वास्तुकला" की कोई सार्वभौमिक अवधारणा नहीं है, केवल "अजगर" की अवधारणा है, इसलिए हमें स्वयं वास्तुकला के साथ आना होगा। कटौती के तहत - वास्तुकला पर प्रतिबिंबों के साथ, और सबसे पहले - निर्भरता प्रबंधन पर पायथन पर लागू होता है।

django.setup ()

मैं dzhangists के लिए एक प्रश्न के साथ शुरू होगा क्या आप अक्सर इन दो पंक्तियों को लिखते हैं?

import django django.setup() 

यदि आप स्वयं django वेब सर्वर को प्रारंभ किए बिना django ऑब्जेक्ट्स के साथ काम करना चाहते हैं, तो आपको इससे फ़ाइल प्रारंभ करने की आवश्यकता है। यह समय ( django.utils.timezone ), और django.urls.reverse ( django.urls.reverse ), और बहुत कुछ के साथ काम करने के लिए मॉडल और टूल पर लागू होता है। यदि ऐसा नहीं किया जाता है, तो आपको एक त्रुटि मिलेगी:

 django.core.exceptions.AppRegistryNotReady: Apps aren't loaded yet. 

मैं इन दोनों पंक्तियों को लगातार लिख रहा हूं। मैं इजेक्शन कोड का बहुत बड़ा प्रशंसक हूं; मैं एक अलग .py फ़ाइल बनाना पसंद करता हूं, इसमें चीजों को .py हूं, इसका पता .py हूं - और फिर इसे प्रोजेक्ट में एम्बेड करता हूं।

और यह निरंतर django.setup() मुझे बहुत परेशान करता है। सबसे पहले, आप इसे हर जगह दोहराते हुए थक जाते हैं; और, दूसरी बात, django आरंभीकरण में कुछ सेकंड लगते हैं (हमारे पास एक बड़ा मोनोलिथ है), और जब आप एक ही फ़ाइल को 10, 20, 100 बार पुनरारंभ करते हैं - तो यह विकास को धीमा कर देता है।

कैसे django.setup() छुटकारा django.setup() ? आपको कोड लिखना होगा जो न्यूनतम रूप से django पर निर्भर करता है।

उदाहरण के लिए, यदि हम किसी बाहरी API का क्लाइंट लिखते हैं, तो हम इसे django पर निर्भर बना सकते हैं:

 from django.conf import settings class APIClient: def __init__(self): self.api_key = settings.SOME_API_KEY # : client = APIClient() 

या यह django से स्वतंत्र हो सकता है:

 class APIClient: def __init__(self, api_key): self.api_key = api_key # : client = APIClient(api_key='abc') 

दूसरे मामले में, निर्माता अधिक बोझिल है, लेकिन इस वर्ग के साथ कोई भी हेरफेर पूरे dzhangovskoy मशीनरी को लोड किए बिना किया जा सकता है।

टेस्ट भी आसान हो रहे हैं। घटक का परीक्षण कैसे करें जो django.conf.settings सेटिंग्स पर निर्भर करता है? बस उन्हें @override_settings डेकोरेटर के साथ लॉक करें। और अगर घटक किसी भी चीज पर निर्भर नहीं करता है, तो गीला होने के लिए कुछ भी नहीं होगा: उसने निर्माणकर्ता को पैरामीटर पारित कर दिया - और उसे निकाल दिया।

निर्भरता प्रबंधन

django निर्भरता कहानी एक समस्या का सबसे हड़ताली उदाहरण है जिसका मैं हर दिन सामना करता हूं: अजगर में निर्भरता प्रबंधन समस्याएं - और अजगर अनुप्रयोगों की समग्र वास्तुकला।

पायथन समुदाय में निर्भरता प्रबंधन के साथ संबंध मिश्रित है। तीन मुख्य शिविरों को प्रतिष्ठित किया जा सकता है:

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

  ब्रैंडन रोड्स, ड्रॉपबॉक्स: अपने आइओ को फहराएं ।
  
  रिपोर्ट से उदाहरण:
  
  

   def main(): """          """ with open("/etc/hosts") as file: for line in parse_hosts(file): print(line) def parse_hosts(lines): """    -   """ for line in lines: if line.startswith("#"): continue yield line 

  
  
  
  
• पायथन का लचीलापन पैर में खुद को गोली मारने का एक अतिरिक्त तरीका है। आपको निर्भरता के प्रबंधन के लिए नियमों का एक कठोर सेट चाहिए। एक अच्छा उदाहरण रूसी सूखा-अजगर लोग हैं। अभी भी एक कम कट्टर दृष्टिकोण है - पैमाने और दीर्घायु के लिए Django संरचना , लेकिन विचार समान है।
  

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

मैंने हाल ही में क्लीन आर्किटेक्चर पढ़ा - और मुझे यह समझ में आ रहा है कि अजगर में निर्भरता इंजेक्शन का मूल्य क्या है और इसे कैसे लागू किया जा सकता है। मैंने इसे अपने स्वयं के प्रोजेक्ट के उदाहरण पर देखा। संक्षेप में, यह कोड को दूसरे कोड में परिवर्तन होने पर टूटने से बचाता है ।

स्रोत डेटा

एक एपीआई क्लाइंट है जो सेवा शॉर्टनर के लिए HTTP अनुरोधों को निष्पादित करता है:

 # shortener_client.py import requests class ShortenerClient: def __init__(self, api_key): self.api_key = api_key def shorten_link(self, url): response = requests.post( url='https://fstrk.cc/short', headers={'Authorization': self.api_key}, json={'url': url} ) return response.json()['url'] 

और एक मॉड्यूल है जो पाठ के सभी लिंक को छोटा करता है। ऐसा करने के लिए, वह शॉर्टनर एपीआई क्लाइंट का उपयोग करता है:

 # text_processor.py import re from shortener_client import ShortenerClient class TextProcessor: def __init__(self, text): self.text = text def process(self): changed_text = self.text links = re.findall( r'https?://[^\r\n\t") ]*', self.text, flags=re.MULTILINE ) api_client = ShortenerClient('abc') for link in links: shortened = api_client.shorten_link(link) changed_text = changed_text.replace(link, shortened) return changed_text 

कोड निष्पादन का तर्क एक अलग नियंत्रण फ़ाइल में रहता है (इसे नियंत्रक कहते हैं):

 # controller.py from text_processor import TextProcessor processor = TextProcessor("""  1: https://ya.ru  2: https://google.com """) print(processor.process()) 

सब कुछ काम करता है। प्रोसेसर पाठ को पार्स करता है, शॉर्टनर का उपयोग करके लिंक को छोटा करता है, परिणाम देता है। निर्भरताएं इस तरह दिखती हैं:

समस्या

यहाँ समस्या यह है: TextProcessor वर्ग ShortenerClient वर्ग पर निर्भर करता है - और जब ShortenerClient इंटरफ़ेस बदलता है तो टूट जाता है ।

यह कैसे हो सकता है?

मान लें कि हमारी परियोजना में हमने shorten_link ट्रैक करने का निर्णय लिया है और shorten_link तर्क को shorten_link विधि में shorten_link है। इस तर्क का अर्थ है कि किसी लिंक पर क्लिक करते समय किन सूचनाओं को आना चाहिए।

ShortenerClient.shorten_link विधि इस तरह दिखना शुरू हुई:

 def shorten_link(self, url, callback_url): response = requests.post( url='https://fstrk.cc/short', headers={'Authorization': self.api_key}, json={'url': url, 'callback_on_click': callback_url} ) return response.json()['url'] 

और क्या होता है? और यह पता चला है कि जब हम शुरू करने की कोशिश करते हैं, तो हमें एक त्रुटि मिलती है:

 TypeError: shorten_link() missing 1 required positional argument: 'callback_url' 

यही है, हमने शॉर्टनर को बदल दिया, लेकिन यह वह नहीं था जो टूट गया, बल्कि उसका ग्राहक:



तो क्या? खैर, कॉलिंग फ़ाइल टूट गई, हमने जाकर इसे ठीक कर दिया। क्या समस्या है?

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

समस्याएँ तब शुरू होती हैं जब:

• कॉलिंग और बुलाया मॉड्यूल में बहुत सारे कोड हैं;
• विभिन्न मॉड्यूल विभिन्न लोगों / टीमों द्वारा समर्थित हैं।

यदि आप ShortenerClient वर्ग लिखते हैं, और आपका सहयोगी TextProcessor लिखता है, तो आपको एक आक्रामक स्थिति मिलती है: आपने कोड बदल दिया, लेकिन यह टूट गया। और यह एक ऐसी जगह टूट गया जिसे आपने जीवन में नहीं देखा है, और अब आपको किसी और के कोड को समझने और समझने की आवश्यकता है।

इससे भी अधिक दिलचस्प यह है कि जब आपका मॉड्यूल कई स्थानों पर उपयोग किया जाता है, और एक में नहीं; और आपका संपादन फ़ाइलों के ढेर पर कोड को तोड़ देगा।

इसलिए, समस्या को निम्नानुसार तैयार किया जा सकता है: कोड को कैसे व्यवस्थित किया जाए ताकि जब ShortenerClient इंटरफ़ेस बदल जाए, तो ShortenerClient स्वयं ShortenerClient , न कि इसके उपभोक्ता (कई हो सकते हैं)?

यहाँ समाधान है:

• क्लास उपभोक्ताओं और वर्ग को स्वयं एक सामान्य इंटरफ़ेस पर सहमत होना चाहिए। यह इंटरफेस कानून बनना चाहिए।
• यदि वर्ग अपने इंटरफेस के अनुरूप है, तो यह उसकी समस्याएं होंगी, न कि उपभोक्ता समस्याएं।

इंटरफ़ेस को फ्रीज करें

अजगर में एक इंटरफेस फिक्सिंग क्या दिखता है? यह एक सार वर्ग है:

 from abc import ABC, abstractmethod class AbstractClient(ABC): @abstractmethod def __init__(self, api_key): pass @abstractmethod def shorten_link(self, link): pass 

यदि अब हमें इस वर्ग से विरासत मिली है और हम किसी विधि को लागू करना भूल जाते हैं, तो हमें एक त्रुटि मिलेगी:

 class ShortenerClient(AbstractClient): def __ini__(self, api_key): self.api_key = api_key client = ShortenerClient('123') >>> TypeError: Can't instantiate abstract class ShortenerClient with abstract methods __init__, shorten_link 

लेकिन यह पर्याप्त नहीं है। एक अमूर्त वर्ग केवल तरीकों के नामों को पकड़ता है, लेकिन उनके हस्ताक्षर नहीं।

दूसरे हस्ताक्षर सत्यापन उपकरण की आवश्यकता है यह दूसरा उपकरण mypy । यह विरासत में मिली विधियों के हस्ताक्षरों को सत्यापित करने में मदद करेगा। ऐसा करने के लिए, हमें इंटरफ़ेस में एनोटेशन जोड़ना होगा:

 # shortener_client.py from abc import ABC, abstractmethod class AbstractClient(ABC): @abstractmethod def __init__(self, api_key: str) -> None: pass @abstractmethod def shorten_link(self, link: str) -> str: pass class ShortenerClient(AbstractClient): def __init__(self, api_key: str) -> None: self.api_key = api_key def shorten_link(self, link: str, callback_url: str) -> str: return 'xxx' 

अगर हम अब इस कोड को mypy के साथ mypy , तो हमें अतिरिक्त mypy तर्क के कारण त्रुटि मिलती है:

 mypy shortener_client.py >>> error: Signature of "shorten_link" incompatible with supertype "AbstractClient" 

अब हमारे पास क्लास इंटरफ़ेस के लिए एक विश्वसनीय तरीका है।

निर्भरता का उलटा

इंटरफ़ेस डीबग करने के बाद, हमें shortener_client.py फ़ाइल पर उपभोक्ता की निर्भरता को पूरी तरह से समाप्त करने के लिए इसे दूसरी जगह ले जाना चाहिए। उदाहरण के लिए, आप इंटरफ़ेस को सीधे उपभोक्ता तक खींच सकते हैं - TextProcessor प्रोसेसर वाली फ़ाइल में:

 # text_processor.py import re from abc import ABC, abstractmethod class AbstractClient(ABC): @abstractmethod def __init__(self, api_key: str) -> None: pass @abstractmethod def shorten_link(self, link: str) -> str: pass class TextProcessor: def __init__(self, text, shortener_client: AbstractClient) -> None: self.text = text self.shortener_client = shortener_client def process(self) -> str: changed_text = self.text links = re.findall( r'https?://[^\r\n\t") ]*', self.text, flags=re.MULTILINE ) for link in links: shortened = self.shortener_client.shorten_link(link) changed_text = changed_text.replace(link, shortened) return changed_text 

और वह लत की दिशा बदल देगा! अब TextProcessor इंटरेक्शन इंटरफ़ेस का मालिक है, और परिणामस्वरूप, ShortenerClient इस पर निर्भर करता है, और इसके विपरीत नहीं।



सरल शब्दों में, हम अपने परिवर्तन के सार का वर्णन इस प्रकार कर सकते हैं:

• TextProcessor कहता है: मैं एक प्रोसेसर हूं, और मैं टेक्स्ट रूपांतरण में शामिल हूं। मैं छोटा तंत्र के बारे में कुछ भी जानना नहीं चाहता: यह मेरा व्यवसाय नहीं है। मैं shorten_link विधि को खींचना चाहता हूं ताकि यह मेरे लिए सब कुछ shorten_link कर दे। इसलिए कृपया, मुझे एक ऐसी वस्तु दें जो मेरे नियमों के अनुसार चले। मैं कैसे बातचीत करता हूं, इसके बारे में निर्णय उसके द्वारा किए गए हैं।
• ShortenerClient कहता है: ऐसा लगता है कि मैं एक शून्य में मौजूद नहीं हो सकता, और उन्हें मुझसे कुछ व्यवहार की आवश्यकता होती है। मैं पूछता TextProcessor कि TextProcessor मुझे क्या मिलान करने की आवश्यकता है ताकि ब्रेक न हो।

कई उपभोक्ताओं

यदि कई मॉड्यूल छोटे लिंक का उपयोग करते हैं, तो इंटरफ़ेस को उनमें से एक में नहीं डाला जाना चाहिए, लेकिन कुछ अलग फ़ाइल में, जो अन्य फ़ाइलों के ऊपर स्थित है, उच्च पदानुक्रम में:

नियंत्रण घटक

यदि उपभोक्ता ShortenerClient आयात नहीं करते हैं, तो कौन इसे आयात करेगा और एक क्लास ऑब्जेक्ट बनाएगा? यह एक नियंत्रण घटक होना चाहिए - हमारे मामले में यह controller.py ।

सबसे सरल दृष्टिकोण एक सीधा निर्भरता इंजेक्शन है, डिपेंडेंसी इंजेक्शन "माथे में"। हम कॉलिंग कोड में ऑब्जेक्ट बनाते हैं, एक ऑब्जेक्ट को दूसरे में ट्रांसफर करते हैं। लाभ।

 # controller.py import TextProcessor import ShortenerClient processor = TextProcessor( text=' 1: https://ya.ru  2: https://google.com', shortener_client=ShortenerClient(api_key='123') ) print(processor.process()) 

अजगर दृष्टिकोण

माना जाता है कि अधिक "पाइथोनिक" दृष्टिकोण को वंशानुक्रम के माध्यम से निर्भरता इंजेक्शन माना जाता है।


इस शैली में कोड को अनुकूलित करने के लिए, आपको TextProcessor को थोड़ा बदलने की TextProcessor , जिससे यह TextProcessor हो सकता है:

 # text_processor.py class TextProcessor: def __init__(self, text: str) -> None: self.text = text self.shortener_client: AbstractClient = self.get_shortener_client() def get_shortener_client(self) -> AbstractClient: """      """ raise NotImplementedError 

और फिर, कॉलिंग कोड में, इसे वारिस करें:

 # controller.py import TextProcessor import ShortenerClient class ProcessorWithClient(TextProcessor): """   ,    """ def get_shortener_client(self) -> ShortenerClient: return ShortenerClient(api_key='abc') processor = ProcessorWithClient( text=' 1: https://ya.ru  2: https://google.com' ) print(processor.process()) 

दूसरा उदाहरण लोकप्रिय ढाँचों में सर्वव्यापी है:

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

दूसरा उदाहरण सुंदर और अधिक परिचित लगता है, है ना? आइए इसे विकसित करें और देखें कि क्या यह सुंदरता संरक्षित है।

अजगर का विकास

व्यावसायिक तर्क में, आमतौर पर दो से अधिक घटक होते हैं। मान लीजिए कि हमारा TextProcessor एक स्वतंत्र वर्ग नहीं है, लेकिन केवल TextProcessor TextPipeline तत्वों में से एक है जो पाठ को संसाधित करता है और इसे मेल पर भेजता है:

 class TextPipeline: def __init__(self, text, email): self.text_processor = TextProcessor(text) self.mailer = Mailer(email) def process_and_mail(self) -> None: processed_text = self.text_processor.process() self.mailer.send_text(text=processed_text) 

यदि हम इस्तेमाल की गई कक्षाओं से TextPipeline को अलग करना चाहते हैं, तो हमें पहले की तरह ही प्रक्रिया का पालन करना चाहिए:

• TextPipeline वर्ग उपयोग किए गए घटकों के लिए इंटरफेस की घोषणा करेगा;
• उपयोग किए गए घटकों को इन इंटरफेस के अनुरूप करने के लिए मजबूर किया जाएगा;
• कुछ बाहरी कोड सब कुछ एक साथ रखेंगे और चलाएंगे।

निर्भरता आरेख इस तरह दिखेगा:



लेकिन इन निर्भरताओं का विधानसभा कोड अब कैसा दिखेगा?

 import TextProcessor import ShortenerClient import Mailer import TextPipeline class ProcessorWithClient(TextProcessor): def get_shortener_client(self) -> ShortenerClient: return ShortenerClient(api_key='123') class PipelineWithDependencies(TextPipeline): def get_text_processor(self, text: str) -> ProcessorWithClient: return ProcessorWithClient(text) def get_mailer(self, email: str) -> Mailer: return Mailer(email) pipeline = PipelineWithDependencies( email='abc@def.com', text=' 1: https://ya.ru  2: https://google.com' ) pipeline.process_and_mail() 

क्या आपने गौर किया है? हम पहली बार TextProcessor क्लास को इसमें TextProcessor सम्मिलित करने के लिए इनहेरिट करते हैं, और फिर इसमें हमारे TextProcessor (साथ ही Mailer ) को सम्मिलित करने के लिए TextPipeline को इनहेरिट करते हैं। हमारे पास अनुक्रमिक पुनर्वित्त के कई स्तर हैं। पहले से ही जटिल है।

इस तरह से सभी चौखटे व्यवस्थित क्यों हैं? हां, क्योंकि यह केवल रूपरेखा के लिए उपयुक्त है।

• ढांचे के सभी स्तरों को स्पष्ट रूप से परिभाषित किया गया है, और उनकी संख्या सीमित है। उदाहरण के लिए, Django में, आप Form ओवरराइड में डालने के लिए FormField को ओवरराइड कर सकते हैं, फ़ॉर्म को ओवरराइड में डालने के लिए। वह सब है। तीन स्तर।
• प्रत्येक फ्रेमवर्क एक उद्देश्य को पूरा करता है। यह कार्य स्पष्ट रूप से परिभाषित है।
• प्रत्येक रूपरेखा में विस्तृत दस्तावेज होते हैं जो बताते हैं कि कैसे और क्या विरासत में मिला है; क्या और किसके साथ गठबंधन करना है।

क्या आप स्पष्ट रूप से और स्पष्ट रूप से अपने व्यावसायिक तर्क की पहचान और दस्तावेज़ कर सकते हैं? विशेष रूप से उस स्तर की वास्तुकला जिस पर वह काम करता है? मैं नहीं करता। दुर्भाग्य से, रेमंड हेटिंगर के दृष्टिकोण में व्यावसायिक तर्क नहीं है।

माथे दृष्टिकोण पर वापस

कई कठिनाई स्तरों पर, एक सरल दृष्टिकोण जीतता है। यह सरल दिखता है - और जब तर्क बदलता है तो बदलना आसान होता है।

 import TextProcessor import ShortenerClient import Mailer import TextPipeline pipeline = TextPipeline( text_processor=TextProcessor( text=' 1: https://ya.ru  2: https://google.com', shortener_client=ShortenerClient(api_key='abc') ), mailer=Mailer('abc@def.com') ) pipeline.process_and_mail() 

लेकिन, जब तर्क के स्तर की संख्या बढ़ जाती है, तो भी ऐसा दृष्टिकोण असुविधाजनक हो जाता है। हमें अनिवार्य रूप से कक्षाओं का एक समूह शुरू करना होगा, उन्हें एक दूसरे में पास करना होगा। मैं घोंसले के शिकार के कई स्तरों से बचना चाहता हूं।

चलो एक और कॉल की कोशिश करो।

ग्लोबल इंस्टेंस स्टोरेज

आइए एक वैश्विक शब्दकोश बनाने की कोशिश करें जिसमें जिन घटकों की हमें ज़रूरत है उनके उदाहरण झूठ होंगे। और इन घटकों को इस शब्दकोश तक पहुंच के माध्यम से एक-दूसरे को प्राप्त करने दें।

चलो इसे INSTANCE_DICT कहते हैं:

 # text_processor.py import INSTANCE_DICT class TextProcessor(AbstractTextProcessor): def __init__(self, text) -> None: self.text = text def process(self) -> str: shortener_client: AbstractClient = INSTANCE_DICT['Shortener'] # ...   

 # text_pipeline.py import INSTANCE_DICT class TextPipeline: def __init__(self) -> None: self.text_processor: AbstractTextProcessor = INSTANCE_DICT[ 'TextProcessor'] self.mailer: AbstractMailer = INSTANCE_DICT['Mailer'] def process_and_mail(self) -> None: processed_text = self.text_processor.process() self.mailer.send_text(text=processed_text) 

ट्रिक को एक्सेस करने से पहले हमारी वस्तुओं को इस शब्दकोश में रखना है । यह हम क्या करते हैं controller.py :

 # controller.py import INSTANCE_DICT import TextProcessor import ShortenerClient import Mailer import TextPipeline INSTANCE_DICT['Shortener'] = ShortenerClient('123') INSTANCE_DICT['Mailer'] = Mailer('abc@def.com') INSTANCE_DICT['TextProcessor'] = TextProcessor(text=' : https://ya.ru') pipeline = TextPipeline() pipeline.process_and_mail() 

एक वैश्विक शब्दकोश के माध्यम से काम करने के लाभ:

• कोई इंजन हुड जादू और अतिरिक्त DI चौखटे;
• निर्भरता की एक फ्लैट सूची जिसमें आपको घोंसले के प्रबंधन की आवश्यकता नहीं है;
• सभी DI बोनस: सरल परीक्षण, स्वतंत्रता, अन्य घटकों के बदलने पर टूटने से घटकों की सुरक्षा।

बेशक, INSTANCE_DICT बनाने के बजाय, आप किसी प्रकार के DI ढांचे का उपयोग कर सकते हैं; लेकिन इसका सार नहीं बदलेगा। रूपरेखा उदाहरणों का अधिक लचीला प्रबंधन प्रदान करेगी; वह आपको एक कारखाने की तरह एकल या बंडलों के रूप में बनाने की अनुमति देगा; लेकिन विचार वही रहेगा।

शायद किसी बिंदु पर यह मेरे लिए पर्याप्त नहीं होगा, और मैं अभी भी किसी प्रकार की रूपरेखा चुनता हूं।

और, शायद, यह सब अनावश्यक है, और इसके बिना करना आसान है: प्रत्यक्ष आयात लिखें और अनावश्यक सार इंटरफेस न बनाएं।

अजगर में निर्भरता प्रबंधन के साथ आपका अनुभव क्या है? और सामान्य तौर पर - क्या यह आवश्यक है, या क्या मैं हवा से एक समस्या का आविष्कार कर रहा हूं?