这就是我正在做的:

@Aspect
public class MethodLogger {
  @Around("(execution(* *(..)) || initialization(*.new(..))) && @annotation(Foo)")
  public Object wrap(ProceedingJoinPoint point) throws Throwable {
    // works fine, but only for methods
  }
}

该代码段工作正常，但仅适用于方法调用。这就是AspectJ maven plugin在应用方面之后说(不是在编译期间，它工作得很好):

around on initialization not supported (compiler limitation)

任何解决方法？我使用的是 OpenJDK 7:

java version "1.7.0_05"
Java(TM) SE Runtime Environment (build 1.7.0_05-b06)
Java HotSpot(TM) 64-Bit Server VM (build 23.1-b03, mixed mode)

最佳答案

由于技术限制，在initialization() 或preinitialization() 切入点上没有around() 建议这样的东西。还有一个问题就是对应的joinpoints进入和退出的时间顺序。看这个例子:

public abstract class ApplicationBase {
    private int id = 0;

    public ApplicationBase(int id) {
        this.id = id;
    }
}

public class Application extends ApplicationBase {
    private String name = "<unnamed>";

    public Application(int id, String name) {
        super(id);
        this.name = name;
    }

    public static void main(String[] args) {
        new Application(1, "Foo");
        new Application(2, "Bar");
    }
}

public aspect ExecutionTimingAspect {
    private String indentText = "";

    pointcut constructorCall() :
        call(*Application*.new(..));

    pointcut constructorRelated() :
        constructorCall() ||
        initialization(*Application*.new(..)) ||
        preinitialization(*Application*.new(..)) ||
        execution(*Application*.new(..));

    after() : constructorRelated() {
        indentText = indentText.substring(2);
        System.out.println(indentText + "<< " + thisJoinPointStaticPart);
    }

    before() : constructorRelated() {
        System.out.println(indentText + ">> " + thisJoinPointStaticPart);
        indentText += "  ";
    }

    Object around() : constructorCall() {
        long startTime = System.nanoTime();
        Object result = proceed();
        System.out.println(indentText + "Constructor runtime = " + (System.nanoTime() - startTime) / 1.0e9 + " s\n");
        return result;
    }
}

您将看到以下输出:

>> call(Application(int, String))
  >> preinitialization(Application(int, String))
  << preinitialization(Application(int, String))
  >> preinitialization(ApplicationBase(int))
  << preinitialization(ApplicationBase(int))
  >> initialization(ApplicationBase(int))
    >> execution(ApplicationBase(int))
    << execution(ApplicationBase(int))
  << initialization(ApplicationBase(int))
  >> initialization(Application(int, String))
    >> execution(Application(int, String))
    << execution(Application(int, String))
  << initialization(Application(int, String))
<< call(Application(int, String))
Constructor runtime = 0.00123172 s

>> call(Application(int, String))
  >> preinitialization(Application(int, String))
  << preinitialization(Application(int, String))
  >> preinitialization(ApplicationBase(int))
  << preinitialization(ApplicationBase(int))
  >> initialization(ApplicationBase(int))
    >> execution(ApplicationBase(int))
    << execution(ApplicationBase(int))
  << initialization(ApplicationBase(int))
  >> initialization(Application(int, String))
    >> execution(Application(int, String))
    << execution(Application(int, String))
  << initialization(Application(int, String))
<< call(Application(int, String))
Constructor runtime = 0.00103393 s

你能看出派生类的预初始化是如何在其基类的预初始化之前开始和完成的吗？以及初始化如何以相反的方式工作，但作为一个额外的复杂构造函数执行嵌入在初始化中？

也许现在您明白了，即使可以通过 around() 测量初始化，也不会反射(reflect)构造函数的总体执行时间。因此，如果您足够幸运能够拦截构造函数 call() 而不是 execution() 因为您可以访问调用代码，那么您就可以了，甚至可以使用around() 就像我在示例中所做的那样(顺便说一句，这不是线程安全的，但我试图保持简单)。如果您不能影响调用者，而只能编织被调用者，则需要使用其他技巧，例如通过 before() 输入某个构造函数的预初始化时的方面内部簿记，然后当通过 after() 退出相同构造函数调用的初始化。 IE。您需要在建议执行之间保持一些内部状态。这是可能的，但有点复杂。如果您想进一步讨论这个问题，请告诉我。

关于java - 如何横切带注释的方法和构造函数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13642646/