प्रॉक्सी पैटर्न

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

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

=== प्रॉक्सी डिज़ाइन पैटर्न किन समस्याओं को हल कर सकता है? ===


 * किसी वस्तु की पहुंच को नियंत्रित किया जाना चाहिए।
 * किसी वस्तु तक पहुँचने पर अतिरिक्त कार्यक्षमता प्रदान की जानी चाहिए।

संवेदनशील वस्तुओं तक पहुँचते समय, उदाहरण के लिए, यह जाँचना संभव होना चाहिए कि ग्राहकों के पास आवश्यक पहुँच अधिकार हैं।

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

यह एक के माध्यम से काम करना संभव बनाता है  किसी विषय तक पहुँचने पर अतिरिक्त कार्यक्षमता करने के लिए ऑब्जेक्ट। उदाहरण के लिए, किसी संवेदनशील वस्तु तक पहुँचने वाले ग्राहकों के पहुँच अधिकारों की जाँच करने के लिए।

किसी विषय के स्थानापन्न के रूप में कार्य करने के लिए, प्रॉक्सी को लागू करना चाहिए  इंटरफेस। ग्राहक यह नहीं बता सकते कि वे किसी विषय या उसके प्रॉक्सी के साथ काम करते हैं या नहीं। नीचे यूएमएल क्लास और सीक्वेंस डायग्राम भी देखें।

यूएमएल वर्ग और अनुक्रम आरेख
उपरोक्त एकीकृत मॉडलिंग भाषा वर्ग आरेख में, वर्ग लागू करता है  इंटरफ़ेस ताकि यह इसके विकल्प के रूप में कार्य कर सके   वस्तुओं। यह एक संदर्भ रखता है प्रतिस्थापित वस्तु के लिए ताकि वह इसे अनुरोधों को अग्रेषित कर सके .

अनुक्रम आरेख रन-टाइम इंटरैक्शन दिखाता है:  ई> वस्तु ए के माध्यम से काम करता है  उस पर आपत्ति करें ए तक पहुंच को नियंत्रित करता है  वस्तु। इस उदाहरण में,  को अनुरोध अग्रेषित करता है , जो अनुरोध करता है।

वर्ग आरेख




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

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

सुरक्षा प्रॉक्सी
एक्सेस अधिकारों के आधार पर संसाधन तक पहुंच को नियंत्रित करने के लिए एक सुरक्षा प्रॉक्सी का उपयोग किया जा सकता है।

सी #
<वाक्यविन्यास प्रकाश लैंग = सीशार्प> इंटरफ़ेस आईसीएआर {   शून्य ड्राइवकार ; }

// वास्तविक वस्तु पब्लिक क्लास कार: आईसीएआर {   सार्वजनिक शून्य ड्राइवकार {       कंसोल। राइटलाइन (कार चलाई गई है!); } }

// प्रॉक्सी ऑब्जेक्ट पब्लिक क्लास प्रॉक्सीकार: आईसीएआर {   निजी चालक चालक; निजी आईसीएआर रियलकार;

सार्वजनिक प्रॉक्सीकार (चालक चालक) {       यह.चालक = चालक; यह.realCar = नई कार ; }

सार्वजनिक शून्य ड्राइवकार {       अगर (ड्राइवर। उम्र <16) कंसोल। राइटलाइन (क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।); अन्य यह.realCar.DriveCar ; } }

पब्लिक क्लास ड्राइवर {   सार्वजनिक int आयु {प्राप्त करें; तय करना; }

सार्वजनिक चालक (पूर्ण आयु) {       यह। आयु = आयु; } }

// उपरोक्त प्रॉक्सी वर्ग का उपयोग कैसे करें? निजी शून्य btnProxy_Click (वस्तु प्रेषक, EventArgs e) { आईसीएआर कार = नया प्रॉक्सीकार (नया ड्राइवर (15)); कार। ड्राइवकार ;

कार = नया प्रॉक्सीकार (नया ड्राइवर (25)); कार। ड्राइवकार ; }  उत्पादन क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। कार चलाई गई है!

