spring AOP 源码详解一

Dear 丶 2023-05-22 06:59 68阅读 0赞

**目录**

概念：

AOP

源码

@EnableAspectJAutoProxy

@EnableAspectJAutoProxyz这个是什么？

AspectJAutoProxyRegistrar这个类

AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator实现了BeanFactoryAware接口

AnnotationAwareAspectJAutoProxyCreator实现BeanPostProcessor接口

AnnotationAwareAspectJAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口

创建代理对象

流程图

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

# 概念： #

## AOP ##

AOP（Aspect Oriented Programming），即面向切面编程。简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

# 源码 #

## **@EnableAspectJAutoProxy** ##

### **@EnableAspectJAutoProxyz**这个是什么？ ###

我们可以注意到，当我们要自己写一个切面的时候，在我们的配置类上面都会加上**@EnableAspectJAutoProxy**这个注解，那么这个注解是什么呢？这个注解的作用是让你自己写的切面起作用，那么他是怎么让我们的切面起作用的呢，下面来看一下这个注解如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70][]

从这个注解中我们一眼就看出，他通过@Import注解引入了AspectJAutoProxyRegistrar这个类。

## AspectJAutoProxyRegistrar这个类 ##

AspectJAutoProxyRegistrar这个类是干什么的？

![202004161950177.png][]

当我们进入到AspectJAutoProxyRegistrar这个类的时候，看到了他实现了ImportBeanDefinitionRegistrar这个类，ImportBeanDefinitionRegistrar这个有必要说一下，在我前几篇博客中提到过这个类，只要实现了ImportBeanDefinitionRegistrar，就可以往我们的容器中添加bean定义，那么他在这里的作用是什么呢？来看一下他的源码。

org.springframework.context.annotation.AspectJAutoProxyRegistrar\#registerBeanDefinitions  
        org.springframework.aop.config.AopConfigUtils\#registerAspectJAnnotationAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry)  
            org.springframework.aop.config.AopConfigUtils\#registerAspectJAnnotationAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)

@Nullable
    	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    			BeanDefinitionRegistry registry, @Nullable Object source) {
            //注册一个名称叫org.springframework.aop.config.internalAutoProxyCreator  类型是AnnotationAwareAspectJAutoProxyCreator的bean定义
    		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    	}

## AnnotationAwareAspectJAutoProxyCreator ##

AnnotationAwareAspectJAutoProxyCreator这个是类是干什么的呢？我们来看一下他的继承关系图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70 1][]

然后我们根据集成图，来看一下AnnotationAwareAspectJAutoProxyCreator干了些什么：

### AnnotationAwareAspectJAutoProxyCreator实现了BeanFactoryAware接口 ###

首先他实现了BeanFactoryAware接口，而我们看一下BeanFactoryAware源码，他到底是干什么的？

public interface BeanFactoryAware extends Aware {
    
    	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
    
    }

BeanFactoryAware很简单，就一个setBeanFactory方法，**AbstractAutoProxyCreator**实现了BeanFactoryAware，一定会复写这个方法，然后我们看一下AbstractAutoProxyCreator的setBeanFactory方法：

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#setBeanFactory  
        org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#setBeanFactory

@Override
    	public void setBeanFactory(BeanFactory beanFactory) {
    		super.setBeanFactory(beanFactory);//调用父类的super.setBeanFactory(beanFactory);
    		if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
    			throw new IllegalArgumentException(
    					"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
    		}
    		initBeanFactory((ConfigurableListableBeanFactory) beanFactory);//初始化bean工厂
    	}

那么这个initBeanFactory（）是怎么实现的呢，来看一下他的源码

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#initBeanFactory  
        org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator\#initBeanFactory

@Override
    	protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    		super.initBeanFactory(beanFactory); //1.调用父类的setBeanFactory
    		if (this.aspectJAdvisorFactory == null) {// 若 apsectj的Advisor（通知）工厂对象为空,我们就创建一个ReflectiveAspectJAdvisorFactory
    			this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
    		}
    		//不为空 我们就把aspectJAdvisorFactory 包装为BeanFactoryAspectJAdvisorsBuilderAdapter
    		this.aspectJAdvisorsBuilder =
    				new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
    	}

总结：实现BeanFactoryAware接口主要做了两件事：1.setBeanFactory 2.为aspectJAdvisorsBuilder的Advisor（通知）赋值

