spring aop源码分析

在spring初始化源码分析这章中已经介绍过bean的详细初始化流程，所以我们知道bean在初始化之后会执行BeanPostProcessor的postProcessAfterInitialization方法，aop的实现原理就在BeanPostProcessor的后置处理方法当中，接下来我们详细分析aop的实现原理

1、启用aop我们需要标注@EnableAspectJAutoProxy注解，我们从@EnableAspectJAutoProxy注解进行分析，源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	// 指定使用cglib进行代理而不是使用jdk的Proxy，在AspectJAutoProxyRegistrar会被用来判断
	boolean proxyTargetClass() default false;

	 // 是否在执行时将代理对象放入ThreadLocal
	boolean exposeProxy() default false;

}

可以看见源码中有一个@Import(AspectJAutoProxyRegistrar.class)，此处为核心，表明导入配置类AspectJAutoProxyRegistrar

2、接下来我们切入AspectJAutoProxyRegistrar中看看他具体做了什么事情

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// 再容器注入一个beanName = org.springframework.aop.config.internalAutoProxyCreator,
		// class = AnnotationAwareAspectJAutoProxyCreator.class的bean
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
		// 获取@EnableAspectJAutoProxy注解的属性值
		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			// 如果指定了proxyTargetClass = true，往beanName为 org.springframework.aop.config.internalAutoProxyCreator的bean中注入proxyTargetClass = true
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			// 如果指定了exposeProxy= true，往beanName为 org.springframework.aop.config.internalAutoProxyCreator的bean中注入exposeProxy = true
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}

}

3、看看AnnotationAwareAspectJAutoProxyCreator到底是个什么东西

首先我们需要先看看AnnotationAwareAspectJAutoProxyCreator的继承关系，我们用流程图来展示他的继承关系

从图中可以看出AnnotationAwareAspectJAutoProxyCreator其实也是一个BeanPostProcessor，所以再bean初始化之后会调用到父类的AbstractAutoProxyCreator的postProcessAfterInitialization方法进行后置处理，aop的实现原理就在此后置处理中实现，下一步开始分析aop动态代理的实现

4、AbstractAutoProxyCreator.postProcessAfterInitialization方法源码分析

• 1、AbstractAutoProxyCreator的后置处理方法

	@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
				// 核心方法，此方法进行动态代理
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

• wrapIfNecessary详细分析

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		// 这三个if判断用来判断bean是否应该被创建动态代理
		// 如果beanName不是空，并且为当前对象自定义了TargetSource直接返回当前对象
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		// 如果当前bean被标记为不需要代理直接返回当前对象
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		// 如果当前bean是Advice、Pointcut、Advisor、AopInfrastructureBean中的任意子类则不会被代理
		// 如果当前bean是一个切面，不会被代理
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// 获取当前bean被哪些切面拦截了，并且获取出每个切面对应的拦截方法，这里不进入此处细看源码
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		// 如果拦截方法不是空
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			// 进行动态代理的创建，核心方法
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}
		// 标记此bean已被动态代理
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

• createProxy详细分析

	protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {
		// 在beanDifine中设置一个属性，key = org.springframework.aop.framework.autoproxy.AutoProxyUtils.originalTargetClass，value = 当前bean的class
		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}
		// 构建代理工厂
		ProxyFactory proxyFactory = new ProxyFactory();
		// 将this中的一些核心属性的值赋值给proxyFactory 
		// proxyTargetClass、optimize、exposeProxy、frozen、opaque
		proxyFactory.copyFrom(this);
		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}

		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		// 创建代理类
		return proxyFactory.getProxy(getProxyClassLoader());
	}

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// isOptimize（是否对生成代理策略进行优化），true : 进行优化，如果有接口就代理接口（使用JDK动态代理），没有接口代理类（CGLIB代理）。默认值：false。
        // proxyTargetClass（是否强制使用CGLIB来实现代理），true : 强制使用CGLIB来实现代理，false : 不强制使用CGLIB来实现代理，首选JDK来实现代理，（默认值）
		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.");
			}
			// 如果是接口使用jdk动态代理
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			// 如果不是接口使用cjlib代理
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

	private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
		Class<?>[] ifcs = config.getProxiedInterfaces();
		return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
	}
}

5、aop拦截方法执行流程

• intercept

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			Object oldProxy = null;
			boolean setProxyContext = false;
			Object target = null;
			TargetSource targetSource = this.advised.getTargetSource();
			try {
				if (this.advised.exposeProxy) {
					oldProxy = AopContext.setCurrentProxy(proxy);
					setProxyContext = true;
				}
				target = targetSource.getTarget();
				Class<?> targetClass = (target != null ? target.getClass() : null);
				// 获取当前方法的拦截器链
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
				// 如果拦截器链是空的，并且方法为public
				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
					// 获取参数
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);				// 执行目标方法
					retVal = methodProxy.invoke(target, argsToUse);
				}
				else {
					// 否则从拦截器链依次进行执行
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
				// 处理返回值
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}
			finally {
				if (target != null && !targetSource.isStatic()) {
					targetSource.releaseTarget(target);
				}
				if (setProxyContext) {
					// Restore old proxy.
					AopContext.setCurrentProxy(oldProxy);
				}
			}
		}

• proceed

	public Object proceed() throws Throwable {
		// this.currentInterceptorIndex默认值为-1 ！！！
		//	如果当前下标是拦截器链的最后一位
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {		
			// 执行目标方法本身
			return invokeJoinpoint();
		}
		// 获取当前下标+1对应的拦截方法
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
		// 如果是拦截方法
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			// 判断当前拦截方法是否应该拦截当前方法
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
			if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
				// 执行拦截方法的调用
				return dm.interceptor.invoke(this);
			}
			else {
				// 不匹配直接跳出，进行下一个拦截方法的判断
				return proceed();
			}
		}
		else {
			// 拦截器链的第一位是一个ExposeInvocationInterceptor，用来调用后续的拦截方法
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}