spring源碼解析-ApplicationContext解析

ApplicationContext和BeanFactory一樣都是bean的容器，而BeanFactory是一切Bean容器的父類，ApplicationContext繼承於BeanFactory（繼承之BeanFactory的子類）

ApplicationContext包含了BeanFactory的所有功能，並且擴展了其他功能。先從ApplicationContext的案例入手，代碼如下：

ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
ctx.getBean("myBean");

 可以看出ApplicationContext和BeanFactory的用法基本一樣，初始化之后就可以直接獲取Bean了，那么我們就先從ApplicationContext的初始化入手，也就是先從ClassPathXmlApplicationContext的構造函數入手，代碼如下：

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        this(new String[] {configLocation}, true, null);
    }

public ClassPathXmlApplicationContext(
            String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
            throws BeansException {

        //調用父類的構造函數
        super(parent);
        //設置配置xml
        setConfigLocations(configLocations);
        //ApplicationContext初始化
        if (refresh) {
            refresh();
        }
    }

 

初始化配置xml可以傳入數組形式，設置方法setConfigLocations代碼如下：

public void setConfigLocations(@Nullable String... locations) {
        if (locations != null) {
            Assert.noNullElements(locations, "Config locations must not be null");
            this.configLocations = new String[locations.length];
            for (int i = 0; i < locations.length; i++) {
                this.configLocations[i] = resolvePath(locations[i]).trim();
            }
        }
        else {
            this.configLocations = null;
        }
    }

 主要用於解析配置的xml信息，將xml路徑信息賦值給configLocations，設置了配置信息之后就需要對ApplicationContext進行初始化操作了，也就是最后一步的refresh方法了，代碼如下：

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            //准備刷新
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            //初始化BeanFactory，並進行XML文件讀取
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            //對BeanFactory進行各種功能擴展
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                //子類覆蓋方法做額外對處理
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                //激活各種BeanFactory處理器
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                //注冊攔截Bean創建對Bean處理器，這里只是注冊，真正調用是在getBean對時候
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                //為上下文初始化Message
                initMessageSource();

                // Initialize event multicaster for this context.
                //初始化應用消息廣播器
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                //留給子類來初始化其他對Bean
                onRefresh();

                // Check for listener beans and register them.
                //在所有注冊對bean中尋找Lestener bean，注冊到消息廣播器中
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                //初始化剩下對單例bean
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                //完成刷新過程，通知生命周期處理器刷新過程，同時發出ContextRefreshEvent通知別人
                finishRefresh();
            }

            catch (BeansException ex) {
                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.
                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...
                resetCommonCaches();
            }
        }
    }
}

 

主要過程為：

1.初始化前對准備工作，對系統屬性或者環境變量的驗證

2.初始化BeanFactory，並進行xml文件讀取，相當於復用了BeanFactory的配置文件讀取解析過程，相當於進行了一次BeanFactory的初始化，剩下的都是對BeanFactory的擴展了

3.對BeanFactory進行功能填充（如@Autowired @Qualifier注解對支持等）

4. 子類覆蓋父類方法做額外的處理（postProcessBeanFactory方法是空函數，方便子類進行擴展）

5.激活各種BeanFactory處理器

6.注冊攔截bean創建的bean處理器

7.剩下的可以看代碼中的注解

 

接下來再細看，初始化前的准備驗證直接跳過，直接看如何初始化BeanFactory的，

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();
        return getBeanFactory();
    }

第一步初始化BeanFactory，進行xml配置讀取解析

第二步返回BeanFactory

@Override
    protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

 

大致過程如下：

1.創建DefaultListableBeanFactory對象，BeanFactory的初始化實際也是創建了這個對象

2.指定序列號ID

3.定制BeanFactory

4.加載BeanDefinition

5.使用全局變量記錄BeanFactory實例

 

這里的第三步的customizeBeanFactory方法是對BeanFactory的擴展，添加了@Qualifier和@Autowired的支持

loadBeanDefinitions方法是加載BeanDefinition，首先是加載Xml，使用XmlBeanDefinitionReader的loadBeanDefinitions方法進行配置文件的加載注冊和BeanFactory的邏輯一樣

 

在BeanFactory初始化之后就是對BeanFactory的擴展，也就是prepareBeanFactory方法及之后的內容

 

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        beanFactory.setBeanClassLoader(getClassLoader());
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        // Configure the bean factory with context callbacks.
        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 interface not registered as resolvable type in a plain factory.
        // MessageSource registered (and found for autowiring) as a bean.
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        // Register early post-processor for detecting inner beans as ApplicationListeners.
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        // Register default environment beans.
        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());
        }
    }

 方法主要內容是：

1.增加對SPEL語言的支持（如#{XXX.xxx}設置屬性）

2.增加對屬性編輯器的支持

3.設置依賴功能可忽略的接口

4.注冊一些固定依賴的屬性

5.增加AspectJ的支持

6.將相關環境變量及屬性注冊以單例模式注冊

 

接下來再看下初始化非延遲加載單例的bean

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));
        }

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // 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.
        beanFactory.preInstantiateSingletons();
    }

 這里的26行的freezeConfiguration方法是對bean定義的凍結，也就是說bean注冊之后就不可改了，而ApplicationContext默認說會將所有的單例bean提前進行初始化的，也就是方法preInstantiateSingletons方法

@Override
    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("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.
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                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 {
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        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();
                }
            }
        }
    }

 

 

高頻面試題：ApplicationContext和BeanFactory的區別？

1.BeanFactory是容器所有容器接口的父類，提供了最基本的bean相關的功能，而ApplicationContext是繼承之BeanFactory，在BeanFactory的基礎上擴展了更多的功能

2.ApplicationContext的初始化過程就包含了BeanFactory的初始化過程，如何額外擴展，

3.BeanFactory中的bean是在獲取的時候才初始化，而ApplicationContext是初始化的時候就初始化所有的單例bean（好處是在啟動的時候就可以檢查到不合法的bean）

4.ApplicationContext增加了SPEL語言的支持（#{xx.xx}等配置）、 消息發送、響應機制（ApplicationEventPublisher）、支持了@Qualiiar和@Autowired等注解