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