Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Proxies dinâmicos em Java: encadear chamadas por reflexão

Escolhe o carregador de classes de um proxy de interface, identifica o método intercetado e acompanha os argumentos e o resultado através de dois gestores de invocação.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, Proxy.newProxyInstance, do pacote java.lang.reflect, recebe um carregador de classes, um array de interfaces e um gestor de invocação. Devolve, como Object, uma instância de uma classe proxy gerada em tempo de execução. Podes converter o resultado para uma das interfaces indicadas: o proxy não é uma subclasse da implementação concreta do serviço.

Class.getClassLoader devolve o carregador que carregou o tipo representado pelo objeto Class. Aqui, Service.class.getClassLoader() obtém o da interface. O carregador escolhido tem de resolver o nome de cada interface do proxy para exatamente o mesmo objeto Class. Algumas implementações usam null para o carregador de arranque. Se houver um gestor de segurança instalado, uma verificação de permissões pode originar SecurityException.

InvocationHandler.invoke(proxy, method, args) recebe o proxy, o objeto Method que descreve a chamada e os argumentos num Object[]. Sem parâmetros, args é null; os argumentos primitivos são encapsulados em objetos. Method.getName() devolve apenas o nome, pelo que as duas sobrecargas de add produzem o mesmo texto. O objeto method identifica a sobrecarga, mas Method.invoke(target, args) usa despacho dinâmico para métodos de instância: o tipo de target em tempo de execução determina qual é a implementação executada. Method.invoke aceita um array null para um método sem parâmetros e devolve os resultados primitivos encapsulados em objetos.

O gestor exterior encaminha a chamada para o proxy interior, e o gestor interior para a implementação. Invocar o método no proxy atual em vez de em target voltaria a acionar o mesmo gestor. A falta de acesso por reflexão pode causar IllegalAccessException. Uma exceção lançada pelo método invocado é encapsulada em InvocationTargetException, pelo que o exemplo relança a causa. Se sair do gestor uma exceção verificada que a cláusula throws do método da interface não permita, o proxy encapsula-a em UndeclaredThrowableException.

O programa chama apenas três métodos do serviço. As chamadas a equals, hashCode e toString no proxy também chegam ao gestor, com Object como classe que os declara; getClass() não chega ao gestor. Não partas do princípio de que o simples encaminhamento preserva o contrato de equals. Os métodos default da interface também chegam ao gestor, que pode executar uma implementação predefinida admissível através de InvocationHandler.invokeDefault.

Exemplos

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

Resultado

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

Para cada chamada, espera-se primeiro `outer`, depois `inner` e por fim o resultado. Ambas as sobrecargas registam `add`, mas devolvem `5` e `11`, respetivamente.

Lições relacionadas

  • Java · Lição 55 · Avançado · Versão: 2

Fontes