Spring源码之IOC

系统管理员 2022-11-12 01:43 150阅读 0赞

# 一：Spring源码之IOC #

## **一、refresh()方法** ##

**使用模板方法模式定义的一个顶级抽象父类，方法具体实现延迟到子类 ，每一个方法都是一个钩子，可以被子类重写。**

@Override
        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // ② IOC初始化前的装备(配置环境参数、创建监听器、事件容器)
                prepareRefresh();
    
                // ③ 这里可以分为两类：            // GenericApplicationContext: 仅仅是控制beanfactory不能重复refresh            // AbstractRefreshableApplicationContext：允许重复refresh，销毁就beanfactory，创建新beanfactory并且重新扫描生成beanDefinitionMap容器。
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                // ④ 设置beanfactory的一些属性（bean的类加载器、忽略接口、BeanPostProcessor、环境参数单例注册到beanfactory单例容器中）
                prepareBeanFactory(beanFactory);
    
                try {
                    // ⑤空方法，留由子类实现。                //例如注册servlet相关的忽略接口、beanPostProcessor、各作用域生成bean的bean工厂                //注册servlet的一些单例（servletContext/servletConfig/contextparameters/contextAttributes）到beanfactory的单例容器中
                    postProcessBeanFactory(beanFactory);
    
                    // ⑥beanFactoryPostProcessor排序并依次调用                // beanFactoryPostProcessor：beanfactory的后置处理器，可以理解为一个beanfactory的拦截器（实例化后需要执行的自定义操作)                // 例如：beanfactory初始化完成后，修改忽略接口、甚至可以对特定的beandefinition做修改
                    invokeBeanFactoryPostProcessors(beanFactory);
    
                    // ⑦BeanPostProcessors排序并依次注册到beanfactory的beanpostProcessor容器中                // beanPostProcessors：bean实例化的处理器，可以理解为一个bean的拦截器（实例化前+实例化后需要执行自定义操作)                // 例如：bean单例化前，修改beandefinition的属性。                //实例化后DI，                //拦截getbean()拦截返回一个代理类bean
                    registerBeanPostProcessors(beanFactory);
    
                    // ⑧初始化国际化文件，支持国际化
                    initMessageSource();
    
                    // ⑨初始化时间监听器并注册到beanfactory的单例容器中
                    initApplicationEventMulticaster();
    
                    // ⑩空方法，子类实现，初始化一些自定义bean并注册到beanfactory的单例容器中                //  例如：themeSource，支持主题切换
                    onRefresh();
    
                    // ⑪注册个中监听器到beanfactory指定容器中
                    registerListeners();
    
                    // ⑫实例化不需要延迟加载的所有单例类型的bean（scope = singleton）
                    finishBeanFactoryInitialization(beanFactory);
    
                    // ⑬容器初始化完成，触发各种事件监控,ApplicationListener.onApplicationEvent()的执行时机（dubbo注册就是在这里实现的）                // 例如：beanfactory的生命周期监控
                    finishRefresh();
                }
    
                catch (BeansException ex) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Exception encountered during context initialization - " +
                                "cancelling refresh attempt: " + ex);
                    }
    
                    // ⑭ 容器初始化失败，销毁所有已实例化的bean
                    destroyBeans();
    
                    // ⑮ 设置active = false
                    cancelRefresh(ex);
    
                    // Propagate exception to caller.
                    throw ex;
                }
    
                finally {
                    // ⑯ 清空公共的反射缓存
                    resetCommonCaches();
                }
            }
        }

**① 加锁：也是SpringIOC中主要加锁方式**

private final Object startupShutdownMonitor = new Object();
        @Override
        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                        ...
                    }
            }

**利用synchronized实现的一个细粒度锁。拥有ReentranLock.lock()的细粒度，还不用释放unlock()。**

**② prepareRefresh()：IOC容器初始化之前的准备（配置环境参数，创建监听器容器，创建事件容器）**

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());
                }
            }
    
            //初始化IOC容器的一些环境参数，默认空方法，子类可重写
            //这里可以先创建一个标准环境变量StandardEnvironment，然后设置一些环境参数
            //并且指定一些必须配置的参数
            initPropertySources();
    
            //若未创建，则创建一个标准环境变量StandardEnvironment
            //校验上面指定的必须配置的参数是否已经配置，没有配置会抛出异常
            getEnvironment().validateRequiredProperties();
    
            // 配置一些refresh()之前的监听器
            if (this.earlyApplicationListeners == null) {
                this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
            }
            else {
                // Reset local application listeners to pre-refresh state.
                this.applicationListeners.clear();
                this.applicationListeners.addAll(this.earlyApplicationListeners);
            }
    
            //创建是一个事件集合
            this.earlyApplicationEvents = new LinkedHashSet<>();
        }

