spring-aop源码解析之bean的创建

谁践踏了优雅 2023-01-08 15:29 203阅读 0赞

前面我们搭建好了一个简单的aop功能，并且成功运行得到了结果。

这里我们来分析以下aop模式下的bean的创建以及aop功能的实现

**1、@EnableAspectJAutoProxy注解的作用**

如果我们不在配置类上面加这个注解，那么我们标注的@Aspect注解不会起作用，那么ioc也只会将切面相关的类管理起来，但是这些类与其他的类就一模一样了。少了它特有的aop的功能。

那么就来看看@EnableAspectJAutoProxy注解到底做了什么事情。

//导入了一个自动代理的bean的解析器
    @Import({ AspectJAutoProxyRegistrar.class})
    public @interface EnableAspectJAutoProxy { 
        boolean proxyTargetClass() default false;
    
        boolean exposeProxy() default false;
    }

通过前面的分析我们知道，**@Import导入的bean也会被解析到ioc中，并且他也会被当成一个配置类，去解析他里面定义的需要注入的bean**

在我们这一篇文章（[https://blog.csdn.net/qq\_41001945/article/details/110875962][https_blog.csdn.net_qq_41001945_article_details_110875962]）的最后一行代码中，就是aop相关beanDefinition的注入。所以我们就来仔细分析这一块

**aop模式下的bd的加载**

this.loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

简单在说一下：在解析配置类的时候，会将他扫描的包里面的bean、@Import等注解导入的bean都当成一个配置类去加载，加载完之后将其放在一个set中。然后去遍历解析这些bean，解析他们里面需要注入的bean， 其中就包括了aop需要注入的bean

也就是说，我们上行代码，**只有正在解析的这个bean的类型是ImportBeanDefinitionRegistrar才会进入这行代码**

**aop模式下bd加载都做了什么**

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { 
        AspectJAutoProxyRegistrar() { 
        }
    
    	//最终代码会走到这里来进行aop的beanDefinition的处理
    	
         public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
         
         	//给容器中添加一个bd 名字为org.springframework.aop.config.internalAutoProxyCreator
            AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
            //获取配置类的@EnableAspectJAutoProxy注解信息
            AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
            //将注解里面的proxyTargetClass与exposeProxy的值设置给上面加载的bd里面
            if (enableAspectJAutoProxy != null) { 
                if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { 
                    AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                }
    
                if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { 
                    AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
                }
            }
    
        }
    }

至此结束。 到目前位置，ioc容器中多了一个bean为org.springframework.aop.config.internalAutoProxyCreator  
他的类型为AnnotationAwareAspectJAutoProxyCreator类型。 那么注入的他的作用又是什么呢

首先看下他的继承关系图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70]  
从上图可以看到，他是Aware接口的实现类。

**我们知道，bean加载完之后，会设置bean的属性，然后去执行初始化这个bean，其中，就有判断bean实现了Aware接口（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware），如果有就会执行相关方法（设置beanName、beanClassLoader、beanFactory）。**

而我们注入的这个bean恰恰实现了BeanFactoryWare接口，那么在执行相关方法之后，他就会持有ioc容器的引用。

看一下具体的代码

private void invokeAwareMethods(String beanName, Object bean) { 
            if (bean instanceof Aware) { 
                if (bean instanceof BeanNameAware) { 
                    ((BeanNameAware)bean).setBeanName(beanName);
                }
    
                if (bean instanceof BeanClassLoaderAware) { 
                    ClassLoader bcl = this.getBeanClassLoader();
                    if (bcl != null) { 
                        ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                    }
                }
    			//在这里设置ioc容器的引用
                if (bean instanceof BeanFactoryAware) { 
                	//往下看
                    ((BeanFactoryAware)bean).setBeanFactory(this);
                }
            }
        }

**设置ioc容器的引用**

