एडेप्टर पैटर्न

सॉफ्टवेयर इंजीनियरिंग में, एडेप्टर पैटर्न सॉफ्टवेयर डिजाइन पैटर्न है (जिसे आवरण समारोह के रूप में भी जाना जाता है, डेकोरेटर पैटर्न के साथ साझा किया गया वैकल्पिक नामकरण) जो मौजूदा वर्ग (कंप्यूटर विज्ञान) के इंटरफ़ेस (कंप्यूटर विज्ञान) को दूसरे इंटरफ़ेस के रूप में उपयोग करने की अनुमति देता है। .इसका उपयोग अक्सर मौजूदा कक्षाओं को उनके स्रोत कोड को संशोधित किए बिना दूसरों के साथ काम करने के लिए किया जाता है।

उदाहरण एडेप्टर है जो XML दस्तावेज़ के दस्तावेज़ ऑब्जेक्ट मॉडल के इंटरफ़ेस को ट्री संरचना में परिवर्तित करता है जिसे प्रदर्शित किया जा सकता है।

सिंहावलोकन

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

एडॉप्टर डिज़ाइन पैटर्न समस्याओं को हल करता है जैसे:

• वर्ग का पुन: उपयोग कैसे किया जा सकता है जिसमें क्लाइंट की आवश्यकता वाला इंटरफ़ेस नहीं है?

• असंगत इंटरफेस वाली कक्षाएं एक साथ कैसे काम कर सकती हैं?
• वर्ग के लिए वैकल्पिक इंटरफ़ेस कैसे प्रदान किया जा सकता है?

अक्सर (पहले से मौजूद) वर्ग का पुन: उपयोग नहीं किया जा सकता है क्योंकि इसका इंटरफ़ेस इंटरफ़ेस क्लाइंट की आवश्यकता के अनुरूप नहीं होता है।

एडेप्टर डिज़ाइन पैटर्न बताता है कि ऐसी समस्याओं को कैसे हल किया जाए:

• अलग परिभाषित करें adapter वर्ग जो वर्ग के (असंगत) इंटरफ़ेस को परिवर्तित करता है (adaptee) दूसरे इंटरफ़ेस में (target) ग्राहकों की आवश्यकता है।
• एक के माध्यम से कार्य करें adapter (पुन: उपयोग) कक्षाओं के साथ काम करने के लिए जिनके पास आवश्यक इंटरफ़ेस नहीं है।

इस पैटर्न में मुख्य विचार अलग के माध्यम से काम करना है adapter जो बिना बदले (पहले से मौजूद) वर्ग के इंटरफ़ेस को एडाप्ट करता है।

ग्राहक नहीं जानते कि वे a के साथ काम करते हैं या नहीं target कक्षा सीधे या एक के माध्यम से adapter वर्ग के साथ जिसके पास नहीं है target इंटरफेस।

नीचे यूएमएल क्लास डायग्राम भी देखें।

परिभाषा

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

उपयोग

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

Pattern	Intent
Adapter or wrapper	Converts one interface to another so that it matches what the client is expecting
Decorator	Dynamically adds responsibility to the interface by wrapping the original code
Delegation	Support "composition over inheritance"
Facade	Provides a simplified interface

संरचना

यूएमएल वर्ग आरेख

एडेप्टर डिज़ाइन पैटर्न के लिए नमूना यूएमएल वर्ग आरेख।

उपरोक्त एकीकृत मॉडलिंग भाषा वर्ग आरेख में, client जिस वर्ग को ए की आवश्यकता है target इंटरफ़ेस का पुन: उपयोग नहीं कर सकता adaptee क्लास सीधे क्योंकि इसका इंटरफ़ेस इसके अनुरूप नहीं है target इंटरफेस।

इसके बजाय, client के माध्यम से कार्य करता है adapter वर्ग जो लागू करता है target इंटरफ़ेस के संदर्भ में adaptee:

• object adapter e> तरीका लागू करता है target को प्रत्यायोजित करके इंटरफ़ेस adaptee रन-टाइम पर वस्तु (adaptee.specificOperation()).
• class adapter e> तरीका लागू करता है target से विरासत में मिला इंटरफ़ेस adaptee संकलन-समय पर वर्ग (specificOperation()).

ऑब्जेक्ट एडेप्टर पैटर्न

इस एडॉप्टर पैटर्न में, एडेप्टर में उस वर्ग का उदाहरण होता है जिसे वह लपेटता है। इस स्थिति में, एडेप्टर लिपटे वस्तु (कंप्यूटिंग) के उदाहरण के लिए कॉल करता है।