**③ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()：控制refresh调用次数。**

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            //抽象方法,控制IOC容器的refresh()次数
            //仅允许refresh()一次,再次刷新会报错：GenericApplicationContext.java
            //允许重复刷新()：AbstractRefreshableApplicationContext.java ，        //刷新逻辑是销毁旧beanfactory，实例化一个新的beanfactory;当然没有旧beanfactory这里会直接实例化一个beanfactory        //并且重新扫描生成beanDefinitionMap容器
            refreshBeanFactory();
            //抽象方法
            //返回容器类ApplicationContext创建时创建的DefaultListableBeanFactory实例
            return getBeanFactory();
        }
    
        /* org/springframework/context/support/AbstractRefreshableApplicationContext.java:129 */
        protected final void refreshBeanFactory() throws BeansException {
            if (hasBeanFactory()) {
                //允许重复刷新，销毁旧beanfactory
                destroyBeans();
                closeBeanFactory();
            }
            try {
                //创建新的beanfactory
                //传统的基于xml解析的ApplicationContext，例如spring2.x经常拿来学习的ClassPathXmlApplitionContext.java
                //beanfactory是在这里实例化的，而不是在applicationContext的构造方法中
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                customizeBeanFactory(beanFactory);
                //重新扫描生成beandefinitionMap容器
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }

**④prepareBeanFactory(beanFactory)：设置DefaultListableBeanFactory实例的属性（类加载器，忽略接口，BeanPostProcessor，将环境变量单例注册到beanfactory中）**

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.
            //设置BeanPostProcessor（后置处理器）
            beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
            //设置需要忽略的接口,这些接口的实现类不会被IOC容器实例化
            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接口不能注册为一个简单工厂的解析类型
            //自动转配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.
            //设置BeanPostProcessor后置处理器
            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()));
            }
    //将环境单例StandardEnvironment注册到beanfactory单例容器中
            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());
            }
        }

**⑤postProcessBeanFactory(beanFactory)：抽象方法，子类具体实现**

**选取AnnotationConfigApplication的父类GenericWebApplicationContext：**

**将serlvet相关的后置处理器、作用域类型、servlet的bean的创建工厂设置到beanfactory中**

**将serlvet的servletContext、servletConfig、contextParameters、contexAttributes注册到beanfactory的单例容器中**

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
            if (this.servletContext != null) {
                //注册servletContext相关处理器
                //忽略servletContext相关的接口
                beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
                beanFactory.ignoreDependencyInterface(ServletContextAware.class);
            }
            //注册beanfactory的servlet的三个作用域实例，并指定servlet相关类型的bean的创建工厂
            WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
            //servletContex、servletConfig、contextParameters、contextAttributes实例注册到beanfactory的单例容器中
            WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
        }
    
        /* WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext); */
        public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory,
                @Nullable ServletContext sc) {
            //注册servlet作用域 request session
            //request:一个请求创建一个request
            //session:一次会话创建一个session
            beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
            beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
            if (sc != null) {
                //注册servlet作用域 application
                //application：所有用户共享
                ServletContextScope appScope = new ServletContextScope(sc);
                beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
                // Register as ServletContext attribute, for ContextCleanupListener to detect it.
                sc.setAttribute(ServletContextScope.class.getName(), appScope);
            }
            //注册对应类型的实例工厂
            beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
            beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
            beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
            beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
            if (jsfPresent) {
                FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
            }
        }
    
        /* WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext); */
        public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf,
                @Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {
            //将servletContext实例注册到beanfactory单例容器中
            if (servletContext != null && !bf.containsBean(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME)) {
                bf.registerSingleton(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME, servletContext);
            }
    
            //将servletConfig实例注册到beanfactory单例容器中
            if (servletConfig != null && !bf.containsBean(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME)) {
                bf.registerSingleton(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME, servletConfig);
            }
    
            //将contextParameters转化成一个Map注册到beanfactory的单例容器中
            if (!bf.containsBean(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME)) {
                Map<String, String> parameterMap = new HashMap<>();
                if (servletContext != null) {
                    Enumeration<?> paramNameEnum = servletContext.getInitParameterNames();
                    while (paramNameEnum.hasMoreElements()) {
                        String paramName = (String) paramNameEnum.nextElement();
                        parameterMap.put(paramName, servletContext.getInitParameter(paramName));
                    }
                }
                if (servletConfig != null) {
                    Enumeration<?> paramNameEnum = servletConfig.getInitParameterNames();
                    while (paramNameEnum.hasMoreElements()) {
                        String paramName = (String) paramNameEnum.nextElement();
                        parameterMap.put(paramName, servletConfig.getInitParameter(paramName));
                    }
                }
                bf.registerSingleton(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME,
                        Collections.unmodifiableMap(parameterMap));
            }
    
            //将contextAttributes转化成Map注册到beanfactory的单例容器中
            if (!bf.containsBean(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME)) {
                Map<String, Object> attributeMap = new HashMap<>();
                if (servletContext != null) {
                    Enumeration<?> attrNameEnum = servletContext.getAttributeNames();
                    while (attrNameEnum.hasMoreElements()) {
                        String attrName = (String) attrNameEnum.nextElement();
                        attributeMap.put(attrName, servletContext.getAttribute(attrName));
                    }
                }
                bf.registerSingleton(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME,
                        Collections.unmodifiableMap(attributeMap));
            }
        }

