Yuxian: socio de contenido de CSDN, nuevo mentor estrella de CSDN, creador estrella creativo de pila completa, 51CTO (principal celebridad + blogger experto), entusiasta del código abierto de github (desarrollo secundario de código fuente cero, arquitectura back-end del juego https: https:/ /github.com/Peakchen)
El principio del modo proxy se explica en detalle:
el modo proxy (Proxy Pattern) es un modo de diseño estructural que controla el acceso a objetos reales mediante la introducción de un objeto proxy. El objeto proxy y el objeto real implementan la misma interfaz, y el cliente accede al objeto real a través del objeto proxy, de modo que se pueden realizar algunas operaciones adicionales antes y después del acceso.
La idea central del patrón proxy es controlar el acceso a objetos reales a través de un objeto proxy. El objeto proxy actúa como intermediario entre el cliente y el objeto real, y el cliente accede indirectamente al objeto real a través del objeto proxy. El objeto proxy puede controlar el acceso del objeto real, por ejemplo, puede realizar algunas operaciones adicionales antes y después del acceso, como verificación de permisos, almacenamiento en caché, registro, etc.
Diagrama de estructura subyacente:
El siguiente es un diagrama de estructura clásico del modo proxy:
+----------------------------+
| Client |
+----------------------------+
| + Request() |
+----------------------------+
^
|
|
|
|
v
+----------------------------+
| Subject |
+----------------------------+
| + Request() |
+----------------------------+
^
|
|
|
|
v
+----------------------------+
| Proxy |
+----------------------------+
| - subject |
| + Request() |
+----------------------------+
^
|
|
|
|
v
+----------------------------+
| RealSubject |
+----------------------------+
| + Request() |
+----------------------------+
En el diagrama estructural anterior, Client es el cliente el que Request() accede al objeto real llamando al método.
Subject Es una interfaz implementada tanto por el objeto real como por el objeto proxy, y define los métodos a los que puede acceder el cliente.
Proxy Un objeto proxy que implementa Subject una interfaz y contiene una referencia a un objeto real.
RealSubject Es un objeto real que implementa una lógica específica, pero el cliente no puede acceder directamente a él.
Explicación del escenario:
el modo Proxy es aplicable a los siguientes escenarios:
-
Cuando necesite controlar el acceso a objetos reales y realizar algunas operaciones adicionales antes y después del acceso, puede usar el patrón de proxy. Los objetos proxy pueden realizar verificación de autorización, almacenamiento en caché, registro y otras operaciones antes y después del acceso.
-
Utilice el patrón proxy cuando necesite ampliar o modificar el objeto real sin modificarlo. El objeto proxy puede heredar la interfaz del objeto real y agregar funciones adicionales en base a ella.
-
El patrón de proxy se puede utilizar cuando no se puede acceder directamente al objeto real por algún motivo. Los objetos proxy pueden realizar algunos preparativos antes de acceder a objetos reales, como conexión de red, inicialización, etc.
Implementación de ejemplo de código:
el siguiente es un ejemplo de implementación del patrón de proxy en el lenguaje Go:
package main
import "fmt"
// Subject 接口
type Subject interface {
Request()
}
// RealSubject 真实对象
type RealSubject struct{}
// Request 真实对象的请求
func (r *RealSubject) Request() {
fmt.Println("RealSubject: Handling request")
}
// Proxy 代理对象
type Proxy struct {
realSubject *RealSubject
}
// Request 代理对象的请求
func (p *Proxy) Request() {
if p.realSubject == nil {
p.realSubject = &RealSubject{}
}
p.preRequest()
p.realSubject.Request()
p.postRequest()
}
func (p *Proxy) preRequest() {
fmt.Println("Proxy: Preparing request")
}
func (p *Proxy) postRequest() {
fmt.Println("Proxy: Finishing request")
}
func main() {
proxy := &Proxy{}
proxy.Request()
}
En el ejemplo anterior, definimos una interfaz Subjectque contiene métodos comunes tanto para el objeto proxy como para el objeto real Request().
RealSubject Es un objeto real que implementa una lógica de solicitud específica.
Proxy es un objeto proxy que contiene una referencia a un objeto real y realiza algunas operaciones adicionales antes y después del acceso.
En main() la función, creamos el objeto proxy proxyy luego llamamos proxy.Request() para acceder al objeto real.
Enlaces a la documentación:
aquí hay algunos enlaces a referencias sobre el patrón Proxy:
-
Patrones de diseño: Elementos de software orientado a objetos reutilizable - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides Link
: Amazon.com -
Patrones de diseño Head First - Eric Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra
Link: Amazon.com.mx : Herramientas y Mejoras del Hogar -
Patrones de diseño GoF en Python - Proxy Pattern
链接：Proxy en Python / Patrones de diseño
Qué productos están actualmente en uso:
el modelo de proxy se usa ampliamente en el desarrollo de software, y muchos productos y marcos usan el modelo de proxy para resolver varios problemas. Los siguientes son algunos productos y marcos comunes que usan el modo proxy o implementan ciertas funciones basadas en el modo proxy:
-
El marco RMI (Invocación de método remoto) en Java utiliza el modo proxy para admitir la invocación y comunicación de objetos remotos.
-
El módulo AOP (Programación orientada a aspectos) en el marco Spring utiliza el modo proxy para implementar preocupaciones transversales, como la gestión de transacciones y el registro.
-
El mecanismo de carga diferida (Lazy Loading) en el marco de Hibernate se implementa utilizando el modo proxy.
-
El mecanismo de proxy dinámico (Dynamic Proxy) en Java también es una aplicación del modo proxy, que permite la creación de objetos proxy en tiempo de ejecución y maneja dinámicamente las llamadas a objetos reales.