前言

了解Spring、Spring IOC/DI、Spring Bean，作者我没有三颗心脏这三篇已经写着很详细了。
Spring学习(1)——快速入门
Spring(2)——Spring IoC 详解
Spring(3)——装配 Spring Bean 详解

ApplicationContext

实例化Bean

Spring用来管理各个Bean，在程序中实例化bean通常会用到下面的代码，有两种方式：
java

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");

web.xml

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
</context-param>
<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

体系结构及流程解析

体系结构流程图

ApplicationContext体系结构图

BeanFactory体系结构图

流程解析

经过断点调试就会知道，ClassPathXmlApplicationContext的初始化最终会指向AbstractApplicationContext的refresh()方法。

    // 完成IoC容器的创建及初始化工作
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // STEP 1： 为context刷新做预处理
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            // * STEP 2：让子类刷新内部beanFactory 
            //      a） 创建IoC容器（DefaultListableBeanFactory--ConfigurableListableBeanFactory 的实现类）
            //      b） 加载解析XML文件（最终存储到Document对象中）
            //      c） 读取Document对象，并完成BeanDefinition的加载和注册工作
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            // STEP 3： 对IoC容器进行一些预处理（设置一些公共属性）
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                // STEP 4： 允许在AbstractApplicationContext的子类中对BeanFactory进行后置处理，postProcessBeanFactory()这个方法是个空实现。
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                // STEP 5： 调用BeanFactoryPostProcessor后置处理器处理BeanFactory实例（BeanDefinition）
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                // STEP 6：
                //      a)  注册BeanPostProcessor后置处理器
                //      b）BeanPostProcessors后置处理器用于拦截bean的创建，对创建后的bean实例进行处理
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                // STEP 7： 初始化一些消息资源
                initMessageSource();

                // Initialize event multicaster for this context.
                // STEP 8： 
                //      a)  初始化应用事件广播器
                //      b)  表明Spring内部基于事件机制
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                // STEP 9： 初始化一些特殊的bean，这个方法是空实现，让AbstractApplicationContext的子类重写
                onRefresh();

                // Check for listener beans and register them.
                // STEP 10： 注册一些监听器（ApplicationListener）
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // * STEP 11： 实例化剩余的单例bean（非懒加载方式）
                // 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                // STEP 12： 完成刷新时，需要发布对应的事件
                finishRefresh();
            }

            catch (BeansException ex) { // 捕获BeansException
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                // 销毁已经创建的单例对象，
                destroyBeans();
               
                // Reset 'active' flag.
                //取消刷新，重置active标识(置为false)
                cancelRefresh(ex);
   
                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                // 重置Spring内核中的常用自检缓存，清空单例bean内缓存
                resetCommonCaches();
            }
        }
    }

创建BeanFactory流程源码分析

// Tell the subclass to refresh the internal bean factory.
// STEP 2：
//      a） 创建IoC容器（DefaultListableBeanFactory）
//      b） 加载解析XML文件（最终存储到Document对象中）
//      c） 读取Document对象，并完成BeanDefinition的加载和注册工作
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

• 进入AbstractApplication的obtainFreshBeanFactory()方法：
  用于创建一个新的IoC容器，这个IoC容器就是DefaultListableBeanFactory对象。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        // 主要是通过该方法完成IoC容器的刷新
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