टिप्पणियाँ:
 * एक प्रॉक्सी क्लाइंट को वास्तविक वस्तु के बारे में जानकारी छुपा सकता है।
 * एक प्रॉक्सी ऑन डिमांड लोडिंग जैसे अनुकूलन का प्रदर्शन कर सकता है।
 * एक प्रॉक्सी अतिरिक्त हाउसकीपिंग का काम कर सकता है जैसे ऑडिट कार्य।
 * प्रॉक्सी डिज़ाइन पैटर्न को सरोगेट डिज़ाइन पैटर्न के रूप में भी जाना जाता है।

सी ++
<वाक्यविन्यास लैंग = सीपीपी>
 * 1) शामिल
 * 2) शामिल <मेमोरी>

कक्षा आईसीएआर { जनता: वर्चुअल ~ आईसीएआर {एसटीडी :: अदालत << आईसीएआर विनाशक! << एसटीडी :: एंडल; }

आभासी शून्य ड्राइवकार = 0; };

वर्ग कार : सार्वजनिक आईसीएआर { जनता: शून्य ड्राइवकार ओवरराइड {std::cout << कार चला दी गई है! << एसटीडी :: एंडल; } };

वर्ग ProxyCar : सार्वजनिक आईसीएआर { जनता: प्रॉक्सीकार (इंट ड्राइवर_एज): ड्राइवर_एज_ (ड्राइवर_एज) {}

शून्य ड्राइवकार ओवरराइड { अगर (driver_age_> 16) { real_car_-> ड्राइवकार ; } अन्य { std::cout << क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। << एसटीडी :: एंडल; } }

निजी: std::unique_ptr real_car_ = std::make_unique; इंट ड्राइवर_एज_; };

मुख्य प्रवेश बिंदु { std::unique_ptr कार = std::make_unique(16); कार-> ड्राइवकार ;

कार = एसटीडी :: Make_unique (25); कार-> ड्राइवकार ; } 

क्रिस्टल
<वाक्यविन्यास लैंग = रूबी> सार वर्ग सारकार अमूर्त डीफ़ ड्राइव अंत

क्लास कार <एब्स्ट्रैक्टकार डीईएफ़ ड्राइव कार चला दी गई है! अंत अंत

वर्ग चालक गेटर उम्र: Int32

डीईएफ़ इनिशियलाइज़ (@आयु) अंत अंत

वर्ग प्रॉक्सीकार <सारकार प्राइवेट गेट्टर ड्राइवर: ड्राइवर निजी प्राप्तकर्ता real_car : सारकार

डीईएफ़ इनिशियलाइज़ (@driver) @real_car = Car.new अंत

डीईएफ़ ड्राइव अगर ड्राइवर की उम्र <= 16 डालता है क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। अन्य @real_car.drive अंत अंत अंत

चालक = चालक। नया (16) कार = ProxyCar.new (चालक) कार चलाना
 * 1) कार्यक्रम

चालक = चालक। नया (25) कार = ProxyCar.new (चालक) कार चलाना 

उत्पादन क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। कार चलाई गई है!

डेल्फी/ऑब्जेक्ट पास्कल
<वाक्यविन्यास लैंग = डेल्फी> // प्रॉक्सी डिजाइन पैटर्न यूनिट डिजाइनपैटर्न.प्रॉक्सी;

इंटरफेस

प्रकार // कार इंटरफ़ेस आईसीएआर = इंटरफेस प्रक्रिया ड्राइवकार; अंत;

// TCar वर्ग, ICar को लागू करना टीसीएआर = कक्षा (टीइंटरफेस ऑब्जेक्ट, आईसीएआर) क्लास फंक्शन न्यू: आईसीएआर; प्रक्रिया ड्राइवकार; अंत;

// चालक इंटरफ़ेस आईडीवर = इंटरफ़ेस कार्य आयु: पूर्णांक; अंत;

// TDriver क्लास, IDriver को लागू करना टीड्राइवर = कक्षा (टीइंटरफेसऑब्जेक्ट, आईडीवर) निजी Fage: पूर्णांक; जनता निर्माता बनाएँ (आयु: पूर्णांक); अधिभार; वर्ग समारोह नया (आयु: पूर्णांक): IDriver; कार्य आयु: पूर्णांक; अंत;