**⑥ invokeBeanFactoryPostProcessors(beanFactory)：需要与上面的BeanPostProcessors区分开，主要是区分两类PostProcessor，然后对bean相关的postjProcessor实例按照优先级排序，按照优先级顺序调用。**

**BeanPostProcessors：处理特定的bean的后置处理器，（bean实例化的拦截器）**

**BeanFactoryPostProcessors：处理beanfactory下所有bean的后置处理器**

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
            //这个方法很长有点复杂
            //1、具体beanfactory中后置处理器beanFactoryPostProcessor分为两类
            //①bean注册相关的后置处理器:BeanDefinitionRegistryPostProcessors
            //②普通后置处理器
            //2、将上面①中后置处理器按照优先级逐一调用
            //①实现PriorityOrdered接口的
            //②实现Ordered接口的
            //③其他BeanDefinitionRegistryPostProcessors
            PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
            // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
            // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
            //目前还不清楚loadTimeWeaver的作用
            if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
                beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            }
        }

**⑦ registerBeanPostProcessors(beanFactory)：其实内容跟上面⑥差不多，只是处理对象不同了。beanPostProcessor实例按照优先级顺序注册到beanfactory的beanpostprocessor容器中。**

**a 实现PriorityOrdered接口的**

**b 实现Ordered接口的，未实现MergedBeanDefinitionPostProcessor接口的**

**c 剩下的未实现MergedBeanDefinitionPostProcessor接口的**

**d 实现MergedBeanDefinitionPostProcessor接口的**

**e 提供一个末位动态注册器，可从bean单例中拉取监听器到末尾**

public static void registerBeanPostProcessors(
                ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    
            String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
            // Register BeanPostProcessorChecker that logs an info message when
            // a bean is created during BeanPostProcessor instantiation, i.e. when
            // a bean is not eligible for getting processed by all BeanPostProcessors.
            //获取所有beanProcessor，并注册一个记录beanProcessor数量的BeanPostProcessor
            int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
            beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
            // 将beanPostProcessor区分为四类类然后按此顺序注册到beanfactory中
            // 实现PriorityOrdered接口的
            // 实现Ordered接口的，未实现MergedBeanDefinitionPostProcessor接口的
            // 剩下的未实现MergedBeanDefinitionPostProcessor接口的
            // 实现MergedBeanDefinitionPostProcessor接口的
            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);
                }
            }
    
            // First, register the BeanPostProcessors that implement PriorityOrdered.
            //将实现PriorityOrdered接口的先排序，后注册
            sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
            registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    
            // Next, register the BeanPostProcessors that implement Ordered.
            //将实现Ordered接口的，排序注册
            List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
            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);
    
            // Now, register all regular BeanPostProcessors.
            //将剩余的，后注册
            List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
            for (String ppName : nonOrderedPostProcessorNames) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                nonOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    
            // Finally, re-register all internal BeanPostProcessors.
            //将实现MergedBeanDefinitionPostProcessor接口重新注册（原来注册过的会删除后，再注册，所以优先级比上面三种低）
            sortPostProcessors(internalPostProcessors, beanFactory);
            registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
            // 注册一个末尾的处理器，可以实现，动态将bean单例中的applicationContextListener注册到末尾（优先级最低）
            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
        }

**⑧ initMessageSource()：国际化支持，注册一个new DelegatingMessageSource()到beanfactory的单例容器中，支持继承关系**

