为什么自调用不能用于Spring代理（例如AOP）？

Question

请解释一下，为什么代理上的自我调用是在目标上执行的，而不是在代理上执行的？如果那是故意的，那为什么？如果代理是通过子类创建的，那么可以在每次方法调用之前执行一些代码，甚至在自我调用时也是如此。我试过了，我有自我调用的代理

public class DummyPrinter {
    public void print1() {
        System.out.println("print1");
    }

    public void print2() {
        System.out.println("print2");
    }

    public void printBoth() {
        print1();
        print2();
    }
}

public class PrinterProxy extends DummyPrinter {
    @Override
    public void print1() {
        System.out.println("Before print1");
        super.print1();
    }

    @Override
    public void print2() {
        System.out.println("Before print2");
        super.print2();
    }

    @Override
    public void printBoth() {
        System.out.println("Before print both");
        super.printBoth();
    }
}

public class Main {
    public static void main(String[] args) {
        DummyPrinter p = new PrinterProxy();
        p.printBoth();
    }
}

Before print both
Before print1
print1
Before print2
print2

在这里，每个方法都在代理上调用。为什么在文档中提到在自我调用的情况下应该使用AspectJ？

Answer 1

请阅读Spring手册中的这一章，到时你就明白了。甚至在那里使用了术语“自我调用”。如果你仍然不明白，请随时提出后续问题，只要他们是在上下文中。

更新：好的，现在，在我们确定你真的读了那一章，在重新阅读你的问题和分析你的代码之后，我发现这个问题实际上是相当深刻的（我甚至反对它），值得更详细地回答。

您的误解是动态代理是如何工作的，因为它们不像示例代码中那样工作。让我将对象ID（哈希代码）添加到日志输出中，以便对您自己的代码进行说明：

package de.scrum_master.app;

public class DummyPrinter {
  public void print1() {
    System.out.println(this + " print1");
  }

  public void print2() {
    System.out.println(this + " print2");
  }

  public void printBoth() {
    print1();
    print2();
  }
}

package de.scrum_master.app;

public class PseudoPrinterProxy extends DummyPrinter {
  @Override
  public void print1() {
    System.out.println(this + " Before print1");
    super.print1();
  }

  @Override
  public void print2() {
    System.out.println(this + " Before print2");
    super.print2();
  }

  @Override
  public void printBoth() {
    System.out.println(this + " Before print both");
    super.printBoth();
  }

  public static void main(String[] args) {
    new PseudoPrinterProxy().printBoth();
  }
}

de.scrum_master.app.PseudoPrinterProxy@59f95c5d Before print both
de.scrum_master.app.PseudoPrinterProxy@59f95c5d Before print1
de.scrum_master.app.PseudoPrinterProxy@59f95c5d print1
de.scrum_master.app.PseudoPrinterProxy@59f95c5d Before print2
de.scrum_master.app.PseudoPrinterProxy@59f95c5d print2

看见没？总是有相同的对象ID，这一点也不奇怪。由于多态性，您的“代理”（它不是真正的代理，而是静态编译的子类）的自调用可以工作。这由Java编译器负责。

现在请记住我们这里讨论的是动态代理，即运行时创建的子类和对象：

• JDK代理为实现接口的类工作，这意味着实现那些接口的类是在运行时创建的。在这种情况下，无论如何都没有超类，这也解释了为什么它只适用于公共方法：接口只有公共方法。
• CGLIB代理也适用于不实现任何接口的类，因此也适用于受保护的和包范围的方法（但不适用私有方法，因为您无法重写这些方法，因此称为私有）。
• 但是，关键的一点是，在上述两种情况下，当创建代理时，原始对象已经（并且仍然）存在，因此不存在多态性。情况是，我们有一个动态创建的代理对象委托给原始对象，即我们有两个对象：代理和委托。

package de.scrum_master.app;

public class DelegatingPrinterProxy extends DummyPrinter {
  DummyPrinter delegate;

  public DelegatingPrinterProxy(DummyPrinter delegate) {
    this.delegate = delegate;
  }

  @Override
  public void print1() {
    System.out.println(this + " Before print1");
    delegate.print1();
  }

  @Override
  public void print2() {
    System.out.println(this + " Before print2");
    delegate.print2();
  }

  @Override
  public void printBoth() {
    System.out.println(this + " Before print both");
    delegate.printBoth();
  }

  public static void main(String[] args) {
    new DelegatingPrinterProxy(new DummyPrinter()).printBoth();
  }
}

de.scrum_master.app.DelegatingPrinterProxy@59f95c5d Before print both
de.scrum_master.app.DummyPrinter@5c8da962 print1
de.scrum_master.app.DummyPrinter@5c8da962 print2

这就是您在使用动态代理的Spring AOP或Spring的其他部分，甚至使用JDK或CGLIB代理的非Spring应用程序中看到的行为。

这是一个特点还是一个局限？作为一个AspectJ（不是Spring AOP）用户，我认为这是一个限制。也许其他人会认为这是一个特性，因为根据Spring中实现代理的方式，原则上您可以在运行时动态注册方面建议或拦截器，即每个原始对象（委托）都有一个代理，但对于每个代理，在调用委托的原始方法之前和/或之后都有一个动态的拦截器列表。在非常动态的环境中，这可能是一件好事。我不知道你要多久用一次。但是在AspectJ中，您还有if()切入点指示符，您可以在运行时使用它来确定是否应用某些建议（拦截器的AOP语言）。