Spring5深度源碼分析(三)之AnnotationConfigApplicationContext啓動原理分析

時間 2019-12-05

標籤 spring5 spring 深度源碼分析 annotationconfigapplicationcontext 啓動原理欄目 Spring 简体版

原文原文鏈接

代碼地址：https://github.com/showkawa/spring-annotation/tree/master/src/main/java/com/brian

AnnotationConfigApplicationContext啓動原理分析主要分析下面三點html

1.@Qualifier與@Primary註解的使用
2.BeanFactory與ApplicationContext區別
3.AnnotationConfigApplicationContext啓動原理分析java

1.@Qualifier與@Primary註解的使用

下面是 @Qualifier 和 @Primary註解的官方解釋git

@Qualifier

This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring. It may also be used to annotate other custom annotations that can then in turn be used as qualifiers.這個註釋可用於做爲預備bean的字段或參數，也能夠用在其餘的自定義註釋下 @Qualifier(「XXX」) Spring的Bean注入配置註解，該註解指定注入的Bean的名稱，Spring框架使用byName方式尋找合格的bean，這樣就消除了byType方式產生的歧義。github

　　qualifer字面意思合格者，通常狀況下：代碼裏面須要注入其餘依賴，通常用@Reource（默認按名稱裝配，當找不到與名稱匹配的bean纔會按類型裝配和@Autowired（默認按類型裝配，若是咱們想使用按名稱裝配，能夠結合@Qualifier註解一塊兒使用）web

@Primary

Indicates that a bean should be given preference when multiple candidates are qualified to autowire a single-valued dependency. If exactly one ‘primary’ bean exists among the candidates, it will be the autowired value. This annotation is semantically equivalent to the {@code} element’s {@code primary} attribute 不難看出若是用primary註解其中一個bean就要優先於其餘的Bean，固然這個對於這種三方jar包最好不要添加的，誰知道它會不會後期又出什麼幺蛾子，只能改本身的代碼了最後的方案是改爲@qualifiel（「getMetricRegistry」），選取了其中一個bean注入spring

primary字面意思最主要者，若是是有配置過多數據源，那必定會熟悉這個註解數組

1.1 @Qualifier的使用

咱們這裏定義一個BookService接口緩存

public interface BookService {

    void printBook();

}

兩個實現類BookServiceImpl和OtherBookServiceImpl實現BookService接口的printBook()方法數據結構

@Service
public class BookServiceImpl implements BookService {
    @Override
    public void printBook() {
        System.out.println("---BookServiceImpl---: spring5源碼分析");
    }
}

@Service
public class OtherBookServiceImpl implements BookService {
    @Override
    public void printBook() {
        System.out.println("---OtherBookServiceImpl---: 天道酬勤，一步一個坑");
    }
}

咱們在BookController注入BooKService併發

@Controller
public class BookController {

    @Autowiredprivate BookService bookService;

    private void printBook() {
        bookService.printBook();
    }

}

附上配置類MainConfig

@Configuration //告訴spring這是一個配置類
/*
* @ComponentScan
*   value:只當於掃描的的包
*   excludeFilters = 指定掃描的時候按照什麼規則排除哪些組件
*   includeFilters = 指定掃描的時候只須要包含哪些組件
*   Filter.ANNOTATION:按照註解
*   Filter.ASSIGNABLE_TYPE: 按照給定的類型
* */

//@ComponentScans(value = {
//        @ComponentScan(value = "com.brian",includeFilters = {
//                @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class}),
//                @ComponentScan.Filter(type=FilterType.ASSIGNABLE_TYPE,classes = {BookService.class}),
//                @ComponentScan.Filter(type = FilterType.CUSTOM,classes = {BrianTypeFilter.class})
//        },useDefaultFilters = false)
//})
@ComponentScan({"com.brian.service", "com.brian.controller"})
//@Import({Brian.class,Alan.class})
@Import({BrianSelector.class})
public class MainConfig {

    @Bean("person") //給容器中註冊一個Bean;類型爲返回值的類型；id默認是方法名做爲id
    public Person person(){
        return new Person("Alan",18);
    }


    /*
    * @Conditional() 按照條件註冊
    *
    * */
    @Conditional({BrianCondition.class})
    @Bean("person01")
    public Person person01() {
        return new Person("Brian",17);
    }

    @Conditional({BrianCondition.class})
    @Bean("person02")
    public Person person02() {
        return new Person("wenTao",19);
    }