यूनिफाइड मॉडलिंग लैंग्वेज में व्यक्त ऑब्जेक्ट एडेप्टर पैटर्न

Lepus3 में व्यक्त वस्तु अनुकूलक पैटर्न

क्लास एडॉप्टर पैटर्न

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

यूनिफाइड मॉडलिंग लैंग्वेज में व्यक्त क्लास एडेप्टर पैटर्न।

Lepus3 में व्यक्त क्लास अडैप्टर पैटर्न

रनटाइम एडेप्टर पैटर्न का एक और रूप

संकलन समय समाधान से प्रेरणा

इसके लिए वांछित है classA सप्लाई करने के लिए classB कुछ आंकड़ों के साथ, आइए हम कुछ मान लें String आंकड़े। संकलन समय समाधान है:

classB.setStringData(classA.getStringData());

हालाँकि, मान लीजिए कि स्ट्रिंग डेटा का प्रारूप विविध होना चाहिए। संकलन समय समाधान वंशानुक्रम का उपयोग करना है:

public class Format1ClassA extends ClassA {
    @Override
    public String getStringData() {
        return format(toString());
    }
}

और शायद फैक्टरी पैटर्न के माध्यम से रनटाइम पर सही स्वरूपण ऑब्जेक्ट बनाएं।

रन-टाइम अनुकूलक समाधान

एडॉप्टर का उपयोग करने वाला समाधान निम्नानुसार आगे बढ़ता है:

1. Define an intermediary "provider" interface, and write an implementation of that provider interface that wraps the source of the data, ClassA in this example, and outputs the data formatted as appropriate:

   public interface StringProvider {
       public String getStringData();
   }
   
   public class ClassAFormat1 implements StringProvider {
       private ClassA classA = null;
   
       public ClassAFormat1(final ClassA a) {
           classA = a;
       }
   
       public String getStringData() {
           return format(classA.getStringData());
       }
   
       private String format(final String sourceValue) {
           // Manipulate the source string into a format required 
           // by the object needing the source object's data
           return sourceValue.trim();
       }
   }
   

2. Write an adapter class that returns the specific implementation of the provider:

   public class ClassAFormat1Adapter extends Adapter {
       public Object adapt(final Object anObject) {
           return new ClassAFormat1((ClassA) anObject);
       }
   }
   

3. Register the adapter with a global registry, so that the adapter can be looked up at runtime:

   AdapterFactory.getInstance().registerAdapter(ClassA.class, ClassAFormat1Adapter.class, "format1");
   

4. In code, when wishing to transfer data from ClassA to ClassB, write:

   Adapter adapter =
       AdapterFactory.getInstance()
           .getAdapterFromTo(ClassA.class, StringProvider.class, "format1");
   StringProvider provider = (StringProvider) adapter.adapt(classA);
   String string = provider.getStringData();
   classB.setStringData(string);
   

   or more concisely:

   classB.setStringData(
       ((StringProvider)
               AdapterFactory.getInstance()
                   .getAdapterFromTo(ClassA.class, StringProvider.class, "format1")
                   .adapt(classA))
           .getStringData());
   

5. The advantage can be seen in that, if it is desired to transfer the data in a second format, then look up the different adapter/provider:

   Adapter adapter =
       AdapterFactory.getInstance()
           .getAdapterFromTo(ClassA.class, StringProvider.class, "format2");
   

6. And if it is desired to output the data from ClassA as, say, image data in Class C:

   Adapter adapter =
       AdapterFactory.getInstance()
           .getAdapterFromTo(ClassA.class, ImageProvider.class, "format2");
   ImageProvider provider = (ImageProvider) adapter.adapt(classA);
   classC.setImage(provider.getImage());
   

7. In this way, the use of adapters and providers allows multiple "views" by ClassB and ClassC into ClassA without having to alter the class hierarchy. In general, it permits a mechanism for arbitrary data flows between objects that can be retrofitted to an existing object hierarchy.

एडेप्टर पैटर्न का कार्यान्वयन

एडेप्टर पैटर्न को लागू करते समय, स्पष्टता के लिए, कोई वर्ग नाम लागू कर सकता है [ClassName]To[Interface]Adapter प्रदाता कार्यान्वयन के लिए; उदाहरण के लिए, DAOToProviderAdapter. इसमें पैरामीटर के रूप में एडाप्टी क्लास वेरिएबल के साथ कंस्ट्रक्टर विधि होनी चाहिए। यह पैरामीटर इंस्टेंस सदस्य को पास किया जाएगा [ClassName]To[Interface]Adapter. जब क्लाइंटमेथोड को कॉल किया जाता है, तो उसके पास एडेप्टी इंस्टेंस तक पहुंच होगी जो एडाप्टी के आवश्यक डेटा तक पहुंचने और उस डेटा पर संचालन करने की अनुमति देता है जो वांछित आउटपुट उत्पन्न करता है।