• 进入AbstractRefreshableApplicationContext的refreshBeanFactory()方法:
  • 销毁以前的容器
  • 创建新的IoC容器
  • 加载BeanDefinition对象注册到IoC容器中

    @Override
    protected final void refreshBeanFactory() throws BeansException {
        // 如果之前有IoC容器，则销毁
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            // 创建IoC容器，也就是DefaultListableBeanFactory
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            // 设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
            customizeBeanFactory(beanFactory);
            // * 调用载入BeanDefinition的方法，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

• 进入AbstractRefreshableApplicationContext的createBeanFactory方法

protected DefaultListableBeanFactory createBeanFactory() {
        return new DefaultListableBeanFactory(getInternalParentBeanFactory());
    }

加载BeanDefinition流程分析

• 进入AbstractXmlApplicationContext的loadBeanDefinitions()方法:
  • 创建一个XmlBeanDefinitionReader，通过阅读XML文件，真正完成BeanDefinition的加载和注册
  • 配置XmlBeanDefinitionReader并进行初始化。
  • 配置XmlBeanDefinitionReader并进行初始化。

    @Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        // 创建一个BeanDefinition阅读器，通过阅读XML文件，真正完成BeanDefinition的加载和注册
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // Allow a subclass to provide custom initialization of the reader,
        // then proceed with actually loading the bean definitions.
        initBeanDefinitionReader(beanDefinitionReader);
    
        // * 委托给BeanDefinition阅读器去加载BeanDefinition
        loadBeanDefinitions(beanDefinitionReader);
    }


protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        // 获取资源的定位
        // 这里getConfigResources是一个空实现，真正实现是调用子类的获取资源定位的方法
        // 比如：ClassPathXmlApplicationContext中进行了实现
        //      而FileSystemXmlApplicationContext没有使用该方法
        Resource[] configResources = getConfigResources();
        if (configResources != null) {
            // XML Bean读取器调用其父类AbstractBeanDefinitionReader读取定位的资源
            reader.loadBeanDefinitions(configResources);
        }
        // 如果子类中获取的资源定位为空，则获取FileSystemXmlApplicationContext构造方法中setConfigLocations方法设置的资源
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
            // XML Bean读取器调用其父类AbstractBeanDefinitionReader读取定位的资源
            reader.loadBeanDefinitions(configLocations);
        }
    }

• loadBeanDefinitions()
  (AbstractBeanDefinitionReader-->XmlBeanDefinitionReader)

    @Override
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        // 将读入的XML资源进行特殊编码处理
        return loadBeanDefinitions(new EncodedResource(resource));
    }

loadBeanDefinitions读取XMl资源进行编码处理,代码有点长，截取重要部分try()里面代码

try {
            // 将资源文件转为InputStream的IO流
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                // 从InputStream中得到XML的解析源
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
                // 这里是具体的读取过程
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }

• loadBeanDefinitions最终来到了XmlBeanDefinitionReader的doLoadBeanDefinitions方法：
  • 一个是对XML文件进行DOM解析
  • 一个是完成BeanDefinition对象的加载与注册

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            // 通过DOM4J加载解析XML文件，最终形成Document对象
            Document doc = doLoadDocument(inputSource, resource);
            // 通过对Document对象的操作，完成BeanDefinition的加载和注册工作
            return registerBeanDefinitions(doc, resource);
        }
        //省略一些catch语句
        catch (Throwable ex) {
            ......
        }
    }

• 这里不去看处理DOM4J加载解析XML的流程
• 进入XmlBeanDefinitionReader的registerBeanDefinitions方法:
  • 创建DefaultBeanDefinitionDocumentReader用来解析Document对象。
  • 获得容器中已注册的BeanDefinition数量
  • 委托给DefaultBeanDefinitionDocumentReader来完成BeanDefinition的加载、注册工作。
  • 统计新注册的BeanDefinition数量

public int  (Document doc, Resource resource) throws BeanDefinitionStoreException {
        // 创建BeanDefinitionDocumentReader来解析Document对象，完成BeanDefinition解析
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        // 获得容器中已经注册的BeanDefinition数量
        int countBefore = getRegistry().getBeanDefinitionCount();
        //解析过程入口，BeanDefinitionDocumentReader只是个接口，具体的实现过程在DefaultBeanDefinitionDocumentReader完成
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        // 统计新的的BeanDefinition数量
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

• 进入DefaultBeanDefinitionDocumentReader的registerBeanDefinitions方法：
  • 获得Document的根元素<beans>标签
  • 真正实现BeanDefinition解析和注册工作

@Override
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        // 获得Document的根元素<beans>标签
        Element root = doc.getDocumentElement();
        // 真正实现BeanDefinition解析和注册工作
        doRegisterBeanDefinitions(root);
    }

