<aop:config proxy-target-class="true">
            <!-- other beans defined here... -->
        </aop:config>

<aop:aspectj-autoproxy proxy-target-class="true"/>

Spring AOP是基于代理机制的。实际上在你编写自己的切面或者 使用任何由Spring框架提供的基于Spring AOP切面之前，深刻领会这一句的意思是非常重要的。

考虑如下场景，当你拿到一个无代理的、无任何特殊之处的POJO对象引用时，如以下代码段所示

public class SimplePojo implements Pojo {
                
                public void foo() {
                // this next method invocation is a direct call on the 'this' reference
                this.bar();
                }
                
                public void bar() {
                // some logic...
                }
            }

当你调用一个对象引用的方法时，此对象引用上的方法直接被调用，如下所示

public class Main {
                
                public static void main(String[] args) {
                
                Pojo pojo = new SimplePojo();
                
                // this is a direct method call on the 'pojo' reference
                pojo.foo();
                }
            }

当客户代码所持有的引用是一个代理的时候则略有不同了。请考虑如下图示和代码段片断

public class Main {
                
                public static void main(String[] args) {
                
                ProxyFactory factory = new ProxyFactory(new SimplePojo());
                factory.addInterface(Pojo.class);
                factory.addAdvice(new RetryAdvice());
                
                Pojo pojo = (Pojo) factory.getProxy();
                
                // this is a method call on the proxy!
                pojo.foo();
                }
            }

理解此处的关键是Main类main(..)方法中的客户代码 拥有一个代理的引用。这意味着对这个对象引用中方法的调用就是对代理的调用， 而这个代理能够代理所有跟特定方法调用相关的拦截器。不过，一旦调用最终抵达了目标对象 （此处为SimplePojo类的引用），任何对自身的调用例如 this.bar()或者this.foo() 将对this引用进行调用而非代理。这一点意义重大， 它意味着自我调用将不会导致和方法调用关联的通知得到执行的机会。

那好，为此要怎么办呢？最好的办法（这里使用最好这个术语不甚精确）就是重构你的代码使自我调用不会出现。 当然，这的确需要你做一些工作，但却是最好的，最少侵入性的方法。另一个方法则很可怕， 也正因为如此我几乎不愿指出这种方法。你可以象如下这样完全把业务逻辑写在你的Spring AOP类中：

public class SimplePojo implements Pojo {
                
                public void foo() {
                // this works, but... gah!
                ((Pojo) AopContext.currentProxy()).bar();
                }
                
                public void bar() {
                // some logic...
                }
            }

这样完全将你的代码交给了Spring AOP，并且让类本身知道它正被用于一个AOP的上下文中， 而它其中的文件直接面对AOP。当代理在被创建时也需要一些额外的配置：

public class Main {
                
                public static void main(String[] args) {
                
                ProxyFactory factory = new ProxyFactory(new SimplePojo());
                factory.adddInterface(Pojo.class);
                factory.addAdvice(new RetryAdvice());
                factory.setExposeProxy(true);
                
                Pojo pojo = (Pojo) factory.getProxy();
                
                // this is a method call on the proxy!
                pojo.foo();
                }
            }

最后，必须注意AspectJ不存在这种自我调用的问题，因为它并不是一个基于代理的AOP框架。