जावा

interface ILightningPhone {
    void recharge();
    void useLightning();
}

interface IMicroUsbPhone {
    void recharge();
    void useMicroUsb();
}

class Iphone implements ILightningPhone {
    private boolean connector;

    @Override
    public void useLightning() {
        connector = true;
        System.out.println("Lightning connected");
    }

    @Override
    public void recharge() {
        if (connector) {
            System.out.println("Recharge started");
            System.out.println("Recharge finished");
        } else {
            System.out.println("Connect Lightning first");
        }
    }
}

class Android implements IMicroUsbPhone {
    private boolean connector;

    @Override
    public void useMicroUsb() {
        connector = true;
        System.out.println("MicroUsb connected");
    }

    @Override
    public void recharge() {
        if (connector) {
            System.out.println("Recharge started");
            System.out.println("Recharge finished");
        } else {
            System.out.println("Connect MicroUsb first");
        }
    }
}
/* exposing the target interface while wrapping source object */
class LightningToMicroUsbAdapter implements IMicroUsbPhone {
    private final ILightningPhone lightningPhone;

    public LightningToMicroUsbAdapter(ILightningPhone lightningPhone) {
        this.lightningPhone = lightningPhone;
    }

    @Override
    public void useMicroUsb() {
        System.out.println("MicroUsb connected");
        lightningPhone.useLightning();
    }

    @Override
    public void recharge() {
        lightningPhone.recharge();
    }
}

public class AdapterDemo {
    static void rechargeMicroUsbPhone(IMicroUsbPhone phone) {
        phone.useMicroUsb();
        phone.recharge();
    }

    static void rechargeLightningPhone(ILightningPhone phone) {
        phone.useLightning();
        phone.recharge();
    }

    public static void main(String[] args) {
        Android android = new Android();
        Iphone iPhone = new Iphone();

        System.out.println("Recharging android with MicroUsb");
        rechargeMicroUsbPhone(android);

        System.out.println("Recharging iPhone with Lightning");
        rechargeLightningPhone(iPhone);

        System.out.println("Recharging iPhone with MicroUsb");
        rechargeMicroUsbPhone(new LightningToMicroUsbAdapter (iPhone));
    }
}

उत्पादन <पूर्व> माइक्रोयूएसबी के साथ एंड्रॉइड रिचार्ज करना माइक्रोयूएसबी जुड़ा हुआ है रिचार्ज शुरू हो गया रिचार्ज खत्म बिजली के साथ iPhone रिचार्जिंग बिजली जुड़ी रिचार्ज शुरू हो गया रिचार्ज खत्म माइक्रोयूएसबी के साथ आईफोन रिचार्ज करना माइक्रोयूएसबी जुड़ा हुआ है बिजली जुड़ी रिचार्ज शुरू हो गया रिचार्ज खत्म </पूर्व>

पायथन

"""
Adapter pattern example.
"""
from abc import ABCMeta, abstractmethod

NOT_IMPLEMENTED = "You should implement this."

RECHARGE = ["Recharge started.", "Recharge finished."]

POWER_ADAPTERS = {"Android": "MicroUSB", "iPhone": "Lightning"}

CONNECTED = "{} connected."
CONNECT_FIRST = "Connect {} first."

class RechargeTemplate(metaclass=ABCMeta):

    @abstractmethod
    def recharge(self):
        raise NotImplementedError(NOT_IMPLEMENTED)

class FormatIPhone(RechargeTemplate):
    @abstractmethod
    def use_lightning(self):
        raise NotImplementedError(NOT_IMPLEMENTED)

class FormatAndroid(RechargeTemplate):
    @abstractmethod
    def use_micro_usb(self):
        raise NotImplementedError(NOT_IMPLEMENTED)

class IPhone(FormatIPhone):
    __name__ = "iPhone"

    def __init__(self):
        self.connector = False

    def use_lightning(self):
        self.connector = True
        print(CONNECTED.format(POWER_ADAPTERS[self.__name__]))

    def recharge(self):
        if self.connector:
            for state in RECHARGE:
                print(state)
        else:
            print(CONNECT_FIRST.format(POWER_ADAPTERS[self.__name__]))