### AnnotationAwareAspectJAutoProxyCreator**实现BeanPostProcessor接口** ###

我们先看看**BeanPostProcessor**这个接口的源码：

public interface BeanPostProcessor {
    
    
    	@Nullable
    	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		return bean;
    	}
    
    
    	@Nullable
    	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		return bean;
    	}

这个接口有两个方法postProcessBeforeInitialization和postProcessAfterInitialization方法，但是AnnotationAwareAspectJAutoProxyCreator实现**BeanPostProcessor**接口主要是用它的postProcessAfterInitialization方法，我们来看一下AnnotationAwareAspectJAutoProxyCreator中的postProcessAfterInitialization方法源码

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
    		if (bean != null) {
    			Object cacheKey = getCacheKey(bean.getClass(), beanName);
    			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
    				return wrapIfNecessary(bean, beanName, cacheKey);  //包装bean  创建代理对象
    			}
    		}
    		return bean;
    	}

### AnnotationAwareAspectJAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口 ###

AnnotationAwareAspectJAutoProxyCreator实现**InstantiationAwareBeanPostProcessor**接口主要是用它的postProcessBeforeInstantiation方法,看一下这个方法的源码：

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#postProcessBeforeInstantiation

@Override   //找通知（advisor），放入缓存
    	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    		Object cacheKey = getCacheKey(beanClass, beanName);
    
    		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {  //判断有没有处理过
    			if (this.advisedBeans.containsKey(cacheKey)) {
    				return null;
    			}	//是不是一些基础的bean（Advice，Pointcut，Advisor，AopInfrastructureBean）||该不该跳过
    			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {  //shouldSkip源码
    				this.advisedBeans.put(cacheKey, Boolean.FALSE);
    				return null;
    			}
    		}
    
    
    		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);// 获取封装当前bean的TargetSource对象，如果不存在，则直接退出当前方法，
    		if (targetSource != null) {  // 否则从TargetSource中获取当前bean对象，并且判断是否需要将切面逻辑应用在当前bean上。
    			if (StringUtils.hasLength(beanName)) {
    				this.targetSourcedBeans.add(beanName);
    			}
    			Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
    			Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
    			this.proxyTypes.put(cacheKey, proxy.getClass());
    			return proxy;
    		}
    
    		return null;
    	}

## 创建代理对象 ##

真正的创建代理对象是从BeanPostProcessor处理器的后置方法开始，看源码路径：

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#postProcessAfterInitialization  
    org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#wrapIfNecessary  
        org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#getAdvicesAndAdvisorsForBean  
            org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#findEligibleAdvisors  
                org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#findAdvisorsThatCanApply  
                    org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#createProxy

然后我们分别来看一下他们的源码；

### org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#postProcessAfterInitialization ###

@Override  //实例化之后
    	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
    		if (bean != null) {
    			Object cacheKey = getCacheKey(bean.getClass(), beanName); 通过传入的class 和beanName生成缓存key
    			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
    				return wrapIfNecessary(bean, beanName, cacheKey);  //有没有必要包装
    			}
    		}
    		return bean;
    	}

### org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#wrapIfNecessary ###

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)) {  //是不是基础bean || 是否需要跳过
    			this.advisedBeans.put(cacheKey, Boolean.FALSE);
    			return bean;
    		}
    
    		// Create proxy if we have advice.
    		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);   //加入advisedBeans集合中
    		return bean;
    	}

### org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#getAdvicesAndAdvisorsForBean ###

protected Object[] getAdvicesAndAdvisorsForBean(  //找到符合条件的通知
    			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
    
    		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);  //找到合适的通知
    		if (advisors.isEmpty()) {
    			return DO_NOT_PROXY;
    		}
    		return advisors.toArray();
    	}

### org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#findEligibleAdvisors ###

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    		List<Advisor> candidateAdvisors = findCandidateAdvisors(); //找候选的通知
    		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName); //找到能用的Advisor
    		extendAdvisors(eligibleAdvisors);
    		if (!eligibleAdvisors.isEmpty()) {
    			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    		}
    		return eligibleAdvisors;
    	}

### org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator\#findCandidateAdvisors ###

org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator\#findCandidateAdvisors

