SpringFramework核心技术五：面向切面编程（AOP）和代理机制

超、凢脫俗 2022-05-21 07:48 231阅读 0赞

## AOP与代理 ##

Spring AOP使用JDK动态代理或CGLIB为给定目标对象创建代理。（只要有选择，JDK动态代理就是首选）。

--------------------

## 一、代理机制 ##

如果要代理的目标对象实现至少一个接口，则将使用JDK动态代理。目标类型实现的所有接口都将被代理。如果目标对象未实现任何接口，则将创建CGLIB代理。  
如果要强制使用CGLIB代理（例如，代理为目标对象定义的每个方法，而不仅仅是那些由其接口实现的方法），您可以这样做。但是，有一些问题需要考虑：

*  final 方法无法建议，因为它们无法被覆盖。
 *  从Spring 3.2开始，不再需要将CGLIB添加到项目类路径中，因为CGLIB类在org.springframework下重新打包并直接包含在spring-core JAR中。这意味着基于CGLIB的代理支持“正常工作”的方式与JDK动态代理总是一样。
 *  从Spring 4.0开始，代理对象的构造函数将不再被调用两次，因为CGLIB代理实例将通过Objenesis创建。只有当您的JVM不允许构造函数绕过时，您才可能看到来自Spring的AOP支持的双重调用和相应的调试日志条目。

要强制使用CGLIB代理，请将元素proxy-target-class属性的值设置`<aop:config>`为true：

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

要在使用`@AspectJ autoproxy`支持时强制CGLIB代理，请将元素的`'proxy-target-class'`属性设置 `<aop:aspectj-autoproxy>`为true：

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

> 多个`<aop:config/>`部分在运行时折叠为单个统一自动代理创建器，它应用指定的任何部分（通常来自不同的XML bean定义文件）的最强代理设置 `<aop:config/>`。这也适用于`<tx:annotation-driven/>`和`<aop:aspectj-autoproxy/>` 元素。  
> 需要明确的是：在使用`proxy-target-class="true"`上`<tx:annotation-driven/>`，`<aop:aspectj-autoproxy/>`或`<aop:config/>`元素将强制使用CGLIB代理对他们三个。

## 二、了解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...
        }
    }

如果在对象引用上调用方法，则直接在该对象引用上调用该方法，如下所示。  
![这里写图片描述][70]

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();
        }
    }

当客户端代码具有的引用是代理时，事情会稍微改变。请考虑以下图表和代码段。  
![这里写图片描述][70 1]

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()or this.foo()）将针对此引用而不是代理进行调用。这具有重要意义。这意味着自我调用 不是 将导致与方法调用相关的建议有机会执行。

好的，那要做些什么呢？最好的方法（这里松散地使用最好的术语）是重构代码，以便不会发生自我调用。当然，这确实需要你做一些工作，但这是最好的，最少侵入性的方法。接下来的方法绝对是可怕的，而且我几乎要谨慎地指出它，因为它太可怕了。你可以（窒息！）通过这样做完全将你的类中的逻辑绑定到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框架。

## 三、@AspectJ代理 ##

更多关于[AspectJ代理的资料][AspectJ]

## 四、什么是面向切面和AOP ##

知乎这边有一篇讲的较好的文章：  
[切面和AOP][AOP]

好啦，就说这么多啦！

[70]: /images/20220521/88fdfa8fc1e1492f868db8997f9b39d7.png
[70 1]: /images/20220521/e3f67537b7a646da95abbf430e2bedc9.png
[AspectJ]: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#aop-aspectj-programmatic
[AOP]: https://www.zhihu.com/question/24863332