AbstractAdvisorAutoProxyCreator   25  line
    
    public void setBeanFactory(BeanFactory beanFactory) { 
            super.setBeanFactory(beanFactory);
            if (!(beanFactory instanceof ConfigurableListableBeanFactory)) { 
                throw new IllegalArgumentException("AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
            } else { 
            	//初始化beanFactory 继续往下看
                this.initBeanFactory((ConfigurableListableBeanFactory)beanFactory);
            }
        }

**初始化beanFactory**

AnnotationAwareAspectJAutoProxyCreator  46  line
    
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
    		//创建了advisorRetrievalHelper 
            super.initBeanFactory(beanFactory);
            if (this.aspectJAdvisorFactory == null) { 
                this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
            }
    		//初始化aspectJAdvisorsBuilder
            this.aspectJAdvisorsBuilder = new AnnotationAwareAspectJAutoProxyCreator.BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
        }

上面貌似只初始化了一些字段而已。 继续分析

还是上面的类的继承图，他同时也是BeanPostProcessor的实现类，那么在初始化bean的时候，会去执行所有的BeanPostProcessor类型的bean的postProcessBeforeInitialization方法，那么我们继续看他的postProcessBeforeInitialization方法都做了什么

**BeanPostProcessor 的postProcessBeforeInitialization**

首先，在设置完aware接口完之后，会调用BeanPostProcessor.postProcessBeforeInitialization对我们的bean进行一个装饰， 这一块也用的是装饰模式，所有的BeanPostProcessor类型的bean都会对本bean进行装饰，最后返回装饰完的bean

AbstractAutowireCapableBeanFactory  243  line
    
    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException { 
            Object result = existingBean;
    
            Object current;
            for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) { 
            	//拿到每一个BeanPostProcessor， 然后对bean进行实例化，然后赋值给current
            	//然后将current赋值给result，在下一次循环的时候，继续操这个bean。
            	//所以每一次的结果是下一次来操作的入参，最后返回操作完的结果。
                BeanPostProcessor processor = (BeanPostProcessor)var4.next();
                current = processor.postProcessBeforeInitialization(result, beanName);
                if (current == null) { 
                    return result;
                }
            }
            return result;
        }

之后再去执行init 方法 afterPropetiesSet postProcessAfterInitialization 之后将bean加入到ioc容器中。bean就被创建好了。 到目前为止，依然没有看到特别重要的信息。

后面应该怎么去分析 ~~~真是为难

**经过仔细分析bean加载的源码之后，我发现遗漏了这一块内容！！！！！！**

AbstractAutowireCapableBeanFactory  315  line
    
    beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);

在加载bean之前，他会解析一些内容，具体解析的是什么东西呢?

**Bean加载之前的一些信息解析**

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { 
            Object bean = null;
            if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { 
            	//如果有InstantiationAwareBeanPostProcessors类型的bean，那么就机型下面的解析
                if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) { 
                    Class<?> targetType = this.determineTargetType(beanName, mbd);
                    if (targetType != null) { 
                    	//解析~~~
                        bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                        if (bean != null) { 
                        	//还是解析 这一块应该会再一次包装~~~
                            bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                        }
                    }
                }
    
                mbd.beforeInstantiationResolved = bean != null;
            }
    		//返回解析完的bean 这一块可能为null，如果为null，就进行我们以前说的bean的反射加载的流程
            return bean;
        }

**解析~~~**

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) { 
            Iterator var3 = this.getBeanPostProcessors().iterator();
            while(var3.hasNext()) { 
            	//获取所有InstantiationAwareBeanPostProcessor类型的bean 进行bean实例化之前的一些操作
                BeanPostProcessor bp = (BeanPostProcessor)var3.next();
                if (bp instanceof InstantiationAwareBeanPostProcessor) { 
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                    //具体操作~~~往下看
                    Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                    if (result != null) { 
                        return result;
                    }
                }
            }
    
            return null;
        }

**AOP模式下的postProcessBeforeInstantiation都做了什么事情？？？**

