spring 源码分析 aop自动创建代理 (AnnotationAwareAspectJAutoProxyCreator )

	@EnableAspectJAutoProxy 		//第一种方式注解
	<aop:aspectj-autoproxy />  		//第二种方式xml配置

 spring aop 通过上述二种方式激活:

spring aop 激活会注册一个 AspectJAutoProxyBeanDefinitionParser 解析类, 这个解析会创建 AnnotationAwareAspectJAutoProxyCreator 的BeanDefinition
bean定义名称为 String AUTO_PROXY_CREATOR_BEAN_NAME = “org.springframework.aop.config.internalAutoProxyCreator”;

spring 创建 BeanDefinitionParser 解析器, 的实现类 AspectJAutoProxyBeanDefinitionParser 调用parse() 方法解析

	/**
	 * 方法所在类路径： org.springframework.aop.config.AspectJAutoProxyBeanDefinitionParser
	 * 解析
	 */
	@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 通过工具类注册
		AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
		// 获取自动代理创建的 BeanDefinition 解析子节点获取值保存到 BeanDefinition 的属性值中 MutablePropertyValues
		extendBeanDefinition(element, parserContext);
		return null;
	}

	// 方法所在类路径： org.springframework.aop.config.AopNamespaceUtils
	public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {
		// 在调用aop工具类, 注册切面注解自动代理
		BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));//<aop:aspectj-autoproxy>
		// 处理 proxy-target-class 以及 expose-proxy 属性
		useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
		// 注册组件并通知，便于监听器作进一步处理
		// 其中 beanDefinition 的 className 为 AnnotationAwareAspectJAutoProxyCreator
		registerComponentIfNecessary(beanDefinition, parserContext);
	}

	/**
	 * 方法所在类路径： org.springframework.aop.config.AopConfigUtils
	 * 注册切面注解自动代理创建 AnnotationAwareAspectJAutoProxyCreator.class
	 */
	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
		//registerOrEscalateApcAsRequired 方法就不分析了, 注册一个AnnotationAwareAspectJAutoProxyCreator.class 的BeanDefinition
		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);	//创建BeanDefinition
	}
	

AnnotationAwareAspectJAutoProxyCreator 分析

AnnotationAwareAspectJAutoProxyCreator 类
本质上还是一个BeanPostProcessor, 通过初始化bean时. 对实例进行代理实现AOP功能

该类是 spring 扩展机制 BeanPostProcessor 接口的实现：
这里使用的方法： Object postProcessAfterInitialization(Object bean, String beanName); //初始化对象后置处理

AnnotationAwareAspectJAutoProxyCreator 类关系图

	/**
	 * org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
	 * 如果子类将bean标识为要代理的bean，则使用配置的拦截器创建代理
	 */
	@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			// 如果已储存beanName代理, 不处理直接返回bean
			if (!this.earlyProxyReferences.contains(cacheKey)) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

	/**
	 * org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
	 * beanName处理
	 */
	protected Object getCacheKey(Class<?> beanClass, @Nullable String beanName) {
		if (StringUtils.hasLength(beanName)) {
			return (FactoryBean.class.isAssignableFrom(beanClass) ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
		}
		else {
			return beanClass;
		}
	}

	/**
	 * org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
	 * 包装给定的bean，例如，如果它符合代理的条件
	 */
	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// 获取所有aop通知
		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;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

	
	/**
	 * 创建给定的Bean的Aop代理
	 */
	protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) {

		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			// 暴露目标class   就是设置beanName对应的BeanDefinition 中的属性originalTargetClass(源目标class)为 beanClass
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}

		// 创建代理工厂
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);

		// 当前代理工厂是否代理目标类 (默认为false)
		if (!proxyFactory.isProxyTargetClass()) {
			// 检测beanName
			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);

		// 指示是否应该冻结代理(默认false)
		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}

		return proxyFactory.getProxy(getProxyClassLoader());
	}

这里使用了ProxyFactory 代理工厂, 创建代理对象.
下章解析…