Comment puis-je ajouter des fonctionnalités similaires à un certain nombre de méthodes dans Java?

Question

J'ai beaucoup de méthodes pour l'exploitation forestière, comme logSomeAction, logAnotherAction etc.

Maintenant, je veux que toutes ces méthodes font une petite pause après les messages d'impression (Thread.sleep).

Si je le fais manuellement, je ferais quelque chose comme ceci:

//before: 
public static void logSomeAction() { 
    System.out.println (msg(SOME_ACTION)); 
} 

//after: 
public static void logSomeAction() { 
    System.out.println (msg(SOME_ACTION)); 
    try { 
     Thread.sleep (2000); 
    } catch (InterruptedException ignored) { } 
} 

Je me souviens que Java a des classes proxy et d'autres outils magiques prise. Est-il possible d'éviter copier-n-coller N sleep-blocks à N méthodes de journalisation?

Answer 1

Vous pouvez utiliser Aspects pour ajouter une fonctionnalité "orthogonale" supplémentaire à vos méthodes. Si cela semble trop ésotérique, une solution simple et pratique consisterait à ajouter le sommeil dans une méthode séparée, puis à appeler cette méthode dans chacune de vos méthodes de journalisation. La première fois que vous faites cela, vous devez toucher chaque méthode, mais la prochaine fois si vous voulez modifier le comportement supplémentaire ou ajouter quelque chose d'autre, vous pouvez le faire en un seul endroit.

Answer 2

Vous pouvez créer une classe d'utilitaire qui a une méthode SleepFor statique qui inclut votre bloc try ... catch et l'appeler de toutes les méthodes dans lesquelles vous voulez dormir?

Answer 3

Il semble que vous souhaitiez utiliser la programmation orientée aspect. Vous pouvez utiliser Spring pour AOP ou AspectJ.

Answer 4

Remplacez tous System.out.println (msg (SOME_ACTION)); avec printAndWait (SOME_ACTION); Vous devriez être en mesure de le faire avec trouver et remplacer. Ensuite, créez une méthode

public static void printAndWait(Object someAction) { 
    System.out.println (msg(someAction)); 
    try { 
     Thread.sleep (2000); 
    } catch (InterruptedException ignored) { 
     Thread.currentThread.interrupt(); 
    } 
} 

De cette façon, le code apparaît une fois et vous pouvez changer facilement en un seul endroit.

Answer 5

Remplacez toutes vos méthodes logSomeAction() par une seule méthode logAction(Action a). Ainsi, lorsque vous ajouterez d'autres actions dans le futur, vous ne répéterez pas votre code pour la gestion du journal d'actions et de la mise en veille du thread.

Answer 6

L'OP mentionne dans un commentaire que la solution préférée est d'utiliser des proxies java simples. Le code actuel est implémenté en tant que méthodes statiques - pour que les proxys java soient utiles, la classe logger devra être retravaillée en tant qu'interface. Quelque chose comme ceci:

public interface SomeActionLogger 
{ 
    void logSomeAction(); 
    void logSomeOtherAction(); 
    // etc.. 
} 

Vous créez ensuite votre mise en œuvre concrète

public class SystemOutActionLogger implements SomeActionLogger 
{ 
    public void logSomeAction() { 
     System.out.println (msg(SOME_ACTION)); 
    } 
} 

Vous pouvez alors proxies Java envelopper l'interface SomeActionLogger

class DelayAfterInvocationHandler implements InvocationHandler 
{ 
    private Object delegate; 
    private int duration; 

    DelayAfterInvocationHandler(Object delegate, int duration) 
    { 
     this.delegate = delegate; 
     this.duration = duration; 
    } 

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
    { 
     Object returnValue = method.invoke(delegate, args); 
     Thread.sleep(duration); 
     // you may want to catch InterruptedEception 
     return returnValue; 
    } 
} 

Pour masquer une partie de la non-soi joli code proxy, vous pouvez alors avoir une méthode qui enveloppe votre enregistreur pour créer le retard, par exemple

public ActionLogger addDelay(SomeActionLogger logger, int delay) 
{ 
    return (ActionLogger)Proxy.newProxyInstance(
     impl.getClass().getClassLoader(), 
     new Class[] { SomeActionLogger.class }, 
     new DelayAfterInvocationHandler(logger, delay)); 
} 

Vous écrivez alors

SomeActionLogger log = addDelay(new SystemOutActionLogger(), 2000); 

Notez que le DelayInvocationHandler est perpendiculaire à l'interface d'enregistrement - il peut être utilisé pour ajouter un délai à toute interface. Vous pourriez alors créer une méthode d'emballage générique comme ceci:

public <T> T addDelay(T delegate, int delay, Class<T> interfaceType) 
{ 
    return (T)Proxy.newProxyInstance(
     delegate.getClass().getClassLoader(), 
     new Class[] { type }, 
     new DelayAfterInvocationHandler(delegate, delay)); 
}