निर्भरता इंजेक्शन

उलटा PHP 5.3 के लिए एक सरल और कार्यात्मक निर्भरता इंजेक्शन कंटेनर है। सेवा उन्मुख वास्तुकला, लिंक, PRS-0, और संगीतकार का समर्थन करता है।



आप packagist.org: granula / inversion के माध्यम से या PRS-0 के लिए एक संगत बूटलोडर डाउनलोड और जोड़कर स्थापित कर सकते हैं।

$container = new Inversion\Container(); $container['foo'] = 'My\Class\Foo'; // ... $foo = $container('foo'); 

उपरोक्त उदाहरण एक कंटेनर की बुनियादी कार्यक्षमता को दर्शाता है। देखते हैं वहां क्या होता है।
पहली पंक्ति में हम कंटेनर का एक उदाहरण बनाते हैं। दूसरे में, हम "फू" और सेवा के बीच एक जुड़ाव बनाते हैं, जो "माय \ क्लास \ फू" श्रेणी का एक उदाहरण है। इस तरह और क्या लिखा जा सकता है:

 $container->addService(new Service('My\Class\Foo'), 'foo'); 

"फू" नाम दूसरे के रूप में आता है इसे पूरी तरह से छोड़ा जा सकता है। अधिक विवरण नीचे।

तीसरी पंक्ति में हमें वस्तु का एक उदाहरण मिलता है। इस तरह और क्या लिखा जा सकता है:

 $foo = $container('foo'); //  $foo = $container->get('foo'); //  $foo = $container['foo']->get(); //  $foo = $container->getService('foo')->get(); 

हालांकि, मैं छोटे संस्करण का उपयोग करने की सलाह देता हूं, हालांकि उनमें से सभी वैध हैं।

निर्भरता विवरण

डिफ़ॉल्ट रूप से, जब एक स्ट्रिंग को कंटेनर में पारित किया जाता है, तो इसे वर्ग नाम के रूप में समझा जाता है और इसे Inversion \ Servise सेवा में प्रतिस्थापित किया जाता है।
इस सेवा में कई विशेषताएं और कार्य हैं।
पहले लोडिंग में देरी हो रही है। जब तक आप इसका इस्तेमाल नहीं करेंगे, तब तक क्लास लोड नहीं होगी।
दूसरा, आप अन्य सेवाओं और मापदंडों पर निर्भरता निर्दिष्ट कर सकते हैं। मैं एक उदाहरण के साथ समझाऊंगा।
मान लीजिए कि हमारे पास बार क्लास है, जो वन और टू क्लास पर निर्भर करता है:

 namespace My\Space; class One {} class Two {} class Bar { public function __construct(One $one, Two $two) { } } 

हम उलटा इस निर्भरता का वर्णन करते हैं:

 use Inversion\Service; //... $container['one'] = 'My\Space\One'; $container['two'] = 'My\Space\Two'; $container['bar'] = new Service('My\Space\Bar', array($container['one'], $container['two'])); 

अब जब आप बार को कॉल करते हैं, तो उन्हें बनाया जाएगा और निर्माणकर्ता में प्रतिस्थापित किया जाएगा। वास्तव में यह और भी आसान हो सकता है। यदि "एक" और "दो" के बजाय उनके वर्ग नामों को इंगित करें:

 $container['My\Space\One'] = 'My\Space\One'; $container['My\Space\Two'] = 'My\Space\Two'; $container['My\Space\Bar'] = new Service('My\Space\Bar'); // "new Service"   

इंटरफेस का उपयोग करते समय निर्भरता का वर्णन करने के लिए यह एक सुविधाजनक तरीका है:

 namespace My\Space; class One implements OneInterface {} class Two implements TwoInterface {} class Bar implements BarInterface { public function __construct(OneInterface $one, TwoInterface $two) { } } 

 $container['My\Space\OneInterface'] = 'My\Space\One'; $container['My\Space\TwoInterface'] = 'My\Space\Two'; $container['My\Space\BarInterface'] = 'My\Space\Bar'; 

सामान्य तौर पर, इंटरफेस के नामों को छोड़ा जा सकता है। वे स्वचालित रूप से कक्षाओं से प्राप्त किए जाएंगे:

 $container[] = 'My\Space\One'; $container[] = 'My\Space\Two'; $container[] = 'My\Space\Bar'; 

बस ऐसे ही।

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

अन्य प्रकार की सेवाएं

पुस्तकालय में कई सेवाएँ हैं, हालाँकि आप Inversion \ ServiceInterface को लागू करके अपना स्वयं का बना सकते हैं।

समापन

वर्ग: उलटा \ Service \ बंद करना
का उपयोग करें:

 $container['closure'] = function () use ($container) { return new My\Class(); }; 

