Método de adaptador: patrones de diseño de Python

El método de adaptador es un patrón de diseño estructural que nos ayuda a hacer que los objetos incompatibles se adapten entre sí. El método Adapter es uno de los métodos más fáciles de entender porque tenemos muchos ejemplos de la vida real que muestran la analogía con él. El objetivo principal de este método es crear un puente entre dos interfaces incompatibles. Este método proporciona una interfaz diferente para una clase. Podemos entender más fácilmente el concepto si pensamos en el Cable Adaptador que nos permite cargar un teléfono en algún lugar que tenga enchufes de diferentes formas. Usando esta idea, podemos integrar las clases que no se pudieron integrar debido a la incompatibilidad de la interfaz.

Problema sin usar el método del adaptador

Imagine que está creando una aplicación que muestra los datos sobre todos los diferentes tipos de vehículos presentes. Toma los datos de las API de diferentes organizaciones de vehículos en formato XML y luego muestra la información. Pero supongamos que en algún momento desea actualizar su aplicación con algoritmos de aprendizaje automático que funcionan a la perfección con los datos y solo obtienen los datos importantes. Pero hay un problema, solo toma datos en formato JSON. Será un enfoque realmente pobre realizar cambios en el algoritmo de aprendizaje automático para que tome datos en formato XML.

Problema-Adaptador-Método

Solución usando el método del adaptador

Para resolver el problema que definimos anteriormente, podemos usar el método de adaptador que ayuda creando un objeto de adaptador. Para usar un adaptador en nuestro código:

1. El cliente debe realizar una solicitud al adaptador llamando a un método utilizando la interfaz de destino.
2. Usando la interfaz de Adaptee, el Adaptador debe traducir esa solicitud en el Adaptee.
3. Resultado de la llamada se recibe el cliente y se desconoce la presencia de la presencia del Adaptador.

# Dog - Cycle
# human - Truck
# car - Car
 
class MotorCycle:
 
    """Class for MotorCycle"""
 
    def __init__(self):
        self.name = "MotorCycle"
 
    def TwoWheeler(self):
        return "TwoWheeler"
 
 
class Truck:
 
    """Class for Truck"""
 
    def __init__(self):
        self.name = "Truck"
 
    def EightWheeler(self):
        return "EightWheeler"
 
 
class Car:
 
    """Class for Car"""
 
    def __init__(self):
        self.name = "Car"
 
    def FourWheeler(self):
        return "FourWheeler"
 
class Adapter:
    """
    Adapts an object by replacing methods.
    Usage:
    motorCycle = MotorCycle()
    motorCycle = Adapter(motorCycle, wheels = motorCycle.TwoWheeler)
    """
 
    def __init__(self, obj, **adapted_methods):
        """We set the adapted methods in the object's dict"""
        self.obj = obj
        self.__dict__.update(adapted_methods)
 
    def __getattr__(self, attr):
        """All non-adapted calls are passed to the object"""
        return getattr(self.obj, attr)
 
    def original_dict(self):
        """Print original object dict"""
        return self.obj.__dict__
 
 
""" main method """
if __name__ == "__main__":
 
    """list to store objects"""
    objects = []
 
    motorCycle = MotorCycle()
    objects.append(Adapter(motorCycle, wheels = motorCycle.TwoWheeler))
 
    truck = Truck()
    objects.append(Adapter(truck, wheels = truck.EightWheeler))
 
    car = Car()
    objects.append(Adapter(car, wheels = car.FourWheeler))
 
    for obj in objects:
       print("A {0} is a {1} vehicle".format(obj.name, obj.wheels()))

Diagrama de clase

Diagrama de clases para el método Adapter, que es un tipo de patrón de diseño estructural :

Adaptador-clase-diagrama

Ventajas

• Principio de Responsabilidad Única: Podemos lograr el principio de responsabilidad Única con el Método Adapter porque aquí podemos separar el código concreto de la lógica primaria del cliente.
• Flexibilidad: el método de adaptador ayuda a lograr la flexibilidad y la reutilización del código.
• Clase menos complicada: nuestra clase de cliente no se complica al tener que usar una interfaz diferente y puede usar polimorfismo para cambiar entre diferentes implementaciones de adaptadores.
• Principio abierto/cerrado: podemos introducir las nuevas clases de adaptadores en el código sin violar el principio abierto/cerrado.

Desventajas

• Complejidad del código: a medida que presentamos el conjunto de nuevas clases, objetos e interfaces, la complejidad del código definitivamente aumenta.
• Adaptabilidad: La mayoría de las veces, requerimos muchas adaptaciones con la string de adaptación para alcanzar la compatibilidad que queremos.

Aplicabilidad

• Para hacer que las clases y las interfaces sean compatibles: el método del adaptador siempre se usa cuando necesitamos hacer que ciertas clases sean compatibles para comunicarse.
• Relativo a la herencia: cuando queremos reutilizar alguna pieza de código, es decir, clases e interfaces que carecen de algunas funcionalidades, se puede hacer usando el método de adaptador .

Leer más: Patrón de adaptador en Java