protected void initMessageSource() {
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            //国际化支持，支持继承关系
            if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
                this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
                // Make MessageSource aware of parent MessageSource.
                if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                    HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                    if (hms.getParentMessageSource() == null) {
                        // Only set parent context as parent MessageSource if no parent MessageSource
                        // registered already.
                        hms.setParentMessageSource(getInternalParentMessageSource());
                    }
                }
                if (logger.isTraceEnabled()) {
                    logger.trace("Using MessageSource [" + this.messageSource + "]");
                }
            }
            else {
                // Use empty MessageSource to be able to accept getMessage calls.
                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 + "]");
                }
            }
        }

**⑨ initApplicationEventMulticaster()：注册一个applicationEvent多路广播器到beanfactory的单例容器中**

protected void initApplicationEventMulticaster() {
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            // 初始化一个applicationEvent多路广播，具体作用未知
            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 {
                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() + "]");
                }
            }
        }

**⑩ onrefresh()：空方法，初始化一些特殊的bean。**

**AnnotationConfigApplicationContext：创建themeSource，主题资源注册**

protected void onRefresh() {
                this.themeSource = UiApplicationContextUtils.initThemeSource(this);
            }
    
            public static ThemeSource initThemeSource(ApplicationContext context) {
            if (context.containsLocalBean(THEME_SOURCE_BEAN_NAME)) {
                ThemeSource themeSource = context.getBean(THEME_SOURCE_BEAN_NAME, ThemeSource.class);
                // Make ThemeSource aware of parent ThemeSource.
                if (context.getParent() instanceof ThemeSource && themeSource instanceof HierarchicalThemeSource) {
                    HierarchicalThemeSource hts = (HierarchicalThemeSource) themeSource;
                    if (hts.getParentThemeSource() == null) {
                        // Only set parent context as parent ThemeSource if no parent ThemeSource
                        // registered already.
                        hts.setParentThemeSource((ThemeSource) context.getParent());
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Using ThemeSource [" + themeSource + "]");
                }
                return themeSource;
            }
            else {
                // Use default ThemeSource to be able to accept getTheme calls, either
                // delegating to parent context's default or to local ResourceBundleThemeSource.
                HierarchicalThemeSource themeSource = null;
                if (context.getParent() instanceof ThemeSource) {
                    themeSource = new DelegatingThemeSource();
                    themeSource.setParentThemeSource((ThemeSource) context.getParent());
                }
                else {
                    themeSource = new ResourceBundleThemeSource();
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Unable to locate ThemeSource with name '" + THEME_SOURCE_BEAN_NAME +
                            "': using default [" + themeSource + "]");
                }
                return themeSource;
            }
        }

**⑪registerListeners()：将各种监听器放入到对应的容器中**

protected void registerListeners() {
            // Register statically specified listeners first.
            for (ApplicationListener<?> listener : getApplicationListeners()) {
                getApplicationEventMulticaster().addApplicationListener(listener);
            }
    
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let post-processors apply to them!
            String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
            for (String listenerBeanName : listenerBeanNames) {
                getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
            }
    
            // Publish early application events now that we finally have a multicaster...
            Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
            this.earlyApplicationEvents = null;
            if (earlyEventsToProcess != null) {
                for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                    getApplicationEventMulticaster().multicastEvent(earlyEvent);
                }
            }
        }

**⑫finishBeanFactoryInitialization(beanFactory)：bean实例化，单独开一章研究**

**⑬finishRefresh();refresh结束，推送相关事件**

protected void finishRefresh() {
            //清空资源缓存
            clearResourceCaches();
    
            // 初始化容器的生命周期处理器
            initLifecycleProcessor();
    
            // 将refresh推送给生命周期处理器
            getLifecycleProcessor().onRefresh();
    
            // 监听器执行，ApplicationListener.onApplicationEvent()
            publishEvent(new ContextRefreshedEvent(this));
    
            // 注册容器到LiveBeansView中，由LiveBeansView监控容器？
            LiveBeansView.registerApplicationContext(this);
        }

**⑭destroyBeans()：refresh失败时，删除已经创建的单例bean**

**⑮cancelRefresh(ex);refresh失败时，设置active标志=false**

**⑯resetCommonCaches();清空公共反射缓存**

protected void resetCommonCaches() {
            ReflectionUtils.clearCache();
            AnnotationUtils.clearCache();
            ResolvableType.clearCache();
            CachedIntrospectionResults.clearClassLoader(getClassLoader());
        }