Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

java.lang.reflect.Proxy — proxy dinamici di interfacce

Proxy.newProxyInstance crea in fase di esecuzione un oggetto che implementa le interfacce specificate. Le chiamate vengono inviate a un InvocationHandler, che determina il risultato invece di usare una normale implementazione del metodo.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

Object proxy = Proxy.newProxyInstance(loader, interfaces, h);

java.lang.reflect.Proxy crea implementazioni dinamiche di interfacce, non sottoclassi di classi arbitrarie. Proxy.newProxyInstance(loader, interfaces, h) accetta un class loader, un array di interfacce e un InvocationHandler. Restituisce un Object che può essere convertito in una delle interfacce indicate. Le interfacce devono essere visibili al class loader e non possono essere nascoste né sealed. Le interfacce non pubbliche devono appartenere allo stesso package e modulo.

L’handler riceve proxy, un oggetto Method e un array di argomenti; l’array può essere null se la chiamata non ha argomenti. Se il metodo del proxy è dichiarato con tipo di ritorno void, il valore restituito dall’handler viene ignorato. Altrimenti, il valore deve essere compatibile con il tipo di ritorno del metodo; se il tipo è primitivo, si usa il tipo wrapper corrispondente. Un’eccezione checked non dichiarata viene racchiusa in UndeclaredThrowableException.

Anche le chiamate a equals, hashCode e toString raggiungono l’handler. Non invocare su proxy lo stesso metodo al suo interno, perché l’handler verrebbe richiamato. Vengono intercettati anche i metodi dichiarati default; la loro implementazione può essere invocata tramite InvocationHandler.invokeDefault.

L’esempio crea un Greeting senza una classe di implementazione separata. Il suo handler compone il saluto e gestisce esplicitamente i tre metodi di Object. Questa voce riguarda Java SE 21; la compatibilità con gli ambienti di produzione non è attestata.

Esempi

import java.lang.reflect.Proxy;

public class Main {
    public interface Greeting {
        String hello(String name);
    }

    public static void main(String[] args) {
        Greeting greeting = (Greeting) Proxy.newProxyInstance(
                Greeting.class.getClassLoader(),
                new Class<?>[] { Greeting.class },
                (proxy, method, values) -> {
                    if (method.getDeclaringClass() == Object.class) {
                        return switch (method.getName()) {
                            case "equals" -> proxy == values[0];
                            case "hashCode" -> System.identityHashCode(proxy);
                            case "toString" -> "GreetingProxy";
                            default -> throw new UnsupportedOperationException(method.getName());
                        };
                    }
                    return "Hello, " + values[0] + "!";
                });

        System.out.println(greeting.hello("Ada"));
        System.out.println(greeting);
    }
}

Risultato

Hello, Ada!
GreetingProxy

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti