1、AOP组件

• Pointcut(切点)：定义哪些连接点会被拦截，描述了匹配规则。
• Advice(通知)：切点上执行的具体操作(Before、After、AfterReturning、Around、AfterThrowing)
• Advisor：切点和通知的组合，将一个切点和一个通知绑定在一起，表示一个完整的切面。
• Aspect(切面)：通常包含多个 Advisor

1.1、PointCut

public interface Pointcut {

    Pointcut TRUE = TruePointcut.INSTANCE;
    
    //匹配目标对象的类
    ClassFilter getClassFilter();

    //确定哪些方法调用应该匹配 Pointcut
    MethodMatcher getMethodMatcher();
}

1.2、Advice

大致接口结构

public interface Advice {
}

public interface AfterAdvice extends Advice {}

public interface AfterReturningAdvice extends AfterAdvice {
    void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}

public interface BeforeAdvice extends Advice {
}

1.3、Advisor

public interface Advisor {
    Advice EMPTY_ADVICE = new Advice() {
    };
    
    //获取通知类型
    Advice getAdvice();

    boolean isPerInstance();
}

2、解析AOP标签、注册AOP BeanDefinition

ApplicationContext context = new GenericXmlApplicationContext("a03.xml");

• 找到ioc流程对aop标签的解析，不熟悉ioc看不懂

aop标签并不在Spring默认命名空间中，我们在顶部声明了xmlns:aop="www.springframework.org/schema/aop

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
        NodeList nl = root.getChildNodes();

        for(int i = 0; i < nl.getLength(); ++i) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element)node;
                //aop标签并不在Spring默认命名空间中
                if (delegate.isDefaultNamespace(ele)) {
                    this.parseDefaultElement(ele, delegate);
                } else {
                    //所以解析aop标签时会来这里(见下图)
                    delegate.parseCustomElement(ele);
                }
            }
        }
    } else {
        delegate.parseCustomElement(root);
    }

}

（aop标签的节点)

@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    // 获取命名空间
    String namespaceUri = this.getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    } else {
        // 初始化aop命名空间的各种解析器并返回
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {
            this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        } else {
            //解析
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
        }
    }
}

@Nullable
public NamespaceHandler resolve(String namespaceUri) {
    Map<String, Object> handlerMappings = this.getHandlerMappings();
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    } else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler)handlerOrClassName;
    } else {
        String className = (String)handlerOrClassName;

        try {
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri + "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
            } else {
                NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
                
                //这一步比较关键，初始化Aop的各种解析器
                //认识一下Aop的各种解析器
                namespaceHandler.init();
                
                //将aop的解析器放进map中，key是aop的命名空间
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
        } catch (ClassNotFoundException var7) {
            throw new FatalBeanException("Could not find NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]", var7);
        } catch (LinkageError var8) {
            throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]", var8);
        }
    }
}

public class AopNamespaceHandler extends NamespaceHandlerSupport {
    public AopNamespaceHandler() {
    }

    public void init() {
        //用于解析 `<aop:config>` 标签
        this.registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        
        //用于解析 `<aop:aspectj-autoproxy>`
        this.registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        
        //用于处理 `<aop:scoped-proxy>` 标签。
        this.registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
        
        //用于解析 `<aop:spring-configured>` 标签。
        this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }
}

@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 获取不同标签的解析器
    // 比如<aop:config>标签要获取对应的解析器
    BeanDefinitionParser parser = this.findParserForElement(element, parserContext);
    
    //解析
    return parser != null ? parser.parse(element, parserContext) : null;
}

public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 用于包装<aop:config>元素
    CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
    
    //放入解析器上下文
    parserContext.pushContainingComponent(compositeDef);
    
    //配置代理对象创建器，我们先看这里
    //AspectjAwareAdvisorAutoProxyCreator
    this.configureAutoProxyCreator(parserContext, element);
    
    //获得子标签列表、<aop:aspect>
    List<Element> childElts = DomUtils.getChildElements(element);
    Iterator var5 = childElts.iterator();

    //可能有多个aspect
    while(var5.hasNext()) {
        Element elt = (Element)var5.next();
        
        //获得标签名称
        String localName = parserContext.getDelegate().getLocalName(elt);
        if ("pointcut".equals(localName)) {
            this.parsePointcut(elt, parserContext);
        } else if ("advisor".equals(localName)) {
            this.parseAdvisor(elt, parserContext);
        } else if ("aspect".equals(localName)) {
            //解析aspect标签
            this.parseAspect(elt, parserContext);
        }
    }

    parserContext.popAndRegisterContainingComponent();
    return null;
}

public static void registerAspectJAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {
    // 注册 AspectJ 自动代理创建器。
    // 将 AspectJAutoProxyCreator 的 Bean 定义注册到 BeanDefinitionRegistry 中。
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    
    // 没有指定则使用CGLIB代理，或者使用JDK代理
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    
    // 注册到spring的bean工厂中，再次校验是否已注册
    registerComponentIfNecessary(beanDefinition, parserContext);
}

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    // 如果已经注册过
    if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
        BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }

        return null;
    } else {
        // 没有注册过
        //cls是指定的类类型， `AspectJAwareAdvisorAutoProxyCreator`
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        
        // order最小，优先级最高
        // 这个代理创建器Bean一会儿会第一个实例化
        beanDefinition.getPropertyValues().add("order", Integer.MIN_VALUE);
        beanDefinition.setRole(2);
        
       //将该 BeanDefinition 注册到 BeanDefinitionMap,key为类名，value为BeanDefinition
        registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
        return beanDefinition;
    }
}

