自定义注释作为方法日志记录的拦截器

Question

爪哇大师，

我对annotations很annotations ，还没有搜索过很多，所以请耐心等待...

我想实现一个Custom Annotation来intercept方法调用； 从一些非常基本的东西开始，它可以只打印方法名称和参数，这样我就可以避免logger语句。

像这样的示例调用：

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

可以转换为：

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

我能得到一些关于这个的提示吗？

Answer 1

根据您对我的评论的回答，您将无法仅使用注释来做到这一点。 当然，您可以创建注释并创建一些反射代码，然后将检测到并执行一些代码，但这不会对您的代码进行太多更改，因为您需要在调用方法之前调用parser方法，我认为这对您没有太大帮助，因为您需要在每次调用之前调用解析器方法。

如果您需要您提到的行为（自动调用），您将需要将您的注释与一些 AOP 框架（如 Spring（纯 Java）或 AspectJ（AspectJ 代码）相结合）。 然后，您可以设置切入点，每次到达该点时，可能会执行一些代码。 您可以配置 then 在方法执行之前和/或之后执行一些代码。

如果第一个场景就足够了，您可以执行以下操作：

记录器：枚举

public enum Logger {
    INFO,
    DEBUG;
}

LogMethodCall：注解

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;

}

人：带注释的类

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：带有日志静态方法的类（这将执行“解析”）

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：带有测试注解处理的代码的类

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 );

    }
}

当然，您需要改进我的代码以满足您的需求。 这只是一个起点。

更多关于注解：

• 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

更多关于 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

使用 Spring AOP 和 Java Annotation。 Spring AOP 不需要编写用于使用 Java 反射解析 Java 类的 util 类。

例子 -

1. 自定义注释 -

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

2. 方面-

    @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. 启用 AspectJ -

    @Configuration @EnableAspectJAutoProxy public class AConfig { }

4. 在代码中使用 -

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

Answer 3

正如已经建议的那样，AOP 和注释是最好的选择。 我建议使用jcabi-aspects 中的现成机制（我是一名开发人员）：

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

所有方法调用都将记录到 SLF4J。