从源码层面剖析SpringAOP原理（二）

2.代理对象的创建

ProxyFactory

上一节讲到了拦截器链的获取，接下来就执行到Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));来创建代理对象

该方法具体代码如下：

	protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}
		
		//创建ProxyFactory
		ProxyFactory proxyFactory = new ProxyFactory();
		// 获取当前类的相关属性
		proxyFactory.copyFrom(this);

		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				// 添加代理接口
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		
		//从拦截器链中获取Advisor增强器
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		// 设置增强
		proxyFactory.addAdvisors(advisors);
		// 设置代理目标类
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		// 从ProxyFactory中获取代理对象
		return proxyFactory.getProxy(getProxyClassLoader());
	}

从上面的代码中可以看到为了生成代理对象，先创建了一个ProxyFactory工厂类，ProxyFactory实现代理需要设置Target(目标对象)、Interface(代理接口)、Advice(增强)，并将这些属性均保存在AdvisedSupport中，然后调用getProxy生成代理对象。而在代码中也确实一一设置好了，设置完毕后即调用proxyFactory.getProxy(getProxyClassLoader());来获取代理对象

那么继续来看getProxy()方法

	public Object getProxy(@Nullable ClassLoader classLoader) {
		return createAopProxy().getProxy(classLoader);
	}

在这个方法中，先通过 createAopProxy()来创建一个具体的代理工厂，跟踪发现createAopProxy()返回的是属性aopProxyFactory，而属性aopProxyFactory又是在ProxyCreatorSupport构造器时进行实例化的，真正的类是DefaultAopProxyFactory，因此继续跟踪DefaultAopProxyFactory的createAopProxy方法

protected final synchronized AopProxy createAopProxy() {
	if (!this.active) {
		activate();
	}
	return getAopProxyFactory().createAopProxy(this);
}
----------------------------------------------------------------
public AopProxyFactory getAopProxyFactory() {
	// 返回的是类中的成员变量aopProxyFactory
	return this.aopProxyFactory;
}
----------------------------------------------------------------
// 成员变量的实例化则是在默认构造器中
private AopProxyFactory aopProxyFactory;

// 构造器，调用了DefaultAopProxyFactory进行实例化，因此aopProxyFactory真正的类型是DefaultAopProxyFactory
public ProxyCreatorSupport() {
	this.aopProxyFactory = new DefaultAopProxyFactory();
}

可以看到，当config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)为真时才会使用Cglib代理，而当代理对象有实现接口，并且没有强制开启cglib代理时默认使用的是JDK代理，也就是JdkDynamicAopProxy类。

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// isOptimize开启激进模式 || proxyTargetClass=true(强制开启cglib代理) || 接口集合为空
		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);
			}
			// 没有接口，只能选择cglib代理
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			// 使用JDK代理
			return new JdkDynamicAopProxy(config);
		}
	}
  ...
}

也就是是说，最后调用的其实就是new JdkDynamicAopProxy(config).getProxy(),其中config为AdvisedSupport，里面存放了之前保存的Target(目标对象)、Interface(代理接口)、Advice(增强)属性

JdkDynamicAopProxy的getProxy()方法实现如下：

// JdkDynamicAopProxy.java
	@Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
		}
		// 从之前传入的AdvisedSupport获取代理接口
		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		// 判断接口是否又hashCode和equals方法
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		// 使用JDK代理(classLoader, 接口, 当前JdkDynamicAopProxy对象：用于回调invoke和target对象方法)
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}

而Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);就是我们熟悉的JDK动态代理，其中传入的InvocationHandler参数为this,也就说明 JdkDynamicAopProxy实现了该接口的invoke()方法，然后把自己传进去。当对目标方法进行调用时，实际上调用对就是该invoke()方法

接下来来具体分析一下JdkDynamicAopProxy对invoke()的实现

