Yuxian: socio de contenido de CSDN, nuevo mentor estrella de CSDN, 51CTO ( principal celebridad + blogger experto), entusiasta del código abierto de github (desarrollo secundario del código fuente go-zero, arquitectura back-end del juego https://github.com/Peakchen)
Explicación detallada del principio del patrón de fachada:
el patrón de fachada (Patrón de fachada) es un patrón de diseño estructural que proporciona una interfaz unificada para acceder a un conjunto de interfaces en el subsistema. El modo de fachada oculta la complejidad del subsistema, de modo que el cliente puede interactuar con el subsistema a través de una interfaz simple sin conocer los detalles internos de implementación del subsistema.
El modo de fachada encapsula las interfaces de un conjunto de subsistemas mediante la introducción de una clase de fachada. Los clientes solo necesitan interactuar con las clases de fachada y no necesitan comunicarse directamente con los subsistemas individuales. La clase de fachada es responsable de reenviar la solicitud del cliente al objeto del subsistema apropiado y devolver el resultado al cliente.
La idea central del patrón de fachada es simplificar la interacción entre el cliente y el subsistema y reducir la dependencia del cliente del subsistema. Proporciona una interfaz de alto nivel que facilita a los clientes el uso del subsistema.
Diagrama de estructura subyacente:
El siguiente es un diagrama de estructura clásico del modo de apariencia:
+----------------------------+
| Client |
+----------------------------+
| + Operation() |
+----------------------------+
^
|
|
|
|
v
+----------------------------+
| Facade |
+----------------------------+
| - subsystem1 |
| - subsystem2 |
| + Operation() |
+----------------------------+
^
|
|
|
|
v
+----------------------------+
| Subsystem1 |
+----------------------------+
| + Operation1() |
+----------------------------+
+----------------------------+
| Subsystem2 |
+----------------------------+
| + Operation2() |
+----------------------------+
En el diagrama estructural anterior, Client es el cliente el que Operation() interactúa con el subsistema llamando a los métodos.
Facade Es una clase de fachada que encapsula un conjunto de interfaces de subsistema y es responsable de reenviar las solicitudes de los clientes a los objetos de subsistema apropiados.
Subsystem1 y Subsystem2 son subsistemas que implementan funciones específicas, pero la interfaz para que los clientes accedan directamente a ellos es más complicada.
Explicación del escenario de uso:
el modo de apariencia se aplica a los siguientes escenarios:
- Los patrones de fachada se utilizan cuando existe la necesidad de simplificar la interfaz de subsistemas complejos y proporcionar una interfaz uniforme de alto nivel. Los patrones de fachada facilitan a los clientes el uso de un subsistema sin conocer los detalles de su implementación interna.
- El patrón de fachada se puede usar cuando hay múltiples subsistemas y el cliente necesita interactuar con más de un subsistema. Los patrones de fachada pueden centralizar estas interacciones en una única clase de fachada, lo que simplifica el código del lado del cliente.
Implementación de ejemplo de código:
el siguiente es un ejemplo del uso del lenguaje Go para implementar el modo de apariencia:
package main
import "fmt"
// Subsystem1 子系统1
type Subsystem1 struct{}
// Operation1 子系统1的操作
func (s *Subsystem1) Operation1() {
fmt.Println("Subsystem1: Operation1")
}
// Subsystem2 子系统2
type Subsystem2 struct{}
// Operation2 子系统2的操作
func (s *Subsystem2) Operation2() {
fmt.Println("Subsystem2: Operation2")
}
// Facade 外观类
type Facade struct {
subsystem1 *Subsystem1
subsystem2 *Subsystem2
}
// NewFacade 创建外观类实例
func NewFacade() *Facade {
return &Facade{
subsystem1: &Subsystem1{},
subsystem2: &Subsystem2{},
}
}
// Operation 客户端调用的操作
func (f *Facade) Operation() {
fmt.Println("Facade: Operation")
f.subsystem1.Operation1()
f.subsystem2.Operation2()
}
func main() {
facade := NewFacade()
facade.Operation()
}
En el ejemplo anterior, definimos el Subsistema 1 ( Subsystem1) y el Subsistema 2 ( Subsystem2), que implementan operaciones específicas respectivamente.
La clase Facade( Facade) encapsula la interfaz del subsistema y proporciona una interfaz unificada Operation(). Los clientes pueden Operation() acceder al subsistema indirectamente llamando a métodos de la clase de fachada.
En main() la función, creamos una instancia de la clase de fachada facadey luego llamamos a facade.Operation() métodos para realizar operaciones. La salida es la siguiente:
Facade: Operation
Subsystem1: Operation1
Subsystem2: Operation2
Enlaces de documentación:
Aquí hay algunos enlaces a la documentación sobre Patrones de fachada donde puede obtener más información sobre Patrones de fachada en detalle:
-
Patrones de diseño: Elementos de software orientado a objetos reutilizable - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Link -
Patrones de diseño Head First - Eric Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra
Link -
Refactoring Guru -
Enlace de patrón de fachada -
Tutorialspoint - Patrón de diseño de fachada en Go
Link
El enlace anterior proporciona algunos libros y tutoriales en línea para seguir estudiando y comprender el concepto, la implementación y la aplicación del patrón de fachada.
Qué productos están actualmente en uso:
el patrón de apariencia es un patrón de diseño común ampliamente utilizado en varios campos del desarrollo de software. Los patrones de fachada son utilizados por muchos productos y marcos de software para simplificar interfaces de subsistemas complejos.
Estos son algunos de los productos y marcos comunes actuales que utilizan el patrón de fachada o conceptos similares:
-
API Java Servlet: La API Java Servlet proporciona una clase de fachada Servlet (
HttpServlet) para simplificar la interfaz para desarrollar aplicaciones web. -
Spring Framework: Spring Framework proporciona una interfaz de fachada unificada (
ApplicationContext) para administrar los diversos componentes y dependencias de una aplicación. -
jQuery: jQuery es una biblioteca de JavaScript popular que proporciona una interfaz simplificada para manejar la compatibilidad del navegador y manipular el DOM.