Automatiquement de déléguer toutes les méthodes d'une classe java

Cette question est de 6 mois déjà et @CoronA est merveilleux réponse a satisfaits et ont été acceptées par @walkeros, mais j'ai pensé que je voudrais ajouter quelque chose ici que je pense que cela peut être poussé plus loin.

Comme discuté avec @CoronA dans les commentaires de sa réponse, au lieu d'avoir à créer et à maintenir une longue liste de MyClass méthodes de WrapperClass (c'est à dire public void methodN() { delegate.methodN(); }), la dynamique de la solution proxy se déplace ce à l'interface. Le problème est que vous avez encore à créer et à maintenir une longue liste de signatures pour l' MyClass les méthodes de l'interface, qui est peut-être un peu plus simple, mais n'a pas de résoudre complètement le problème. C'est particulièrement le cas si vous n'avez pas accès à MyClass afin de connaître toutes les méthodes.

Selon Trois approches pour la décoration de votre code,

Pour plus de classes, un programmeur doit choisir le moindre de deux maux:
mettre en œuvre de nombreuses méthodes de wrapper et de garder le type de l'objet décoré
ou de maintenir un simple décorateur de mise en œuvre et le sacrifice de soutènement
la décorées type d'objet.

Donc c'est peut-être prévu de limiter le Pattern Décorateur.

@Marc-Bramnik, cependant, donne un fascinant de la solution à l'aide de CGLIB à En interposant sur Java les Méthodes de la Classe (sans interfaces). J'ai été en mesure de combiner cela avec @CoronaA de la solution, afin de créer un wrapper qui peuvent remplacer les méthodes individuelles mais alors passer tout le reste de l'objet enveloppé de sans nécessitant une interface.

Ici est MyClass.

public class MyClass {
public void method1() { System.out.println("This is method 1 - " + this); } 
public void method2() { System.out.println("This is method 2 - " + this); } 
public void method3() { System.out.println("This is method 3 - " + this); } 
public void methodN() { System.out.println("This is method N - " + this); }
}

Ici est WrapperClass qui remplace uniquement method2(). Comme vous le verrez ci-dessous, la non-substituée méthodes sont, en fait, pas transmis au délégué, qui peut être un problème.

public class WrapperClass extends MyClass {
private MyClass delagate;
public WrapperClass(MyClass delegate) { this.delagate = delegate; }
@Override
public void method2() {
System.out.println("This is overridden method 2 - " + delagate);
}
}