    /*
    *
    *給容器中註冊組件
    * 1，包掃描+ 組件標註註解（@Controller/@Service/@Repository/@Component）[本身寫的方法]
    * 2， @Bean [導入的第三方包裏面的組件]
    * 3，@Import [快速的給容器導入一個組件]
    *       1.@Import(要導入的組件class)
    *       2.ImportSelector：返回須要導入的組件的全類名數組
    *       3.ImportBeanDefinitionRegistrar: 手動註冊bean到容器
    *  4. 使用Spring提供的FactoryBean
    * */
    @Bean
    public BrianBeanFactory brianBeanFactory() {
        return new BrianBeanFactory();
    }

}

在測試類MainTest類中測試該printBook()方法

public class MainTest {
    public static void main(String[] args) {
         ApplicationContext mainConfig =
                 new AnnotationConfigApplicationContext(MainConfig.class);

        System.out.println("MainConfig容器建立成功");

        BookController bookController = mainConfig.getBean(BookController.class);
        try {
            Method printBook = bookController.getClass().getDeclaredMethod("printBook");
            printBook.setAccessible(true);
            printBook.invoke(bookController);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
//         Alan alan1 =  acac.getBean(Alan.class);
//        System.out.println("--ALAN--:" + alan1);
        // Alan alan2 =  acac.getBean(Alan.class);
        //System.out.println("比較兩個Alan實例: " + (alan1 == alan2));

//        Person person1 = (Person) acac.getBean("person01");
//        System.out.println("---main---test---person1---: " + person1.toString());
//        Person person2 = (Person) acac.getBean("person02");
//        System.out.println("---main---test---person2---: " + person2.toString());


       // MathCalculator mathCalculator = (MathCalculator) acac.getBean("mathCalculator");
       // System.out.println("----get--mathCalculator---: " + mathCalculator);

//        BrianBeanFactory beanFactory = acac.getBean(BrianBeanFactory.class);
//        WenTao wentao = null;
//        try {
//            wentao = beanFactory.getObject();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        System.out.println("----get--WenTao---: " + wentao);


        //關閉ioc容器
        ((AnnotationConfigApplicationContext) mainConfig).close();
    }
}

看到有報錯No qualifying bean of type 'com.brian.service.BookService' available: expected single matching bean but found 2: bookServiceImpl,otherBookServiceImpl，就是由於默認按類型裝配

OK,此時我在BookController注入BookSevice的時候加上@Qualifier指定beanName,再次測試

@Controller
public class BookController {

    @Autowired
    @Qualifier("bookServiceImpl")
    private BookService bookService;

    private void printBook() {
        bookService.printBook();
    }

}

1.2 @Primary的使用

繼續返回到上面的報錯時候的場景，由於此時BookService有兩個實現類，此時我在OtherBookServiceImpl類上加上@Primary註解，再次測試

@Service
@Primary
public class OtherBookServiceImpl implements BookService {
    @Override
    public void printBook() {
        System.out.println("---OtherBookServiceImpl---: 天道酬勤，一步一個坑");
    }
}

這裏順便總結下經常使用的註解：

@Configuration把一個類做爲一個IoC容器，它的某個方法頭上若是註冊了@Bean，就會做爲這個Spring容器中的Bean。 @Scope註解做用域 @Lazy(true) 表示延遲初始化 @Service用於標註業務層組件、 @Controller用於標註控制層組件 @Repository用於標註數據訪問組件，即DAO組件。 @Component泛指組件，當組件很差歸類的時候，咱們可使用這個註解進行標註。 @Scope用於指定scope做用域的（用在類上） @PostConstruct用於指定初始化方法（用在方法上） @PreDestory用於指定銷燬方法（用在方法上） @Resource 默認按名稱裝配，當找不到與名稱匹配的bean纔會按類型裝配。 @DependsOn：定義Bean初始化及銷燬時的順序 @Primary：自動裝配時當出現多個Bean候選者時，被註解爲@Primary的Bean將做爲首選者，不然將拋出異常 @Autowired 默認按類型裝配，若是咱們想使用按名稱裝配，能夠結合@Qualifier註解一塊兒使用 @Autowired @Qualifier("OtherBookServiceImpl") 存在多個實例配合使用

2.BeanFactory與ApplicationContext區別

以前的源碼分析有見過BeanFactory和FactoryBean接口的區別，FactoryBean是建立bean對象，而BeanFactory是獲取對象。但ApplicationContext也能夠獲取對象，我上面的測試類getBean()方法就是的。一樣均可以獲取bean對象BeanFactory與ApplicationContext有什麼區別？

