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

前面我们搭建好了一个简单的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）的最后一行代码中，就是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类型。 那么注入的他的作用又是什么呢

首先看下他的继承关系图

从上图可以看到，他是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()

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）解析方法上的注解得到的方法的增强类型

（2）Around的增强类

注意看下上面的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;
    }

来个流程图 简单整理一下思路