Modo proxy
1. Propósito:
Proporcionar un proxy para que otros objetos controlen el acceso a este objeto.
(Proporcione un objeto proxy para un objeto, y el objeto proxy controla la referencia del objeto específico).
2. Participantes:
• Asunto abstracto (Asunto): Define la interfaz común entre el asunto real (Real Asunto) y el proxy (Proxy) , de modo que el proxy (Proxy) se pueda usar dondequiera que se use el sujeto real (Real Asunto) .
• Asunto Real: Definela entidad representada por el Proxy .
• Apoderado:
1) Contiene una referencia al objeto Real Subject internamente, para que el objeto Real Subject pueda operarse;
2) Al mismo tiempo, el objeto sujeto proxy (Proxy) proporciona la misma interfaz sujeto abstracto (Asunto) que el objeto sujeto real (Asunto real) , de modo que pueda reemplazar al sujeto real (Asunto real) en cualquier momento ;
3) Controlar la referencia al sujeto real (Real Subject) y ser responsable de crear (o eliminar) el objeto sujeto real cuando sea necesario;
4) Al mismo tiempo, el objeto Proxy puede adjuntar otras operaciones al realizar operaciones en el objeto Real Subject , en lugar de simplemente pasar la llamada al objeto Real Subject .
3. Estructura:
Personalmente, creo que el patrón de agente es un patrón de diseño más fácil de entender.
O entender el modelo de agencia a través de la vida real.
En la vida real, a menudo escuchamos la palabra agente. Al tratar con agentes, los compradores pueden obtener mejores y más servicios, y los vendedores también pueden concentrarse en la producción de productos sin tener que gastar más energía en otras cosas superiores.
Tomemos como ejemplo la compra de un automóvil. En la vida real, cuando compras un automóvil a un vendedor ( Asunto abstracto) , generalmente no compras un automóvil directamente al fabricante ( Asunto real) . Puedes ir a una tienda 4S. ( Función de proxy ) Compre un automóvil y obtenga más servicios allí.
Veamos cómo se implementa en código Java:
Vendedor de autos (tema abstracto):
/**
* 抽象主题（Subject）
*
* 汽车的销售商
*
*/
public interface CarSeller {
/*
* 销售汽车
*/
public Object sellCars(int type);
}
Fabricante de Audi (tema real):
/**
* 真实主题(Real Subject)角色
* 奥迪厂家
*
*/
public class AudiCarFactory implements CarSeller {
/*
* 实现了抽象主题（Subject）角色的方法
*/
public Object sellCars(int type) {
System.out.println("奥迪工厂出售汽车。");
if(type == 1){
return "AudiA6";
}else{
return "AudiA8";
}
}
}
Concesionario de automóviles (agencia):
**
* 代理（Proxy）角色
*
* 汽车代理商
* （这个代理商销售的是奥迪汽车）
*
*/
public class CarProxy implements CarSeller {
private AudiCarFactory carFactory = new AudiCarFactory();
/*
* 同样也实现了抽象主题（Subject）角色的方法
*/
public Object sellCars(int type) {
// 售前服务
serveBeforeSell();
// 代理奥迪厂家来销售汽车
Object car = carFactory.sellCars(type);
System.out.println("由代理商从厂家取得客户需要的汽车");
// 售后服务
serveAfterSell();
return car;
}
protected void serveBeforeSell(){
System.out.println("汽车代理商为客户提供了一些售前服务");
}
protected void serveAfterSell(){
System.out.println("汽车代理商为客户提供了一些售后服务");
}
}
Cliente (llamada de cliente):
/**
* 客户端调用
*/
public class Customer {
public static void main(String[] args){
// 顾客找到代理商
CarSeller carSeller = new CarProxy();
// 由代理商来销售汽车，可以发现代理商在销售给顾客汽车时，为顾客提供了更多的其他服务
Object car = carSeller.sellCars(1);
System.out.println("顾客从代理商那里买了一辆" + car);
}
}
resultado de la operación:
汽车代理商为客户提供了一些售前服务
奥迪工厂出售汽车。
由代理商从厂家取得客户需要的汽车
汽车代理商为客户提供了一些售后服务
顾客从代理商那里买了一辆AudiA6
¿Cuáles son las ventajas del modelo de agencia?
A través del modo proxy se agrega un intermediario entre el cliente y el sujeto real (Real Asunto) , lo que impide que el cliente acceda directamente al sujeto real (Real Asunto) , esto tiene los siguientes beneficios:
1) Como se muestra en el ejemplo anterior, se pueden agregar algunas operaciones adicionales antes o después de acceder al tema real;
2) Posibilidad de ocultar algunos detalles de acceso;
3) Se pueden agregar algunos controles para acceder a temas reales, como verificación de seguridad, etc.
Según el ejemplo anterior, se puede encontrar que en el patrón de proxy, el rol de Sujeto Real debe existir de antemano y usarse como un atributo interno del objeto Proxy . Este es en realidad el modo Static Proxy .
En el modo de proxy estático, la relación entre el proxy (Proxy) y el sujeto real (Real Asunto) se ha definido de antemano en el código y está fijada.
Imagínense, si un agente aumenta o cambia los tipos de productos que representa (por ejemplo: actuando como agente de automóviles BMW),
1) Entonces, ¿necesitas modificar la clase de proxy? Hacerlo afectará la estabilidad del sistema existente.
2) Si no modifica la clase de proxy existente , pero agrega una nueva clase de proxy ( el riesgo de código de agregar una nueva clase es mucho menor que modificar el código de una clase existente ), asegúrese de que el rol de Asunto Real corresponda a un proxy (Proxy) , lo que conducirá a una fuerte expansión de la clase.
Este estrecho acoplamiento no favorece la expansión del sistema ni la respuesta a futuros cambios en la demanda.
Entonces, ¿hay alguna forma de que el sistema pueda vincular dinámicamente la relación entre el sujeto real (Real Asunto) y el proxy (Proxy) según sea necesario durante el tiempo de ejecución?
Dynamic Proxy ofrece una solución; consulteNotas sobre patrones de diseño de Java para principiantes: Dynamic Proxy of Proxy Pattern