spring源码-5-aop动态代理

aop的核心整个流程

1.AbstractAutoProxyCreator #postProcessAfterInitialization:初始化前的操作

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            //beanName !=null 或有值 return &beanName 否则return beanClass
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                //对bean进行包装
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

2.AbstractAutoProxyCreator #wrapIfNecessary:如果需要则包装bean（代理）

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //已经增强过了
        if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        //不需要增强
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //是否是aop类组成类 advice  Pointcut  Advisor AopInfrastructureBean
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        //获取advices 和 advisor
        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;
    }

2.1.AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors 查询所有的增强方法

@Override
    protected List<Advisor> findCandidateAdvisors() {
        // Add all the Spring advisors found according to superclass rules.
        //获取父类的aop组件
        List<Advisor> advisors = super.findCandidateAdvisors();
        // Build Advisors for all AspectJ aspects in the bean factory.
        //提取所有通知方法
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }

2.2.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 LinkedList<>();
                    aspectNames = new LinkedList<>();
                    // 获取所有的beanName
                    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                            this.beanFactory, Object.class, true, false);
                    for (String beanName : beanNames) {
                        if (!isEligibleBean(beanName)) {  //判断beanName是否合法
                            continue;
                        }
                        // We must be careful not to instantiate beans eagerly as in this case they
                        // would be cached by the Spring container but would not have been weaved.
                        Class<?> beanType = this.beanFactory.getType(beanName);  //获取Class类型
                        if (beanType == null) {
                            continue;
                        }
                        //是否存在 @aspect注解  (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
                        if (this.advisorFactory.isAspect(beanType)) {
                            aspectNames.add(beanName);
                            AspectMetadata amd = new AspectMetadata(beanType, beanName);
                            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                                MetadataAwareAspectInstanceFactory factory =
                                        new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                //获取 advisors 通知
                                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                                if (this.beanFactory.isSingleton(beanName)) { //是否单例
                                    this.advisorsCache.put(beanName, classAdvisors);
                                }
                                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)); //提取所有的aspect方法
                            }
                        }
                    }
                    this.aspectBeanNames = aspectNames;
                    return advisors;
                }
            }
        }

        if (aspectNames.isEmpty()) {
            return Collections.emptyList();
        }
        List<Advisor> advisors = new LinkedList<>();
        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;
    }

2.3AbstractAutoProxyCreator#createProxy 创建代理

protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) { //beanFactory 配置清单
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
        ProxyFactory proxyFactory = new ProxyFactory();
        //获取当前类有关属性 并填充到proxyFactory中
        proxyFactory.copyFrom(this);
        //是否和代理接口一样代理目标类
        if (!proxyFactory.isProxyTargetClass()) {
            //使用目标类代理而非接口代理
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                //接口代理
                //hasReasonableProxyInterface 有合法的接口 则接口代理
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
        //确定该beanName 的增强方法
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            // 加入增强器
            proxyFactory.addAdvisor(advisor);
        }
        //设置要代理的类
        proxyFactory.setTargetSource(targetSource);
        //可以实现此方法  自定义代理
        customizeProxyFactory(proxyFactory);
        //代理被配置后，不能修改代理的配置 缺省值为false
        proxyFactory.setFrozen(this.freezeProxy);
        // 过滤 拦截链
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
        return proxyFactory.getProxy(getProxyClassLoader());  //代理
    }