Anotación personalizada como interceptor para un método de registro

Verificamos de forma completamente cada artículos de nuestra web con la meta de enseñarte en todo momento información más veraz y actualizada.

Solución:

Según sus respuestas a mis comentarios, no podrá hacer esto solo con anotaciones. Por supuesto, puede crear sus anotaciones y crear algún código reflectante que luego se detecte y ejecute algún código, pero esto no cambiará demasiado su código, porque deberá llamar al parser antes de llamar a sus métodos y creo que eso no le ayudará demasiado, ya que necesitará 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 AOP como Spring (Java simple) o AspectJ (código AspectJ). Con entonces, puede establecer puntos de acceso y cada vez que se alcanza este punto, se puede ejecutar algún código. Puede configurar luego para ejecutar algún código antes y / o después de la ejecución del método.

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

Registrador: enumeración

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 registro static método (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 procesamiento de anotaciones

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, necesitará 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/

Utilice Spring AOP junto con Java Annotation. Spring AOP niega el requisito de escribir una clase de utilidad para analizar las clases de Java utilizando 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 código –

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

Como ya se sugirió, AOP y anotaciones es la mejor opción. Recomendaría usar un mecanismo listo para usar de jcabi-aspectos (soy un desarrollador):

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

Todas las llamadas a métodos se registrarán en SLF4J.

Aquí tienes las comentarios y calificaciones

Si para ti ha resultado de provecho este post, nos gustaría que lo compartas con el resto desarrolladores de este modo nos ayudas a difundir nuestra información.

---

---

Utiliza Nuestro Buscador