// 正式注册
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

private void parseAspect(Element aspectElement, ParserContext parserContext) {
    //aop id属性
    String aspectId = aspectElement.getAttribute("id");
    
    //aop ref属性，表示切面
    String aspectName = aspectElement.getAttribute("ref");

    try {
        this.parseState.push(new AspectEntry(aspectId, aspectName));
        List<BeanDefinition> beanDefinitions = new ArrayList();
        List<BeanReference> beanReferences = new ArrayList();
        List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, "declare-parents");

        for(int i = 0; i < declareParents.size(); ++i) {
            Element declareParentsElement = (Element)declareParents.get(i);
            beanDefinitions.add(this.parseDeclareParents(declareParentsElement, parserContext));
        }
        
        // 解析advice节点
        NodeList nodeList = aspectElement.getChildNodes();
        boolean adviceFoundAlready = false;

        for(int i = 0; i < nodeList.getLength(); ++i) {
            Node node = nodeList.item(i);
            // 校验aop:aspect必须有ref属性，否则无法对切入点进行观察操作
            if (this.isAdviceNode(node, parserContext)) {
                if (!adviceFoundAlready) {
                    adviceFoundAlready = true;
                    if (!StringUtils.hasText(aspectName)) {
                        parserContext.getReaderContext().error("<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.", aspectElement, this.parseState.snapshot());
                        return;
                    }

                    beanReferences.add(new RuntimeBeanReference(aspectName));
                }
                // 解析advice节点并注册到bean工厂中
                AbstractBeanDefinition advisorDefinition = this.parseAdvice(aspectName, i, aspectElement, (Element)node, parserContext, beanDefinitions, beanReferences);
                beanDefinitions.add(advisorDefinition);
            }
        }

        AspectComponentDefinition aspectComponentDefinition = this.createAspectComponentDefinition(aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
        parserContext.pushContainingComponent(aspectComponentDefinition);
        List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, "pointcut");
        Iterator var21 = pointcuts.iterator();
        
        //解析pointcut节点并注册到bean工厂
        while(var21.hasNext()) {
            Element pointcutElement = (Element)var21.next();
            this.parsePointcut(pointcutElement, parserContext);
        }

        parserContext.popAndRegisterContainingComponent();
    } finally {
        this.parseState.pop();
    }
}

3、创建Advisor对象

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("Creating instance of bean '" + beanName + "'");
    }

    RootBeanDefinition mbdToUse = mbd;
    Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    try {
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var9) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
    }

    Object beanInstance;
    try {
        // 在这里返回代理对象
        beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        if (beanInstance != null) {
            return beanInstance;
        }
    } catch (Throwable var10) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
    }

    try {
        beanInstance = this.doCreateBean(beanName, mbdToUse, args);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Finished creating instance of bean '" + beanName + "'");
        }

        return beanInstance;
    } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
        throw var7;
    } catch (Throwable var8) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
    }
}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    
    // 如果beforeInstantiationResolved值为null或者true，那么表示尚未被处理
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        //mbd.isSynthetic(): 检查mbd是否是合成的
        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;
    }

    return bean;
}

@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {

    // 获取BeanPostProcessors所有实现类，调用其postProcessBeforeInstantiation
    // 主要是AspectJAwareAdvisorAutoProxyCreator的调用
    Iterator var3 = this.getBeanPostProcessorCache().instantiationAware.iterator();

    Object result;
    do {
        if (!var3.hasNext()) {
            return null;
        }
        
        //迭代
        InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var3.next();
        
        //调用其postProcessBeforeInstantiation方法
        result = bp.postProcessBeforeInstantiation(beanClass, beanName);
    } while(result == null);

    return result;
}

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    Object cacheKey = this.getCacheKey(beanClass, beanName);
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        // 检查是否处理过了，不管是否是需要增强的，处理过了就放入map
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        
        // 检查beanClass类型、是否应该跳过
        // 这个shoudSkip是关键方法(为什么要起这种容易忽视的名字)
        // shuoldSkip中会完成Advisor的实例化
        if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
            // 正常不会进入这里，是判一些没必要的行为进入且跳过
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }

        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    } else {
        return null;
    }
}

protected boolean isInfrastructureClass(Class<?> beanClass) {
    //如果是Advice、PointCut、Advisor、AopInfrastructureBean则返回true
    boolean retVal = Advice.class.isAssignableFrom(beanClass) || Pointcut.class.isAssignableFrom(beanClass) || Advisor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass);
    if (retVal && this.logger.isTraceEnabled()) {
        this.logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
    }

    return retVal;
}

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    // 获取所有的Advisor
    List<Advisor> candidateAdvisors = this.findCandidateAdvisors();
    Iterator var4 = candidateAdvisors.iterator();

    Advisor advisor;
    do {
        if (!var4.hasNext()) {
            return super.shouldSkip(beanClass, beanName);
        }

        advisor = (Advisor)var4.next();
    } while(!(advisor instanceof AspectJPointcutAdvisor) || !((AspectJPointcutAdvisor)advisor).getAspectName().equals(beanName));

    return true;
}

