PHP में प्रोग्रामिंग इंटरफ़ेस "द्रव इंटरफ़ेस"। ताजा देखो

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

विकास। सरल से जटिल तक।

मैं यह मान सकता हूं कि प्रत्येक प्रोग्रामर एक PHP प्रोग्रामर के रूप में अपनी यात्रा शुरू करता है एक भोज एप्लीकेशन लिखकर, "हैलो, दुनिया!" जिसके बाद भाषा सीखने के लंबे साल होंगे और कुछ खास करने के लिए अनाड़ी प्रयास होंगे: ORM / CMS / फ्रेमवर्क (आवश्यक रूप से रेखांकित करें)। मुझे लगता है कि हर किसी के पास वह कोड है, जो किसी को नहीं दिखाना बेहतर है। लेकिन यह एक बिल्कुल सामान्य विकास प्रक्रिया है, क्योंकि सरल चीजों को समझने के बिना आप जटिल लोगों को नहीं समझ सकते हैं! इसलिए, इस तरह से दोहराएं - हम सरल उदाहरणों के साथ शुरू करेंगे और AOP का उपयोग करके एक अलग वर्ग के रूप में "द्रव" इंटरफ़ेस के कार्यान्वयन के लिए प्राप्त करेंगे। जो लोग ओओपी में इस प्रोग्रामिंग पैटर्न को जानते हैं - सुरक्षित रूप से लेख के अंतिम भाग में जा सकते हैं, वहां आपको विचार के लिए शानदार भोजन मिल सकता है।

आइए शुरुआत करते हैं

ताकि हमें एक उदाहरण के लिए दूर न जाना पड़े, आइए कुछ उपयोगकर्ता इकाई लें जिसमें पहले नाम, अंतिम नाम और पासवर्ड के गुण हों:

class User { public $name; public $surname; public $password; } 

एक उत्कृष्ट वर्ग जो आसानी से और सुरुचिपूर्ण ढंग से उपयोग किया जा सकता है:

 $user = new User; $user->name = 'John'; $user->surname = 'Doe'; $user->password = 'root'; 

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

जल्द से जल्द नहीं कहा:

 class User { protected $name; protected $surname; protected $password; public function setName($name) { $this->name = $name; } public function setSurname($surname) { $this->surname = $surname; } public function setPassword($password) { if (!$password) { throw new InvalidArgumentException("Password shouldn't be empty"); } $this->password = $password; } } 

नए वर्ग के लिए, कॉन्फ़िगरेशन थोड़ा बदल गया है और अब सेटर विधि कॉल का उपयोग करता है:

 $user = new User; $user->setName('John'); $user->setSurname('Doe'); $user->setPassword('root'); 

कुछ भी जटिल नहीं है, है ना? लेकिन क्या होगा अगर हमें 20 संपत्तियों को कॉन्फ़िगर करने की आवश्यकता है? 30 गुण? इस कोड को सेटर कॉल और $user-> की निरंतर उपस्थिति के साथ बमबारी किया $superImportantUser $user-> यदि चर नाम $superImportantUser , तो कोड की पठनीयता और भी खराब हो जाएगी। इस कोड को कॉपी करने से छुटकारा पाने के लिए क्या किया जा सकता है?

द्रवित इंटरफ़ेस

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

सरल होने के लिए, एक द्रव इंटरफ़ेस को लागू करने के लिए, हमें सभी सेटर विधियों में वर्तमान वस्तु को वापस करने की आवश्यकता है:

 class User { protected $name; protected $surname; protected $password; public function setName($name) { $this->name = $name; return $this; } public function setSurname($surname) { $this->surname = $surname; return $this; } public function setPassword($password) { if (!$password) { throw new InvalidArgumentException("Password shouldn't be empty"); } $this->password = $password; return $this; } } 

यह दृष्टिकोण हमें चर की बहुवचन नाम से बचने के लिए कॉल की एक श्रृंखला बनाने की अनुमति देगा:

 $user = new User; $user->setName('John')->setSurname('Doe')->setPassword('root'); 