 1. BeanFactory負責讀取bean配置文檔，管理bean的加載，實例化，維護bean之間的依賴關係，負責bean的聲明週期。

 2. ApplicationContext除了提供上述BeanFactory所能提供的功能以外，還提供了更完整的框架功能：
     a. 國際化支持
     b. 資源訪問：Resource rs = ctx. getResource(「classpath:config.properties」), 「file:E:/config.properties」
     c. 事件傳遞：經過實現ApplicationContextAware接口

 3. 經常使用的獲取ApplicationContext的方法：
　　　AnnotationConfigApplicationContext  從@Configuration配置類建立容器
     FileSystemXmlApplicationContext：從【文件系統】 或者 【classpath的xml配置文件】 建立，參數爲配置文件名或文件名數組
     ClassPathXmlApplicationContext：從【classpath的xml配置文件】建立，能夠從【jar包】中讀取配置文件
     WebApplicationContextUtils：從web應用的根目錄讀取配置文件，須要先在web.xml中配置，能夠配置監聽器或者servlet來實現

Spring的IoC容器就是一個實現了BeanFactory接口的可實例化類。事實上， Spring提供了兩種不一樣的容器：一種是最基本的BeanFactory，另外一種是擴展的ApplicationContext。

BeanFactory 僅提供了最基本的依賴注入支持，而 ApplicationContext 則擴展了BeanFactory ,提供了更多的額外功能。

ApplicationContext的初始化和BeanFactory有一個重大的區別:

BeanFactory在初始化容器時 並未實例化Bean, 直到第一次訪問 某個Bean時才實例目標Bean;而ApplicationContext則在初始化應用上下文時就實例化全部的單實例的Bean。
所以ApplicationContext的初始化時間會比BeanFactory稍長一些.

3.AnnotationConfigApplicationContext啓動原理分析

從AnnotationConfigApplicationContext的類圖中能夠看出：

AnnotationConfigApplicationContext繼承GenericApplicationContext這個通用應用上下文，GenericApplicationContext內部定義了一個DefaultListableBeanFactory實例，
GenericApplicationContext實現了BeanDefinitionRegistry接口，因此能夠經過AnnotationConfigApplicationContext實例註冊beanDefinition，而後調用refresh()方法來初始化上下文。

AnnotationConfigApplicationContext繼承AbstractApplicationContext，AbstractApplicationContext提供了ApplicationContext的抽象實現。

我這邊就從MainTest這個測試類開始AnnotationConfigApplicationContext啓動原理分析：

MainTest測試類：

public class MainTest {
    public static void main(String[] args) {
　　　　　 // 1.讀取配置類建立IOC容器　　
         ApplicationContext mainConfig =
                 new AnnotationConfigApplicationContext(MainConfig.class);

        System.out.println("MainConfig容器建立成功");

        BookController bookController = mainConfig.getBean(BookController.class);
        try {
            Method printBook = bookController.getClass().getDeclaredMethod("printBook");
            printBook.setAccessible(true);
            printBook.invoke(bookController);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }//關閉ioc容器
        ((AnnotationConfigApplicationContext) mainConfig).close();
    }
}

AnnotationConfigApplicationContext點進去，我這邊後面的源碼都會附帶官方註釋的翻譯

　　　/**
　　　　*建立一個新的AnnotationConfigApplicationContext，派生bean定義
　　　　*來自給定的帶註釋的類並自動刷新上下文。
　　　　* @param annotatedClasses一個或多個帶註釋的類，
　　　　*例如 {@link Configuration @Configuration}類
　　　　*/

　　　　public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
　　　　　　//1. 初始化bean讀取器和掃描器;
　　　　　　/** 調用父類GenericApplicationContext無參構造函數，初始化一個BeanFactory: this.beanFactory = new DefaultListableBeanFactory()*/
　　　　　　this();
　　　　　　// 2.註冊bean配置類
　　　　　　register(annotatedClasses);
　　　　　　// 3.刷新上下文
　　　　　　refresh(); 　

　　　　}

如今咱們點進去this()這個方法；