**AnnotationAwareAspectJAutoProxyCreator.postProcessBeforeInstantiation**

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) { 
            Object cacheKey = this.getCacheKey(beanClass, beanName);
            //判断targetSourcedBeans是否包含正在处理的bean
            if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) { 
                //判断advisedBeans是否包含正在处理的bean
                if (this.advisedBeans.containsKey(cacheKey)) { 
                    //包含返回null
                    return null;
                }
    
    			//advisedBeans与targetSourcedBeans的作用是什么？？为什么要判断这个？我暂时还没弄明白 
    
    			//切面相关注解判断 是否需要跳过 这两个方法往下看
                if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) { 
                    //处理中的bean是aop相关的，则加入到map中
                    this.advisedBeans.put(cacheKey, Boolean.FALSE);
                    return null;
                }
            }
    
            ......这一块不是aop的重点 略过
        }

**Advice与Pointcut、Advisor注解是否存在的判断**

AbstractAutoProxyCreator  196  line
    
    //这个方法重写了父类的 先判断父类 在判断自己重写的逻辑
    protected boolean isInfrastructureClass(Class<?> beanClass) { 
    		//调用父类的方法 判断处理的类是否有@Aspect注解 这一块就涉及到了aop哦
            return super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass);
        }
    
    protected boolean isInfrastructureClass(Class<?> beanClass) { 
    		//正在处理的类是否有 @Advice、Advisor注解或者@Pointcut注解
            boolean retVal = Advice.class.isAssignableFrom(beanClass) || Pointcut.class.isAssignableFrom(beanClass) || Advisor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass);
            
            //返回判断的结果
            return retVal;
        }

**重点！！！candidateAdvisors 的获取**

protected List<Advisor> findCandidateAdvisors() { 
    		//获取容器中的Advisor类型的beanName
            List<Advisor> advisors = super.findCandidateAdvisors();
            if (this.aspectJAdvisorsBuilder != null) { 
            	//获取Aspect类型的beanName 重点！！！ 往下看
                advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
            }
    
            return advisors;
        }

**重点！！！获取Aspect类型的beanName**

public List<Advisor> buildAspectJAdvisors() { 
    		//判断是否已经获取过了 因为每个bean加载的时候都会走到这里，所以第一个处理完之后其他直接用就行。
            List<String> aspectNames = this.aspectBeanNames;
            //没处理过则 获取
            if (aspectNames == null) { 
            	//加锁？？ 这个为啥需要加锁？
                synchronized(this) { 
                	//再次检查一边 防止重复加载
                    aspectNames = this.aspectBeanNames;
                    if (aspectNames == null) { 
                        List<Advisor> advisors = new ArrayList();
                        List<String> aspectNames = new ArrayList();
                        //获取容器中所有的beanName
                        String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                        String[] var18 = beanNames;
                        int var19 = beanNames.length;
    
                        for(int var7 = 0; var7 < var19; ++var7) { 
                            String beanName = var18[var7];
                            if (this.isEligibleBean(beanName)) { 
                            	//获取bean的类型
                                Class<?> beanType = this.beanFactory.getType(beanName, false);
                                //如果bean有Aspect注解 并且bean没有以ajc开头的方法
                                if (beanType != null && this.advisorFactory.isAspect(beanType)) { 
                                    //将这个beanName加入到集合中
                                    aspectNames.add(beanName);
                                    //拿到这个bean的基本信息
                                    AspectMetadata amd = new AspectMetadata(beanType, beanName);
                                    if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) { 
                                        MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                        //获取所有的Advisor 重点在这一块了
                                        List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
    
    
                                        //注意！！！这一块会将切面bean与生成的增强绑定起来放在map中
    								
    									//AnnotationAwareAspectJAutoProxyCreator中的advisorsCache
    									//保存了切面bean与相关的增强的方法
    									
    									//（我们注入的aop相关的bean就是AnnotationAwareAspectJAutoProxyCreator）
    
                                        if (this.beanFactory.isSingleton(beanName)) { 
                                            this.advisorsCache.put(beanName, classAdvisors);
                                        } else { 
                                            this.aspectFactoryCache.put(beanName, factory);
                                        }
    									//将其加入到集合中
                                        advisors.addAll(classAdvisors);
                                    } else { 
                                        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;
                    }
                }
            }
    
            ......
                return advisors;
            }
        }

**获取Advisor**

ReflectiveAspectJAdvisorFactory   56  line
    
     public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) { 
            //获取标注了@Aspect注解的类的类型
            Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
            //获取类名
            String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
            //校验检查一下
            this.validate(aspectClass);
            //初始化一个工厂 看名字就知道工厂的作用
            MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
            List<Advisor> advisors = new ArrayList();
            //1、获取切面类的方法
            Iterator var6 = this.getAdvisorMethods(aspectClass).iterator();
            while(var6.hasNext()) { 
                Method method = (Method)var6.next();
                //实例化切面类
                Advisor advisor = this.getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
                if (advisor != null) { 
                    advisors.add(advisor);
                }
            }
    
            if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) { 
                Advisor instantiationAdvisor = new ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
                advisors.add(0, instantiationAdvisor);
            }
    
            Field[] var12 = aspectClass.getDeclaredFields();
            int var13 = var12.length;
    
            for(int var14 = 0; var14 < var13; ++var14) { 
                Field field = var12[var14];
                //获取标注了@DeclareParents注解的字段，并将其解析成一个切面类
                Advisor advisor = this.getDeclareParentsAdvisor(field);
                if (advisor != null) { 
                    advisors.add(advisor);
                }
            }
    
            return advisors;
        }