• 进入DefaultBeanDefinitionDocumentReader中的doRegisterBeanDefinitions方法：
  • 这里使用了委托模式，将具体的BeanDefinition解析工作交给了BeanDefinitionParserDelegate去完成
  • 在解析Bean定义之前，进行自定义的解析，增强解析过程的可扩展性
  • 委托给BeanDefinitionParserDelegate,从Document的根元素开始进行BeanDefinition的解析
  • 在解析Bean定义之后，进行自定义的解析，增加解析过程的可扩展性

/**
     * Register each bean definition within the given root {@code <beans/>} element.
     */
    protected void doRegisterBeanDefinitions(Element root) {
        
        // 这里使用了委托模式，将具体的BeanDefinition解析工作交给了BeanDefinitionParserDelegate去完成
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);

        // 判断该根标签是否包含http://www.springframework.org/schema/beans默认命名空间
        if (this.delegate.isDefaultNamespace(root)) {
            String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
            if (StringUtils.hasText(profileSpec)) {
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                        profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                "] not matching: " + getReaderContext().getResource());
                    }
                    return;
                }
            }
        }
        // 在解析Bean定义之前，进行自定义的解析，增强解析过程的可扩展性，方法里面都是空实现
        preProcessXml(root);
        // 委托给BeanDefinitionParserDelegate,从Document的根元素开始进行BeanDefinition的解析
        parseBeanDefinitions(root, this.delegate);
        // 在解析Bean定义之后，进行自定义的解析，增加解析过程的可扩展性
        postProcessXml(root);

        this.delegate = parent;
    }

• parseBeanDefinitions()解析文档中跟层次的元素

    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        // 加载的Document对象是否使用了Spring默认的XML命名空间（beans命名空间）
        if (delegate.isDefaultNamespace(root)) {
            // 获取Document对象根元素的所有子节点（bean标签、import标签、alias标签和其他自定义标签context、aop等）
            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;
                    // bean标签、import标签、alias标签，则使用默认解析规则
                    if (delegate.isDefaultNamespace(ele)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {//像context标签、aop标签、tx标签，则使用用户自定义的解析规则解析元素节点
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            // 如果不是默认的命名空间，则使用用户自定义的解析规则解析元素节点
            delegate.parseCustomElement(root);
        }
    }

• parseDefaultElement()自定义标签读取

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        // 解析<import>标签
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
        // 解析<alias>标签
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
        // 解析<bean>标签
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
        // 解析内置<bean>标签
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            // 递归调用
            doRegisterBeanDefinitions(ele);
        }
    }

• processBeanDefinition()解析自定义标签

/**
     * Process the given bean element, parsing the bean definition
     * and registering it with the registry.
     */
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        // 解析<bean>标签，获取BeanDefinition
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            // 如果需要，则装饰BeanDefinition对象
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.
                // 注册最终的BeanDefinition到BeanDefinitionRegistry（DefaultListableBeanFactory）
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to register bean definition with name '" +
                        bdHolder.getBeanName() + "'", ele, ex);
            }
            // Send registration event.
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

• 进入BeanDefinitionParserDelegate中的parseBeanDefinitionElement方法：
  • 获取bean的id和name
  • 通过这个方法实现解析<bean>标签，获取BeanDefinition
  • 将BeanDefinition对象和BeanName封装到BeanDefinitionHolder对象中

