5.8. 代理机制

Spring AOP 使用 JDK 动态代理或 CGLIB 为给定的目标对象创建代理。JDK 动态代理内置在 JDK 中,而 CGLIB 是一个通用的开源类定义库(重新打包到spring-core).

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

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

  • 使用 CGLIB,不能通知final方法,因为它们不能在运行时生成的子类中被覆盖。

  • 从 Spring 4.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 自动代理支持时强制 CGLIB 代理,请将 元素的proxy-target-class属性设置为,如下所示:<aop:aspectj-autoproxy>``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 代理

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

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

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 上下文与 AOP 相悖。在创建代理时还需要一些额外的配置,如以下示例所示:

public class Main {

    public static void main(String[] args) {
        ProxyFactory factory = new ProxyFactory(new SimplePojo());
        factory.addInterface(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 框架。

最后更新于