public List<Advisor> findAdvisorBeans() {
    String[] advisorNames = this.cachedAdvisorBeanNames;
    if (advisorNames == null) {
        // 获取所有的advisorName
        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
        this.cachedAdvisorBeanNames = advisorNames;
    }

    if (advisorNames.length == 0) {
        return new ArrayList();
    } else {
        List<Advisor> advisors = new ArrayList();
        String[] var3 = advisorNames;
        int var4 = advisorNames.length;
        
        // 迭代处理每个Advisor
        for(int var5 = 0; var5 < var4; ++var5) {
            String name = var3[var5];
            if (this.isEligibleBean(name)) {
                
                // 判断是不是正在创建
                if (this.beanFactory.isCurrentlyInCreation(name)) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Skipping currently created advisor '" + name + "'");
                    }
                } else {
                    try {
                    
                        // 通过getBean实例化每个Advisor，并放入advisors
                        // 这里debug非常困难，算是进入递归了
                        // 一方面是有很多不必要的行为，一方面是Advisor中的pointCut和advice也要实例化
                        advisors.add(this.beanFactory.getBean(name, Advisor.class));
                    } catch (BeanCreationException var11) {
                        Throwable rootCause = var11.getMostSpecificCause();
                        if (rootCause instanceof BeanCurrentlyInCreationException) {
                            BeanCreationException bce = (BeanCreationException)rootCause;
                            String bceBeanName = bce.getBeanName();
                            if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                                if (logger.isTraceEnabled()) {
                                    logger.trace("Skipping advisor '" + name + "' with dependency on currently created bean: " + var11.getMessage());
                                }
                                continue;
                            }
                        }

                        throw var11;
                    }
                }
            }
        }
        
        // 返回advisors
        return advisors;
    }
}

4、创建代理对象

• advisor创建完成了，我们回到之前的方法

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = this.determineTargetType(beanName, mbd);
            if (targetType != null) {
                
                // 我们从这里出来了
                bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                
                // 正常创建了advisors，返回null
                if (bean != null) {
                    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }

        mbd.beforeInstantiationResolved = bean != null;
    }
    
    //return null
    return bean;
}

// 然后会debug到这里
if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;

    Object current;
    // 遍历该工厂创建的bean的BeanPostProcessors
    for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
        // 调用postProcessAfterInitialization来对现有的bean实例进行包装
        // 某一次会调用到关键BeanPostProcessor
        BeanPostProcessor processor = (BeanPostProcessor)var4.next();
        current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
    }

    return result;
}

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 获取当前bean的key,beanName为空则已bean.class为key
        Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
        
        // 判断当前Bean是否正在被代理，如果已经被代理不需要包装
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 走到这的是还没被代理的
            return this.wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    
    return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    //targetSourcedBeans 集合存储被代理过的 bean 的名称，如果已经存在就不代理了
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    //值为false说明不需要被代理
    } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
    
        //获取当前的Advice和Advisors的Bean
        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
        
        // 没有被代理过
        if (specificInterceptors != DO_NOT_PROXY) {
            
            //advisorBeans 值为TRUE，表示该Bean已经被代理
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            
            // 终于要生成代理对象了
            // 根据获取到的Advice和Advisors为Bean生成代理对象
            Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            
            // 缓存代理对象类型
            this.proxyTypes.put(cacheKey, proxy.getClass());
            
            // 返回代理对象
            return proxy;
        } else {
        
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    } else {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
}

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();
    
    // 把代理创建器copy到代理工厂
    proxyFactory.copyFrom(this);
    
    // 代理类而非接口
    // 判断使用cglib还是jdk代理
    if (proxyFactory.isProxyTargetClass()) {

        if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
            Class[] var6 = beanClass.getInterfaces();
            int var7 = var6.length;

            for(int var8 = 0; var8 < var7; ++var8) {
                Class<?> ifc = var6[var8];

                proxyFactory.addInterface(ifc);
            }
        }
    } else if (this.shouldProxyTargetClass(beanClass, beanName)) {
        proxyFactory.setProxyTargetClass(true);
    } else {
        // 代理接口
        this.evaluateProxyInterfaces(beanClass, proxyFactory);
    }
    
    // 构建增强器
    Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);
    
    // 设置到要代理的类
    proxyFactory.setTargetSource(targetSource);
    this.customizeProxyFactory(proxyFactory);
    proxyFactory.setFrozen(this.freezeProxy);
    if (this.advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    ClassLoader classLoader = this.getProxyClassLoader();
    if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
        classLoader = ((SmartClassLoader)classLoader).getOriginalClassLoader();
    }
    
    // 创建代理对象
    return proxyFactory.getProxy(classLoader);
}

• 代理对象终于是被创建出来了