@Nullable
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
        // 获取bean的id
        String id = ele.getAttribute(ID_ATTRIBUTE);
        // 获取bean的name
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

        List<String> aliases = new ArrayList<>();
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }

        String beanName = id;
        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
            beanName = aliases.remove(0);
            if (logger.isDebugEnabled()) {
                logger.debug("No XML 'id' specified - using '" + beanName +
                        "' as bean name and " + aliases + " as aliases");
            }
        }

        if (containingBean == null) {
            // 检查bean的id或者name是否唯一
            checkNameUniqueness(beanName, aliases, ele);
        }
        // 解析<bean>标签，获取BeanDefinition对象
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            if (!StringUtils.hasText(beanName)) {
                try {
                    if (containingBean != null) {
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                                beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else {
                        beanName = this.readerContext.generateBeanName(beanDefinition);
                        // Register an alias for the plain bean class name, if still possible,
                        // if the generator returned the class name plus a suffix.
                        // This is expected for Spring 1.2/2.0 backwards compatibility.
                        String beanClassName = beanDefinition.getBeanClassName();
                        if (beanClassName != null &&
                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                            aliases.add(beanClassName);
                        }
                    }
                    if (logger.isDebugEnabled()) {
                        logger.debug("Neither XML 'id' nor 'name' specified - " +
                                "using generated bean name [" + beanName + "]");
                    }
                }
                catch (Exception ex) {
                    error(ex.getMessage(), ele);
                    return null;
                }
            }
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            // 将BeanDefinition对象和BeanName封装到BeanDefinitionHolder对象中
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }

        return null;
    }

• 通过parseBeanDefinitionElement()方法解析bean标签
  通过parseBeanDefinitionAttributes()解析bean标签属性

    /**
     * Parse the bean definition itself, without regard to name or aliases. May return
     * {@code null} if problems occurred during the parsing of the bean definition.
     */
    @Nullable
    public AbstractBeanDefinition parseBeanDefinitionElement(
            Element ele, String beanName, @Nullable BeanDefinition containingBean) {

        this.parseState.push(new BeanEntry(beanName));

        String className = null;
        // 获取bean标签的class属性
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        String parent = null;
        // 获取bean标签的parent属性
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }

        try {
            // 创建BeanDefinition对象GenericBeanDefinition
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
            
            // 解析<bean>标签的属性
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            /** 解析<bean>标签的子标签  --- begin**/
            // 解析<description>标签
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            // 解析<meta>标签
            parseMetaElements(ele, bd);
            // 解析<lookup-method>标签
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            // 解析<replaced-method>标签
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

            // 解析<constructor-arg>标签
            parseConstructorArgElements(ele, bd);
            // 解析<property>标签
            parsePropertyElements(ele, bd);
            // 解析<qualifier>标签
            parseQualifierElements(ele, bd);
            /** 解析<bean>标签的子标签  --- end**/

            bd.setResource(this.readerContext.getResource());
            bd.setSource(extractSource(ele));

            return bd;
        }
        catch (ClassNotFoundException ex) {
            error("Bean class [" + className + "] not found", ele, ex);
        }
        catch (NoClassDefFoundError err) {
            error("Class that bean class [" + className + "] depends on not found", ele, err);
        }
        catch (Throwable ex) {
            error("Unexpected failure during bean definition parsing", ele, ex);
        }
        finally {
            this.parseState.pop();
        }

        return null;
    }

    /**
     * Apply the attributes of the given bean element to the given bean * definition.
     * @param ele bean declaration element
     * @param beanName bean name
     * @param containingBean containing bean definition
     * @return a bean definition initialized according to the bean element attributes
     */
    public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
            @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

        // 解析<bean>标签的singleton属性
        if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
            error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
        }
        // 解析<bean>标签的scope属性
        else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
            bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
        }
        else if (containingBean != null) {
            // Take default from containing bean in case of an inner bean definition.
            bd.setScope(containingBean.getScope());
        }

        // 解析<bean>标签的abstract属性
        if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
            bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
        }
        // 解析<bean>标签的lazy-init属性
        String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
        if (DEFAULT_VALUE.equals(lazyInit)) {
            lazyInit = this.defaults.getLazyInit();
        }
        bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

        // 解析<bean>标签的autowire属性
        String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
        bd.setAutowireMode(getAutowireMode(autowire));

        // 解析<bean>标签的depends-on属性
        if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
            String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
            bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
        }

        // 解析<bean>标签的autowire-candidate属性
        String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
        if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
            String candidatePattern = this.defaults.getAutowireCandidates();
            if (candidatePattern != null) {
                String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
                bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
            }
        }
        else {
            bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
        }

        // 解析<bean>标签的primary属性
        if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
            bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
        }

        // 解析<bean>标签的init-method属性
        if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
            String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
            bd.setInitMethodName(initMethodName);
        }
        else if (this.defaults.getInitMethod() != null) {
            bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }

        // 解析<bean>标签的destroy-method属性
        if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
            String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
            bd.setDestroyMethodName(destroyMethodName);
        }
        else if (this.defaults.getDestroyMethod() != null) {
            bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }

        // 解析<bean>标签的factory-method属性
        if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
            bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
        }
        // 解析<bean>标签的factory-bean属性
        if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
            bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
        }

        return bd;
    }