class Android(FormatAndroid):
    __name__ = "Android"

    def __init__(self):
        self.connector = False

    def use_micro_usb(self):
        self.connector = True
        print(CONNECTED.format(POWER_ADAPTERS[self.__name__]))

    def recharge(self):
        if self.connector:
            for state in RECHARGE:
                print(state)
        else:
            print(CONNECT_FIRST.format(POWER_ADAPTERS[self.__name__]))

class IPhoneAdapter(FormatAndroid):
    def __init__(self, mobile):
        self.mobile = mobile

    def recharge(self):
        self.mobile.recharge()

    def use_micro_usb(self):
        print(CONNECTED.format(POWER_ADAPTERS["Android"]))
        self.mobile.use_lightning()

class AndroidRecharger:
    def __init__(self):
        self.phone = Android()
        self.phone.use_micro_usb()
        self.phone.recharge()

class IPhoneMicroUSBRecharger:
    def __init__(self):
        self.phone = IPhone()
        self.phone_adapter = IPhoneAdapter(self.phone)
        self.phone_adapter.use_micro_usb()
        self.phone_adapter.recharge()

class IPhoneRecharger:
    def __init__(self):
        self.phone = IPhone()
        self.phone.use_lightning()
        self.phone.recharge()

print("Recharging Android with MicroUSB recharger.")
AndroidRecharger()
print()

print("Recharging iPhone with MicroUSB using adapter pattern.")
IPhoneMicroUSBRecharger()
print()

print("Recharging iPhone with iPhone recharger.")
IPhoneRecharger()

सी #

<वाक्यविन्यास प्रकाश लैंग = सी #> सार्वजनिक इंटरफ़ेस ILightningPhone { शून्य कनेक्टलाइटिंग (); शून्य रिचार्ज (); }

सार्वजनिक इंटरफ़ेस IUsbPhone { शून्य कनेक्टयूएसबी (); शून्य रिचार्ज (); }

सार्वजनिक सीलबंद वर्ग AndroidPhone: IUsbPhone { निजी बूल जुड़ा हुआ है;

सार्वजनिक शून्य ConnectUsb () { यह कनेक्टेड = सच है; कंसोल। राइटलाइन (एंड्रॉइड फोन जुड़ा हुआ है।); }

सार्वजनिक शून्य रिचार्ज () { अगर (यह जुड़ा हुआ है) { कंसोल। राइटलाइन (एंड्रॉइड फोन रिचार्जिंग।); } अन्य { कंसोल। राइटलाइन (पहले यूएसबी केबल कनेक्ट करें।); } } }

सार्वजनिक मुहरबंद वर्ग ApplePhone: ILightningPhone { निजी बूल जुड़ा हुआ है;

सार्वजनिक शून्य कनेक्टलाइटिंग () { यह कनेक्टेड = सच है; कंसोल। राइटलाइन (एप्पल फोन जुड़ा हुआ है।); }

सार्वजनिक शून्य रिचार्ज () { अगर (यह जुड़ा हुआ है) { कंसोल। राइटलाइन (ऐप्पल फोन रिचार्जिंग।); } अन्य { कंसोल। राइटलाइन (पहले लाइटनिंग केबल कनेक्ट करें।); } } }

पब्लिक सील्ड क्लास LightningToUsbAdapter : IUsbPhone { केवल पढ़ने के लिए निजी लाइटनिंगफोन लाइटनिंगफोन;

निजी बूल जुड़ा हुआ है;

पब्लिक लाइटनिंगटूयूएसबीएडाप्टर(आईलाइटनिंगफोन लाइटनिंगफोन) { यह.लाइटिंगफोन = लाइटनिंगफोन; this.lightningPhone.ConnectLightning (); }

सार्वजनिक शून्य ConnectUsb () { यह कनेक्टेड = सच है; कंसोल। राइटलाइन (एडाप्टर केबल जुड़ा हुआ है।); }

सार्वजनिक शून्य रिचार्ज () { अगर (यह जुड़ा हुआ है) { यह.लाइटिंगफोन.रिचार्ज (); } अन्य { कंसोल। राइटलाइन (पहले यूएसबी केबल कनेक्ट करें।); } } }

सार्वजनिक शून्य मुख्य () { लाइटनिंगफोन ऐप्पलफोन = नया ऐप्पलफोन (); IUsbPhone अडैप्टरकेबल = नया लाइटनिंगटूयूएसबीएडाप्टर (ऐप्पलफोन); एडेप्टरकेबल.कनेक्टयूएसबी (); एडॉप्टरकेबल। रिचार्ज (); }

</syntaxhighlight>आउटपुट:

Apple phone connected.
Adapter cable connected.
Apple phone recharging.

यह भी देखें

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