　　　/**
      *建立一個須要填充的新AnnotationConfigApplicationContext
      *經過{@link #register}調用，而後手動{@linkplain #refresh刷新}。
    　*/

    public AnnotationConfigApplicationContext() {
　　　　　//在IOC容器中初始化註解bean讀取器AnnotatedBeanDefinitionReader
        this.reader = new AnnotatedBeanDefinitionReader(this);
　　　　 //在IOC容器中初始化按類路徑掃描註解bean的掃描器
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

this()方法在調用自身的無參構造方法時會先走父類GenericApplicationContext的無參構造方法

/**
      *建立一個新的GenericApplicationContext。
      * @see #registerBeanDefinition
      * @see #refresh
     */

    public GenericApplicationContext() {
　　　　　//初始化一個BeanFactory
        this.beanFactory = new DefaultListableBeanFactory();
    }

如今咱們再點進去看下register(annotatedClasses)這個方法,直接調用AnnotatedBeanDefinitionReader的register方法

/**
*註冊一個或多個要處理的註釋類。
* <p>對{@code register}的調用是冪等的; 添加相同的
*註釋類不止一次沒有額外的效果。
* @param annotatedClasses一個或多個帶註釋的類，
*例如 {@link Configuration @Configuration}類
*/
public void register(Class<?>... annotatedClasses) {
    for (Class<?> annotatedClass : annotatedClasses) {
        registerBean(annotatedClass);
    }
}


/**
*從給定的bean類註冊bean，從中派生元數據
*類聲明的註釋。
* @param annotatedClass bean的類
*/
public void registerBean(Class<?> annotatedClass) {
    doRegisterBean(annotatedClass, null, null, null);
}



/**
*從給定的bean類註冊bean，從中派生元數據
*類聲明的註釋。
* @param annotatedClass bean的類
* @param instanceSupplier用於建立bean實例的回調
*（多是{@code null}）
* @param命名bean的顯式名稱
* @param限定符特定限定符註釋要考慮，若是有的話，
*除了bean類級別的限定符
* @param definition定製一個或多個用於自定義的回調
*工廠的{@link BeanDefinition}，例如 設置lazy-init或主標誌
* @since 5.0
*/
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
        @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
　　 /** 將Bean配置類信息轉成容器中AnnotatedGenericBeanDefinition數據結構,
　　　*  AnnotatedGenericBeanDefinition繼承自BeanDefinition做用是定義一個bean的數據結構，
　　  * 下面的getMetadata能夠獲取到該bean上的註解信息 */
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);

    //@Conditional裝配條件判斷是否須要跳過註冊
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }
　　
　　 //設置回調 @param instanceSupplier 用於建立bean實例的回調
    abd.setInstanceSupplier(instanceSupplier);

    //解析bean做用域(單例或者原型)，若是有@Scope註解，則解析@Scope，沒有則默認爲singleton 
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);

    //做用域寫回BeanDefinition數據結構, abd中缺損的狀況下爲空，將默認值singleton從新賦值到abd
    abd.setScope(scopeMetadata.getScopeName());

　　 //生成bean配置類beanName
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