实例化剩余的单例Bean（非懒加载模式）

finishBeanFactoryInitialization方法解析（STEP 11）

• 进入AbstractApplicationContext中的finishBeanFactoryInitialization()方法，看最后一行

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        // Allow for caching all bean definition metadata, not expecting further changes.
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        // 实例化剩余的单例bean（非懒加载方式）
        // 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
        beanFactory.preInstantiateSingletons();
    }

• 进入DefaultListableBeanFactory中的preInstantiateSingletons()方法：
  • 通过beanName获取bean实例，如果获取到的实例不满足条件就看最后一行getBean(beanName)；
  • 核心代码 getBean(beanName);

@Override
    public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Pre-instantiating singletons in " + this);
        }

        // Iterate over a copy to allow for init methods which in turn register new bean definitions.
        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        // 得到Bean定义名称
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        // 触发所有非懒加载方式的单例bean的创建
        for (String beanName : beanNames) {
        // 遍历得到对应的bean定义信息
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 如果bean不是抽象的，而且是单例的，同时还不是懒加载的，则进行下面的操作
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                // 如果bean是一个工厂bean，则走下面的方法 ，和普通bean区别就是还可以生成bean
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                            ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else { // 普通bean走下面的方法
                    getBean(beanName);
                }
            }
        }

• 进入AbstractBeanFactory通过doGetBean()方法获取Bean的实例
  • 通过getSingleton(beanName)方法去缓存中获取单例Bean（第一次初始化，缓存中不存在）
  • 如果取出来的bean实例是factoryBean的实例，则需要从factoryBean中产生一个Bean对象
  • 根据当前的beanfactory获取父一级的beanFactory,递归查找我们需要的Bean（Bean是早不到的，第一次初始化）
  • 获取实例化Bean的BeanDefinition对象
  • 重要，我们一般是单例Bean，用匿名内部类的写法，创建单例BeanBean

@Override
    public Object getBean(String name) throws BeansException {
        // 获取Bean的实例
        return doGetBean(name, null, null, false);
    }


@SuppressWarnings("unchecked")
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

        // 获取bean名称
        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        // 从缓存中获取单例bean
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) { //如果获取到单例bean，则走下面代码
            if (logger.isDebugEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            // 如果取出来的Bean实例是FactoryBean的Bean实例，则需要从FactoryBean实例中产生一个对象实例。
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {//如果没有获取到单例bean，则走下面代码
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            
            // 如果原型模式的Bean发生循环引用，则直接不处理，抛出异常
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            ////获取父类的beanfactory
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                // 获取要实例化的bean的BeanDefinition对象
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 检查该BeanDefinition对象对应的Bean是否是抽象的
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }

                // Create bean instance.
                // 如果是单例的Bean，请下面的代码
                if (mbd.isSingleton()) {                    //匿名内部类的写法
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            // * 创建单例Bean的主要方法
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            // Explicitly remove instance from singleton cache: It might have been put there
                            // eagerly by the creation process, to allow for circular reference resolution.
                            // Also remove any beans that received a temporary reference to the bean.
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
************省略中间代码
                      return (T) bean;
}

• 通过DefaultSingletonBeanRegistry中的getSingleton()从缓存中获取单例bean

@Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 从一级缓存中获取单例对象
        Object singletonObject = this.singletonObjects.get(beanName);
        // isSingletonCurrentlyInCreation : 
        //      判断当前单例bean是否正在创建中，也就是没有初始化完成
        //      比如A的构造器依赖了B对象所以得先去创建B对象，或者在A的populateBean过程中依赖了B对象，得先去创建B对象
        //      这时的A就是处于创建中的状态。
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                // 从二级缓存中获取单例bean
                singletonObject = this.earlySingletonObjects.get(beanName);
                // allowEarlyReference 
                //      是否允许从singletonFactories中通过getObject拿到对象
                if (singletonObject == null && allowEarlyReference) {
                    // 从三级缓存中获取单例bean
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        // 通过单例工厂获取单例bean
                        singletonObject = singletonFactory.getObject();
                        // 从三级缓存移动到了二级缓存
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

• 分析一下createBean()方法：
  • 处理方法覆盖，也就是方法重写
  • 获取BeanPostProcessor代理对象，beanPostProcessor是可以临时修改bean的，它的优先级高于正常实例化Bean，beanPostProcessor如果能返回就直接返回了
  • 完成Bean的实例化创建doCreateBean()

@Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
省略一些代码**********************
// 处理方法覆盖
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }
}
*********************************
try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            // 获取BeanPostProcessor代理对象
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }

