WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Dynamische Java-Proxys: reflektive Methodenaufrufe verketten

Wähle den Klassenlader für einen Schnittstellenproxy, erkenne die abgefangene Methode und verfolge Argumente und Ergebnis durch zwei Handler bis zur eigentlichen Implementierung.

Version: Java SE 21

Syntax

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 erwartet Proxy.newProxyInstance aus java.lang.reflect einen Klassenlader, ein Array von Schnittstellen und einen Aufruf-Handler. Die Methode gibt eine Instanz einer zur Laufzeit erzeugten Proxyklasse als Object zurück. Das Ergebnis lässt sich in eine der angegebenen Schnittstellen umwandeln; der Proxy erbt nicht von der konkreten Dienstklasse.

Class.getClassLoader liefert den Klassenlader, der den vom Class-Objekt repräsentierten Typ geladen hat. Hier liefert Service.class.getClassLoader() den Lader der Schnittstelle. Der gewählte Lader muss jede Proxy-Schnittstelle anhand ihres Namens zu genau demselben Class-Objekt auflösen. Manche Implementierungen verwenden null für den Bootstrap-Klassenlader. Bei installiertem Security Manager kann eine Berechtigungsprüfung eine SecurityException auslösen.

InvocationHandler.invoke(proxy, method, args) erhält den Proxy, das Method-Objekt zum Aufruf und die Argumente als Object[]. Ohne Parameter ist args gleich null; primitive Argumente werden in Wrapper-Objekte verpackt. Method.getName() liefert nur den Namen, daher ergeben beide Überladungen von add denselben Text. Das Objekt method gibt die konkrete Überladung vor. Beim Aufruf einer Instanzmethode mit Method.invoke(target, args) gilt jedoch dynamische Bindung: Der Laufzeittyp von target bestimmt, welche Implementierung ausgeführt wird. Bei parameterlosen Methoden ist ein null-Array zulässig; primitive Ergebnisse werden in Wrapper-Objekte verpackt.

Der äußere Handler leitet an den inneren Proxy weiter, der innere an die Implementierung. Ein Aufruf auf dem aktuellen proxy statt auf target würde denselben Handler erneut betreten. Fehlender Zugriff bei der Reflexion kann zu IllegalAccessException führen. Eine Ausnahme aus der aufgerufenen Methode wird in InvocationTargetException verpackt; das Beispiel wirft deshalb deren Ursache weiter. Verlässt eine geprüfte Ausnahme den Handler, die laut throws-Klausel der Schnittstellenmethode nicht zulässig ist, verpackt der Proxy sie in UndeclaredThrowableException.

Das Programm ruft nur drei Dienstmethoden auf. equals, hashCode und toString auf einem Proxy erreichen ebenfalls den Handler, mit Object als deklarierender Klasse; getClass() hingegen nicht. Bloßes Weiterleiten wahrt den Vertrag von equals nicht unbedingt. Auch default-Methoden der Schnittstelle erreichen den Handler, der eine zulässige Standardimplementierung über InvocationHandler.invokeDefault ausführen kann.

Beispiele

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));
    }
}

Ergebnis

outer: status
inner: status
ready
outer: add
inner: add
5
outer: add
inner: add
11

Bei jedem Aufruf erscheint zuerst `outer`, dann `inner` und anschließend das Ergebnis. Beide Überladungen protokollieren `add`, liefern aber `5` beziehungsweise `11`.

Zugehörige Lektionen

  • Java · Lektion 55 · Fortgeschritten · Version: 2

Quellen