spring容器的refresh方法分析

    public void refresh() throws BeansException, IllegalStateException {

        synchronized (this.startupShutdownMonitor) {

            //刷新前的预处理;

            prepareRefresh();

            //获取BeanFactory；默认实现是DefaultListableBeanFactory，在创建容器的时候创建的

            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            //BeanFactory的预准备工作（BeanFactory进行一些设置，比如context的类加载器，BeanPostProcessor和XXXAware自动装配等）

            prepareBeanFactory(beanFactory);

            try {

                //BeanFactory准备工作完成后进行的后置处理工作

                postProcessBeanFactory(beanFactory);

                //执行BeanFactoryPostProcessor的方法；

                invokeBeanFactoryPostProcessors(beanFactory);

                //注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行

                registerBeanPostProcessors(beanFactory);

                //初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

                initMessageSource();

                //初始化事件派发器

                initApplicationEventMulticaster();

                //子类重写这个方法，在容器刷新的时候可以自定义逻辑；如创建Tomcat，Jetty等WEB服务器

                onRefresh();

                //注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的

                registerListeners();

                //初始化所有剩下的非懒加载的单例bean

                finishBeanFactoryInitialization(beanFactory);

                //完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）

                finishRefresh();

            }

            ......

    }

    /**

     * Configure the factory's standard context characteristics,

     * such as the context's ClassLoader and post-processors.

     * @param beanFactory the BeanFactory to configure

     */

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

        //设置BeanFactory的类加载器

        beanFactory.setBeanClassLoader(getClassLoader());

        //设置支持表达式解析器

        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        //添加部分BeanPostProcessor【ApplicationContextAwareProcessor】

        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

        //设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xx,因为ApplicationContextAwareProcessor#invokeAwareInterfaces已经把这5个接口的实现工作做了

        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、ResourceLoader、ApplicationEventPublisher、ApplicationContext

        //其他组件中可以通过 @autowired 直接注册使用

        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

        beanFactory.registerResolvableDependency(ResourceLoader.class, this);

        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        //添加BeanPostProcessor【ApplicationListenerDetector】后置处理器，在bean初始化前后的一些工作

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

        }

        //给BeanFactory中注册一些能用的组件；

        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {

            //环境信息ConfigurableEnvironment

            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

        }

        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {

          //系统属性，systemProperties【Map<String, Object>】

            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

        }

        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {

          //系统环境变量systemEnvironment【Map<String, Object>】

            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());

        }

    }

    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

        if (this.servletContext != null) {

            beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));

            beanFactory.ignoreDependencyInterface(ServletContextAware.class);

        }

        WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);

        WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);

    }

    @Override

    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

        super.postProcessBeanFactory(beanFactory);

        // 查看basePackages属性，如果设置了会使用ClassPathBeanDefinitionScanner去扫描basePackages包下的bean并注册

        if (this.basePackages != null && this.basePackages.length > 0) {

            this.scanner.scan(this.basePackages);

        }

        // 查看annotatedClasses属性，如果设置了会使用AnnotatedBeanDefinitionReader去注册这些bean

        if (!this.annotatedClasses.isEmpty()) {

            this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));

        }

    }

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

    public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {

        TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();

        for (ConfigurationClass configClass : configurationModel) {

            //对每一个配置类，调用loadBeanDefinitionsForConfigurationClass方法

            loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);

        }

    }

    private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,

            TrackedConditionEvaluator trackedConditionEvaluator) {

        //使用条件注解判断是否需要跳过这个配置类

        if (trackedConditionEvaluator.shouldSkip(configClass)) {

            //跳过配置类的话在Spring容器中移除bean的注册

            String beanName = configClass.getBeanName();

            if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {

                this.registry.removeBeanDefinition(beanName);

            }

            this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());

            return;

        }

        if (configClass.isImported()) {

            //如果自身是被@Import注释所import的，注册自己

            registerBeanDefinitionForImportedConfigurationClass(configClass);

        }

        //注册方法中被@Bean注解修饰的bean

        for (BeanMethod beanMethod : configClass.getBeanMethods()) {

            loadBeanDefinitionsForBeanMethod(beanMethod);

        }

        //注册@ImportResource注解注释的资源文件中的bean

        loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

        //注册@Import注解中的ImportBeanDefinitionRegistrar接口的registerBeanDefinitions

        loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

    }

    protected void registerListeners() {

        //1、从容器中拿到所有已经创建的ApplicationListener

        for (ApplicationListener<?> listener : getApplicationListeners()) {

            //2、将每个监听器添加到事件派发器中；

            getApplicationEventMulticaster().addApplicationListener(listener);

        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans

        // uninitialized to let post-processors apply to them!

        // 1.获取所有还没有创建的ApplicationListener

        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);

        for (String listenerBeanName : listenerBeanNames) {

            //2、将每个监听器添加到事件派发器中；

            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

        }

        // earlyApplicationEvents 中保存之前的事件，

        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;

        this.earlyApplicationEvents = null;

        if (earlyEventsToProcess != null) {

            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {

                //3、派发之前步骤产生的事件；

                getApplicationEventMulticaster().multicastEvent(earlyEvent);

            }

        }

    }

    protected void finishRefresh() {

        super.finishRefresh();

        WebServer webServer = startWebServer();

        if (webServer != null) {

            publishEvent(new ServletWebServerInitializedEvent(webServer, this));

        }

    }