// प्रॉक्सी ऑब्जेक्ट TProxyCar = क्लास (TInterfacedObject, ICar) निजी एफड्राइवर: आईडीवर; FRealCar: आईसीएआर; जनता निर्माता बनाएँ (ड्राइवर: IDriver); अधिभार; क्लास फंक्शन न्यू (ड्राइवर: IDriver): ICar; प्रक्रिया ड्राइवकार; अंत;

कार्यान्वयन

{टीसीएआर कार्यान्वयन}

क्लास फंक्शन TCar.New: ICar; शुरू परिणाम := सृजन; अंत;

प्रक्रिया TCar.DriveCar; शुरू WriteLn ('कार चलाई गई है!'); अंत;

{टीड्राइवर कार्यान्वयन}

निर्माता TDriver.Create (आयु: पूर्णांक); शुरू विरासत में मिला; आयु := आयु; अंत;

वर्ग समारोह TDriver.New (आयु: पूर्णांक): IDriver; शुरू परिणाम : = बनाएँ (आयु); अंत;

समारोह TDriver.आयु: पूर्णांक; शुरू परिणाम := फेज; अंत;

{TProxyCar कार्यान्वयन}

कंस्ट्रक्टर TProxyCar.Create (ड्राइवर: IDriver); शुरू विरासत में मिला; स्व.एफ चालक := चालक; Self.FRealCar := TCar.Create AS ICar; अंत;

क्लास फंक्शन TProxyCar.New (ड्राइवर: IDriver): ICar; शुरू परिणाम : = बनाएँ (चालक); अंत;

प्रक्रिया TProxyCar.DriveCar; शुरू अगर (FDriver.आयु <= 16) फिर WriteLn('क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।') वरना FRealCar.DriveCar ; अंत;

अंत। 

प्रयोग <वाक्यविन्यास लैंग = डेल्फी> कार्यक्रम परियोजना1; {$APPTYPE कंसोल} उपयोग DesignPattern.Proxy 'DesignPattern.Proxy.pas' में; शुरू TProxyCar.New (TDriver.New (16))। ड्राइवकार; TProxyCar.New (TDriver.New (25))। ड्राइवकार; अंत। 

उत्पादन क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। कार चलाई गई है!

जावा
निम्न जावा (प्रोग्रामिंग भाषा) उदाहरण वर्चुअल प्रॉक्सी पैटर्न दिखाता है।  e> वर्ग का उपयोग दूरस्थ विधि तक पहुँचने के लिए किया जाता है।

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

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

<वाक्यविन्यास लैंग = जावा> इंटरफ़ेस छवि { सार्वजनिक शून्य प्रदर्शन छवि ; }

// सिस्टम ए पर वर्ग RealImage छवि लागू करता है { निजी अंतिम स्ट्रिंग फ़ाइल नाम;

/**    * कंस्ट्रक्टर * @पारम फ़ाइल नाम */   सार्वजनिक वास्तविक छवि (स्ट्रिंग फ़ाइल नाम) { यह फ़ाइल नाम = फ़ाइल नाम; लोडइमेजफ्रॉमडिस्क ; }

/**    * डिस्क से छवि लोड करता है */   निजी शून्य लोडइमेजफ्रॉमडिस्क  { System.out.println (लोड हो रहा है + फ़ाइल नाम); }

/**    * छवि प्रदर्शित करता है */   सार्वजनिक शून्य प्रदर्शन छवि  { System.out.println (प्रदर्शित + फ़ाइल नाम); } }

// सिस्टम बी पर वर्ग ProxyImage छवि लागू करता है { निजी अंतिम स्ट्रिंग फ़ाइल नाम; निजी वास्तविक छवि छवि; /**    * कंस्ट्रक्टर * @पारम फ़ाइल नाम */   सार्वजनिक प्रॉक्सी छवि (स्ट्रिंग फ़ाइल नाम) { यह फ़ाइल नाम = फ़ाइल नाम; }

/**    * छवि प्रदर्शित करता है */   सार्वजनिक शून्य प्रदर्शन छवि  { अगर (छवि == अशक्त) { छवि = नया रीयलइमेज (फ़ाइल नाम); }       इमेज.डिस्प्ले इमेज ; } }