**先来看看实例化切面类**

ReflectiveAspectJAdvisorFactory   119  line
    
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) { 
            //再次校验这个类是不是@Aspect标注的类
            this.validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
            //2、获取切点方法
            AspectJExpressionPointcut expressionPointcut = this.getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
            //3、构造切面类
            return expressionPointcut == null ? null : new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
        }

## 1、获取切面类的方法 ##

ReflectiveAspectJAdvisorFactory   91  line
    
    private List<Method> getAdvisorMethods(Class<?> aspectClass) { 
            List<Method> methods = new ArrayList();
            //获取类的所有方法
            ReflectionUtils.doWithMethods(aspectClass, (method) -> { 
            	//筛选出 没有 标注 @PointCut注解的方法，将其收集起来
                if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) { 
                    methods.add(method);
                }
    
            }, ReflectionUtils.USER_DECLARED_METHODS);
            //进行以下排序
            if (methods.size() > 1) { 
                methods.sort(METHOD_COMPARATOR);
            }
            return methods;
        }

## 2、切点方法的获取 ##

ReflectiveAspectJAdvisorFactory   126  line
    
    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) { 
            AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
            if (aspectJAnnotation == null) { 
                return null;
            } else { 
                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;
            }
        }

这里执行完之后的属性值如下图 从图中可以看出， 我们已经获取了标注切点的方法了 就是 **method()**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70 1]

## 3、切面类的构造 ##

InstantiationModelAwarePointcutAdvisorImpl    44  line
    
    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()) { 
                Pointcut preInstantiationPointcut = Pointcuts.union(aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
                this.pointcut = new InstantiationModelAwarePointcutAdvisorImpl.PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
                this.lazy = true;
            } else { 
            	//我们不是懒加载 在这里 继续往下看
                this.pointcut = this.declaredPointcut;
                this.lazy = false;
                //4、advice的增强
                this.instantiatedAdvice = this.instantiateAdvice(this.declaredPointcut);
            }
    
        }

## 4、切面增强 ##

InstantiationModelAwarePointcutAdvisorImpl    86  line
    
    private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) { 
    		//继续往下看 5、Advice的解析获取
            Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
            return advice != null ? advice : EMPTY_ADVICE;
        }

## 5、Advice的解析获取 ##

