Spring源碼解析——refresh方法

refresh方法在ConfigurableApplicationContext類中定義的具體實現是在AbstractApplicationContext中實現。這個方法的原文描述信息是：由於這是一個啓動方法，如果它調用失敗，它應該銷燬已創建的單例，以避免懸空資源。換句話說，在調用該方法之後，應該實例化所有單例或者不是單例的對象。

接下來分析refresh方法

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
//----------------------------------------1--------------------------------------//
            // 準備刷新和加載之前的上下文
            prepareRefresh();
//----------------------------------------1--------------------------------------//

//----------------------------------------2--------------------------------------//
            //告訴子類刷新內部bean工廠
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//----------------------------------------2--------------------------------------//

//----------------------------------------3--------------------------------------//
            // 準備在此上下文中使用的bean工廠
            prepareBeanFactory(beanFactory);
//----------------------------------------3--------------------------------------//

            try {
        //----------------------------------------4--------------------------------------//
                //註冊對應的BeanPostProcessor接口，就是ServletContextAwareProcessor
                postProcessBeanFactory(beanFactory);
      //----------------------------------------4--------------------------------------//

  //----------------------------------------5--------------------------------------//
                //調用註冊的BeanFactoryPostProcessor的postProcessBeanDefinitionRegistry方法
                invokeBeanFactoryPostProcessors(beanFactory);
  //----------------------------------------5--------------------------------------//

//----------------------------------------6--------------------------------------//
                // 註冊攔截bean創建的bean處理器
                registerBeanPostProcessors(beanFactory);
//----------------------------------------6--------------------------------------//

                //初始化上下文的消息源。
                initMessageSource();
                //初始化上下文的事件傳播器。
                initApplicationEventMulticaster();
                //在特定上下文子類中初始化其他特殊bean。
                onRefresh();
                // 檢查監聽器bean並註冊它們
                registerListeners();
//----------------------------------------7--------------------------------------//
                //實例化所有剩餘（非延遲初始化）單例。
                finishBeanFactoryInitialization(beanFactory);
//----------------------------------------7--------------------------------------//

//----------------------------------------8--------------------------------------//
                //最後一步：發佈相應的事件。
                finishRefresh();
//----------------------------------------8-------------------------------------//
            }

            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：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();
        // 初始化傳播器
        this.earlyApplicationEvents = new LinkedHashSet<>();
    }

方法2：obtainFreshBeanFactory

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //初始化BeanFactory
        refreshBeanFactory();
        //返回實例化的BeanFactory
        return getBeanFactory();
    }

其中的refreshBeanFactory方法的作用用來實例化BeanFactory並加載解析對應的Bean配置，其加載Bean的過程和前面講到的BeanFactory加載的過程相同

protected final void refreshBeanFactory() throws BeansException {
        //通過beanFactoryMonitor這個Bean工廠的監視器來判斷是否已經實例化了BeanFactory
        if (hasBeanFactory()) {
            //如果實例化了BeanFactory，則先銷燬所有的單例Bean
            destroyBeans();
            //關閉BeanFactory，也就是將beanFactory的值置爲null
            closeBeanFactory();
        }
        try {
            //創建BeanFactory實例，如果實現了ConfigurableApplicationContext則返回父上下文的內部bean工廠;否則，返回父上下文本身
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            //如果用戶自定義了允許Bean定義覆蓋和允許循環引用則設置爲定義的，默認爲不允許
            customizeBeanFactory(beanFactory);
            //加載bean，前面已經講過bean的加載
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

方法3：prepareBeanFactory

這個方法主要是配置BeanFactory的各種類加載器，需要的依賴和需要忽略的依賴，後處理器，解析器等

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        //設置加載Bean用的類加載器
        beanFactory.setBeanClassLoader(getClassLoader());
        //設置Bean中表達式解析用的解析器，默認的SpEL解析器
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        //添加屬性註冊時候的註冊器，可以自定義註冊器，只需要實現PropertyEditorRegistrar接口
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
        //添加ApplicationContextAwareProcessor（其中包含了ApplicationContext，起到了傳遞的作用）
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        //忽略給定的自動裝配依賴關係接口，放到ignoredDependencyInterfaces中保存
        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.
        //自動裝配值註冊特殊依賴關係類型，放到resolvableDependencies集合中保存
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        //註冊ApplicationListenerDetector作爲早期後處理器以檢測內部bean實現了ApplicationListener的情況
        // Register early post-processor for detecting inner beans as ApplicationListeners.
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        //如果beanFactory中包含loadTimeWeaver名稱的bean，則需要使用對應的臨時的類加載器處理
        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.
        //註冊默認的需要的上下文環境bean，包含environment，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());
        }
    }