*****
    try {
            // 完成Bean实例的创建（实例化、填充属性、初始化）
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isDebugEnabled()) {
                logger.debug("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
****

doCreateBean完成Bean实例的创建（实例化、填充属性、初始化）

• bean初始化第一步，默认调用无参数构造实例化bean
• bean初始化第二步，填充属性（DI依赖注入发生在此步骤）
• bean初始化第三步，调用初始化方法，完成bean的初始化操作AOP发生在此步骤）

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        // 用BeanWrapper来持有创建出来的Bean对象
        BeanWrapper instanceWrapper = null;
        // 如果是单例的话，则先把缓存中的bean清除
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        // bean初始化第一步：默认调用无参构造实例化Bean
        // 构造参数依赖注入，就是发生在这一步
                // 为了下一步populateBean方法的属性注入做准备
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        // 实例化后的Bean对象
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        // 解决循环依赖的关键步骤
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        // 如果需要提前暴露单例Bean，则将该Bean放入三级缓存中
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // 将刚创建的bean放入三级缓存中singleFactories(key是beanName，value是FactoryBean)
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            // bean初始化第二步：填充属性（DI依赖注入发生在此步骤）
            populateBean(beanName, mbd, instanceWrapper);
            // bean初始化第三步：调用初始化方法，完成bean的初始化操作（AOP发生在此步骤）
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
******************************************
}

属性注入

• 通过AbstractAutowireCapableBeanFactory中populateBean()方法完成

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
/******************省略中间代码***********************/
        // 完成依赖注入
        // PropertyValues pvs：待依赖的属性值集合
        // BeanWrapper bw :实例化后的Bean的包装对象
        if (pvs != null) {
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
}

• 这个有深了....，跟进去applyPropertyValues()方法，将PropertyValue一个一个赋值到一个新的List里面去，起名为deepCopy ，最后setPropertyValue()

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        // Create a deep copy, resolving any references for values.
        List<PropertyValue> deepCopy = new ArrayList<>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {
                deepCopy.add(pv);
            }
            else {
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                boolean convertible = bw.isWritableProperty(propertyName) &&
                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }
                // Possibly store converted value in merged bean definition,
                // in order to avoid re-conversion for every created bean instance.
                if (resolvedValue == originalValue) {
                    if (convertible) {
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                else if (convertible && originalValue instanceof TypedStringValue &&
                        !((TypedStringValue) originalValue).isDynamic() &&
                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));
                }
            }
        }
        if (mpvs != null && !resolveNecessary) {
            mpvs.setConverted();
        }

        // 完成依赖注入
        // Set our (possibly massaged) deep copy.
        try {
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        
}

• 通过AbstractPropertyAccessor中的 setPropertyValues()
  • 遍历前面的deepCopy，每拿到一个PropertyValue，然后再setPropertyValue