　　 //通用註解解析到abd結構中，主要是處理Lazy, primary DependsOn, Role ,Description這五個註解
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

    // @Qualifier特殊限定符處理，@param  qualifiers 除了bean類級別的限定符以外，要考慮的限定符特定限定符註釋（若是有）
    if (qualifiers != null) {
        for (Class<? extends Annotation> qualifier : qualifiers) {
            if (Primary.class == qualifier) {
　　　　　　　　　　// 若是配置@Primary註解，則設置當前Bean爲自動裝配autowire時首選bean
                abd.setPrimary(true);
            }
            else if (Lazy.class == qualifier) {
　　　　　　　　　　//設置當前bean爲延遲加載
                abd.setLazyInit(true);
            }
            else {
　　　　　　　　　　//其餘註解，則添加到abd結構中
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }

　　 /**自定義bean註冊，一般用在applicationContext建立後，手動向容器中一lambda表達式的方式註冊bean,
　　 * 好比：applicationContext.registerBean(BookService.class, () -> new BookService()); */

for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
　　　　　//自定義bean添加到BeanDefinition
        customizer.customize(abd);
    }

　　 //根據beanName和bean定義信息封裝一個beanhold,heanhold其實就是一個 beanname和BeanDefinition的映射
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

　　 //建立代理對象
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

　　 /** BeanDefinitionReaderUtils.registerBeanDefinition 內部經過
     *  DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
　　  *  按名稱將bean定義信息註冊到容器中，實際上DefaultListableBeanFactory內部維護一個Map<String, BeanDefinition>類型變量beanDefinitionMap，
     *  用於保存注bean定義信息（beanname 和 beandefine映射）*/
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

register方法重點完成了bean配置類自己的解析和註冊，處理過程能夠分爲如下幾個步驟：

1.根據bean配置類，使用BeanDefinition解析Bean的定義信息，主要是一些註解信息
2.Bean做用域的處理，沒有@Scope註解默認解析成單例
3.藉助AnnotationConfigUtils工具類解析通用註解
4.將bean定義信息已beanname，beandifine鍵值對的形式註冊到ioc容器中

而後咱們繼續點進去refresh()方法

refresh方法在AbstractApplicationContext容器中實現，refresh()方法的做用加載或者刷新當前的配置信息，若是已經存在spring容器，則先銷燬以前的容器，從新建立spring容器，載入bean定義，完成容器初始化工做，因此能夠看出AnnotationConfigApplicationContext容器是經過調用其父類AbstractApplicationContext的refresh()函數啓動整個IoC容器完成對Bean定義的載入。

AbstractApplicationContext類的refresh()方法源代碼以下:

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            //1.刷新前的預處理
            prepareRefresh();

            //2.獲取刷新後的內部Bean工廠
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            //3.BeanFactory的預準備工做
            prepareBeanFactory(beanFactory);

            try {
                // BeanFactory準備工做完成後，能夠作一些後置處理工做
　　　　　　　　　 // 4.空方法，用於在容器的子類中擴展
                postProcessBeanFactory(beanFactory);

                // 5. 執行BeanFactoryPostProcessor的方法，BeanFactory的後置處理器，在BeanFactory標準初始化以後執行的
                invokeBeanFactoryPostProcessors(beanFactory);

                // 6. 註冊BeanPostProcessor（Bean的後置處理器）,用於攔截bean建立過程，實現對bean的加強
                registerBeanPostProcessors(beanFactory);

                // 7. 初始化MessageSource組件（作國際化功能；消息綁定，消息解析）
                initMessageSource();

                // 8. 初始化事件派發器
                initApplicationEventMulticaster();

                // 9.空方法，能夠用於子類實如今容器刷新時自定義邏輯
                onRefresh();

                // 10. 註冊事件監聽器，將全部項目裏面的ApplicationListener註冊到容器中來
                registerListeners();

                // 11. 初始化全部剩下的單實例bean,單例bean在初始化容器時建立，原型bean在獲取時（getbean）時建立
                finishBeanFactoryInitialization(beanFactory);

                // 12. 完成BeanFactory的初始化建立工做，IOC容器就建立完成；
                finishRefresh();
            }

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

                //銷燬已經建立的單例，以免掛起資源。
                destroyBeans();

                //重置「活動」標誌。
                cancelRefresh(ex);

                //向調用者傳播異常。
                throw ex;
            }

            finally {
                //在Spring的core中重置常見的內省緩存，由於咱們可能再也不須要單例bean的元數據了...
                resetCommonCaches();
            }
        }
    }

接下來咱們要分析refresh()裏面的這些方法

3.1 prepareRefresh ()刷新預處理方法:

　　/**
　　*準備此上下文以進行刷新，設置其啓動日期和
　　*活動標誌以及執行屬性源的任何初始化。
　　*/

 protected void prepareRefresh() {
        //設置容器啓動時間
        this.startupDate = System.currentTimeMillis();
　　　　 //啓動標識
        this.closed.set(false);
        this.active.set(true);

        if (logger.isDebugEnabled()) {
            if (logger.isTraceEnabled()) {
                logger.trace("Refreshing " + this);
            }
            else {
                logger.debug("Refreshing " + getDisplayName());
            }
        }

        //空方法，用於子容器自定義個性化的屬性設置方法
        initPropertySources();

　　　　　//檢驗屬性的合法等
        getEnvironment().validateRequiredProperties();

        //存儲預刷新應用程序監聽器…
        if (this.earlyApplicationListeners == null) {
            this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
        }
        else {
            //將本地應用程序偵聽器重置爲預刷新狀態。
            this.applicationListeners.clear();
            this.applicationListeners.addAll(this.earlyApplicationListeners);
        }

        //保存容器中的一些早期的事件
        this.earlyApplicationEvents = new LinkedHashSet<>();
    }

3.2 obtainFreshBeanFactory()方法

該方法獲取刷新後的內部Bean工廠，obtainFreshBeanFactory方法爲內部bean工廠從新生成id，並返回bean工廠

　　/**
　　*告訴子類刷新內部bean工廠。
　　* @return新鮮的BeanFactory實例
　　* @see #refreshBeanFactory（）
　　* @see #getBeanFactory（）
　　*/　

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

