KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Dynamische Java-proxy’s: reflectieve methodeaanroepen schakelen

Kies een classloader voor een interfaceproxy, herken de onderschepte methode en volg de argumenten en het resultaat door twee handlers tot aan de echte implementatie.

Versie: 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 krijgt Proxy.newProxyInstance uit java.lang.reflect een classloader, een array met interfaces en een aanroephandler. De methode geeft als Object een instantie terug van een proxyklasse die tijdens de uitvoering is gegenereerd. Je kunt het resultaat casten naar een opgegeven interface; de proxy is geen subklasse van de concrete serviceklasse.

Class.getClassLoader geeft de loader terug die het type achter het Class-object heeft geladen. Hier haalt Service.class.getClassLoader() de loader van de interface op. De gekozen loader moet elke proxy-interface op naam terugvinden als exact hetzelfde Class-object. Sommige implementaties gebruiken null voor de bootstraploader. Met een geïnstalleerde securitymanager kan een machtigingscontrole een SecurityException veroorzaken.

InvocationHandler.invoke(proxy, method, args) krijgt de proxy, het Method-object dat de aanroep beschrijft en de argumenten als Object[]. Zonder parameters is args gelijk aan null; primitieve argumenten worden verpakt in wrapperobjecten. Method.getName() geeft alleen de naam terug, dus beide overloads van add leveren dezelfde tekst op. Het object method geeft aan om welke overload het gaat, maar Method.invoke(target, args) gebruikt voor instantiemethoden dynamische dispatch: het type van target tijdens de uitvoering bepaalt welke implementatie wordt uitgevoerd. Voor een methode zonder parameters mag de array null zijn; primitieve resultaten worden verpakt in wrapperobjecten.

De buitenste handler stuurt de aanroep door naar de binnenste proxy, en de binnenste handler naar de implementatie. Aanroepen op de huidige proxy in plaats van op target zou dezelfde handler opnieuw activeren. Ontbrekende reflectieve toegang kan tot IllegalAccessException leiden. Een uitzondering uit de aangeroepen methode wordt verpakt in InvocationTargetException; daarom gooit het voorbeeld de oorzaak opnieuw. Laat de handler een gecontroleerde uitzondering ontsnappen die de throws-clausule van de interfacemethode niet toestaat, dan verpakt de proxy die in UndeclaredThrowableException.

Het programma roept alleen drie servicemethoden aan. Ook equals, hashCode en toString op een proxy bereiken de handler, met Object als declarerende klasse; getClass() niet. Ga er niet van uit dat simpel doorsturen het contract van equals bewaart. Ook default-methoden van de interface bereiken de handler, die met InvocationHandler.invokeDefault een toegestane standaardimplementatie kan uitvoeren.

Voorbeelden

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

Resultaat

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

Verwacht bij elke aanroep eerst `outer`, daarna `inner` en tot slot het resultaat. Beide overloads loggen `add`, maar geven respectievelijk `5` en `11` terug.

Gerelateerde lessen

  • Java · Les 55 · Gevorderd · Versie: 2

Bronnen