Ici est MyInterceptor qui s'étend MyClass. Il emploie la solution proxy à l'aide de CGLIB comme décrit par @Marc-Bramnik. Il emploie également @CononA de la méthode de détermination de savoir si ou de ne pas envoyer la méthode de l'emballage (si elle est remplacée) ou de l'objet renvoyé à la ligne (si elle ne l'est pas).

import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class MyInterceptor extends MyClass implements MethodInterceptor {
private Object realObj;
public MyInterceptor(Object obj) { this.realObj = obj; }
@Override
public void method2() {
System.out.println("This is overridden method 2 - " + realObj);
}
@Override
public Object intercept(Object arg0, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable {
Method m = findMethod(this.getClass(), method);
if (m != null) { return m.invoke(this, objects); }
Object res = method.invoke(realObj, objects);
return res;
}
private Method findMethod(Class<?> clazz, Method method) throws Throwable {
try {
return clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
} catch (NoSuchMethodException e) {
return null;
}
}
}

Ici est Main et les résultats que vous obtenez si vous l'exécutez.

import net.sf.cglib.proxy.Enhancer;
public class Main {
private static MyClass unwrapped;
private static WrapperClass wrapped;
private static MyClass proxified;
public static void main(String[] args) {
unwrapped = new MyClass();
System.out.println(">>> Methods from the unwrapped object:");
unwrapped.method1();
unwrapped.method2();
unwrapped.method3();
wrapped = new WrapperClass(unwrapped);
System.out.println(">>> Methods from the wrapped object:");
wrapped.method1();
wrapped.method2();
wrapped.method3();
proxified = createProxy(unwrapped);
System.out.println(">>> Methods from the proxy object:");
proxified.method1();
proxified.method2();
proxified.method3();
}
@SuppressWarnings("unchecked")
public static <T> T createProxy(T obj) {
Enhancer e = new Enhancer();
e.setSuperclass(obj.getClass());
e.setCallback(new MyInterceptor(obj));
T proxifiedObj = (T) e.create();
return proxifiedObj;
}
}
>>> Methods from the unwrapped object:
This is method 1 - MyClass@e26db62
This is method 2 - MyClass@e26db62
This is method 3 - MyClass@e26db62
>>> Methods from the wrapped object:
This is method 1 - WrapperClass@7b7035c6
This is overridden method 2 - MyClass@e26db62
This is method 3 - WrapperClass@7b7035c6
>>> Methods from the proxy object:
This is method 1 - MyClass@e26db62
This is overridden method 2 - MyClass@e26db62
This is method 3 - MyClass@e26db62

Comme vous pouvez le voir, lorsque vous exécutez la méthode sur wrapped vous obtenez le wrapper pour les méthodes qui ne sont pas remplacées (c'est à dire method1() et method3()). Lorsque vous exécutez la méthode sur proxified, cependant, toutes les méthodes sont à exécuter sur l'objet enveloppé sans la douleur d'avoir à déléguer tous dans WrapperClass ou de mettre toutes les signatures de méthode dans une interface. Grâce à @CoronA et @Marc-Bramnik pour ce qui semble être une super solution à ce problème.

Vérifier l' @Délégation annotation de Lombok cadre:
https://projectlombok.org/features/Delegate.html

Définir une méthode dans WrapperClass c'est à dire delegate() qui retourne l'instance de MyClass

OU

Vous pouvez utiliser la réflexion pour le faire, mais l'appelant a passer le nom de la méthode que d'un argument à une méthode exposée. Et il y aura des complications concernant les arguments de la méthode/surcharge des méthodes, etc.

BTW: je ne peux pas utiliser l'héritage parce que le délégué n'est pas sous mon contrôle.Je viens d'obtenir son instance d'ailleurs (un autre cas serait si MyClass était définitive)

Le code que vous avez posté, a public class WrapperClass extends MyClass

Fait votre application actuelle de la WrapperClass est en fait un décorateur sur le dessus de MyClass

Permettez-moi de redéfinir le problème pour un cas spécifique.
Je veux remplacer la méthode close de l'interface ResultSet jdbc. Mon but est de fermer la preparedstatement dans la méthode close de l'ensemble de résultats. Je ne pouvais pas l'accès à la Classe (DelegatingResultSet) qui met en œuvre dans le jeu de résultat de l'interface. Il ya beaucoup de méthodes dans le jeu de résultat de l'interface et de leur remplaçant, un par un, et d'appeler la méthode correspondante de l'objet ResultSet est une solution. Pour une solution dynamique, j'ai utilisé Dynamique ProxyClasses (https://docs.oracle.com/javase/1.5.0/docs/guide/reflection/proxy.html).

    //New ResultSet implementation
public class MyResultSet implements InvocationHandler {
ResultSet rs;
PreparedStatement ps;
private Method closeMethod;
public MyResultSet(ResultSet rs, PreparedStatement ps) {
super();
this.rs = rs;
this.ps = ps;
try {
closeMethod = ResultSet.class.getMethod("close",null);
} catch (NoSuchMethodException | SecurityException e) {
e.printStackTrace();
}
}
public void close() {
try {
rs.close();
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static Object newInstance(ResultSet rs, PreparedStatement ps) {
return java.lang.reflect.Proxy.newProxyInstance(rs.getClass().getClassLoader(), rs.getClass().getInterfaces(),
new MyResultSet(rs,ps));
}
public Object invoke(Object proxy, Method m, Object[] args) 
throws Throwable {
Object result = null;
try {
Class declaringClass = m.getDeclaringClass();
if (m.getName().compareTo("close")==0) {
close();
} else {
result = m.invoke(rs, args);
}
} catch (InvocationTargetException e) {
throw e.getTargetException();
} catch (Exception e) {
throw new RuntimeException(e.getMessage());
} finally {
}
return result;
}
}

//Comment l'appeler:

ResultSet prs = (ResultSet) MyResultSet.newInstance(rs,ps);