方法4：postProcessBeanFactory

這個方法主要註冊web請求相關的處理器和bean以及配置

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        //將ServletContextAwareProcessor註冊到bean註冊前處理器中
        beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
        //將ServletContextAware和ServletConfigAware設置爲忽略依賴
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
        beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
        //註冊特定於Web的範圍(如request，session和application），添加對應的web請求依賴（ServletRequest，ServletResponse，HttpSession，WebRequest使用各自對應的BeanFactory）
        WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
        //註冊環境變量，在servletContext和servletConfig中設置的和自帶的
        WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
    }

方法5：invokeBeanFactoryPostProcessors

這個方法主要是調用實現了的bean後處理器

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        /**
         * 這裏的調用所有的實現了BeanFactoryPostProcessor接口的類的方法，調用postProcessBeanDefinitionRegistry方法的時候按照會按照一定順序來調用
         * 1.調用實現PriorityOrdered的BeanDefinitionRegistryPostProcessors
         * 2.調用實現Ordered的BeanDefinitionRegistryPostProcessors
         * 3.調用所有其他BeanDefinitionRegistryPostProcessors，直到不再出現其他BeanDefinitionRegistryPostProcessors
         * 調用postProcessBeanFactory沒有順序
         */
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
        //這裏特殊處理前面說到的bean名稱爲loadTimeWeaver的Bean
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

方法6：registerBeanPostProcessors

這個方法主要是註冊實現了的bean後處理器

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        /**
         * 這裏的註冊所有的實現了BeanPostProcessor接口的類的方法一定順序來註冊
         * 1.註冊實現PriorityOrdered的BeanPostProcessor
         * 2.註冊實現Ordered的BeanPostProcessor
         * 3.註冊所有其他BeanPostProcessor，直到不再出現其他BeanPostProcessor
         * 最後，重新註冊ApplicationListenerDetector爲後處理器以檢測內部bean實現ApplicationListener接口的，並將其移動到處理器鏈的末尾
         */
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

方法7：finishBeanFactoryInitialization

 在這裏加載並實例化所有的懶加載的bean

protected void  finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        //設置對應的用於類型轉換的服務接口，ConversionService可以自己實現
        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);
        }

        //停止使用臨時ClassLoader進行類型匹配,因爲已經加載完了bean
        beanFactory.setTempClassLoader(null);

        //凍結所以的bean定義，說明註冊的bean定義將不被修改或任何進一步的處理
        beanFactory.freezeConfiguration();

        //初始化剩下的單實例(非惰性)，在這個方法中最終會調用getBean方法，就會實例化bean
        beanFactory.preInstantiateSingletons();
}

方法8：finishRefresh

protected void finishRefresh() {
                //清除上下文級資源緩存
        clearResourceCaches();

        // 爲此上下文初始化生命週期處理器，可以自定義LifecycleProcessor，如果沒有則使用默認的DefaultLifecycleProcessor
        initLifecycleProcessor();

        // 刷新bean的生命週期  
        getLifecycleProcessor().onRefresh();

        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));

        // Participate in LiveBeansView MBean, if active.
        LiveBeansView.registerApplicationContext(this);
}