Spring AOP的实现:建立AopProxy代理对象

梦里梦外; 2022-05-11 12:38 180阅读 0赞

前面我们讲述了AOP的基本知识以及在Spring AOP机制中的一些基本的数据结构及其功能。下面开始正式的讲述Spring AOP的实现部分。

来看一下这个以ProxyFactory为中心的继承关系图

![70][]

可以将ProxyConfig看做是一个数据基类，这个基类为ProxyFactoryBean这样的子类提供了属性的配置。而AdvisedSupport则是实现了对于通知器和通知的相关操作。

在分析Spring AOP的实现原理中。原书是以ProxyFactoryBean的实现作为例子的。通过这个工程Bean，生产出了我们需要的AopProxy代理对象。

那么书上首先给了我们这样的关于ProxyFactoryBean的配置方法。

![70 1][]

我们可以看到，我们需要给我们的ProxyFactoryBean配置一个通知器，这个通知器是它的interceptorNames属性。当然还需要配置proxyInterfaces,这个是目标接口，也就是被代理的接口。target ，目标对象。

值得注意一点，虽然这里声明了interceptorNames属性，但是这个不是之后我会提到的拦截器。这个属性声明的是供AOP应用配置通知器的地方，需要为target目标对象生成Proxy代理对象，从而为AOP横切面的编织做好准备工作。

在ProxyFactoryBean中，它的AOP实现需要依赖JDK或者CGLIB提供的Proxy特性(也就是我前面所说的代理模式)。从FactoryBean中获取对象，是使用getObject()方法来完成的

@Override
    	public Object getObject() throws BeansException {
    		initializeAdvisorChain();
    		if (isSingleton()) {
    			return getSingletonInstance();
    		}
    		else {
    			if (this.targetName == null) {
    				logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
    						"Enable prototype proxies by setting the 'targetName' property.");
    			}
    			return newPrototypeInstance();
    		}
    	}

首先要对通知器链进行初始化操作，通知器链封装了一系列的拦截器，这些拦截器都要从配置中读取，然后为代理对象的生成做好准备。Spring中有singleton和prototype类型这两种不同的bean，所以这里对代理对象的生成需要做一个区分。

现在来看一下initializeAdvisorChain();这个方法，它为Proxy代理对象配置Advistor链是在这个方法中完成的。从代码中我们可以看到，从ListableBeanFactory中取得相应的通知器并把这些通知器加入到通知器链中。

生成singleton代理对象是在getSingletonInstance()中实现的。

private synchronized Object getSingletonInstance() {
    		if (this.singletonInstance == null) {
    			this.targetSource = freshTargetSource();
    			if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
    				// Rely on AOP infrastructure to tell us what interfaces to proxy.
    				Class<?> targetClass = getTargetClass();
    				if (targetClass == null) {
    					throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
    				}
    				setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
    			}
    			// Initialize the shared singleton instance.
    			super.setFrozen(this.freezeProxy);
    			this.singletonInstance = getProxy(createAopProxy());
    		}
    		return this.singletonInstance;
    	}

首先需要设置代理对象的接口

setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));

之后我们会使用ProxyFactory来生成我们需要的Proxy。

this.singletonInstance = getProxy(createAopProxy());

protected Object getProxy(AopProxy aopProxy) {
    		return aopProxy.getProxy(this.proxyClassLoader);
    	}

这里使用的时候AopProxy的getProxy()方法生成代理对象。AopProxy的获得方法是由

org.springframework.aop.framework.ProxyCreatorSupport.createAopProxy()

实现的

protected final synchronized AopProxy createAopProxy() {
    		if (!this.active) {
    			activate();
    		}
    		return getAopProxyFactory().createAopProxy(this);
    	}

在DefaultAopProxyFactory中创建AopProxy

@Override
    	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    			Class<?> targetClass = config.getTargetClass();
    			if (targetClass == null) {
    				throw new AopConfigException("TargetSource cannot determine target class: " +
    						"Either an interface or a target is required for proxy creation.");
    			}
    			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    				return new JdkDynamicAopProxy(config);
    			}
    			return new ObjenesisCglibAopProxy(config);
    		}
    		else {
    			return new JdkDynamicAopProxy(config);
    		}
    	}

接下里具体的代理对象的生成可以由两种方式。AOP代理对象的生成，是根据我们的目标对象的类型。如果是接口类，那么就使用JDK来生成代理对象，否则Spring使用CGLIB来生成目标对象的代理对象。当返回的是JDKDynamicAopProxy对象时。它的getProxy()方法如下所示

@Override
    	public Object getProxy(ClassLoader classLoader) {
    		if (logger.isDebugEnabled()) {
    			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    		}
    		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    	}

在这个地方我们看到了

Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

这就是我之前的一篇博客[https://blog.csdn.net/qq1641530151/article/details/83036756][https_blog.csdn.net_qq1641530151_article_details_83036756]

中提到的动态链接。这里我们也可以看到，spring的底层实际上也调用了jdk的代理模式。

这个地方为我们返回了目标对象的代理对象。

关于CGLIB对于代理对象的生成方式，是类似的。书上也有相应的代码。

下次我将来讲述关于Spring AOP的拦截器的调用。

[70]: /images/20220505/f9bbe11606524fd19bbb7c8cfd1b16cd.png
[70 1]: /images/20220505/8eac28c3b1f142c197437e94c154ea8b.png
[https_blog.csdn.net_qq1641530151_article_details_83036756]: https://blog.csdn.net/qq1641530151/article/details/83036756