@Override
    public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
            throws BeansException {

        List<PropertyAccessException> propertyAccessExceptions = null;
        List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
                ((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
        for (PropertyValue pv : propertyValues) {
            try {
                // This method may throw any BeansException, which won't be caught
                // here, if there is a critical failure such as no matching field.
                // We can attempt to deal only with less serious exceptions.
                
                // 依赖属性注入
                setPropertyValue(pv);
            }
            catch (NotWritablePropertyException ex) {
                if (!ignoreUnknown) {
                    throw ex;
                }
                // Otherwise, just ignore it and continue...
            }
            catch (NullValueInNestedPathException ex) {
                if (!ignoreInvalid) {
                    throw ex;
                }
                // Otherwise, just ignore it and continue...
            }
            catch (PropertyAccessException ex) {
                if (propertyAccessExceptions == null) {
                    propertyAccessExceptions = new LinkedList<>();
                }
                propertyAccessExceptions.add(ex);
            }
        }

• AbstractNestablePropertyAccessor
  执行上面的setPropertyValue方法

    @Override
    public void setPropertyValue(PropertyValue pv) throws BeansException {
        PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
        if (tokens == null) {
            String propertyName = pv.getName();
            AbstractNestablePropertyAccessor nestedPa;
            try {
                nestedPa = getPropertyAccessorForPropertyPath(propertyName);
            }
            catch (NotReadablePropertyException ex) {
                throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Nested property in path '" + propertyName + "' does not exist", ex);
            }
            tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
            if (nestedPa == this) {
                pv.getOriginalPropertyValue().resolvedTokens = tokens;
            }
            // 属性注入
            nestedPa.setPropertyValue(tokens, pv);
        }
        else {
            // 属性注入
            setPropertyValue(tokens, pv);
        }
    }

• 进入 setPropertyValue方法的最后一步

    protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
        // tokens.keys只要不为空，则表示要依赖的属性是集合类型的属性
        if (tokens.keys != null) {
            processKeyedProperty(tokens, pv);
        }
        else { // 设置非集合类型的属性
            processLocalProperty(tokens, pv);
        }
    }

• 进入processLocalProperty()方法
  • 获取属性的处理器PropertyHandler
  • 通过PropertyHandler完成依赖注入

    private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
        // 获取属性处理器
        PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
        if (ph == null || !ph.isWritable()) {
            if (pv.isOptional()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Ignoring optional value for property '" + tokens.actualName +
                            "' - property not found on bean class [" + getRootClass().getName() + "]");
                }
                return;
            }
            else {
                throw createNotWritablePropertyException(tokens.canonicalName);
            }
        }

        Object oldValue = null;
        try {
            // 获取原始的值
            Object originalValue = pv.getValue();
            Object valueToApply = originalValue;
            if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                if (pv.isConverted()) {
                    valueToApply = pv.getConvertedValue();
                }
                else {
                    if (isExtractOldValueForEditor() && ph.isReadable()) {
                        try {
                            oldValue = ph.getValue();
                        }
                        catch (Exception ex) {
                            if (ex instanceof PrivilegedActionException) {
                                ex = ((PrivilegedActionException) ex).getException();
                            }
                            if (logger.isDebugEnabled()) {
                                logger.debug("Could not read previous value of property '" +
                                        this.nestedPath + tokens.canonicalName + "'", ex);
                            }
                        }
                    }
                    valueToApply = convertForProperty(
                            tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
                }
                pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
            }
            // 通过PropertyHandler去完成依赖注入
            ph.setValue(valueToApply);
        }
        catch (TypeMismatchException ex) {
            throw ex;
        }
        catch (InvocationTargetException ex) {
            PropertyChangeEvent propertyChangeEvent = new PropertyChangeEvent(
                    getRootInstance(), this.nestedPath + tokens.canonicalName, oldValue, pv.getValue());
            if (ex.getTargetException() instanceof ClassCastException) {
                throw new TypeMismatchException(propertyChangeEvent, ph.getPropertyType(), ex.getTargetException());
            }
            else {
                Throwable cause = ex.getTargetException();
                if (cause instanceof UndeclaredThrowableException) {
                    // May happen e.g. with Groovy-generated methods
                    cause = cause.getCause();
                }
                throw new MethodInvocationException(propertyChangeEvent, cause);
            }
        }
        catch (Exception ex) {
            PropertyChangeEvent pce = new PropertyChangeEvent(
                    getRootInstance(), this.nestedPath + tokens.canonicalName, oldValue, pv.getValue());
            throw new MethodInvocationException(pce, ex);
        }
    }