वर्ग प्रॉक्सी उदाहरण { /**   * परिक्षण विधि */  सार्वजनिक स्थैतिक शून्य मुख्य (अंतिम स्ट्रिंग [] तर्क) { छवि छवि 1 = नई प्रॉक्सी छवि ( HiRes_10MB_Photo1 ); इमेज इमेज2 = नई प्रॉक्सीइमेज (HiRes_10MB_Photo2);

छवि 1. प्रदर्शन छवि ; // लोड करना आवश्यक है छवि 1. प्रदर्शन छवि ; // अनावश्यक लोड हो रहा है छवि 2. प्रदर्शन छवि ; // लोड करना आवश्यक है छवि 2. प्रदर्शन छवि ; // अनावश्यक लोड हो रहा है छवि 1. प्रदर्शन छवि ; // अनावश्यक लोड हो रहा है } } 

उत्पादन लोड हो रहा है HiRes_10MB_Photo1 HiRes_10MB_Photo1 प्रदर्शित कर रहा है HiRes_10MB_Photo1 प्रदर्शित कर रहा है लोड हो रहा है HiRes_10MB_Photo2 HiRes_10MB_Photo2 प्रदर्शित कर रहा है HiRes_10MB_Photo2 प्रदर्शित कर रहा है HiRes_10MB_Photo1 प्रदर्शित कर रहा है

जावास्क्रिप्ट
<वाक्यविन्यास हाइलाइट लैंग = जावास्क्रिप्ट> // चालक वर्ग वर्ग चालक { निर्माता (उम्र) { यह आयु = आयु } }

// कार वर्ग क्लास कार { गाड़ी चलाना { कंसोल.लॉग ('कार चलाई गई है!') } }

// प्रॉक्सी कार वर्ग क्लास प्रॉक्सीकार { निर्माता (चालक) { यह कार = नई कार यह.ड्राइवर = ड्राइवर }

गाड़ी चलाना { अगर (यह.ड्राइवर.उम्र <= 16) { कंसोल.लॉग ('क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।') } अन्य { यह.कार.ड्राइव } } }

// प्रोग्राम चलाओ कॉन्स्ट ड्राइवर = नया ड्राइवर (16) कास्ट कार = नई प्रॉक्सीकार (ड्राइवर) कार चलाना

कॉन्स्ट ड्राइवर 2 = नया ड्राइवर (25) const car2 = new ProxyCar(driver2) कार2.ड्राइव



उत्पादन क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। कार चलाई गई है!

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

पीएचपी
<वाक्यविन्यास लैंग = php>  फ़ाइल नाम = $ फ़ाइल नाम; $this->loadImageFromDisk; }

/**    * डिस्क से छवि लोड करता है */   निजी फ़ंक्शन लोडइमेजफ्रॉमडिस्क {       इको लोड हो रहा है {$this->filename} । \PHP_EOL; }

/**    * छवि प्रदर्शित करता है */   सार्वजनिक समारोह प्रदर्शन छवि {   {$this->filename} प्रदर्शित कर रहा है। \PHP_EOL; } }

// सिस्टम बी पर वर्ग ProxyImage छवि लागू करता है {   निजी? छवि $ छवि = अशक्त; निजी स्ट्रिंग $ फ़ाइल नाम = अशक्त;

सार्वजनिक कार्य __ निर्माण (स्ट्रिंग $ फ़ाइल नाम) {       $ यह-> फ़ाइल नाम = $ फ़ाइल नाम; }

/**    * छवि प्रदर्शित करता है */   सार्वजनिक समारोह प्रदर्शन छवि {       अगर ($ यह-> छवि === शून्य) { $this->image = new RealImage($this->filename); }       $this->image->displayImage; } }

$image1 = नई प्रॉक्सी इमेज ( HiRes_10MB_Photo1 ); $image2 = नया प्रॉक्सीइमेज( HiRes_10MB_Photo2 );

$image1->displayImage; // आवश्यक लोड हो रहा है $image1->displayImage; // अनावश्यक लोड हो रहा है $image2->displayImage; // आवश्यक लोड हो रहा है $image2->displayImage; // अनावश्यक लोड हो रहा है $image1->displayImage; // अनावश्यक लोड हो रहा है 

