La clase Java Dynamic Proxy se encuentra debajo del paquete Java.Lang.Reflect, y generalmente implica principalmente las siguientes dos clases:
(1) InvocationHandler: solo se define un método en esta interfaz
Public Object Invoke (Obj OBJ, Método, Objeto [] args)
En uso real, el primer parámetro OBJ generalmente se refiere a la clase proxy, el método es el método proxy, como la solicitud () En el ejemplo anterior, Args es la matriz de parámetros del método. Este método abstracto se implementa dinámicamente en la clase proxy.
(2) proxy: esta clase es una clase de proxy dinámica, y su función es similar a la proxySubject en el ejemplo anterior, que contiene principalmente el siguiente contenido protegido proxy (InvocationHandler h): un constructor, utilizado para asignar valores al interno h.
clase estática getProxyClass (cargador de carnes de clases, interfaces de clase [])
Obtenga una clase proxy donde el cargador es el cargador de clase e interfaces es una matriz de todas las interfaces propiedad de la clase real.
Objeto estático NewProxyInstance (ClassLoader Loader, Interfaces de clase [], InvocationHandler H)
Devuelve una instancia de la clase proxy.
El llamado proxy dinámico es una clase: es una clase generada en tiempo de ejecución. Por supuesto, puede usar la instancia de la clase como cualquiera de estas interfaces. Por supuesto, este proxy dinámico es en realidad un proxy, que no hará un trabajo sustancial para usted.
Al usar clases de proxy dinámico, debemos implementar la interfaz InvocationHandler:
Ver el programa Asunto.Java
Vea el programa RealSubject.java
Consulte el programa Dynamicsubject.java
Ver el programa Client.java
La copia del código es la siguiente:
paquete com.langsin.dynamicproxy;
// Rol de abstracto (anteriormente era una clase abstracta, debería cambiarse a una interfaz aquí):
Asunto de la interfaz pública
{
Solicitud de vacío público abstracto ();
}
La copia del código es la siguiente:
paquete com.langsin.dynamicproxy;
// papel específico
El sujeto de la clase real de la clase real implementa el sujeto
{
Public RealSubject ()
{
}
Solicitud de vacío público ()
{
System.out.println ("de sujeto real");
}
}
La copia del código es la siguiente:
paquete com.langsin.dynamicproxy;
import java.lang.reflect.invocationHandler;
import java.lang.reflect.method;
// procesador proxy
/**
* Las propiedades internas de la clase proxy son la clase de objeto.
* Además, el método de Invoke también se implementa en esta clase, Method.Invoke (sub, args);
* De hecho, es llamar al método a ejecutar por el objeto proxy.
* Args es el parámetro requerido para realizar la operación correspondiente del objeto proxy.
* A través de las clases de proxy dinámicos, podemos realizar algunas operaciones relacionadas antes o después de la llamada
*/
La clase pública DynamicSubject implementa InvocationHandler
{
objeto privado sub;
Public DynamicSubject ()
{
}
Public DynamicSubject (obj obj)
{
sub = obj;
}
Public Object Invoke (proxy de objeto, método método, objeto [] args) lanza lanzamiento
{
System.out.println ("antes de llamar" + método);
Method.Invoke (sub, args);
System.out.println ("después de llamar" + método);
regresar nulo;
}
}
La copia del código es la siguiente:
paquete com.langsin.dynamicproxy;
import java.lang.reflect.invocationHandler;
import java.lang.reflect.proxy;
//Cliente
cliente de clase pública
{
estática pública void main (string [] args) lanza tiradas
{
RealSubject rs = new RealSubject ();
InvocationHandler ds = new DynamicSubject (RS);
Clase <?> Cls = rs.getClass ();
// El siguiente es un agente de generación único
Sujeto sujeto = (sujeto) proxy.newproxyinstance (
cls.getClassLoader (), cls.getInterfaces (), ds);
Sujeto.Request ();
}
}
Ejemplo 2:
La copia del código es la siguiente:
paquete com.langsin.dynamicproxy;
import java.lang.reflect.invocationHandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import java.util.list;
import java.util.vector;
clase pública VectorProxy implementa InvocationHandler
{
objeto privado proxyobj;
Public VectorProxy (Obj Obj) {
proxyobj = obj;
}
fábrica de objetos estáticos públicos (objeto obj) {
Clase <?> Cls = obj.getClass ();
return proxy.newproxyInstance (cls.getClassLoader (), cls.getInterfaces (), new VectorProxy (OBJ));
}
Public Object Invoke (Proxy de objeto, método Método, objeto [] args) lanza lanzable {
System.out.println ("antes de llamar" + método);
if (args! = null) {
para (int i = 0; i <args.length; i ++) {
System.out.println (args [i] + "");
}
}
Objeto objeto = método.invoke (proxyobj, args);
System.out.println ("después de llamar" + método);
Objeto de retorno;
}
@SupessWarnings ("sin control")
public static void main (string [] args) {
List <String> V = (List <String>) Factory (new Vector <String> (10));
V.Add ("nuevo");
V.Add ("York");
System.out.println (v);
v.remove (0);
System.out.println (v);
}
}
Ejemplo 3.
La copia del código es la siguiente:
paquete com.langsin.dynamicproxy;
interfaz pública foo {
nulo doaction ();
}
paquete com.langsin.dynamicproxy;
clase pública fooimpl implementa foo {
public fooImpl () {
}
public void doaction () {
System.out.println ("en fooimp1.doaction ()");
}
}
paquete com.langsin.dynamicproxy;
clase pública fooimpl2 implementa foo {
public fooImpl2 () {
}
public void doaction () {
System.out.println ("en fooimp2.doaction ()");
}
}
paquete com.langsin.dynamicproxy;
import java.lang.reflect.invocationHandler;
import java.lang.reflect.method;
clase pública CommonInVocationHandler implementa InvocationHandler {
// Ejecución dinámica de objetos, objetos que requieren devoluciones de llamada
objetivo de objeto privado;
// inyección de constructor de soporte
Public CommonInVocationHandler () {
}
// inyección de constructor de soporte
Public CommonInVocationHandler (objetivo de objeto) {
settarget (objetivo);
}
/**
*
* Use el método setter para inyectar
*
* @param objetivo
*
*/
public void settarget (objetivo de objeto) {
this.target = Target;
}
/**
*
* Llame al método especificado en proxy y pase en la lista de parámetros args
*
* @param proxy
* El tipo de clase proxy, como definir la interfaz proxy correspondiente al método
*
* @Param Método
* Método de ser proxyed
*
* @param args
* Parámetros que llaman al método proxy
*
* @devolver
*
* @throws java.lang.throwable
*
*/
Public Object Invoke (Proxy de objeto, método Método, objeto [] args) lanza lanzable {
return Method.Invoke (Target, Args);
}
}
paquete com.langsin.dynamicproxy;
import java.lang.reflect.proxy;
demostración de clase pública {
public static void main (string [] args) {
// 1. Implementación de proxy dinámico general
CommonInVocationHandler Handler = new CommonInVocationHandler ();
Foo f;
// 2. Implementación de la interfaz 1
handler.settarget (new fooImpl ());
// Descripción del parámetro del método: clase proxy, lista de implementación de la clase proxy, procesador de clase proxy
// Asociar la clase proxy, los métodos de interfaz y los procesadores en la clase de proxy.
// Si la clase proxy no implementa la lista de interfaz especificada, se lanzará una excepción de parámetros ilegales
f = (foo) proxy.newproxyInstance (foo.class.getclassloader (),,
nueva clase [] {foo.class},
entrenador de animales);
f.doaction ();
// 3. Implementación de la interfaz 2
handler.settarget (nuevo fooImpl2 ());
f = (foo) proxy.newproxyInstance (foo.class.getclassloader (),,
nueva clase [] {foo.class},
entrenador de animales);
f.doaction ();
}
}
Porque tengo talento literario limitado, la mayor parte del contenido es el código.