Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Dynamiczne proxy w Javie: łańcuch przekazywania wywołań

Zobacz, jak dobrać mechanizm ładowania klas dla proxy interfejsu, rozpoznać wywołaną metodę i przekazać ją przez dwa obiekty proxy do właściwej implementacji.

Wersja: Java SE 21

Składnia

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

W Java SE 21 Proxy.newProxyInstance z pakietu java.lang.reflect przyjmuje mechanizm ładowania klas, tablicę interfejsów i obiekt obsługi wywołań. Zwraca jako Object instancję klasy proxy utworzonej w czasie działania. Wynik można rzutować na podany interfejs; proxy nie jest podklasą implementacji usługi.

Class.getClassLoader zwraca mechanizm, który załadował typ reprezentowany przez dany obiekt Class. W przykładzie Service.class.getClassLoader() pobiera go dla interfejsu. Wybrany mechanizm musi rozpoznawać każdy interfejs po nazwie jako ten sam obiekt Class. W niektórych implementacjach null oznacza mechanizm bootstrap; przy działającym menedżerze bezpieczeństwa kontrola uprawnień może zakończyć się SecurityException.

InvocationHandler.invoke(proxy, method, args) otrzymuje proxy, obiekt Method opisujący wywołaną metodę i argumenty w Object[]. Przy braku parametrów args ma wartość null, a argumenty typów prostych trafiają do tablicy w obiektach opakowujących. Method.getName() zwraca tylko nazwę, więc oba przeciążenia add dają ten sam tekst. Obiekt method wskazuje konkretne przeciążenie, ale przy wywołaniu metody instancyjnej przez Method.invoke(target, args) obowiązuje dynamiczne wiązanie: to rzeczywisty typ obiektu target decyduje, która implementacja się wykona. Method.invoke akceptuje null jako tablicę dla metody bez parametrów, a wynik typu prostego zwraca w obiekcie opakowującym.

W przykładzie zewnętrzne proxy przekazuje wywołanie do wewnętrznego, a wewnętrzne do implementacji. Wywołanie metody na bieżącym proxy zamiast na target ponownie uruchomiłoby ten sam kod obsługi. Brak dostępu przy wywołaniu refleksyjnym może spowodować IllegalAccessException. Wyjątek rzucony przez wywołaną metodę jest opakowany w InvocationTargetException, więc kod rzuca dalej jego przyczynę. Jeśli z kodu obsługi wydostanie się wyjątek kontrolowany niedozwolony przez deklarację throws interfejsu, proxy opakuje go w UndeclaredThrowableException.

Program wywołuje tylko trzy metody usługi. equals, hashCode i toString wywołane na proxy także trafiają do obsługi, z Object jako klasą deklarującą; getClass() tam nie trafia. Nie zakładaj, że zwykłe przekazanie wywołania zachowa kontrakt equals. Metody interfejsu oznaczone default również trafiają do obsługi, która może uruchomić odpowiednią implementację domyślną przez InvocationHandler.invokeDefault.

Przykłady

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

Wynik

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

Dla każdego wywołania oczekuj najpierw wiersza `outer`, potem `inner`, a na końcu wyniku. Oba przeciążenia zapisują `add`, ale zwracają odpowiednio `5` i `11`.

Powiązane lekcje

  • Java · Lekcja 55 · Zaawansowany · Wersja: 2

Źródła