जैसा कि आपने पहले ही देखा था, ऑब्जेक्ट का कॉन्फ़िगरेशन अब कम जगह लेता है और पढ़ने में आसान होता है। हमने अपना लक्ष्य प्राप्त कर लिया है! इस बिंदु पर, कई डेवलपर्स से पूछना चाहिए: “तो क्या? मुझे यह पहले से ही पता है ... "फिर सवाल का जवाब देने की कोशिश करें:" इस रूप में खराब द्रव इंटरफ़ेस क्या है? "लेख के अगले ब्लॉक को पढ़ने से पहले।

तो वह बुरा क्यों है?

शायद आपको जवाब नहीं मिला और इसे पढ़ने का फैसला किया? ) तो ठीक है, आगे बढ़ो! मैं आपको आश्वस्त करने के लिए जल्दबाजी करता हूं: द्रव इंटरफ़ेस के साथ OOP के वर्तमान स्तर पर, सब कुछ ठीक है। हालाँकि, यदि आप इसके बारे में सोचते हैं, तो आप देखेंगे कि इसे एक अलग वर्ग के रूप में लागू नहीं किया जा सकता है और इसे इच्छित वस्तु से जोड़ा जा सकता है। यह सुविधा इस तथ्य में व्यक्त की जाती है कि आपको प्रत्येक विधि के अंत में नीरस रूप से इसे return $this करना होगा। यदि हमारे पास दर्जनों वर्गों के एक जोड़े के साथ दर्जनों कक्षाएं हैं जिन्हें हम तरल बनाना चाहते हैं, तो हमें मैन्युअल रूप से इस अप्रिय ऑपरेशन से निपटना होगा। यह क्लासिक क्रॉस-कटिंग कार्यक्षमता है।

चलो अंत में इसे एक अलग वर्ग के साथ बनाते हैं

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

सबसे पहले, हम "द्रव" इंटरफ़ेस के इंटरफ़ेस मार्कर का वर्णन करेंगे:

 /** * Fluent interface marker */ interface FluentInterface { } 

और फिर पहलू के अंदर सलाह के रूप में "द्रव" इंटरफ़ेस का बहुत तर्क:

 use Go\Aop\Aspect; use Go\Aop\Intercept\MethodInvocation; use Go\Lang\Annotation\Around; class FluentInterfaceAspect implements Aspect { /** * Fluent interface advice * * @Around("within(FluentInterface+) && execution(public **->set*(*))") * * @param MethodInvocation $invocation * @return mixed|null|object */ protected function aroundMethodExecution(MethodInvocation $invocation) { $result = $invocation->proceed(); return $result!==null ? $result : $invocation->getThis(); } } 

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

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

 class User implements FluentInterface { //... public function setName($name) { $this->name = $name; } } 

अब हमें एक विशेष वर्ग में अब द्रव इंटरफ़ेस का उपयोग करने की आवश्यकता है, बस एक इंटरफ़ेस जोड़ना है - implements FluentInterface । कोई भी नकल नहीं return $this , सैकड़ों तरीकों से, केवल स्वच्छ स्रोत कोड, एक समझने योग्य इंटरफ़ेस मार्कर, और एक साधारण पहलू वर्ग के रूप में "द्रव" इंटरफ़ेस का कार्यान्वयन। एओपी सभी काम पर ले जाएगा।

यह लेख केवल मार्गदर्शन के लिए है और इसका उद्देश्य उन संभावनाओं पर चिंतन करना है जिन्हें PHP में AOP का उपयोग करके एक्सेस किया जा सकता है। मुझे आशा है कि आप इस प्रोग्रामिंग पैटर्न के कार्यान्वयन के बारे में उत्सुक थे।

संदर्भ:

1. जाओ! PHP के लिए पहलू-उन्मुख फ्रेमवर्क
2. विकिपीडिया - धाराप्रवाह इंटरफ़ेस
3. गिथब परियोजना