5.8代理机制

SpringAOP使用JDK动态代理或CGLIB为给定的目标对象创建代理。JDK动态代理内置于JDK中,而CGLIB是一个公共的开放源码类定义库(重新打包到Spring核心中)。

如果要代理的目标对象实现至少一个接口,则使用JDK动态代理。由目标类型实现的所有接口都是代理的。如果目标对象不实现任何接口,则创建一个CGLIB代理。

如果要强制使用CGLIB代理(例如,代理为目标对象定义的每个方法,而不仅仅是由其接口实现的方法),可以这样做。但是,你应该考虑以下问题:

  • 对于cglib,不能通知final方法,因为它们不能在运行时生成的子类中被重写。

  • 从Spring4.0开始,代理对象的构造函数不再被调用两次,因为cglib代理实例是通过Objenesis创建的。只有当你的JVM不允许绕过构造函数时,你可能会看到来自Spring的AOP支持的双重调用和相应的调试日志条目。

要强制使用cglib代理,请将<aop:config>元素的proxy target class属性的值设置为true,如下所示:

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

要在使用@Aspectj auto proxy支持时强制cglib代理,请将<aop:aspectj-autoproxy>元素的proxy-target-class属性设置为true,如下所示:

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

多个<aop:config/>节在运行时折叠为一个统一的自动代理创建者,这将应用指定的任何<aop:config/>节(通常来自不同的XML bean定义文件)所指定的最强代理设置。这也适用于<tx:annotation-driven/>和<aop:aspectj-autoproxy/>元素。

要清楚,在<tx:annotation-driven/>、<aop:aspectj autoproxy/>或<aop:config/>元素上使用proxy target class=“true”将强制对这三个元素使用cglib代理。

5.8.1 理解AOP Proxies

SpringAOP是基于代理的。在编写自己的方面或使用Spring框架提供的任何基于SpringAOP的方面之前,掌握最后一条语句的实际语义是非常重要的。

首先考虑一个场景,其中你有一个普通的、未代理的、没有什么特别之处的、直接的对象引用,如下面的代码片段所示:

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(..)方法中的代码具有对代理的引用。这意味着对该对象引用的方法调用是对代理的调用。因此,代理可以委托给与该特定方法调用相关的所有拦截器(通知)。但是,一旦调用最终到达目标对象(在本例中为SimplePojo的引用),它可以对自身进行的任何方法调用(如this.bar()或this.foo())都将针对该引用而不是代理进行调用。这有重要的意义。这意味着自调用不会导致与方法调用相关联的advice获得执行的机会。

好吧,那我们该怎么办?最好的方法(这里松散地使用术语“best”)是重构代码,这样就不会发生自调用。这确实需要你做一些工作,但这是最好的,微创的方法。下一个方法绝对是可怕的,我们毫不犹豫地指出它,正是因为它是如此可怕。你可以(尽管对我们来说很痛苦)将类中的逻辑完全绑定到SpringAOP,如下示例所示:

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

这完全将你的代码与SpringAOP结合在一起,并且它使类本身意识到它正在一个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框架。