@Override
    	protected List<Advisor> findCandidateAdvisors() {
    		// Add all the Spring advisors found according to superclass rules.
    		List<Advisor> advisors = super.findCandidateAdvisors();  //找到事务的增强器
    		// Build Advisors for all AspectJ aspects in the bean factory.
    		if (this.aspectJAdvisorsBuilder != null) {
    			advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());//buildAspectJAdvisors 找AspectJ的增强器
    		}
    		return advisors;
    	}

*  **解析findCandidateAdvisors 步骤1.findAdvisorBeans**

org.springframework.aop.framework.autoproxy.BeanFactoryAdvisorRetrievalHelper\#findAdvisorBeans

public List<Advisor> findAdvisorBeans() {
    		String[] advisorNames = this.cachedAdvisorBeanNames; //去缓存中找通知
    		if (advisorNames == null) { //没有获取到
    			// Do not initialize FactoryBeans here: We need to leave all regular beans
    			// uninitialized to let the auto-proxy creator apply to them!
    			advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( //从IOC容器中找到所有实现Advisor的实现类的beanName
    					this.beanFactory, Advisor.class, true, false);
    			this.cachedAdvisorBeanNames = advisorNames; //赋值给增强器缓存
    		}
    		if (advisorNames.length == 0) {  //在IOC容器中没有获取到直接返回
    			return new ArrayList<>();
    		}
    
    		List<Advisor> advisors = new ArrayList<>();
    		for (String name : advisorNames) {   //遍历所有的通知（advisor）
    			if (isEligibleBean(name)) {
    				if (this.beanFactory.isCurrentlyInCreation(name)) {  //忽略正在创建的advisor
    					if (logger.isDebugEnabled()) {
    						logger.debug("Skipping currently created advisor '" + name + "'");
    					}
    				}
    				else {
    					try {    //通过getBean的形式创建通知（advisot） //并且将bean 添加到advisors中
    						advisors.add(this.beanFactory.getBean(name, Advisor.class));
    					}
    					catch (BeanCreationException ex) {
    						Throwable rootCause = ex.getMostSpecificCause();
    						if (rootCause instanceof BeanCurrentlyInCreationException) {
    							BeanCreationException bce = (BeanCreationException) rootCause;
    							String bceBeanName = bce.getBeanName();
    							if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
    								if (logger.isDebugEnabled()) {
    									logger.debug("Skipping advisor '" + name +
    											"' with dependency on currently created bean: " + ex.getMessage());
    								}
    						
    								continue;
    							}
    						}
    						throw ex;
    					}
    				}
    			}
    		}
    		return advisors;
    	}

*  **解析findCandidateAdvisors 步骤 2.buildAspectJAdvisors**

org.springframework.aop.aspectj.annotation.BeanFactoryAspectJAdvisorsBuilder\#buildAspectJAdvisors

public List<Advisor> buildAspectJAdvisors() {
    		List<String> aspectNames = this.aspectBeanNames;  //从缓存中获取
    
    		if (aspectNames == null) {  //缓存中没有获取到
    			synchronized (this) {
    				aspectNames = this.aspectBeanNames; //再次冲缓存中获取
    				if (aspectNames == null) {
    					List<Advisor> advisors = new ArrayList<>();
    					aspectNames = new ArrayList<>();
    					String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(	//找到所有的beanName
    							this.beanFactory, Object.class, true, false);
    					for (String beanName : beanNames) { //遍历beanNames
    						if (!isEligibleBean(beanName)) {
    							continue;
    						}
    						
    						Class<?> beanType = this.beanFactory.getType(beanName); //获取bean的类型
    						if (beanType == null) {
    							continue;
    						}
    						if (this.advisorFactory.isAspect(beanType)) {  //判断是不是切面 源码
    							aspectNames.add(beanName);
    							AspectMetadata amd = new AspectMetadata(beanType, beanName);  //创建Aspect类的源信息对象
    							if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
    								MetadataAwareAspectInstanceFactory factory =
    										new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
    								List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);//从aspectj中获取通知（advisor） 源码
    								if (this.beanFactory.isSingleton(beanName)) {
    									this.advisorsCache.put(beanName, classAdvisors); //key 类名 value 通知（advisor）
    								}
    								else {
    									this.aspectFactoryCache.put(beanName, factory);
    								}
    								advisors.addAll(classAdvisors);
    							}
    							else {
    								// Per target or per this.
    								if (this.beanFactory.isSingleton(beanName)) {
    									throw new IllegalArgumentException("Bean with name '" + beanName +
    											"' is a singleton, but aspect instantiation model is not singleton");
    								}
    								MetadataAwareAspectInstanceFactory factory =
    										new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
    								this.aspectFactoryCache.put(beanName, factory);
    								advisors.addAll(this.advisorFactory.getAdvisors(factory));
    							}
    						}
    					}
    					this.aspectBeanNames = aspectNames;
    					return advisors;
    				}
    			}
    		}
    
    		if (aspectNames.isEmpty()) {
    			return Collections.emptyList();  //没有，则返回空
    		}
    		List<Advisor> advisors = new ArrayList<>(); //缓存中有通知（Advisor） 从缓存中获取并返回
    		for (String aspectName : aspectNames) {
    			List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
    			if (cachedAdvisors != null) {
    				advisors.addAll(cachedAdvisors);
    			}
    			else {
    				MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
    				advisors.addAll(this.advisorFactory.getAdvisors(factory));
    			}
    		}
    		return advisors;
    	}

