java - que - Anotación personalizada como Interceptor para un registro de método.

java lang annotation

Question

Java Gurus,

Soy bastante nuevo para las annotations y no he buscado esto mucho, así que por favor, tengan paciencia conmigo ...

Me gustaría implementar una Custom Annotation que intercept una llamada de método; para comenzar con algo muy básico, solo puede imprimir el nombre de los métodos y los parámetros para que pueda evitar la declaración del logger .

Una llamada de muestra como esta:

public MyAppObject findMyAppObjectById(Long id) throws MyCustomException {
log.debug("in findMyAppObjectById(" + id + ")");
//....
} 

se puede convertir en:

@LogMethodCall(Logger.DEBUG)
public MyAppObject findMyAppObjectById(Long id) throws MyCustomException {
//....
} 

¿Podría obtener algunos consejos sobre esto?

Answer 1

Basado en las respuestas de mis comentarios, no podrá hacer esto con solo anotaciones. Por supuesto, puede crear sus anotaciones y crear un código reflexivo que luego se detectará y ejecutar un código, pero esto no cambiará demasiado su código, ya que tendrá que llamar al método del parser antes de llamar a sus métodos y creo que eso no le ayudará mucho, ya que tendrá que llamar al método del analizador antes de cada llamada.

Si necesita el comportamiento que mencionó (llamada automática), deberá combinar sus anotaciones con algún marco de AOP como Spring (Java plano) o AspectJ (código AspectJ). Con entonces, puede establecer puntos de corte y cada vez que se alcanza este punto, se puede ejecutar algún código. Puede configurar entonces para ejecutar algún código antes y / o después de la ejecución del método.

Si el primer escenario es suficiente, puedes hacer algo como:

Logger: enum

public enum Logger {
INFO,
DEBUG;
}

LogMethodCall: anotación

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention( RetentionPolicy.RUNTIME ) // the annotation will be available during runtime
@Target( ElementType.METHOD ) // this can just used in methods
public @interface LogMethodCall {
Logger logLevel() default Logger.INFO;
}

Persona: clase anotada

public class Person {
// will use the default log level (INFO)
@LogMethodCall
public void foo( int a ) {
System.out.println( "foo! " + a );
}
@LogMethodCall( logLevel = Logger.DEBUG )
public void bar( int b ) {
System.out.println( "bar! " + b );
}
}

Utils: clase con el método de registro estático (esto realizará el "análisis")

public class Utils {
public static void log( Object o, String methodName ) {
// gets the object class
Class klass = o.getClass();
// iterate over its methods
for ( Method m : klass.getMethods() ) {
// verify if the method is the wanted one
if ( m.getName().equals( methodName ) ) {
// yes, it is
// so, iterate over its annotations
for ( Annotation a : m.getAnnotations() ) {
// verify if it is a LogMethodCall annotation
if ( a instanceof LogMethodCall ) {
// yes, it is
// so, cast it
LogMethodCall lmc = ( LogMethodCall ) a;
// verify the log level
switch ( lmc.logLevel() ) {
case INFO:
System.out.println( "performing info log for /"" + m.getName() + "/" method" );
break;
case DEBUG:
System.out.println( "performing debug log for /"" + m.getName() + "/" method" );
break;
}
}
}
// method encountered, so the loop can be break
break;
}
}
}
}

AnnotationProcessing: clase con código para probar el proceso de anotación

public class AnnotationProcessing {
public static void main(String[] args) {
Person p = new Person();
Utils.log( p, "foo" );
p.foo( 2 );
Utils.log( p, "bar" );
p.bar( 3 );
}
}

Por supuesto, deberá mejorar mi código para que se ajuste a sus necesidades. Es solo un punto de partida.

Más sobre anotaciones:

• http://docs.oracle.com/javase/1.5.0/docs/guide/language/annotations.html
• http://docs.oracle.com/javase/tutorial/java/javaOO/annotations.html
• http://tutorials.jenkov.com/java-reflection/annotations.html

Más sobre AOP:

• http://en.wikipedia.org/wiki/Aspect-oriented_programming
• http://static.springsource.org/spring/docs/3.0.x/reference/aop.html
• http://www.eclipse.org/aspectj/

Answer 2

Como ya se sugirió, AOP y las anotaciones son la mejor opción. Recomendaría usar un mecanismo ya hecho de jcabi-aspects (soy un desarrollador):

@Loggable(Loggable.DEBUG)
public String load(URL url) {
return url.openConnection().getContent();
}

Todas las llamadas de método se registrarán en SLF4J.

Answer 3

Utilice Spring AOP junto con Java Annotation. Spring AOP niega el requisito de escribir una clase de utilidad para analizar las clases de Java usando Java Reflection.

Ejemplo -

1. Anotación personalizada -

   @Retention(RetentionPolicy.RUNTIME)
   @Target(ElementType.METHOD)
   public @interface A {
   boolean startA() default false;
   boolean endA() default false;
   }

2. Aspecto-

    @Aspect
   public class AAspect {
   @Pointcut(value = "execution(* *.*(..))")
   public void allMethods() {
   LOGGER.debug("Inside all methods");
   }
   @Before("allMethods() && @annotation(A)")`
   public void startAProcess(JoinPoint pjp, A a) throws Throwable {
   if (a.startA()) {
   //Do something
   }
   }

3. Habilitar AspectJ -

   @Configuration
   @EnableAspectJAutoProxy
   public class AConfig {
   }

4. Usar en codigo

   @A(startA = true, endA = true)
   public void setUp(){
   //Do something- logic
   }