¿Cuál es la diferencia entre el patrón de fachada y adaptador?

He estado leyendo ambas definiciones y parecen iguales. ¿Alguien podría señalar cuáles son sus diferencias?

Gracias

La página wiki de Facade Pattern tiene una breve nota sobre esto.

"Un adaptador se usa cuando el envoltorio debe respetar una interfaz en particular y debe soportar un comportamiento polimórfico. Por otro lado, una fachada se usa cuando uno quiere una interfaz más fácil o más simple para trabajar".

Escuché una analogía de que debes pensar en tu control remoto universal que has configurado para trabajar con todos tus diferentes sistemas estéreo: presionas "on" y enciende tu decodificador, tu receptor y tu televisor. Tal vez sea un cine en casa realmente elegante y atenúe las luces y también dibuje las cortinas. Eso es una fachada: un botón / función que se encarga de una serie de pasos más complicados.

El patrón Adaptador simplemente enlaza dos interfaces incompatibles.

EDITAR: Una analogía rápida para el patrón del adaptador (basada en los comentarios) podría ser algo así como un adaptador DVI a VGA. Las tarjetas de video modernas suelen ser DVI, pero tienes un monitor VGA antiguo. Con un adaptador que se conecta a la entrada DVI esperada de su tarjeta de video y tiene su propia entrada VGA, podrá hacer que su antiguo monitor funcione con su nueva tarjeta de video.

Adaptador == haciendo que una clavija cuadrada encaje en un agujero redondo.

Fachada == un solo panel de control para ejecutar todos los componentes internos.

Honestamente, muchos patrones podrían implementarse de la misma manera programáticamente: la diferencia está en la intención.

El patrón de diseño del Adaptador está destinado a 'traducir' la interfaz de una o más clases en una interfaz que el cliente espera usar; el adaptador traduciría las llamadas a la interfaz esperada en la interfaz real que usan las clases envueltas.

El patrón Facade se usa cuando se desea una interfaz más simple (y nuevamente, podría implementarse de la misma manera envolviendo las clases ofensivas). No diría que está usando una fachada cuando la interfaz existente es incompatible, solo cuando lo necesita para hacerlo más legible, menos mal diseñado, etc.

Fachada:

Conclusiones clave: (del artículo de journaldev de Pankaj Kumar)

1. El patrón de fachada es más como un ayudante para aplicaciones cliente
2. El patrón de fachada se puede aplicar en cualquier punto del desarrollo, generalmente cuando el número de interfaces aumenta y el sistema se vuelve complejo .
3. Las interfaces del subsistema no conocen Facade y no deberían tener ninguna referencia a la interfaz Facade
4. El patrón de fachada debe aplicarse para tipos similares de interfaces , su propósito es proporcionar una interfaz única en lugar de múltiples interfaces que realizan trabajos similares.

Diagrama de clases de fachada:

Adaptador:

1. Es un patrón estructural
2. Es útil trabajar con dos interfaces incompatibles
3. Hace que las cosas funcionen una vez diseñadas

Diagrama de clases del adaptador:

Puede encontrar más detalles sobre el adaptador en esta publicación de SE:

Diferencia entre el patrón de puente y el patrón de adaptador

Diferencias clave:

1. Facade define una nueva interfaz, mientras que Adapter usa una interfaz antigua . El adaptador hace que dos interfaces existentes funcionen juntas en lugar de definir una completamente nueva
2. Adaptador y Fachada son envoltorios; pero son diferentes tipos de envoltorios. La intención de Facade es producir una interfaz más simple, y la intención de Adapter es diseñar una interfaz existente

Eche un vistazo al artículo sobre creación de fuentes también para una mejor comprensión.

Una fachada está diseñada para organizar múltiples servicios detrás de una única puerta de enlace de servicios. Un adaptador está diseñado para proporcionar una forma de utilizar una interfaz conocida para acceder a una desconocida.

El propósito de un

fachada es sencillez

adaptador es interoperabilidad .

La fachada suele contrastarse con el adaptador.

+--------------------------------------------------------------+-----------------------------------------------+
|                            Facade                            |                    Adapter                    |
+--------------------------------------------------------------+-----------------------------------------------+
| Simplifies multiple complex components with single interface | Provides differnet interface for an interface |
| Works with multiple components                               | Works with single component                   |
| Control panel is an example                                  | A power adapter is an example                 |
| High-level interface                                         | Low-level interface                           |
+--------------------------------------------------------------+-----------------------------------------------+

Como es habitual, existen similitudes entre varios patrones. Pero lo vería así:

• Una fachada se utiliza para encapsular una capa completa y ofrecer algunos métodos para acceder a ella "cómodamente"
• Se usa un adaptador, donde tiene dos componentes que ya deberían funcionar juntos, pero no lo hacen, solo debido a algunas diferencias "sin importancia" en la interfaz.

Intentaré explicar esto en palabras sencillas, sin mucha formalidad.