　　　　　　/**
　　　　　　*爲beanfactory生成惟一序列化id，beanfactory已經在GenericApplicationContext構造函數中初始化了，
　　　　　　*refreshBeanFactory的邏輯在AbstractApplicationContext的實現類GenericApplicationContext中
　　　　　　*/

 refreshBeanFactory();
　　　　　//獲取beanfactory return getBeanFactory(); }

GenericApplicationContext類的refreshBeanFactory()方法

    //---------------------------------------------------------------------
    實現AbstractApplicationContext的模板方法
    //---------------------------------------------------------------------
    / * *
    *什麼都不作:咱們只有一個內部BeanFactory，而且依賴於調用者
    *經過咱們的公共方法(或BeanFactory的)註冊bean。
    * @see # registerBeanDefinition
    * /  
    @Override
    protected final void refreshBeanFactory() throws IllegalStateException {
        if (!this.refreshed.compareAndSet(false, true)) {
            throw new IllegalStateException(
                    "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
        }
　　　　　//生成一個序列化id
        this.beanFactory.setSerializationId(getId());
    }

這裏使用AbstractApplicationContext.refreshBeanFactory()若是是註解的方式實現，則並無解析項目包下的註解，而是經過在refresh()方法中執行ConfigurationClassPostProcessor後置處理器完成對bean的加載.

3.3 prepareBeanFactory(beanFactory)方法

prepareBeanFactory主要完成beanFactory的一些屬性設置，BeanFactory的預準備工做

/**
*配置工廠的標準上下文特徵，
*例如上下文的ClassLoader和後置處理器。
* @param beanFactory要配置的BeanFactory
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        //告訴內部bean工廠使用上下文的類加載器等等。
        //設置類加載器
　　　　　beanFactory.setBeanClassLoader(getClassLoader());
　　　　　//bean表達式解析器
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        //使用上下文回調配置bean工廠。
        //添加一個BeanPostProcessor實現ApplicationContextAwareProcessor
　　　　 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

　　　　 //設置忽略的自動裝配接口，表示這些接口的實現類不容許經過接口自動注入
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

        //註冊能夠自動裝配的組件，就是能夠在任何組件中容許自動注入的組件
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        //將早期後置處理器註冊爲application監聽器，用於檢測內部bean。
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        //添加編譯時的AspectJ
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            //爲匹配的類型設置一個臨時類加載器。
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        // 給beanfactory容器中註冊組件ConfigurableEnvironment、systemProperties、systemEnvironment
        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
        }
    }

3.4 invokeBeanFactoryPostProcessors(beanFactory)方法

invokeBeanFactoryPostProcessors 執行bean工廠後置處理器

/**
*實例化並調用全部已註冊的BeanFactoryPostProcessor beans，
*若是給定則遵照顯示的順序。
* <p>必須在單例實例化以前調用。
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

invokeBeanFactoryPostProcessors方法內部執行實現了BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor這兩個接口的Processor，先獲取全部BeanDefinitionRegistryPostProcessor的實現，按優先級執行（是否實現PriorityOrdered優先級接口，是否實現Ordered順序接口）；再以相同的策略執行全部BeanFactoryPostProcessor的實現。

PostProcessorRegistrationDelegate. invokeBeanFactoryPostProcessors實現:

public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

        //若是有的話，首先調用BeanDefinitionRegistryPostProcessors。
        Set<String> processedBeans = new HashSet<>();

        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor =
                            (BeanDefinitionRegistryPostProcessor) postProcessor;
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                }
                else {
                    regularPostProcessors.add(postProcessor);
                }
            }

　　　　　　　　　//不要在這裏初始化FactoryBeans：咱們須要保留全部常規bean

　　　　　　　　　//未初始化的，讓bean工廠的後置處理程序負責於它們!

　　　　　　　　List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

            //首先，調用實現PriorityOrated接口的BeanDefinitionRegistryPostProcessors類的方法。
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();

            //接下來，調用實現Ordered接口的BeanDefinitionRegistryPostProcessors類的方法。
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();

            //最後，調用全部其餘BeanDefinitionRegistryPostProcessors，直到沒有其餘的後置處理器出現。
            boolean reiterate = true;
            while (reiterate) {
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                for (String ppName : postProcessorNames) {
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }

            //如今，調用到目前爲止處理完全部處理器的postProcessBeanFactory回調。
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

        else {
            //調用在上下文實例中註冊的工廠處理器。
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }

        //不要在這裏初始化FactoryBeans:咱們須要保留全部常規bean
        //未初始化，以讓bean工廠的後值處理器負責於它們!
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

       
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        for (String ppName : postProcessorNames) {
            if (processedBeans.contains(ppName)) {
                //跳過-已經在上面的第一階段處理
            }
            else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            }
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }

        //首先，調用實現PriorityOrated接口的BeanFactoryPostProcessors類。
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        //接下來，調用實現Ordered接口的BeanFactoryPostProcessors類方法。
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
        for (String postProcessorName : orderedPostProcessorNames) {
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        sortPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        //最後，調用全部其餘BeanFactoryPostProcessors，直到沒有其餘的後置處理器出現。
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        //清除緩存的合併bean定義，由於後置處理器可能修改了原始元數據，例如替換了值中的佔位符……
        beanFactory.clearMetadataCache();
    }

這裏面在處理BeanDefinitionRegistryPostProcessors時有一個很是重要的過程，AnnotationConfigApplicationContext構造函數在初始化reader時爲內部beanFactory容器初始化了一個id爲org.springframework.context.annotation.internalConfigurationAnnotationProcessor的組件，這是一個ConfigurationClassPostProcessor組件，用來處理添加@Configuration註解的類，並將Bean定義註冊到BeanFactory中。

3.5 invokeBeanFactoryPostProcessors(beanFactory)方法

註冊後置處理器的大體邏輯是：

　　1.獲取全部的 BeanPostProcessor

　　2.根據處理器實現的接口區分出4中類型：

　　　　2.1.實現PriorityOrdered接口的處理器

　　　　2.2.實現Ordered接口的處理器，

　　　　2.3.實現MergedBeanDefinitionPostProcessor接口的處理器，

　　　　2.4.普通後置處理器

　　3.按這個4中類型依次註冊到容器中

　　4.註冊一個特殊的後置處理器ApplicationListenerDetector，ApplicationListenerDetector自己也實現了MergedBeanDefinitionPostProcessor接口

/ * *
*實例化並註冊全部BeanPostProcessor bean，若是給定則遵循顯式順序。
* <p>必須在應用程序bean的任何實例化以前調用。
* /
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    }

public static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

        //註冊BeanPostProcessorChecker，當bean在BeanPostProcessor實例化過程當中被建立時，即當一個bean沒有資格被全部BeanPostProcessor處理時，它記錄一條信息到日誌。
        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

        //按優先級分類
        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                priorityOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }

        //首先，調用實現PriorityOrated接口的BeanPostProcessors類。
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

        //接下來，調用實現Ordered接口的BeanPostProcessors類方法。
        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
        for (String ppName : orderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            orderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        sortPostProcessors(orderedPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, orderedPostProcessors);

        //如今，註冊全部常規的BeanPostProcessors。
        List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
        for (String ppName : nonOrderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            nonOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

        //最後，調用全部其餘BeanPostProcessors，直到沒有其餘的後置處理器出現。
        sortPostProcessors(internalPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, internalPostProcessors);

        //註冊ApplicationListenerDetector，用於Bean建立完時檢查是不是ApplicationListener
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

3.6 initMessageSource()方法

初始化MessageSource組件（作國際化功能；消息綁定，消息解析）

/ * *
初始化MessageSource。
*若是在此上下文中沒有定義，則使用父類的。
* /
protected void initMessageSource() {
       //獲取beanFactory 
　　　　ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
            //讓MessageSource知道父類的MessageSource。
            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                if (hms.getParentMessageSource() == null) {
                    //若是沒有註冊父類的MessageSource，則只將父類的上下文設置爲父類的MessageSource。
                    hms.setParentMessageSource(getInternalParentMessageSource());
                }
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Using MessageSource [" + this.messageSource + "]");
            }
        }
        else {
            //使用空的MessageSource來接受getMessage調用。
            DelegatingMessageSource dms = new DelegatingMessageSource();
            dms.setParentMessageSource(getInternalParentMessageSource());
            this.messageSource = dms;
            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
            if (logger.isTraceEnabled()) {
                logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
            }
        }
    }

3.7 initApplicationEventMulticaster()方法

初始化事件派發器

/ * *
初始化ApplicationEventMulticaster。
若是上下文中沒有定義，則使用SimpleApplicationEventMulticaster。
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
* /
protected void initApplicationEventMulticaster() {
        //獲取BeanFactory
　　　　ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        //若是有配置beanName爲applicationEventMulticaster的事件派發器，則將其賦給容器中的applicationEventMulticaster對象
        if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
            this.applicationEventMulticaster =
                    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        }
        else {
　　　　　　　//不存在，則建立一個SimpleApplicationEventMulticaster事件派發器，並註冊到beanfactory中
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
            if (logger.isTraceEnabled()) {
                logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                        "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
            }
        }
    }

3.8 registerListeners()方法

registerListeners方法主要實現將事件監聽器添加到IOC容器中的事件派發器中，並在最後作了一個事件發佈的邏輯(若是以前的步驟有產生事件，則將earlyApplicationEvents中保存的事件逐一發布)

/ * *
添加實現ApplicationListener做爲偵聽器的bean。
*不影響其餘偵聽器，能夠在不添加bean的狀況下添加。
* /
protected void registerListeners() {
        //首先註冊靜態指定的監聽器。
        for (ApplicationListener<?> listener : getApplicationListeners()) {
            getApplicationEventMulticaster().addApplicationListener(listener);
        }

        //不要在這裏初始化factorybean:咱們須要不初始化全部常規bean，以便讓後置處理器處理它們
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String listenerBeanName : listenerBeanNames) {
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        //發佈早期的application事件…
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (earlyEventsToProcess != null) {
            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

3.9 finishBeanFactoryInitialization(beanFactory)方法

初始化全部剩下的單實例bean,單例bean在初始化容器時建立，原型bean在獲取時（getbean）時建立

/ * *
*完成這個上下文的bean工廠的初始化，
初始化全部剩餘的單例bean。
* /
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        //初始化此上下文的轉換服務。
        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));
        }

        //若是以前沒有註冊bean後置處理器(例如PropertyPlaceholderConfigurer bean)，則註冊一個默認的嵌入式值解析器:此時，主要用於在註釋屬性值中進行解析。
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        //提早初始化LoadTimeWeaverAware beans，以便儘早註冊它們的轉換器。
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        //中止使用臨時類加載器進行類型匹配。
        beanFactory.setTempClassLoader(null);

        //容許緩存全部bean定義元數據，不須要進一步更改。
        beanFactory.freezeConfiguration();

        //實例化全部剩餘的(非懶加載初始化)單例。
        beanFactory.preInstantiateSingletons();
    }

DefaultListableBeanFactory. preInstantiateSingletons()方法的實現：

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

        //容器中全部bean名稱
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

        
        for (String beanName : beanNames) {
　　　　　　　//獲取Bean的定義信息；RootBeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
　　　　　　　　//非抽象，單例，非延遲加載
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
　　　　　　　　　　//是不是FactoryBean
                if (isFactoryBean(beanName)) {
　　　　　　　　　　　　// 經過"&beanName"獲取工廠Bean實例
                    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 {
　　　　　　　　　　　　//不是FactoryBean,則利用getBean(beanName)實例化bean 
                    getBean(beanName);
                }
            }
        }

       
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }

3.10 finishRefresh()方法

完成BeanFactory的初始化建立工做，代碼走到這一步IOC容器就建立完成

/ * *
*調用LifecycleProcessor，完成此上下文的刷新
方法併發布
* {@link org.springframework.context.event.ContextRefreshedEvent}。
* /
protected void finishRefresh() {
        //清除上下文級的資源緩存(例如來自掃描的ASM元數據)。
        clearResourceCaches();

        //初始化和生命週期有關的後置處理器LifecycleProcessor，默認DefaultLifecycleProcessor
        initLifecycleProcessor();

        // 回調生命週期處理器
        getLifecycleProcessor().onRefresh();

        //發佈容器刷新完成事件：ContextRefreshedEvent
        publishEvent(new ContextRefreshedEvent(this));

        
        LiveBeansView.registerApplicationContext(this);
    }

以上基本分析了AnnotationConfigApplicationContext容器的初始化過程， Spring容器在啓動過程當中，會先保存全部註冊進來的Bean的定義信息；Spring容器根據條件建立Bean實例，區分單例，仍是原型，後置處理器等（後置處理器會在容器建立過程當中經過getBean建立，並執行相應的邏輯）；Spring容器在建立bean實例後，會使用多種後置處理器來增長bean的功能，好比處理自動注入，AOP，異步，這種後置處理器機制也豐富了bean的功能。

我這邊在AnnotationConfigApplicationContext啓動原理分析的代碼走讀部分有參考博客： http://www.javashuo.com/article/p-olqgtwrp-et.html ，不過有些類的方法會有點不同，由於我這邊時基於Spring5.X的版本分析