1. Modo agente
Un agente es una persona o institución que actúa en nombre de otra persona o institución. En algunos casos, un cliente no quiere o no puede hacer referencia a un objeto directamente, y un objeto proxy puede actuar como intermediario entre el cliente y el objeto de destino.
El patrón de proxy proporciona un objeto proxy para un objeto, y el objeto proxy controla la referencia al objeto original.
Ejemplo en la vida real: estás ocupado trabajando horas extras durante el Año Nuevo y no tienes tiempo para comprar boletos de tren. En este momento, puedes llamar al centro de boletos cercano y pedirles que te compren un boleto de tren a casa. agregue tarifas laborales adicionales. Pero debe quedar claro que el centro de venta de boletos en sí no vende boletos. Sólo la estación de tren vende boletos. Los boletos que el centro de boletos le vende se obtienen a través de la estación de tren. ¡Esto es muy importante!
En el ejemplo anterior, usted es el "cliente", el centro de venta de boletos es el "rol de agente", la estación de tren es el "rol real" y la venta de boletos se denomina "rol abstracto".
Ejemplo de código JAVA en modo agente:
Rol abstracto: clase abstracta o interfaz
Copie el código de código de la siguiente manera:
interfazNegocios
{
acción nula();
}
Papel real: implementar verdaderamente la interfaz de lógica empresarial
Rol de agente: no implementa la interfaz de lógica de negocios, pero llama al rol real para implementarla.
Copie el código de código de la siguiente manera:
la clase BusinessImplProxy implementa Business
{
negocio privadoImpl bi;
acción pública vacía()
{
si (bi==nulo)
{
bi = nuevo BusinessImpl();
}
hacerAntes();
bi.doAcción();
hacerDespués();
}
vacío público hacer antes()
{
System.out.println("¡Preprocesamiento!");
}
vacío público hacerDespués()
{
System.out.println("¡Postprocesamiento!");
}
}
//clase de prueba
prueba de clase
{
principal vacío estático público (String [] argumentos)
{
//Las variables de referencia se definen como tipos de roles abstractos
Negocio bi = nuevo BusinessImplProxy();
bi.doAcción();
}
}
Copie el código de código de la siguiente manera:
<span></span>
Por lo tanto, con el soporte de JVM, las clases de proxy ("roles de agente") se pueden generar dinámicamente en tiempo de ejecución, y podemos resolver el problema de la expansión del código en el modo proxy anterior. Después de usar el proxy dinámico, no será necesario "roles de agente". para ser generado manualmente, que es generado dinámicamente por la JVM en tiempo de ejecución especificando tres parámetros: cargador de clases, matriz de interfaz y controlador de llamadas.
Ejemplo de código JAVA en modo proxy dinámico:
Copie el código de código de la siguiente manera:
importar java.lang.reflect.InvocationHandler;
importar java.lang.reflect.Proxy;
importar java.lang.reflect.Method;
// Rol abstracto: la implementación del proxy dinámico de Java actualmente solo admite interfaces y no admite clases abstractas
interfaz BusinessFoo
{
foo vacío();
}
interfazBusinessBar
{
Barra de cadena (mensaje de cadena);
}
// Papel real: implementar realmente métodos de lógica empresarial
clase BusinessFooImpl implementa BusinessFoo
{
público vacío foo()
{
System.out.println("BusinessFooImpl.foo()");
}
}
clase BusinessBarImpl implementa BusinessBar
{
barra de cadena pública (mensaje de cadena)
{
System.out.println("BusinessBarImpl.bar()");
mensaje de respuesta;
}
}
// Rol dinámico: generar dinámicamente una clase de proxy
la clase BusinessImplProxy implementa InvocationHandler
{
objeto objeto privado;
BusinessImplProxy() {
}
BusinessImplProxy(Objeto obj) {
this.obj = obj;
}
Invocación de objeto público (proxy de objeto, método de método, argumentos de objeto []) lanza arrojable
{
Resultado del objeto = nulo;
hacerAntes();
resultado = método.invoke(obj,args);
hacerDespués();
resultado de devolución;
}
vacío público hacer antes(){
System.out.println("hacer algo antes de Business Logic");
}
vacío público hacerDespués(){
System.out.println("hacer algo después de Business Logic");
}
Fábrica pública de objetos estáticos (Objeto obj)
{
Clase cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
}
}
//clase de prueba
clase pública DynamicProxy
{
public static void main(String[] args) lanza Throwable
{
BusinessFooImpl bfoo = nuevo BusinessFooImpl();
BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
bf.foo();
System.out.println();
BusinessBarImpl bbar = nuevo BusinessBarImpl();
BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
Mensaje de cadena = bb.bar ("Hola, mundo");
System.out.println(mensaje);
}
}
Descripción del flujo del programa:
new BusinessFooImpl(); crea un "rol real", lo pasa al método de fábrica BusinessImplProxy.factory() y luego inicializa el "procesador de invocación", la clase que implementa InvocationHandler. Y devuelve una instancia de clase de proxy creada dinámicamente. Dado que el "rol de agente" también debe implementar los métodos de lógica empresarial proporcionados por el "rol abstracto", se puede transformar a BusinessBar y asignarlo a la referencia bb que apunta al tipo BusinessBar.
El método newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) permite a los programadores especificar parámetros y devolver dinámicamente la clase de proxy requerida, mientras que el método invoke(Object proxy, Method método, Object[] args) es utilizado por La JVM se llama dinámicamente en tiempo de ejecución. Al ejecutar el método "bb.bar("Hello,World");", la JVM asigna dinámicamente un "controlador de invocación", pasa parámetros a la invocación externa y llama a método.invoke(obj, args) para ejecutarlo.
El método estático BusinessImplProxy.Factory se utiliza para generar dinámicamente clases de proxy ("roles de agente"). Los roles de proxy se generan dinámicamente en tiempo de ejecución en función de diferentes interfaces de lógica empresarial BusinessFoo y BusinessBar. El "rol abstracto", el "rol de agente" y el controlador de invocación (clase que implementa la interfaz InvocationHandler) se pueden cambiar, por lo que el proxy dinámico de JAVA es muy poderoso.