• BeanWrapperImpl
  通过属性处理器setValue()完成依赖工作

@Override
        public void setValue(final @Nullable Object value) throws Exception {
            // 使用JDK 内省技术，获取对指定属性的setter方法的获取(writeMethod)
            final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
                    ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
                    this.pd.getWriteMethod());
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    ReflectionUtils.makeAccessible(writeMethod);
                    return null;
                });
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
                            writeMethod.invoke(getWrappedInstance(), value), acc);
                }
                catch (PrivilegedActionException ex) {
                    throw ex.getException();
                }
            }
            else {
                // 通过反射工具类，对setter方法开启暴力破解（私有的方法，我也可以调用）
                ReflectionUtils.makeAccessible(writeMethod);
                // 利用反射技术，去执行对应的setter方法（不一定真正拥有该属性，但是一定要有对应的setter方法）
                writeMethod.invoke(getWrappedInstance(), value);
                // method.invoke(obj,args);
            }
        }

Aware注入

// bean初始化第三步：调用初始化方法，完成bean的初始化操作（AOP发生在此步骤）
exposedObject = initializeBean(beanName, exposedObject, mbd);
}

• AbstractAutowireCapableBeanFactory
  在使用Spring的时候，我们将自己的Bean实现BeanNameAware接口和BeanFactoryAware接口等，依赖容器帮我们注入当前Bean的名称或者Bean工厂。进入上面的initializeBean()方法。
  • 应用BeanPostProcessor的postProcessBeforeInitialization方法在初始化之前被调用
  • 执行初始化方法（先调用InitializingBean的afterPropertiesSet，再调用init-method属性指定的初始化方法）
  • 应用BeanPostProcessor的postProcessAfterInitialization方法(AOP代理对象生成)在初始化之后被调用

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            // 判断beanName是哪个接口的的实现类如果bean是BeanNameAware接口的实现类会调用setBeanName方法、如果bean是BeanClassLoaderAware接口的实现类会调用setBeanClassLoader方法、如果是BeanFactoryAware接口的实现类会调用setBeanFactory方法，注入对应的属性值。
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //应用BeanPostProcessor的postProcessBeforeInitialization方法
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            //执行初始化方法（先调用InitializingBean的afterPropertiesSet，再调用init-method属性指定的初始化方法）
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        if (mbd == null || !mbd.isSynthetic()) {
            //应用BeanPostProcessor的postProcessAfterInitialization方法(AOP代理对象生成)
            // AOP是等着对象创建完毕，在进行增强
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

• 调用初始化方法invokeInitMethods()
  • 判断是否是InitializingBean接口的实现类，如果是县初始化InitializingBean
  • 如果不是则调用InitializingBean接口中的afterPropertiesSet方法
  • 然后再初始化<bean>标签对应的init-method属性中的方法

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {

        boolean isInitializingBean = (bean instanceof InitializingBean);
        // 如果是InitializingBean接口的实现类，则先初始化InitializingBean的实现类
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                // 调用InitializingBean接口的afterPropertiesSet方法
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }

        // 然后再初始化<bean>标签对应的init-method属性中的方法
        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                // 调用自定义的初始化方法
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

• 在initializeBean方法中调用BeanPostProcessor的applyBeanPostProcessorsAfterInitialization方法
  • 在初始化Bean的时候都会调用每一个配置的BeanPostProcessor的方法

@Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

补充：
Spring源码系列：BeanWrapper