*  **解析findCandidateAdvisors 步骤 3.getAdvisors**

org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory\#getAdvisors

public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    		Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); //获取标识了@AspectJ标志的切面类
    		String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();	//获取切面的名称
    		validate(aspectClass);
    
    		MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
    				new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
    
    		List<Advisor> advisors = new ArrayList<>();
    		for (Method method : getAdvisorMethods(aspectClass)) { //获取切面类中的所有除了切点（@Pointcut注解）的方法，包括object方法
    			Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);// 每个method获取通知（advisor）  源码
    			if (advisor != null) {
    				advisors.add(advisor);
    			}
    		}
    
    
    		if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
    			Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
    			advisors.add(0, instantiationAdvisor);
    		}
    
    		// Find introduction fields.
    		for (Field field : aspectClass.getDeclaredFields()) {
    			Advisor advisor = getDeclareParentsAdvisor(field);
    			if (advisor != null) {
    				advisors.add(advisor);
    			}
    		}
    
    		return advisors;
    	}
    
    
    //org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory#getAdvisor
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
    			int declarationOrderInAspect, String aspectName) {
    
    		validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
    		//获取切点表达式  源码
    		AspectJExpressionPointcut expressionPointcut = getPointcut(
    				candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    		if (expressionPointcut == null) {
    			return null;
    		}
    		//创建切面的实现类 源码
    		return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
    				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    	}
    
    //org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory#getPointcut
    	private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
    		AspectJAnnotation<?> aspectJAnnotation =		//获取切面注解 @Before   @After。。。。。。
    				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);  //源码
    		if (aspectJAnnotation == null) {
    			return null;
    		}
    		//获取切点表达式对象
    		AspectJExpressionPointcut ajexp =
    				new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
    		ajexp.setExpression(aspectJAnnotation.getPointcutExpression());  //设置切点表达式
    		if (this.beanFactory != null) {
    			ajexp.setBeanFactory(this.beanFactory);
    		}
    		return ajexp;
    	}
    
    
    
    /**
    *org.springframework.aop.aspectj.annotation.InstantiationModelAwarePointcutAdvisorImpl#In*stantiationModelAwarePointcutAdvisorImpl
    */
    
    	public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
    			Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
    			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    
    		this.declaredPointcut = declaredPointcut;
    		this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
    		this.methodName = aspectJAdviceMethod.getName();
    		this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
    		this.aspectJAdviceMethod = aspectJAdviceMethod;
    		this.aspectJAdvisorFactory = aspectJAdvisorFactory;
    		this.aspectInstanceFactory = aspectInstanceFactory;
    		this.declarationOrder = declarationOrder;
    		this.aspectName = aspectName;
    
    		if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {  //是不是懒加载
    			// Static part of the pointcut is a lazy type.
    			Pointcut preInstantiationPointcut = Pointcuts.union(
    					aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
    
    			// Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
    			// If it's not a dynamic pointcut, it may be optimized out
    			// by the Spring AOP infrastructure after the first evaluation.
    			this.pointcut = new PerTargetInstantiationModelPointcut(
    					this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
    			this.lazy = true;
    		}
    		else {
    			// A singleton aspect.
    			this.pointcut = this.declaredPointcut;
    			this.lazy = false;
    			this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut); //实例化切面  源码
    		}
    	}
    
    /**
    *org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory#getAdvice
    *
    */
    
    	public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
    			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    
    		Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); //1.找到候选的切面类
    		validate(candidateAspectClass);
    
    		AspectJAnnotation<?> aspectJAnnotation =
    				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);//找到方法上的注解
    		if (aspectJAnnotation == null) {
    			return null;
    		}
    
    		// If we get here, we know we have an AspectJ method.
    		// Check that it's an AspectJ-annotated class
    		if (!isAspect(candidateAspectClass)) {
    			throw new AopConfigException("Advice must be declared inside an aspect type: " +
    					"Offending method '" + candidateAdviceMethod + "' in class [" +
    					candidateAspectClass.getName() + "]");
    		}
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Found AspectJ method: " + candidateAdviceMethod);
    		}
    
    		AbstractAspectJAdvice springAdvice;
    		//判断注解的类型
    		switch (aspectJAnnotation.getAnnotationType()) {
    			case AtPointcut:  //是切点的返回null
    				if (logger.isDebugEnabled()) {
    					logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
    				}
    				return null;
    			case AtAround:	//是不是环绕通知
    				springAdvice = new AspectJAroundAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				break;
    			case AtBefore:	//是不是后置通知
    				springAdvice = new AspectJMethodBeforeAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				break;
    			case AtAfter:	//后置通知
    				springAdvice = new AspectJAfterAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				break;
    			case AtAfterReturning:	//返回通知
    				springAdvice = new AspectJAfterReturningAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
    				if (StringUtils.hasText(afterReturningAnnotation.returning())) {
    					springAdvice.setReturningName(afterReturningAnnotation.returning());
    				}
    				break;
    			case AtAfterThrowing:	//是不是异常通知
    				springAdvice = new AspectJAfterThrowingAdvice(
    						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
    				AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
    				if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
    					springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
    				}
    				break;
    			default:
    				throw new UnsupportedOperationException(
    						"Unsupported advice type on method: " + candidateAdviceMethod);
    		}
    
    		// Now to configure the advice...
    		springAdvice.setAspectName(aspectName);
    		springAdvice.setDeclarationOrder(declarationOrder);
    		String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod); //获取方法的参数列表名称
    		if (argNames != null) {
    			springAdvice.setArgumentNamesFromStringArray(argNames);     //为切面设置参数
    		}
    		springAdvice.calculateArgumentBindings();
    
    		return springAdvice;
    	}

