Java: Einfache Technik für die Annotation-basierte Code-Injektion?

Question

Gibt es eine Möglichkeit diesen Code Arbeit zu machen?

LogonControl.java

@Audit(AuditType.LOGON) 
public void login(String username, String password) { 
// do login 
} 

AuditHandler.java

public void audit(AuditType auditType) { 
// persist audit 
} 

Endgame wird, dass jedes Mal, Login() aufgerufen wird, Audit() wird auch mit der entsprechenden audittype genannt.

Ich denke, AOP ist wahrscheinlich die Lösung, aber ich möchte es so einfach wie möglich (die AspectJ Tutorials, die ich mir angesehen habe, haben normalerweise sehr komplizierte Anmerkungen).

Hinweis: Ich will nicht die Methoden vordefinieren haben, die Prüfung nennen, ich dies für ein erweiterbares Framework zu schreiben, und andere müssen es benutzen.

Answer 1

Reflexion Verwendung ist einfach nur ein Verfahren, mit @Audit Anmerkungen versehen, ebenso wie Testläufer in JUnit:

public interface Login { 

    void login(String name, String password); 
} 

public class LoginImpl implements Login { 

    @Audit(handler = LoginHandler.class) 
    public void login(String name, String password) { 
     System.out.println("login"); 
    } 

} 

@Audit definiert ist als:

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD) 
public @interface Audit { 

    Class<? extends Handler> handler(); 
} 

wo Handler ist:

interface Handler { 

    void handle(); 
} 

class LoginHandler implements Handler { 

    public void handle() { 
     System.out.println("HANDLER CALLED!"); 
    } 
} 

und jetzt der echte Code:

public class LoginFactory { 

    private static class AuditInvocationHandler implements InvocationHandler { 

     private final Login realLogin; 

     public AuditInvocationHandler(Login realLogin) { 
      this.realLogin = realLogin; 
     } 

     public Object invoke(Object proxy, Method method, Object[] args) 
         throws Throwable { 
      Method realMethod = realLogin.getClass().getMethod(
             method.getName(), 
             method.getParameterTypes()); 
      Audit audit = realMethod.getAnnotation(Audit.class); 

      if (audit != null) { 
       audit.handler().newInstance().handle(); 
      } 

      return method.invoke(realLogin, args); 
     } 
    } 

    public static Login createLogin() { 
     return (Login) Proxy.newProxyInstance(
       LoginFactory.class.getClassLoader(), 
       new Class[]{Login.class}, 
       new AuditInvocationHandler(new LoginImpl())); 
    } 
} 

@Test:

Login login = LoginFactory.createLogin(); 
    login.login("user", "secret"); 
    login.logout(); 

Ausgang:

 
HANDLER CALLED! 
login 
logout 

Answer 2

Es ist geschafft - verwenden Spring oder Guice.

Roll Ihren eigenen macht Sinn, wenn Sie know how wheels work wollen, oder wenn Sie denken, dass Sie etwas tun kann, das ist deutlich leichter. Seien Sie sicher, dass beide wahr sind, bevor Sie es unternehmen.

Answer 3

Werfen Sie einen Blick auf das Abfangen Methoden in Guice: http://code.google.com/p/google-guice/wiki/AOP

Ein ähnlicher Ansatz sollte mit jedem AOP Framework arbeiten.