उत्पादन लोड हो रहा है HiRes_10MB_Photo1 HiRes_10MB_Photo1 प्रदर्शित कर रहा है HiRes_10MB_Photo1 प्रदर्शित कर रहा है लोड हो रहा है HiRes_10MB_Photo2 HiRes_10MB_Photo2 प्रदर्शित कर रहा है HiRes_10MB_Photo2 प्रदर्शित कर रहा है HiRes_10MB_Photo1 प्रदर्शित कर रहा है

पायथन
<वाक्यविन्यास लैंग = अजगर> प्रॉक्सी पैटर्न उदाहरण। abc से ABCMeta आयात करें, सार विधि

NOT_IMPLEMENTED = आपको इसे लागू करना चाहिए।

वर्ग सार कार: __metaclass__ = ABCMeta

@abstractmethod डीईएफ़ ड्राइव (स्वयं): लागू नहीं की गई त्रुटि बढ़ाएं (NOT_IMPLEMENTED)

वर्ग कार (सारकार): डीईएफ़ ड्राइव (स्वयं) -> कोई नहीं: प्रिंट (कार चलाई गई है!)

वर्ग चालक: def __init__(स्वयं, आयु: int) -> कोई नहीं: स्व.उम्र = आयु

क्लास प्रॉक्सीकार (सारकार): def __init__(स्वयं, चालक) -> कोई नहीं: स्व.कार = कार सेल्फ.ड्राइवर = ड्राइवर

डीईएफ़ ड्राइव (स्वयं) -> कोई नहीं: यदि स्व.ड्राइवर.उम्र <= 16: प्रिंट (क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।) अन्य: सेल्फ.कार.ड्राइव

चालक = चालक(16) कार = प्रॉक्सीकार (चालक) कार चलाना

चालक = चालक(25) कार = प्रॉक्सीकार (चालक) कार चलाना 

उत्पादन क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है। कार चलाई गई है!

जंग
<वाक्यविन्यास प्रकाश लैंग = जंग> विशेषता आईसीएआर { एफएन ड्राइव (और स्वयं); }

संरचना कार {}

कार के लिए इंप्ला आईसीएआर { fn ड्राइव (और स्वयं) { Println! (कार चला दी गई है!); } }

निहित कार { fn नया -> कार { कार {} } }

संरचना प्रॉक्सीकार <'ए> { real_car: और एक आईसीएआर, ड्राइवर उम्र: i32, }

impl<'a> ICar for ProxyCar<'a> { fn ड्राइव (और स्वयं) { अगर सेल्फ.ड्राइवर_एज > 16 { सेल्फ.रियल_कार.ड्राइव ; } अन्य { Println! (क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।) }   } }

impl<'a> ProxyCar<'a> { fn new(driver_age: i32, other_car: &'a ICar) -> ProxyCar { प्रॉक्सीकार { वास्तविक_कार: अन्य_कार, ड्राइवर की उम्र: ड्राइवर की उम्र, }   } }

आधुनिक परीक्षण { सुपर :: * का प्रयोग करें; #[परीक्षा] fn test_underage { चलो कार = कार :: नया ; चलो प्रॉक्सी_कार = प्रॉक्सीकार :: नया (16, और कार); प्रॉक्सी_कार.ड्राइव ; }
 * 1) [सीएफजी (परीक्षण)]

#[परीक्षा] fn test_can_drive { चलो कार = कार :: नया ; चलो प्रॉक्सी_कार = प्रॉक्सीकार :: नया (17, और कार); प्रॉक्सी_कार.ड्राइव ; } } 

उत्पादन क्षमा करें, आपके ड्राइव करने के लिए कार बहुत छोटी है। कार चलाई गई है!

यह भी देखें

 * समग्र पैटर्न
 * डेकोरेटर पैटर्न
 * आलसी आरंभीकरण

बाहरी संबंध

 * PerfectJPattern Open Source Project, Provides componentized implementation of the Proxy Pattern in Java
 * Proxy Design Pattern
 * Proxy pattern description from the Portland Pattern Repository
 * Proxy Design Pattern
 * Proxy pattern description from the Portland Pattern Repository
 * Proxy pattern description from the Portland Pattern Repository