JdkDynamicAopProxy

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object oldProxy = null;
		boolean setProxyContext = false;
		// 从之前传入的AdvisedSupport中获取代理目标对象
		TargetSource targetSource = this.advised.targetSource;
		Object target = null;

		try {
			// 省略一部分非关键代码
			// 1. 之前传入的AdvisedSupport获取拦截器链
			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

		
			// 拦截器为空，直接调用切点方法
			if (chain.isEmpty()) {
				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
				// 2. 将拦截器统一封装成ReflectiveMethodInvocation
				MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				// 3. 执行拦截器链
				retVal = invocation.proceed();
			}

			// Massage return value if necessary.
			Class<?> returnType = method.getReturnType();
			if (retVal != null && retVal == target &&
					returnType != Object.class && returnType.isInstance(proxy) &&
					!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
				retVal = proxy;
			}
			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
				throw new AopInvocationException(
						"Null return value from advice does not match primitive return type for: " + method);
			}
			return retVal;
		}
		finally {
				// 省略...
		}
	}

invoke()主要包括三个步骤：
1.获取之前创建的该类的拦截器链
2. 将拦截器统一封装成ReflectiveMethodInvocation
3. 执行拦截器链

接下来对这三步进行一一分析

获取拦截器链

该方法将获取到所有与当前method匹配的advice(增强)，跟踪getInterceptorsAndDynamicInterceptionAdvice代码，发现Spring AOP也使用缓存进行提高性能，如果该方法已经获取过拦截器，则直接取缓存，否则通过advisorChainFactory获取拦截器链

	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
		MethodCacheKey cacheKey = new MethodCacheKey(method);
		// 从缓存中获取
		List<Object> cached = this.methodCache.get(cacheKey);
		if (cached == null) {
			// 获取拦截器链
			cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
					this, method, targetClass);
			// 设置缓存
			this.methodCache.put(cacheKey, cached);
		}
		return cached;
	}

继续进入getInterceptorsAndDynamicInterceptionAdvice方法

// DefaultAdvisorChainFactory.java
public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

	@Override
	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, @Nullable Class<?> targetClass) {
			
		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
		Advisor[] advisors = config.getAdvisors();
		// 创建返回的拦截器链列表
		List<Object> interceptorList = new ArrayList<>(advisors.length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
		Boolean hasIntroductions = null;

		// 循环所有切面
		for (Advisor advisor : advisors) {
			if (advisor instanceof PointcutAdvisor) {

				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
				// 校验当前Advisor是否适用于当前对象
				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
					boolean match;
					if (mm instanceof IntroductionAwareMethodMatcher) {
						// Introduction相关内容这里先忽略
						if (hasIntroductions == null) {
							hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
						}
						match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
					}
					else {
						//在这里进行匹配，判断Advisor是否应用到当前方法上
						match = mm.matches(method, actualClass);
					}
					// 匹配成功
					if (match) {
            			// 从advisor中获取拦截器数组
						MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
						if (mm.isRuntime()) {
							for (MethodInterceptor interceptor : interceptors) {
								// 添加动态拦截器
								interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
							}
						}
						else {
							// 将拦截器添加到拦截器列表中
							interceptorList.addAll(Arrays.asList(interceptors));
						}
					}
				}
			}
			// 忽略引介增强相关代码....
		}

		return interceptorList;
	}
	...
}

说白了，就是把这个类之前创建的advisor都拿出来，然后通过pointcut判断是不是和当前的方法相匹配，如果是，就将其中的拦截器链返回

将拦截器封装成ReflectiveMethodInvocation

	protected ReflectiveMethodInvocation(
			Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
			@Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {

		this.proxy = proxy;
		this.target = target;
		this.targetClass = targetClass;
		this.method = BridgeMethodResolver.findBridgedMethod(method);
		this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
		this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
	}

执行拦截器链invocation.proceed();

在该proceed()方法中对拦截器的执行顺序进行了保障，内部运用了责任链设计模式，怎么保证的见笔记

参考文献：https://blog.csdn.net/chaitoudaren/article/details/105278409