Java adnotacji do owijania metody

Question

Mam dużo kodu boilerplate że w zasadzie zachowuje ten wzór:

function doSomething() { 
    try { 
    [implementation] 
    [implementation] 
    [implementation] 
    [implementation] 
    } catch (Exception e) { 
    MyEnv.getLogger().log(e); 
    } finally { 
    genericCleanUpMethod(); 
    } 
} 

Chciałbym stworzyć własną adnotacji oczyścić mój kod się trochę:

@TryCatchWithLoggingAndCleanUp 
function doSomething() { 
    [implementation] 
    [implementation] 
    [implementation] 
    [implementation] 
} 

Sygnatury metod różnią się znacznie (w zależności od rzeczywistej implementacji metody), ale część wypalania/catch/finally jest zawsze taka sama.

Adnotacja, którą mam na myśli, automatycznie zawinąłaby zawartość opisanej metody z całym hoopla try...catch...finally.

Przeszukałem wysokie i niskie w prosty sposób, ale nic nie znalazłem. Nie wiem, może po prostu nie widzę lasu dla wszystkich opisywanych drzew.

Wszelkie wskazówki dotyczące tego, w jaki sposób mogę wprowadzić taką adnotację, byłyby mile widziane.

Answer 1

Aby to zrobić, potrzebowałbyś pewnej struktury AOP, która używała proxy wokół twojej metody. Ten serwer proxy przechwyciłby wyjątek i wykonałby blok finally. Szczerze mówiąc, jeśli nie korzystasz już z frameworka obsługującego AOP, nie jestem pewien, czy użyłbym jednego, aby zapisać te kilka linii kodu.

Można użyć następującego wzoru to zrobić w bardziej elegancki sposób, ale:

public void doSomething() { 
    logAndCleanup(new Callable<Void>() { 
     public Void call() throws Exception { 
      implementationOfDoSomething(); 
      return null; 
     } 
    }); 
} 

private void logAndCleanup(Callable<Void> callable) { 
    try { 
     callable.call(); 
    } 
    catch (Exception e) { 
     MyEnv.getLogger().log(e); 
    } 
    finally { 
     genericCleanUpMethod(); 
    } 
} 

Używałem Callable<Void> jako interfejs, ale można zdefiniować własne Command interfejs:

public interface Command { 
    public void execute() throws Exception; 
} 

, a tym samym unikaj konieczności używania standardowego Callable<Void> i zwróć wartość null z opcji Callable.

EDYCJA: w przypadku, gdy chcesz zwrócić coś ze swoich metod, zmień metodę logAndCleanup(). Oto pełna przykład:

public class ExceptionHandling { 
    public String doSomething(final boolean throwException) { 
     return logAndCleanup(new Callable<String>() { 
      public String call() throws Exception { 
       if (throwException) { 
        throw new Exception("you asked for it"); 
       } 
       return "hello"; 
      } 
     }); 
    } 

    public Integer doSomethingElse() { 
     return logAndCleanup(new Callable<Integer>() { 
      public Integer call() throws Exception { 
       return 42; 
      } 
     }); 
    } 

    private <T> T logAndCleanup(Callable<T> callable) { 
     try { 
      return callable.call(); 
     } 
     catch (Exception e) { 
      System.out.println("An exception has been thrown: " + e); 
      throw new RuntimeException(e); // or return null, or whatever you want 
     } 
     finally { 
      System.out.println("doing some cleanup..."); 
     } 
    } 

    public static void main(String[] args) { 
     ExceptionHandling eh = new ExceptionHandling(); 

     System.out.println(eh.doSomething(false)); 
     System.out.println(eh.doSomethingElse()); 
     System.out.println(eh.doSomething(true)); 
    } 
} 

EDIT: I z Java 8, owinięty kod może być nieco ładniejsza:

public String doSomething(final boolean throwException) { 
    return logAndCleanup(() -> {     
     if (throwException) { 
      throw new Exception("you asked for it"); 
     } 
     return "hello";     
    }); 
} 

Answer 2

afaik musisz monitorować każde wywołanie metody dla adnotacji @TryCatchWithLoggingAndCleanUp, co byłoby bardzo uciążliwe. zasadniczo można uzyskać adnotacje każdej metody przez odbicie, a następnie wykonać obsługę wyjątków i rejestrację. ale nie jestem pewien, czy chciałbyś to zrobić.

Answer 3

możesz zaimplementować procesor opisów i adnotacji sam i kod instrumentu za każdym razem, gdy wykonujesz kompilację (javac -processor). Innym sposobem jest użycie AOP, powiedzmy AspectJ lub Spring AOP (jeśli używasz Spring).

Answer 4

Można używać dynamicznych proxy do wdrożenia tego. Zajmuje trochę konfiguracji, ale po wykonaniu jest dość proste.

Najpierw definiujesz interfejs i umieszczasz adnotację w interfejsie.

public interface MyInterface { 
    @TryCatchWithLogging 
    public void doSomething(); 
} 

Teraz, gdy chcemy zapewnić implementację interfejsu do konsumenta, nie zapewniają mu z rzeczywistą realizacją, ale zamiast Pełnomocnictwo do niego.

MyInterface impl = new java.lang.reflect.Proxy.newProxyInstance(
         Impl.class.getClassLoader(), 
         Impl.class.getInterfaces(), YourProxy(new Impl()); 

Następnie zaimplementuj YourProxy.

public class YourProxy implements InvocationHandler { 
.... 

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
     if (method.isAnnotationPresent(TryCatchLogging.class)) { 
       // Enclose with try catch 
}