CKTIS / Java
Proxies dinámicos en Java: encadenar llamadas por reflexión
Elige el cargador de clases de un proxy de interfaz, identifica el método interceptado y sigue los argumentos y el resultado a través de dos manejadores de invocación.
Versión: Java SE 21
Sintaxis
ClassLoader loader = Service.class.getClassLoader();
InvocationHandler handler = (proxy, method, args) -> {
System.out.println(method.getName());
try {
return method.invoke(target, args);
} catch (InvocationTargetException e) {
throw e.getCause();
}
};
Service service = (Service) Proxy.newProxyInstance(
loader, new Class<?>[] { Service.class }, handler);En Java SE 21, Proxy.newProxyInstance, del paquete java.lang.reflect, recibe un cargador de clases, un array de interfaces y un manejador de invocación. Devuelve como Object una instancia de una clase proxy generada en tiempo de ejecución. Puedes convertir el resultado al tipo de una de las interfaces indicadas: el proxy no hereda de la clase concreta del servicio.
Class.getClassLoader devuelve el cargador que cargó el tipo representado por el objeto Class. Aquí, Service.class.getClassLoader() obtiene el de la interfaz. El cargador elegido debe resolver el nombre de cada interfaz del proxy al mismo objeto Class. Algunas implementaciones usan null para el cargador de arranque. Si hay un gestor de seguridad instalado, una comprobación de permisos puede provocar SecurityException.
InvocationHandler.invoke(proxy, method, args) recibe el proxy, el objeto Method que describe la llamada y los argumentos en un Object[]. Sin parámetros, args es null; los argumentos primitivos se convierten en objetos envoltorio. Method.getName() devuelve solo el nombre, por lo que las dos sobrecargas de add producen el mismo texto. El objeto method identifica la sobrecarga concreta, pero Method.invoke(target, args) usa despacho dinámico para los métodos de instancia: el tipo de target en tiempo de ejecución determina qué implementación se ejecuta. Method.invoke admite un array null para un método sin parámetros y devuelve los resultados primitivos como objetos envoltorio.
El manejador externo delega en el proxy interno, y el interno en la implementación. Invocar sobre el proxy actual en vez de sobre target volvería a activar el mismo manejador. La falta de acceso por reflexión puede provocar IllegalAccessException. Una excepción lanzada por el método invocado se envuelve en InvocationTargetException, por lo que el ejemplo relanza su causa. Si del manejador sale una excepción comprobada que la cláusula throws del método de interfaz no permite, el proxy la envuelve en UndeclaredThrowableException.
El programa solo llama a tres métodos del servicio. Las llamadas a equals, hashCode y toString sobre el proxy también llegan al manejador, con Object como clase declarante; getClass() no. No des por hecho que delegar sin más respete el contrato de equals. Los métodos default de la interfaz también llegan al manejador, que puede ejecutar una implementación predeterminada válida mediante InvocationHandler.invokeDefault.
Ejemplos
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
public class ProxyChainDemo {
public interface Service {
String status();
int add(int x);
int add(int x, int y);
}
private static final class RealService implements Service {
@Override
public String status() { return "ready"; }
@Override
public int add(int x) { return x + 1; }
@Override
public int add(int x, int y) { return x + y; }
}
private static Service wrap(String label, Service target) {
InvocationHandler handler = (proxy, method, args) -> {
System.out.println(label + ": " + method.getName());
try {
return method.invoke(target, args);
} catch (InvocationTargetException e) {
throw e.getCause();
}
};
return (Service) Proxy.newProxyInstance(
Service.class.getClassLoader(),
new Class<?>[] { Service.class },
handler);
}
public static void main(String[] args) {
Service inner = wrap("inner", new RealService());
Service outer = wrap("outer", inner);
System.out.println(outer.status());
System.out.println(outer.add(4));
System.out.println(outer.add(4, 7));
}
}Resultado
outer: status inner: status ready outer: add inner: add 5 outer: add inner: add 11
En cada llamada se espera primero `outer`, luego `inner` y después el resultado. Las dos sobrecargas registran `add`, pero devuelven `5` y `11`, respectivamente.
Lecciones relacionadas
- Java · Lección 55 · Avanzado · Versión: 2