In software engineering, the adapter pattern is a software design pattern (also known as wrapper, an alternative naming shared with the decorator pattern) that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code.
An example is an adapter that converts the interface of a Document Object Model of an XML document into a tree structure that can be displayed.
classB with some data, let us suppose some
publicclass Format1ClassAextendsClassA{
@Override
publicStringgetStringData(){
returnformat(toString());
}
}
and perhaps create the correctly "formatting" object at runtime by means of the factory pattern.
Run-time adapter solution
editA solution using "adapters" proceeds as follows:
\ninterface StringProvider {\n public String getStringData();\n}\n\npublic class ClassAFormat1 implements StringProvider {\n private ClassA classA = null;\n\n public ClassAFormat1(final ClassA a) {\n classA = a;\n }\n\n public String getStringData() {\n return format(classA.getStringData());\n }\n\n private String format(final String sourceValue) {\n // Manipulate the source string into a format required \n // by the object needing the source object's data\n return sourceValue.trim();\n }\n}\n</syntaxhighlight>\n\n"},"2":{"wt":"Write an adapter class that returns the specific implementation of the provider:\n\n<syntaxhighlight lang=Java>\npublic class ClassAFormat1Adapter extends Adapter {\n public Object adapt(final Object anObject) {\n return new ClassAFormat1((ClassA) anObject);\n }\n}\n</syntaxhighlight>\n\n"},"3":{"wt":"Register the {{Java|adapter}} with a global registry, so that the {{Java|adapter}} can be looked up at runtime:\n\n<syntaxhighlight lang=Java>\nAdapterFactory.getInstance().registerAdapter(ClassA.class, ClassAFormat1Adapter.class, \"format1\");\n</syntaxhighlight>\n\n"},"4":{"wt":"In code, when wishing to transfer data from {{Java|ClassA}} to {{Java|ClassB}}, write:\n\n<syntaxhighlight lang=Java>\nAdapter adapter = AdapterFactory.getInstance()\n .getAdapterFromTo(ClassA.class, StringProvider.class, \"format1\");\nStringProvider provider = (StringProvider) adapter.adapt(classA);\nString string = provider.getStringData();\nclassB.setStringData(string);\n</syntaxhighlight>\n\nor more concisely:\n\n<syntaxhighlight lang=Java>\nclassB.setStringData(((StringProvider)AdapterFactory.getInstance()\n .getAdapterFromTo(ClassA.class, StringProvider.class, \"format1\")\n .adapt(classA))\n .getStringData()\n);\n</syntaxhighlight>\n\n"},"5":{"wt":"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:\n\n<syntaxhighlight lang=Java>\nAdapter adapter = AdapterFactory.getInstance()\n .getAdapterFromTo(ClassA.class, StringProvider.class, \"format2\");\n</syntaxhighlight>\n\n"},"6":{"wt":"And if it is desired to output the data from {{Java|ClassA}} as, say, image data in {{Java|Class C}}:\n<syntaxhighlight lang=Java>\nAdapter adapter = AdapterFactory.getInstance()\n .getAdapterFromTo(ClassA.class, ImageProvider.class, \"format2\");\nImageProvider provider = (ImageProvider) adapter.adapt(classA);\nclassC.setImage(provider.getImage());\n</syntaxhighlight>\n\n"},"7":{"wt":"In this way, the use of adapters and providers allows multiple \"views\" by {{Java|ClassB}} and {{Java|ClassC}} into {{Java|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.\n"}},"i":0}}]}'>
- Define an intermediary "provider" interface, and write an implementation of that provider interface that wraps the source of the data, adapter
can be looked up at runtime:
ClassB
, write:
Adapteradapter=AdapterFactory.getInstance()
.getAdapterFromTo(ClassA.class,StringProvider.class,"format2");
- And if it is desired to output the data from Adapteradapter=AdapterFactory.getInstance()
.getAdapterFromTo(ClassA.class,ImageProvider.class,"format2");
ImageProviderprovider=(ImageProvider)adapter.adapt(classA);
classC.setImage(provider.getImage());
- In this way, the use of adapters and providers allows multiple "views" by 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.
Implementation of the adapter pattern
editWhen implementing the adapter pattern, for clarity, one can apply the class name [ClassName]To[Interface]Adapter. When the clientMethod is called, it will have access to the adaptee instance that allows for accessing the required data of the adaptee and performing operations on that data that generates the desired output.
"""
Adapter pattern example.
"""
fromabcimport ABCMeta, abstractmethod
fromtypingimport NoReturn
RECHARGE: list[str] = ["Recharge started.", "Recharge finished."]
POWER_ADAPTERS: dict[str, str] = {"Android": "MicroUSB", "iPhone": "Lightning"}
CONNECTED_MSG: str = "{} connected."
CONNECT_FIRST_MSG: str = "Connect {} first."
classRechargeTemplate(metaclass = ABCMeta):
@abstractmethod
defrecharge(self) -> NoReturn:
raise NotImplementedError("You should implement this.")
classFormatIPhone(RechargeTemplate):
@abstractmethod
defuse_lightning(self) -> NoReturn:
raise NotImplementedError("You should implement this.")
classFormatAndroid(RechargeTemplate):
@abstractmethod
defuse_micro_usb(self) -> NoReturn:
raise NotImplementedError("You should implement this.")
classIPhone(FormatIPhone):
__name__: str = "iPhone"
def__init__(self):
self.connector: bool = False
defuse_lightning(self) -> None:
self.connector = True
print(CONNECTED_MSG.format(POWER_ADAPTERS[self.__name__]))
defrecharge(self) -> None:
if self.connector:
for state in RECHARGE:
print(state)
else:
print(CONNECT_FIRST_MSG.format(POWER_ADAPTERS[self.__name__]))
classAndroid(FormatAndroid):
__name__: str = "Android"
def__init__(self) -> None:
self.connector: bool = False
defuse_micro_usb(self) -> None:
self.connector = True
print(CONNECTED_MSG.format(POWER_ADAPTERS[self.__name__]))
defrecharge(self) -> None:
if self.connector:
for state in RECHARGE:
print(state)
else:
print(CONNECT_FIRST_MSG.format(POWER_ADAPTERS[self.__name__]))
classIPhoneAdapter(FormatAndroid):
def__init__(self, mobile: FormatAndroid) -> None:
self.mobile: FormatAndroid = mobile
defrecharge(self) -> None:
self.mobile.recharge()
defuse_micro_usb(self) -> None:
print(CONNECTED_MSG.format(POWER_ADAPTERS["Android"]))
self.mobile.use_lightning()
classAndroidRecharger:
def__init__(self) -> None:
self.phone: Android = Android()
self.phone.use_micro_usb()
self.phone.recharge()
classIPhoneMicroUSBRecharger:
def__init__(self) -> None:
self.phone: IPhone = IPhone()
self.phone_adapter: IPhoneAdapter = IPhoneAdapter(self.phone)
self.phone_adapter.use_micro_usb()
self.phone_adapter.recharge()
classIPhoneRecharger:
def__init__(self) -> None:
self.phone: IPhone = 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()