### org.springframework.aop.support.AopUtils\#findAdvisorsThatCanApply ###

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    		if (candidateAdvisors.isEmpty()) {
    			return candidateAdvisors;
    		}
    		List<Advisor> eligibleAdvisors = new ArrayList<>();
    		for (Advisor candidate : candidateAdvisors) {	//遍历候选的通知 把他增加到eligibleAdvisors集合中返回
    			if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {  判断是当前的通知是否能用 通过方法匹配来计算当前是否合适当前类的增强器  源码
    				eligibleAdvisors.add(candidate);
    			}
    		}
    		boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    		for (Advisor candidate : candidateAdvisors) {
    			if (candidate instanceof IntroductionAdvisor) {
    				// already processed
    				continue;
    			}
    			if (canApply(candidate, clazz, hasIntroductions)) {
    				eligibleAdvisors.add(candidate);
    			}
    		}
    		return eligibleAdvisors;
    	}

### org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#createProxy ###

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 = new ProxyFactory();	//创建代理工厂
    		proxyFactory.copyFrom(this);
    
    		if (!proxyFactory.isProxyTargetClass()) {  //proxyTargetClass 强制使用cglib代理
    			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()); //获取代理对象 源码
    	}

# 流程图 #

看了以上代码，我们画个加单的图来看一下aop创建代理对象的过程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70]: /images/20230521/b9a48e7787504d55a5360e9f6135756b.png
[202004161950177.png]: /images/20230521/d3987f0b811749c485d85adad2f41929.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70 1]: /images/20230521/70f2cf2480b24a399380d96a2ac71f4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjMwODEw_size_16_color_FFFFFF_t_70 2]: /images/20230521/6a2004183ac54dbf943fd8d45ff62d60.png