CKTIS / Java
Proxys dynamiques Java : enchaîner les appels par réflexion
Choisissez le chargeur de classes d’un proxy d’interface, identifiez la méthode interceptée et suivez les arguments et le résultat à travers deux gestionnaires d’appels.
Version : Java SE 21
Syntaxe
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);Dans Java SE 21, Proxy.newProxyInstance, du paquet java.lang.reflect, reçoit un chargeur de classes, un tableau d’interfaces et un gestionnaire d’appels. La méthode renvoie, sous le type Object, une instance d’une classe de proxy générée à l’exécution. Vous pouvez convertir le résultat vers une interface de la liste : le proxy n’hérite pas de la classe concrète du service.
Class.getClassLoader renvoie le chargeur qui a chargé le type représenté par l’objet Class. Ici, Service.class.getClassLoader() récupère celui de l’interface. Le chargeur choisi doit résoudre le nom de chaque interface du proxy vers exactement le même objet Class. Certaines implémentations représentent le chargeur d’amorçage par null. Si un gestionnaire de sécurité est installé, une vérification d’autorisation peut déclencher SecurityException.
InvocationHandler.invoke(proxy, method, args) reçoit le proxy, l’objet Method décrivant l’appel et les arguments sous forme de Object[]. Sans paramètre, args vaut null ; les arguments primitifs sont encapsulés dans des objets. Method.getName() ne renvoie que le nom : les deux surcharges de add donnent donc le même texte. L’objet method identifie la surcharge, mais Method.invoke(target, args) utilise la liaison dynamique pour les méthodes d’instance : le type de target à l’exécution détermine l’implémentation exécutée. Un tableau null est accepté pour une méthode sans paramètre, et les résultats primitifs sont encapsulés dans des objets.
Le gestionnaire externe transmet l’appel au proxy interne, et le gestionnaire interne à l’implémentation. Appeler la méthode sur le proxy courant au lieu de target ferait repasser par le même gestionnaire. Un accès refusé par réflexion peut provoquer IllegalAccessException. Une exception levée par la méthode appelée est enveloppée dans InvocationTargetException ; l’exemple relance donc sa cause. Si une exception contrôlée non autorisée par la clause throws de la méthode d’interface sort du gestionnaire, le proxy l’enveloppe dans UndeclaredThrowableException.
Le programme n’appelle que trois méthodes du service. Appelées sur le proxy, equals, hashCode et toString atteignent aussi le gestionnaire, avec Object comme classe déclarante ; ce n’est pas le cas de getClass(). Une simple délégation ne préserve pas forcément le contrat de equals. Les méthodes default de l’interface atteignent également le gestionnaire, qui peut exécuter une implémentation par défaut admissible via InvocationHandler.invokeDefault.
Exemples
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));
}
}Résultat
outer: status inner: status ready outer: add inner: add 5 outer: add inner: add 11
Pour chaque appel, attendez-vous à voir `outer`, puis `inner`, puis le résultat. Les deux surcharges affichent `add`, mais renvoient respectivement `5` et `11`.
Leçons associées
- Java · Leçon 55 · Avancé · Version : 2