Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti