ब्रिज और एडेप्टर पैटर्न के बीच अंतर क्या है?
ब्रिज और एडेप्टर पैटर्न के बीच अंतर क्या है?
जवाबों:
"एडॉप्टर चीजों को डिज़ाइन करने के बाद काम करता है; ब्रिज उन्हें काम करने से पहले बनाता है। [GoF, P219]"
प्रभावी रूप से, एडॉप्टर पैटर्न तब उपयोगी होता है जब आपके पास मौजूदा कोड होता है, चाहे वह थर्ड पार्टी हो, या इन-हाउस हो, लेकिन आपके नियंत्रण से बाहर, या अन्यथा उस इंटरफ़ेस को पूरा करने के लिए परिवर्तनशील नहीं जिसे आपको इसकी आवश्यकता होती है। उदाहरण के लिए, हमारे पास एक SuperWeaponsArray है जो प्रलय के उपकरणों की एक अच्छी सरणी को नियंत्रित कर सकता है।
public class SuperWeaponsArray {
/*...*/
public void destroyWorld() {
for (Weapon w : armedWeapons) {
w.fire();
}
}
}
महान। सिवाय इसके कि हम महसूस करते हैं कि हमारे शस्त्रागार में एक परमाणु उपकरण है जो हथियार इंटरफेस में बड़े पैमाने पर रूपांतरण करता है। लेकिन हम वास्तव में इसे यहाँ काम करना पसंद करेंगे ... तो हम क्या करते हैं ... इसे अंदर करें!
NukeWeaponsAdaptor - हमारे Nuke वर्ग पर आधारित है, लेकिन हथियार इंटरफ़ेस का निर्यात कर रहा है। मीठा, अब हम निश्चित रूप से दुनिया को नष्ट कर सकते हैं। यह एक कीचड़ की तरह लगता है, लेकिन यह काम करता है।
ब्रिज पैटर्न कुछ आप सामने लागू है - यदि आप जानते हैं कि आप दो ओर्थोगोनल पदानुक्रम है, यह इंटरफेस और इस तरह से कि आप वर्गों में से एक पागल संख्या नहीं मिलता है में कार्यान्वयन दसगुणा के लिए एक रास्ता प्रदान करता है। मान लीजिए कि आपके पास है:
MemoryMappedFile और DirectReadFile फ़ाइल ऑब्जेक्ट्स के प्रकार। मान लें कि आप विभिन्न स्रोतों (शायद लिनक्स बनाम विंडोज कार्यान्वयन, आदि) से फ़ाइलों को पढ़ने में सक्षम होना चाहते हैं। ब्रिज आपको इससे बचने में मदद करता है:
मेमोरीमेडब्लू विंडोफाइल मेमोरीमेडप्लाइनक्लिपफाइल
http://en.wikipedia.org/wiki/Adapter_pattern
एडाप्टर पैटर्न एक नए सिस्टम या इंटरफ़ेस के साथ काम करने के लिए आपके मौजूदा कोड को प्राप्त करने के बारे में अधिक है।
यदि आपके पास कंपनी-मानक वेब सेवा API का एक सेट है, जिसे आप किसी अन्य एप्लिकेशन के मौजूदा एक्स्टेंसिबिलिटी इंटरफ़ेस के लिए प्रस्तुत करना चाहते हैं, तो आप ऐसा करने के लिए एडेप्टर का एक सेट लिखने पर विचार कर सकते हैं। ध्यान दें कि एक ग्रे क्षेत्र है और यह इस बारे में अधिक है कि आप तकनीकी रूप से पैटर्न को कैसे परिभाषित करते हैं, क्योंकि अन्य पैटर्न जैसे कि मुखौटा समान हैं।
http://en.wikipedia.org/wiki/Bridge_pattern
ब्रिज पैटर्न आपको संभवतः एल्गोरिथम या सिस्टम के वैकल्पिक कार्यान्वयन की अनुमति देने जा रहा है।
हालांकि एक क्लासिक ब्रिज पैटर्न उदाहरण नहीं है, कल्पना करें कि क्या आपके पास डेटा स्टोर के कुछ कार्यान्वयन हैं: एक अंतरिक्ष में कुशल है, दूसरा कच्चे प्रदर्शन में कुशल है ... और आपके पास अपने ऐप या ढांचे में दोनों की पेशकश के लिए एक व्यावसायिक मामला है ।
आपके प्रश्न के संदर्भ में, "जहां मैं किस पैटर्न का उपयोग कर सकता हूं," जवाब है, जहां भी यह आपकी परियोजना के लिए समझ में आता है! शायद चर्चा को निर्देशित करने के लिए एक स्पष्टीकरण देने की पेशकश पर विचार करें जहां आप मानते हैं कि आपको एक या दूसरे का उपयोग करने की आवश्यकता है।
एडाप्टर:
यूएमएल आरेख: से dofactory लेख:
लक्ष्य : क्लाइंट द्वारा उपयोग किए जाने वाले डोमेन-विशिष्ट इंटरफ़ेस को परिभाषित करता है।
एडेप्टर : इंटरफ़ेस को एडापेटी को टार्गेट इंटरफेस में एडाप्ट करता है।
Adaptee : एक मौजूदा इंटरफ़ेस को परिभाषित करता है जिसे एडैपिंग की आवश्यकता होती है।
क्लाइंट : लक्ष्य इंटरफ़ेस के अनुरूप वस्तुओं के साथ सहयोग करता है।
उदाहरण:
स्क्वायर और आयत दो अलग-अलग आकार हैं और उनमें से प्रत्येक के क्षेत्र () को अलग-अलग तरीकों की आवश्यकता होती है। लेकिन फिर भी कुछ गुणों के रूपांतरण के साथ आयत इंटरफेस पर स्क्वायर काम करते हैं।
public class AdapterDemo{
public static void main(String args[]){
SquareArea s = new SquareArea(4);
System.out.println("Square area :"+s.getArea());
}
}
class RectangleArea {
public int getArea(int length, int width){
return length * width;
}
}
class SquareArea extends RectangleArea {
int length;
public SquareArea(int length){
this.length = length;
}
public int getArea(){
return getArea(length,length);
}
}
पुल:
संपादित करें: (@quasoft सुझाव के अनुसार)
इस पैटर्न में आपके चार घटक हैं।
अमूर्त : यह एक इंटरफ़ेस को परिभाषित करता है
RefinedAbstraction : यह अमूर्तता को लागू करता है:
कार्यान्वयनकर्ता : यह कार्यान्वयन के लिए एक इंटरफ़ेस परिभाषित करता है
कंक्रीटइम्प्लीमर : यह इंप्लायर इंटरफेस को लागू करता है।
सांकेतिक टुकड़ा:
Gear gear = new ManualGear();
Vehicle vehicle = new Car(gear);
vehicle.addGear();
gear = new AutoGear();
vehicle = new Car(gear);
vehicle.addGear();
संबंधित पोस्ट:
आप ब्रिज पैटर्न का उपयोग कब करते हैं? यह एडेप्टर पैटर्न से कैसे अलग है?
मुख्य अंतर: से sourcemaking लेख
यह पोस्ट काफी समय से आसपास है। हालांकि, यह समझना महत्वपूर्ण है कि एक मुखौटा कुछ हद तक एक एडेप्टर के समान है, लेकिन यह काफी समान चीज नहीं है। एक एडेप्टर एक मौजूदा वर्ग को आमतौर पर गैर-संगत क्लाइंट क्लास में "एडैप्ट" करता है। मान लीजिए कि आपके पास एक पुरानी वर्कफ़्लो प्रणाली है जिसे आपका एप्लिकेशन क्लाइंट के रूप में उपयोग कर रहा है। आपकी कंपनी संभवतः वर्कफ़्लो सिस्टम को एक नए "असंगत" एक (इंटरफेस के संदर्भ में) के साथ बदल सकती है। ज्यादातर मामलों में, आप एडेप्टर पैटर्न का उपयोग कर सकते हैं और कोड लिख सकते हैं जो वास्तव में नए वर्कफ़्लो इंजन के इंटरफेस को कॉल करता है। एक पुल का उपयोग आम तौर पर एक अलग तरीके से किया जाता है। यदि आपके पास वास्तव में एक सिस्टम है जिसे विभिन्न फाइल सिस्टम (यानी स्थानीय डिस्क, एनएफएस, आदि) के साथ काम करने की आवश्यकता है, तो आप अपने सभी फाइल सिस्टम के साथ काम करने के लिए ब्रिज पैटर्न का उपयोग कर सकते हैं और एक अमूर्त परत बना सकते हैं। यह मूल रूप से ब्रिज पैटर्न के लिए एक सरल उपयोग मामला होगा। मुखौटा और एडाप्टर कुछ गुण साझा करते हैं लेकिनfacades आमतौर पर एक मौजूदा इंटरफ़ेस / वर्ग को सरल बनाने के लिए उपयोग किया जाता है । ईजेबी के शुरुआती दिनों में ईजेबी के लिए कोई स्थानीय कॉल नहीं थे। डेवलपर्स ने हमेशा स्टब प्राप्त किया, इसे नीचे संकुचित किया और इसे "छद्म-दूर से" कहा। यह कई बार प्रदर्शन की समस्याओं का कारण बनता है (वास्तव में जब तार पर कहा जाता है)। अनुभवी डेवलपर्स क्लाइंट को एक बहुत मोटे-मोटे इंटरफ़ेस प्रदान करने के लिए मुखौटा पैटर्न का उपयोग करेंगे। यह मोहरा फिर बारी-बारी से अलग-अलग और बेहतर तरीके से कई कॉल करता है। सब के सब, यह आवश्यक विधि कॉल की संख्या को काफी कम कर दिया और प्रदर्शन में वृद्धि की।
ब्रिज को बेहतर बनाया गया है। ब्रिज में एडॉप्टर शामिल है और इसमें अतिरिक्त लचीलापन जोड़ा गया है। यहां बताया गया है कि पैटर्न के बीच रवींद्र के उत्तर मानचित्र के तत्व कैसे हैं:
Adapter | Bridge
-----------|---------------
Target | Abstraction
-----------|---------------
| RefinedAbstraction
|
| This element is Bridge specific. If there is a group of
| implementations that share the same logic, the logic can be placed here.
| For example, all cars split into two large groups: manual and auto.
| So, there will be two RefinedAbstraction classes.
-----------|---------------
Adapter | Implementor
-----------|---------------
Adaptee | ConcreteImplementor
शीर्ष उत्तर में, @James ने GoF, पृष्ठ 219 से एक वाक्य उद्धृत किया है। मुझे लगता है कि यह यहाँ पूर्ण विवरण को पुन: प्रस्तुत करने योग्य है।
एडाप्टर बनाम ब्रिज
एडाप्टर और ब्रिज पैटर्न में कुछ सामान्य विशेषताएं हैं। दोनों किसी अन्य वस्तु को अप्रत्यक्ष स्तर प्रदान करके लचीलेपन को बढ़ावा देते हैं। दोनों में अपने स्वयं के अलावा एक इंटरफ़ेस से इस ऑब्जेक्ट के लिए अग्रेषण अनुरोध शामिल हैं।
इन पैटर्न के बीच महत्वपूर्ण अंतर उनके इरादों में निहित है। एडाप्टर दो मौजूदा इंटरफेस के बीच असंगतताओं को हल करने पर केंद्रित है। यह इस बात पर ध्यान केंद्रित नहीं करता है कि उन इंटरफेस को कैसे लागू किया जाता है, न ही यह विचार करता है कि वे स्वतंत्र रूप से कैसे विकसित हो सकते हैं। यह एक या दूसरे को फिर से लागू किए बिना दो स्वतंत्र रूप से डिज़ाइन की गई कक्षाओं को एक साथ बनाने का एक तरीका है। दूसरी ओर, पुल एक अमूर्त पुल और इसके (संभावित रूप से कई) कार्यान्वयन को पूरा करता है। यह ग्राहकों को एक स्थिर इंटरफ़ेस प्रदान करता है, यहां तक कि यह आपको इसे लागू करने वाले वर्गों को अलग करने देता है। यह प्रणाली के विकसित होते ही नए कार्यान्वयन को भी समायोजित करता है।
इन अंतरों के परिणामस्वरूप, एडेप्टर और ब्रिज को अक्सर सॉफ़्टवेयर जीवन चक्र में विभिन्न बिंदुओं पर उपयोग किया जाता है। एक एडेप्टर अक्सर आवश्यक हो जाता है जब आपको पता चलता है कि दो असंगत वर्गों को एक साथ काम करना चाहिए, आम तौर पर प्रतिकृति कोड से बचने के लिए। युग्मन अप्रत्याशित है। इसके विपरीत, एक पुल का उपयोगकर्ता ऊपर-सामने समझता है कि एक अमूर्त में कई कार्यान्वयन होने चाहिए, और दोनों स्वतंत्र रूप से विकसित हो सकते हैं। एडेप्टर पैटर्न डिज़ाइन किए जाने के बाद चीजों को काम करता है ; ब्रिज बनने से पहले वे उन्हें काम करते हैं। इसका मतलब यह नहीं है कि एडेप्टर किसी भी तरह ब्रिज से नीचा है; प्रत्येक पैटर्न केवल एक अलग समस्या को संबोधित करता है।
मान लीजिए कि आप एक (सामान्य / अमूर्त) ड्राइंग कार्यक्षमता के साथ एक सार आकार वर्ग है और एक सर्कल जो आकृति को लागू करता है। ब्रिज पैटर्न बस कार्यान्वयन (सर्कल में ड्राइंग) और जेनेरिक / एब्स्ट्रैक्टेड कार्यक्षमता (आकृति वर्ग में ड्राइंग) को डिकूप करने के लिए दो-तरफा अमूर्त दृष्टिकोण है।
इसका वास्तव में क्या अर्थ है? पहली नज़र में, यह कुछ ऐसा लगता है जो आप पहले से ही बना रहे हैं (निर्भरता उलटा)। तो कम-लकीर या अधिक मॉड्यूलर कोड आधार होने के बारे में कोई चिंता नहीं है। लेकिन इसके पीछे थोड़ा गहरा दर्शन है।
मेरी समझ से, उपयोग पैटर्न की आवश्यकता तब उभर सकती है जब मुझे नई कक्षाओं को जोड़ने की आवश्यकता होती है जो वर्तमान प्रणाली (जैसे RedCircle या GreenCircle) के साथ निकटता से संबंधित हैं और जो कि वे केवल एक कार्यक्षमता (जैसे रंग) से भिन्न होती हैं। और मुझे ब्रिज पैटर्न की आवश्यकता होगी, खासकर अगर मौजूदा सिस्टम क्लासेस (सर्कल या शेप) को अक्सर बदला जाना है और आप नहीं चाहते कि नए जोड़े गए क्लासेस उन बदलावों से प्रभावित हों। इसीलिए जेनेरिक ड्राइंग कार्यक्षमता को एक नए इंटरफ़ेस में अलग कर दिया जाता है ताकि आप आकृति या सर्कल से स्वतंत्र ड्राइंग व्यवहार को बदल सकें।