Imagina que tienes algunas clases de dominio y desde la interfaz de usuario quieres interactuar con ellas. Se puede utilizar una fachada para proporcionar funciones que se pueden llamar desde la capa de la interfaz de usuario para que la capa de la interfaz de usuario no conozca ninguna clase de dominio que no sea la fachada. Eso significa que en lugar de llamar a las funciones en las clases de dominio, llama a una sola función desde la fachada, que será responsable de llamar a las funciones necesarias de las otras clases.

Un adaptador, por otro lado, se puede utilizar para integrar otros componentes externos que pueden tener la misma funcionalidad que usted necesita, pero sus funciones no se llaman de la misma manera. Supongamos que tiene una Carclase en su dominio y trabaja con un proveedor de automóviles externo que también tiene una clase de automóvil definida. En esta clase, tienes la función car.getDoors()pero el proveedor externo tiene el equivalente car.getNumDoors(). No desea cambiar la forma en que llama a esta función, por lo que puede usar una clase de adaptador para envolver la clase de automóvil externa de modo que una llamada al getDoors()adaptador se delegue a getNumDoors()la clase externa.

El patrón de adaptador permite que dos interfaces, previamente incompatibles, funcionen entre sí. Tiene 2 interfaces separadas en juego.

El patrón de fachada toma una interfaz conocida, que es de bajo nivel / grano fino, y la envuelve con una interfaz de nivel superior / grano fino. Tiene una única interfaz, que se ha simplificado al encapsular con otra.

El adaptador hace que dos interfaces funcionen juntas.

Facade expone una sola clase a un nivel más alto y más limitado. Por ejemplo, la fachada de un modelo de vista solo puede exponer ciertas propiedades de solo lectura de una clase de nivel inferior.

Fachada

Resume la complejidad para proporcionar una interfaz más simple. Digamos, por ejemplo, que el sistema operativo de una computadora abstrae la complejidad del hardware subyacente. O un lenguaje de programación de alto nivel (Python / JavaScript) abstrae la complejidad en comparación con un lenguaje de bajo nivel (C).

Adaptador

Es análogo a los adaptadores de hardware. Supongamos que desea conectar USB devicea a serial port, necesitará un USB-serial port adapter.

El patrón de adaptador vincula dos interfaces incompatibles al proporcionar una nueva interfaz.

El patrón de fachada simplifica un subsistema complejo (que tiene múltiples componentes) con una sola interfaz.

La diferencia entre estos dos patrones es clara, pero no en el ámbito de los patrones de diseño, sino en el modelado de dominios. A continuación, explicaré por qué.

Primero, quiero reiterar que otros han dicho aquí, y luego agregaré la nota:

Una fachada es una interfaz a un subsistema (un sistema externo o heredado) que simplifica el acceso para el cliente (nosotros). Facade oculta la interfaz del otro subsistema (agregue algunas llamadas u oculte algunas API que no necesitamos), por lo que su cliente solo accede a ese subsistema a través de esta Facade.

Por otro lado, un adaptador es un envoltorio alrededor de otro servicio u objeto. Hace que el objeto envuelto se ajuste a una interfaz estándar que espera el cliente. Digamos que hay un método en el objeto "Ledger", que necesita para hacer un ajuste (cambiar sus parámetros, cambiar su nombre, etc.). Puedes envolverlo con un adaptador.

Ahora bien, es posible que la diferencia aún no esté clara. Ahí es donde quiero plantear la diferencia clave entre estos dos patrones, sin dejar lugar a más confusión :

Facade no cambia el modelo de dominio del otro subsistema, mientras que Adapter sí lo hace. Ésta es la diferencia clave. Período.

Es por eso que combina estos dos cuando crea una capa anticorrupción . Digamos que tiene un subsistema que desea usar, pero no desea que su modelo de dominio confunda su modelo de dominio. ¿Qué harías? Crearías una capa anticorrupción. ¿Cómo? Primero crea una Fachada, que simplifica el acceso a la interfaz para el subsistema, y ​​luego adaptadores para los objetos de dominio usados ​​en esa interfaz (recuerde que la fachada aún contiene el modelo de dominio para el otro subsistema), por lo que se ajusta a su modelo.

Se pueden utilizar muchos patrones de diseño en el modelado de dominios. Esto también es válido para los patrones de diseño de fachadas y adaptadores. Aunque la diferencia entre estos dos patrones puede no ser clara en el ámbito del "patrón de diseño", es más clara en el ámbito del "modelado de dominio".

He estado leyendo ambas definiciones y parecen iguales.

De Verdad ?

He notado que el término Adaptador se usa a veces para describir lo que de hecho es una estrategia , tal vez porque la palabra es más expresiva.

Por ejemplo, en Zend Framework , todas las clases de Adaptador son de hecho implementaciones del patrón de Estrategia , porque solo envuelven el código nativo detrás de las clases, para tener varios comportamientos.

Los adaptadores se utilizan a menudo para envolver código heredado o "antiguo".

El principal objetivo de la fachada patrón es hacer que la clase o el subsistema sea más fácil de usar, mientras que el objetivo principal del patrón Adapter es ajustar la interfaz a lo que espera el cliente.