CKTIS / Java
Proxy dinamici in Java: concatenare le chiamate riflessive
Scegli il class loader per un proxy di interfaccia, identifica il metodo intercettato e segui gli argomenti e il risultato attraverso due gestori fino all’implementazione.
Versione: Java SE 21
Sintassi
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);In Java SE 21, Proxy.newProxyInstance del package java.lang.reflect riceve un class loader, un array di interfacce e un gestore delle invocazioni. Restituisce come Object un’istanza di una classe proxy generata a runtime. Puoi eseguire il cast a una delle interfacce indicate: il proxy non estende la classe concreta del servizio.
Class.getClassLoader restituisce il class loader che ha caricato il tipo rappresentato dall’oggetto Class. Qui Service.class.getClassLoader() recupera quello dell’interfaccia. Il loader scelto deve risolvere il nome di ogni interfaccia del proxy nello stesso identico oggetto Class. Alcune implementazioni usano null per il loader di bootstrap. In presenza di un security manager, un controllo dei permessi può causare SecurityException.
InvocationHandler.invoke(proxy, method, args) riceve il proxy, l’oggetto Method che descrive la chiamata e gli argomenti in un Object[]. Senza parametri, args è null; gli argomenti primitivi vengono incapsulati in oggetti wrapper. Method.getName() restituisce solo il nome, quindi i due overload di add producono lo stesso testo. L’oggetto method identifica l’overload, ma per i metodi di istanza Method.invoke(target, args) usa il dispatch dinamico: è il tipo di target a runtime a determinare quale implementazione viene eseguita. Method.invoke accetta un array null per un metodo senza parametri e restituisce i risultati primitivi come oggetti wrapper.
Il gestore esterno inoltra la chiamata al proxy interno e il gestore interno all’implementazione. Invocare il metodo sul proxy corrente invece che su target richiamerebbe lo stesso gestore. Se il metodo non è accessibile per riflessione, può verificarsi IllegalAccessException. Un’eccezione lanciata dal metodo invocato è racchiusa in InvocationTargetException, quindi l’esempio rilancia la causa. Se dal gestore esce un’eccezione controllata non ammessa dalla clausola throws del metodo di interfaccia, il proxy la racchiude in UndeclaredThrowableException.
Il programma chiama solo tre metodi del servizio. Anche le chiamate a equals, hashCode e toString sul proxy raggiungono il gestore, con Object come classe dichiarante; getClass() no. Non dare per scontato che il semplice inoltro rispetti il contratto di equals. Anche i metodi default dell’interfaccia raggiungono il gestore, che può eseguire un’implementazione predefinita ammessa tramite InvocationHandler.invokeDefault.
Esempi
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));
}
}Risultato
outer: status inner: status ready outer: add inner: add 5 outer: add inner: add 11
Per ogni chiamata, l’ordine atteso è `outer`, poi `inner`, poi il risultato. Entrambi gli overload registrano `add`, ma restituiscono rispettivamente `5` e `11`.
Lezioni correlate
- Java · Lezione 55 · Avanzato · Versione: 2