आप निर्भरता भी निर्दिष्ट कर सकते हैं:

 $container['closure'] = function (One $foo, Two $foo) use ($container) { return new My\Class(); }; 

उलटा \ सेवा के साथ के रूप में , आप उन्हें स्पष्ट रूप से निर्दिष्ट कर सकते हैं:

 $container['closure'] = new Closure(function (One $foo, Two $foo) use ($container) { return new My\Class(); }, array($container['one'], $container['two'])); 

फ़ैक्टरी

वर्ग: उलटा \ Service \ Factory
का उपयोग करें:

 $container['factory'] = new Factory('My\ClassFactory', 'create'); 

आप स्पष्ट रूप से तीसरे पैरामीटर के रूप में कंस्ट्रक्टर के लिए निर्भरता भी निर्दिष्ट कर सकते हैं।

वस्तु

वर्ग: उलटा \ Service \ वस्तु
का उपयोग करें:

 $container['object'] = new My\Class(); 

या

 $container['object'] = new Object(new My\Class()); 

प्रोटोटाइप

वर्ग: उलटा \ Service \ प्रोटोटाइप
का उपयोग करें:

 $container['prototype'] = new Prototype($object); 

प्रत्येक कॉल एक नई प्रति बनाएगी: क्लोन $ वस्तु।

डेटा

वर्ग: उलटा \ Service \ Data
का उपयोग करें:

 $container['data'] = new Data('what you want'); 

डिफ़ॉल्ट रूप से, सभी सरणियों को डेटा सेवाओं में बदल दिया जाता है।

 $container['data'] = array(...); 

के बराबर:

 $container['data'] = new Data(array(...)); 

सेवा लिंक

उलटा लिंक का समर्थन करता है। लिंक प्राप्त करने के लिए, एक सरणी के रूप में कंटेनर को देखें:

 $container['foo'] = new Service(...); $ref = $container['foo']; //   . 

इस प्रकार, आप किसी भी सेवा के लिए एक उपनाम बना सकते हैं:

 $container['My\Class\FooInterface'] = new Service('My\Class\Foo'); $container['foo'] = $container['My\Class\FooInterface']; //... $foo = $container('foo'); 

अब यदि कोई "My \ Class \ FooInterface" को फिर से लिखता है, तो "फू" अभी भी इस सेवा को संदर्भित करेगा:

 //... $container['My\Class\FooInterface'] = new Service('Another\FooImpl'); //... $foo = $container('foo'); // $foo instanseof Another\FooImpl 

आप लिंक से लिंक भी बना सकते हैं:

 $container['foo'] = 'My\Class\Foo'; $container['ref'] = $container['foo']; $container['ref2'] = $container['ref']; $container['ref3'] = $container['ref2']; //... $foo = $container('ref3'); // $foo instanseof My\Class\Foo $name = $container->getRealName('ref3'); // $name == 'foo' 

सेवा विस्तार

उदाहरण के लिए, यदि हम कुछ सेवा का विस्तार करना चाहते हैं, तो यह विधि काम नहीं करेगी। वह पहला ओवरराइट करेगा:

 $container['My\Class\FooInterface'] = 'My\Class\Foo'; //... $container['My\Class\FooInterface'] = function (FooInterface $foo) { $foo->extendSome(...); return $foo; }; 

परिणामस्वरूप, इससे बचने के लिए एक लूप होगा, विस्तार करने के लिए निम्न फ़ंक्शन का उपयोग करें:

 $container['My\Class\FooInterface'] = 'My\Class\Foo'; //... $container->extend('My\Class\FooInterface', function (FooInterface $foo) { return new FooDecorator($foo); }); 

परीक्षण

उलटा पुस्तकालय पूरी तरह से परीक्षण किया गया है। लाइब्रेरी के आकार को कम करने के लिए टेस्ट एक अलग रिपॉजिटरी ( ग्रैनुला / टेस्ट ) में स्थित हैं।

सिंगलटन की तरह

स्थैतिक विधियों और सिंगलटन के उपयोग के बिना उलटा पूरी तरह से डिज़ाइन किया गया है, हालांकि एक सिंगलटन की तरह कंटेनर रखना शायद ही उपयोगी है:

 $container = Inversion\Container::getInstanse(); 

अन्य कार्यान्वयन

• सिम्फनी डिपेंडेंसी इंजेक्शन एक शक्तिशाली और भारी निर्भरता इंजेक्शन लाइब्रेरी है। अच्छा प्रलेखन है।
• दाना सिम्फनी के निर्माता से एक सरल और बहुत हल्का (सिर्फ एक फ़ाइल) "कंटेनर" है।