Appelez une méthode chaque fois que d’autres méthodes sont appelées

y a-t-il de toute façon une sorte de “superméthodologie” appelée chaque fois qu’une méthode est appelée, même pour des méthodes non définies? Un peu comme ça:

public void onStart() { System.out.println("Start"); } public void onEnd() { System.out.println("End"); } public SuperMethod superMethod() { System.out.println("Super"); } // "Start" // "Super" onStart(); // "End" // "Super" onEnd(); // "Super" onRun();

Merci pour toute aide.

Éditer – Détails: J’ai une bibliothèque qui met à jour beaucoup et est réobfus à chaque mise à jour. Pour faciliter mon stream de travail, je fais en sorte que mon programme mette automatiquement à jour la bibliothèque (nécessaire pour faire ce que je veux, je ne dirai pas pourquoi, mais mon programme fonctionnera avec les mises à jour ultérieures) et je télécharge les mappages d’obfuscation avec bibliothèque, je veux créer une sorte de proxy appelé Library par exemple, puis lorsque j’appelle Library.getInstance() il obtiendra le mappage de getInstance() pour getInstance() et appellera la méthode getInstance() ou abz de la abz car elle est mappée à ce moment actuel dans le temps.

Voici une implémentation en Java pur utilisant la classe Proxy :

 import java.lang.reflect.*; import java.util.*; public class Demo { public static void main(Ssortingng[] args) { Map map = new HashMap(); map.put("onStart", "abc"); map.put("onEnd", "def"); Library library = new LibraryProxy(map, new LibraryImpl()).proxy(); library.onStart(); library.onEnd(); library.onRun(); } } interface Library { void onStart(); void onEnd(); void onRun(); } class LibraryImpl { public void abc() { System.out.println("Start"); } public void def() { System.out.println("End"); } } class LibraryProxy implements InvocationHandler { Map map; Object impl; public LibraryProxy(Map map, Object impl) { this.map = map; this.impl = impl; } public Library proxy() { return (Library) Proxy.newProxyInstance(Library.class.getClassLoader(), new Class[] { Library.class }, this); } @Override public Object invoke(Object proxy, Method m, Object[] args) throws Throwable { Object res = null; Ssortingng name = map.get(m.getName()); if (name == null) { System.out.println("[" + m.getName() + " is not defined]"); } else { m = impl.getClass().getMethod(name, m.getParameterTypes()); res = m.invoke(impl, args); } System.out.println("super duper"); return res; } }

Sortie:

 Start super duper End super duper [onRun is not defined] super duper

Bien sûr, vous pouvez le faire, pas avec Java standard mais avec AspectJ

Voici un exemple simple:

Aspect avec un conseil après

 package net.fsa.aspectj.test; public aspect SuperMethdAspect { pointcut afterPointCut() : execution(public * com.my.pack.age.MyClass.*(..)); after() : afterPointCut() { System.out.println("Super"); } }

Vous ciblez la classe

 package com.my.pack.age; public class MyClass { public void onStart() { System.out.println("Start"); } public void onEnd() { System.out.println("End"); } }

Et enfin une application de test

 package net.fsa.aspectj.test; import com.my.pack.age.MyClass; public class MyApp { public static void main(Ssortingng... args) { MyClass myClass = new MyClass(); myClass.onStart(); myClass.onEnd(); } }

Sortie

 Start Super End Super

Java ne permet pas vraiment la magie comme ça. Pour qu’un appel ait lieu, il doit apparaître dans votre code (compilé). La réponse est donc non, non sans append explicitement un appel aux méthodes appropriées. Cependant, vous pouvez le cacher en utilisant un préprocesseur ou une génération de code d’exécution.

Je pense que AspectJ pourrait être ce que vous voulez.

Je suppose que ce n’est pas exactement ce que vous voulez, mais vous pouvez envelopper tout le code dans les méthodes dans try {}finally {supermethod ()} . Cela garantirait que superméthode s’appelle.

Le terme derrière ce concept s’appelle intercepteur. Vous avez besoin d’un conteneur qui effectue cette opération, comme un serveur d’applications, un conteneur CDI, un ressort ou un AOP. Ça marche comme ça

 1. call your Method 2. pause your Method 3. call intercepter 4. do interceptor stuff 5. resume your Method inside the interceptor