ReflectiveAspectJAdvisorFactory   142   line
    
    public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) { 
            //这一块的类行依旧是我们标注了@Aspect注解的类 class com.aop.LogPrintAspect
            Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
            //再次校验以下类是否有@Aspect注解
            this.validate(candidateAspectClass);
            //获取方法上标注的相关注解信息 最终结果看下如图 （1）解析方法上的注解得到的方法的增强类型
            AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
            if (aspectJAnnotation == null) { 
                return null;
            } else if (!this.isAspect(candidateAspectClass)) { 
                throw new AopConfigException("Advice must be declared inside an aspect type: Offending method '" + candidateAdviceMethod + "' in class [" + candidateAspectClass.getName() + "]");
            } else { 
                Object springAdvice;
                //根据注解类型去创建对应的增强类 这里我们就看一下我们的around创建之后是怎么样子的
                //（2）Around的增强类
                switch(aspectJAnnotation.getAnnotationType()) { 
                case AtPointcut:
                    if (this.logger.isDebugEnabled()) { 
                        this.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())) { 
                        ((AbstractAspectJAdvice)springAdvice).setReturningName(afterReturningAnnotation.returning());
                    }
                    break;
                case AtAfterThrowing:
                    springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                    AfterThrowing afterThrowingAnnotation = (AfterThrowing)aspectJAnnotation.getAnnotation();
                    if (StringUtils.hasText(afterThrowingAnnotation.throwing())) { 
                        ((AbstractAspectJAdvice)springAdvice).setThrowingName(afterThrowingAnnotation.throwing());
                    }
                    break;
                default:
                    throw new UnsupportedOperationException("Unsupported advice type on method: " + candidateAdviceMethod);
                }
    			//设置一下切面名字
                ((AbstractAspectJAdvice)springAdvice).setAspectName(aspectName);
                ((AbstractAspectJAdvice)springAdvice).setDeclarationOrder(declarationOrder);
                String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
                if (argNames != null) { 
                    ((AbstractAspectJAdvice)springAdvice).setArgumentNamesFromStringArray(argNames);
                }
    			//6、参数绑定
                ((AbstractAspectJAdvice)springAdvice).calculateArgumentBindings();
                return (Advice)springAdvice;
            }
        }

**（1）解析方法上的注解得到的方法的增强类型**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70 2]  
**（2）Around的增强类**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70 3]  
注意看下上面的**pointcut类里面的一个参数 pointcutExpression**，它就是解析我们的切入点表达式得到的类，目前在创建好增强之后，他还没有解析切入点表达式。

## 6、参数绑定 ##

**最后再来看看shouldSkip**  
如果这个返回true，则说明处理中的bean是aop相关的bean，否则就不是的

判断完之后，会将beanName加入到advisedBeans这个map中，key为beanName，value表示它是否和aop相关。  
如果下面这一块代码没加入到map中，那么在bean实例化之后，执行beanPostProcess的post方法的时候，会将其放入map中。如果这个bean是与aop相关（bean没有标注aop相关的注解，这里的bean是切入点所在的bean），那么则创建一个代理对象，将其加入到map中。

AspectJAwareAdvisorAutoProxyCreator  58  line
    
    protected boolean shouldSkip(Class<?> beanClass, String beanName) { 
    		//很简单 从容器中拿到Advisor.class类型的所有bean 重点！！！
            List<Advisor> candidateAdvisors = this.findCandidateAdvisors();
            Iterator var4 = candidateAdvisors.iterator();
    
            Advisor advisor;
            do { 
                if (!var4.hasNext()) { 
                	//candidateAdvisors为空则使用父类中方法去判断是否需要跳过这一步
                    return super.shouldSkip(beanClass, beanName);
                }
    
                advisor = (Advisor)var4.next();
                //如果循环的advisor不是AspectJPointcutAdvisor类型，并且beanName也不是当前处理的bean 继续循环
            } while(!(advisor instanceof AspectJPointcutAdvisor) || !((AspectJPointcutAdvisor)advisor).getAspectName().equals(beanName));
    
            return true;
        }

来个流程图 简单整理一下思路  
![aop流程图][aop]

[https_blog.csdn.net_qq_41001945_article_details_110875962]: https://blog.csdn.net/qq_41001945/article/details/110875962
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70]: /images/20221119/9dce26d9e15c4de08c5bb6b734d968e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70 1]: /images/20221119/1d0cc71eb0034a3ab64a545aa6548b4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70 2]: /images/20221119/b51d34c7b9064ad9846d80d75e34c9a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70 3]: /images/20221119/5767fb8571f64bfda7df94bf482d7b56.png
[aop]: /images/20221119/6bf0365ebacc4fdb8844883a56f1f169.png