Spring框架核心流程

文章目录

• • 一、Spring的使用
  • 二、核心流程
  • • 2.1通过XML加载的方式启动
    • • 总流程：
      • 2.1.1 创建ApplicationContext对象
      • • 2.1.1.1 构建父类
        • 2.1.1.2 调用setConfiguration()
        • 2.1.1.3** 执行refresh() （核心）
      • 2.1.2 使用
    • 2.2通过注解加载的方式启动

一、Spring的使用

Spring启动的方式有很多种，大体分为XML方式和注解方式。

XML方式使用ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext

• FileSystemXmlApplicationContext是从文件系统加载Bean和相关资源
• ClassPathXmlApplicationContext则是从classPath下的配置文件获取Bean的信息以及相关资源。

注解方式则需要配合@ComponentScan注解和配置类来使用，适用于无配置文件，通过注解进行配置的Spring启动。

二、核心流程

2.1通过XML加载的方式启动

使用方式：

//创建springIOC容器
ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器中获取mapper
DepartmentMapper bean = ioc.getBean(DepartmentMapper.class);

总流程：

1. 创建父类

   ClassPathXmlApplicationContext —> AbstractXmlApplicationContext
   —>AbstractRefreshableConfigApplicationContext
   —>AbstractRefreshableApplicationContext
   —>AbstractApplicationContext
   创建完设置一些属性

2. 调用setConfigurations方法

   2.1 调用resolvePath方法，该方法创建Environment对象并调用Environment的resolveRequiredPlaceholders解析配置文件中的占位符。

   2.2 在创建Environment的过程中，Environment通过customizePropertySources加载系统变量和环境变量。

3. refresh()-----prepareRefresh

   设置了一个ApplicationEvent容器(存放早期事件)，同时设置关闭标志为false，开启标志为true。

4. refresh()-----obtainFreshBeanFacotry()(重点)

   创建BeanFactory，加载并解析XML文件，通过XmlBeanDefinitionReader将XML中配置的要加载的Bean，封装为BeanDefinition放入BeanFactory。

5. refresh()-----prepareBeanFactory(beanFacory)

   为BeanFactory设置一些属性，此时BeanFactory只含有我们在配置文件配置的那些Bean的BeanDefinition定义，再为其设置表示Environment的Bean及其他的Bean还有一些PostProcessor等

6. refresh()-----postProcessBeanFactory(beanFactory)

   空方法，留给子类扩展。用于定制BeanFactory

7. refresh()-----invokeBeanFactoryPostProcessors(beanFactory)(重点)

   执行所有注册的BeanFactoryPostProcessor，特别是ConfigurationClassPostProcessor，该类负责处理我们设置的配置类，即处理含有@Component、@Import、@Bean注解的类，将该类含有的这些注解进行处理。例如扫描@Component注解指向的包，将该包下的@component注解标注类加入到BeanFactory。
   在执行的时候，先执行所有实现PriorityOrder接口的BeanFactoryPostProcessor的postProcessBeanDefinitionRegistry()，再执行所有实现Order接口的，最后是其余的普通的，执行这些BeanFactoryPostProcessor的postProcessBeanDefinitionRegistry()以后，再执行他们的PostProcessorBeanFactory()方法。

8. refresh()-----registerBeanPostProcessors(beanFactory)
   将BeanFactory中的BeanPostProcessor按照PriorityOrder、Order、普通的、容器内的这四个级别排序。

9. refresh()-----initMessageSource()

   进行一些国际化的设置

10. refresh()-----initApplicationEventMulticaster()
    初始化事件多播器

11. refresh()-----onRefresh()(重点)

    空方法，留给子类实现，SpringBoot通过该方法完成Spring容器启动的同时启动Tomcat容器。

12. refresh()-----registerListeners()
    将事件监听器注册到事件多播器上，当发生Spring发生某个事件时，会获取多播器，从多播器中找到监听该事件的监听器，然后通知这些监听者。

13. refresh()-----finishBeanFactoryInitialization(beanFactory)(重点)
    完成非懒加载的类的实例化(解决循环依赖问题)

14. refresh()-----finishRefresh()
    创建声明周期对象，并启动。

2.1.1 创建ApplicationContext对象

//configLocation为配置文件的位置
 public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        this(new String[]{configLocation}, true, (ApplicationContext)null);
    }

 public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
        super(parent);
        this.setConfigLocations(configLocations);
        if (refresh) {
            this.refresh();
        }

    }

2.1.1.1 构建父类

这里首先调用了父类的构造方法，ClassPathXmlApplicationContext的父类是AbstractXmlApplicationContext。这一步主要设置了一些属性

public AbstractXmlApplicationContext(ApplicationContext parent) {
        super(parent);
    }
----------又调用了父类的构造方法
public AbstractRefreshableConfigApplicationContext(ApplicationContext parent) {
        super(parent);
    }

-------继续深入
 public AbstractRefreshableApplicationContext(ApplicationContext parent) {
        super(parent);
    }

    public AbstractApplicationContext(ApplicationContext parent) {
        this();
        this.setParent(parent);
    }

//传递过来的Parent为null，调用this();
    public AbstractApplicationContext() {
        this.logger = LogFactory.getLog(this.getClass());
        this.id = ObjectUtils.identityToString(this);
        this.displayName = ObjectUtils.identityToString(this);
        this.beanFactoryPostProcessors = new ArrayList();
        this.active = new AtomicBoolean();
        this.closed = new AtomicBoolean();
        this.startupShutdownMonitor = new Object();
        this.applicationListeners = new LinkedHashSet();
        this.resourcePatternResolver = this.getResourcePatternResolver();
    }
//设置了一些属性，初始化了BeanFactoryPostProcessor容器和监听器容器

2.1.1.2 调用setConfiguration()

然后调用了ClassPathXmlApplicationContext的setConfiguration方法。这一步主要加载了系统的资源以及环境变量等,还有一个作用就是解析配置文件中的占位符

this.setConfigLocations(configLocations);

------------该方法的具体代码
public void setConfigLocations(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) {
                //创建一个Environment对象，同时加载资源
                this.configLocations[i] = this.resolvePath(locations[i]).trim();
            }
        } else {
            this.configLocations = null;
        }

    }
---------------resolvePath方法
protected String resolvePath(String path) {
        return this.getEnvironment().resolveRequiredPlaceholders(path);
    }
//首先判断当前的environment对象是否为空，是空的话则创建一个StandarEnvironment对象，
//创建该对象会加载系统资源。
//AbtsractEnvironment为StandarEnvironment类的抽象类
 public AbstractEnvironment() {
        this.propertySources = new MutablePropertySources(this.logger);
        this.propertyResolver = new PropertySourcesPropertyResolver(this.propertySources);
        //这句很关键，加载了系统资源
        this.customizePropertySources(this.propertySources);
        
-------------分别加载了系统的属性和系统的环境变量
 protected void customizePropertySources(MutablePropertySources propertySources) {
        propertySources.addLast(new MapPropertySource("systemProperties", this.getSystemProperties()));
        propertySources.addLast(new SystemEnvironmentPropertySource("systemEnvironment", this.getSystemEnvironment()));
    }
            
---------------创建完Environment，调用Environment中PropertyResolver
---------------的resolveRequiredPlaceholders(path)方法

 public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
        return this.propertyResolver.resolveRequiredPlaceholders(text);
    }
--------------调用propertyResolver.resolveRequiredPlaceholders(text)
public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
        if (this.strictHelper == null) {
            this.strictHelper = this.createPlaceholderHelper(false);
        }
        //解析占位符
        return this.doResolvePlaceholders(text, this.strictHelper);
    }

2.1.1.3** 执行refresh() （核心）

该方法ClassPathXmlApplicationContext并未改写，即Spring的核心流程都是在父类AbstractApplicationContext中完成的，其他的实现类也仅仅是前期的准备工作不同。

this.refresh();

------------refresh方法--------------------------------------------------

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            //设置一些属性
            this.prepareRefresh();
            //创建BeanFactory，加载xml中配置的Bean以及xml中配置的功能
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //为BeanFactory设置一些属性
            this.prepareBeanFactory(beanFactory);

            try {
                //空方法，用于扩展
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

refresh()-----prepareRefresh()

该方法主要设置了一个ApplicationEvent容器，同时设置关闭标志为false，开启标志为true。

protected void prepareRefresh() {
        //开启计时
        this.startupDate = System.currentTimeMillis();
        //将关闭标志设置为false
        this.closed.set(false);
        //设置激活位为true 
        this.active.set(true);
        if (this.logger.isInfoEnabled()) {
            this.logger.info("Refreshing " + this);
        }
        //初始化属性源，空方法，留给子类扩展
        this.initPropertySources();
        //调用Environment的propertyResolver的validateRequiredProperties()
        //用于验证所需要的属性是否准备好
        this.getEnvironment().validateRequiredProperties();
        //初始化一个存放ApplicationEvent的容器
        this.earlyApplicationEvents = new LinkedHashSet();
    }

refresh()-----obtainFreshBeanFacotry()(重点)

该方法主要过程如下：
主要逻辑在refreshBeanFactory (该方法用子类AbstractRefreshableApplicationContext的实现 )
主要作用就是创建一个BeanFactory，并加载BeanDefinitions到ApplicationContext中(XML中配置的)。
refreshBeanFactory：

1. 创建一个DefaultListableBeanFactory，在这个过程中初始化父类。设置了一些属性，例如allowCircularReferences。
2. this.customizeBeanFactory(beanFactory)，不执行逻辑，留给子类扩展
3. this.loadBeanDefinitions(beanFactory),这里调用的是子类AbstractXmlApplicationContext的实现，该方法会创建一个XmlBeanDefinitionReader，然后调用Reader的loadBeanDefinitions。此处注意，在创建XmlBeanDefinitionReader时会将第一步创建的BeanFactory传递进去，作为一个BeanDefinitionRegistry，当XmlBeanDefinitionReader读取到BeanDefinition后，会通过该registry注册到BeanFactory中。
4. 调用Reader的loadBeanDefinitions其实是调用抽象父类(AbstractXmlApplication)的loadBeanDefinitions。
5. AbstractXmlApplication的loadBeanDefinitions最终调用XmlBeanDefinitionReader的loadBeanDefinitions
6. 最终调用 XmlBeanDefinitionReader 的 doLoadBeanDefinitions()方法完成加载(具体为7.8两步)
7. 调用Document的doLoadCocument方法，使用DefaultDocumentLoader中的实现加载BeanDefinition
8. 调用XmlBeanDefinitionReader 的registerBeanDefinitions将读取出来的BeanDefinition注册到BeanFactory。最终通过DefaultBeanDefinitionDocumentReader的doRegisterBeanDefinitions完成注册。

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

--------------------------------obtainFreshBeanFactory-------------------------------
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //创建BeanFactory，加载BeanDefinitions
        this.refreshBeanFactory();
        //获取创建好的BeanFactory并返回
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }

        return beanFactory;
    }
    
-------------1.refreshBeanFactory在AbstractApplicationContext的父类AbstractRefreshableApplicationContext中

protected final void refreshBeanFactory() throws BeansException {
        //如果已经有BeanFactory了，则销毁并关闭
        if (this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
            //创建一个DefaultListableBeanFactory
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            //设置序列化ID
            beanFactory.setSerializationId(this.getId());
            //2.定制BeanFactory，用于扩展，此处是不执行任何逻辑的
            this.customizeBeanFactory(beanFactory);
            //核心，加载BeanDefinition
            this.loadBeanDefinitions(beanFactory);
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }
    
-----------------1.1在创建 DefaultListableBeanFactory 的时候，会先创建其父类-----------

  public AbstractAutowireCapableBeanFactory() {
        this.instantiationStrategy = new CglibSubclassingInstantiationStrategy();
        this.parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
        this.allowCircularReferences = true;  //允许循环引用
        this.allowRawInjectionDespiteWrapping = false;
        this.ignoredDependencyTypes = new HashSet();
        this.ignoredDependencyInterfaces = new HashSet();
        this.factoryBeanInstanceCache = new ConcurrentHashMap(16);
        this.filteredPropertyDescriptorsCache = new ConcurrentHashMap(256);
        this.ignoreDependencyInterface(BeanNameAware.class);
        this.ignoreDependencyInterface(BeanFactoryAware.class);
        this.ignoreDependencyInterface(BeanClassLoaderAware.class);
    }

--------------------3.核心方法loadBeanDefinitions(子类：AbstractXmlApplicationContext)----

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        //定义一个XML文件的Reader解析XML文件，读取BeanDefinitions，在该过程中会将BeanFactory
        //作为一个BeanDefinitionRegistry传到XmlBeanDefinitionReader的父类
        //AbstractBeanDefinitionReader,作为其registry属性。
        //后面XmlBeanDefinitionReader读取到BeanDefinition后要通过registry属性注册
        //即将读取出来的BeanDefinition存入到BeanFactory中
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        //设置Environment，这一步没怎么看懂，ApplicationContext中的Environment对象
        //和Reader创建的Environment都是只含有系统变量和系统环境的。。为啥要覆盖一次？？？
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        //将当前的对象设置为ResourceLoader，后面加载Resource会用到
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        this.initBeanDefinitionReader(beanDefinitionReader);
        this.loadBeanDefinitions(beanDefinitionReader);
    }

-------------3.1 loadBeanDefinitions(beanDefinitionReader)方法---------------
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        //null
        Resource[] configResources = this.getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
        //传入的xml文件
        String[] configLocations = this.getConfigLocations();
        if (configLocations != null) {
            //调用Reader的loadBeanDefinitions加载配置文件
            reader.loadBeanDefinitions(configLocations);
        }     
    }

-------------4.XmlReader的loadBeanDefinitions(实际上是AbstractBeanDefinitionReader的方法)
//分别加载每一个配置文件(XmlBeanDefinitionReader)
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
        Assert.notNull(locations, "Location array must not be null");
        int counter = 0;
        String[] var3 = locations;
        int var4 = locations.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String location = var3[var5];
            counter += this.loadBeanDefinitions(location);
        }
//加载单个配置文件的函数(XmlBeanDefinitionReader)
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
        return this.loadBeanDefinitions(location, (Set)null);
    }
//this.loadBeanDefinitions((Resource)resource)这里 该重载方法由子类XmlBeanDefinitionReader实现
//因为我们创建的实际类就是XmlBeanDefinitionReader
    public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
        ResourceLoader resourceLoader = this.getResourceLoader();
        if (resourceLoader == null) {
            throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
        } else {
            int loadCount;
            if (!(resourceLoader instanceof ResourcePatternResolver)) {
                Resource resource = resourceLoader.getResource(location);
               
                loadCount = this.loadBeanDefinitions((Resource)resource);
                //...其他语句
                return loadCount;
            } else {
                try {
                    Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location);
                     //核心，该方法由子类实现
                    loadCount = this.loadBeanDefinitions(resources);
                    //......其他语句
                    return loadCount;
                } catch (IOException var10) {
                    throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var10);
                }
            }
        }
    }

------------------5. XmlBeanDefinitionReader的loadBeanDefinitions--------
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
       
        //.....
        Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
        //....
        //最终工作的语句
        var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        //.....

---------------------------6. doLoadBeanDefinitions-------------
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
        try {
            Document doc = this.doLoadDocument(inputSource, resource);
            //将读取的BeanDefinition存入到BeanFactory
            return this.registerBeanDefinitions(doc, resource);
            }catch(...){
            }//....

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        this.logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        //7.
        this.doRegisterBeanDefinitions(root);
    }
-------------------------8. DefaultBeanDefinitionDocumentReader
//在doRegisterBeanDefinitions调用this.parseBeanDefinitions(root, this.delegate);
// parseBeanDefinitions中调用this.parseDefaultElement(ele, delegate);
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }
//在processBeanDefinition中调用
//BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
//将BeanDefinition注册到BeanFactory中，BeanFactory实现是DefultListableBeanFactory
 public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
   //....  将BeanDefinition放入Map
    this.beanDefinitionMap.put(beanName, beanDefinition);

}
------------------------完成资源加载---------------------------------

refresh()-----prepareBeanFactory(beanFacory)

该方法主要为BeanFactory设置一些属性，此时BeanFactory只含有我们在配置文件配置的那些Bean的BeanDefinition定义，再为其设置表示Environment的Bean及其他的Bean还有一些PostProcessor等

1. 设置类加载器；
2. 设置EL表达式解析器（Bean创建完成填充属性时使用）和属性注册解析器
3. 利用BeanPostProcessor的特性给各种Aware接口的实现类注入ApplicationContext中对应的属性
4. 设置各种Aware接口的实现类为忽略自动装配
5. 设置这些类的具体装配实例（BeanFactory，ResourceLoader，ApplicationEventPublisher，ApplicationContext）
6. 如果BeanFactory中存在loadTimeWeaver的bean，那么需要添加动态织入功能
7. 注册各种可用组件（environment，systemProperties，systemEnvironment）

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        //设置类加载器
        beanFactory.setBeanClassLoader(this.getClassLoader());
        //设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
         //设置属性注册解析器PropertyEditor，即我们通过property文件动态设置bean属性
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
        // 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，
        //从而在Aware接口实现类中的注入applicationContext
        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时，注入beanFactory
        //防止有多个实例时，注入不知道注入哪一个，主要为了解决spring框架内部注入的问题
        //如果是我们外部人员可以通过指定的方式来解决，spring内部则相当于在这里指定
        //注入某个类型时具体要注入的类
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        //注册一个BeanPostProcessor，负责在每个Bean初始化完成后判断是否是监听器，
        //是的话注册到应用的事件多播器上
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
         //如果当前BeanFactory包含loadTimeWeaver Bean，
         //说明存在类加载期织入AspectJ，则把当前BeanFactory交给类加载期BeanPostProcessor实现类
         //LoadTimeWeaverAwareProcessor来处理，从而实现类加载期织入AspectJ的目的
        if (beanFactory.containsBean("loadTimeWeaver")) {
           //BeanPostProcessor在类初始化的时候起作用
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
        //注册当前容器环境environment组件Bean
        if (!beanFactory.containsLocalBean("environment")) {
            beanFactory.registerSingleton("environment", this.getEnvironment());
        }
         //注册系统配置systemProperties组件Bean
        if (!beanFactory.containsLocalBean("systemProperties")) {
            beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
        }
         //注册系统环境systemEnvironment组件Bean
        if (!beanFactory.containsLocalBean("systemEnvironment")) {
            beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
        }

    }

refresh()-----postProcessBeanFactory(beanFactory)

空方法，主要是用来交给子类去扩展。SpringBoot启动时好像就重写了该方法。
负责给BeanFactory加一些定制的BeanFacotyPostProcessor。

refresh()-----invokeBeanFactoryPostProcessors(beanFactory)(重点)

执行所有注册的BeanFctoryPostProcessor，此处主要有ConfigurationClassPostProcessor，该类主要用于加载通过@Import，@Bean，@ComponentScan等注解加入的Bean。将我们没在配置文件，而是用注解注入的Bean加载到BeanFactory中。(即完成通过注解注入的那些Bean的扫描)

1. invokeBeanFactoryPostProcessors(beanFactory)
2. 匹配 PriorityOrder 的 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry()方法
3. 匹配 Order 的 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry()方法
4. 其余的 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry()方法
5. 所有的 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory()方法

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

----------------------核心invokeBeanFactoryPostProcessors()------------------
//执行所有的BeanFactoryPostProcessor
/*
此处逻辑:从BeanFactory中找出所有BeanDefinitionRegistryPostProcessor
先找匹配PriorityOrder类型的(即在xml中配置了PriorityOrder属性)，然后排序并执行postProcessBeanDefinitionRegistry。
再找匹配Order的，排序后执行postProcessBeanDefinitionRegistry。
最后执行所有剩下的其他的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法。
执行通过函数invokeBeanDefinitionRegistryPostProcessors()完成。
--------------
最后把所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法执行
通过invokeBeanFactoryPostProcessors()
*/

//执行的主要方法是：invokeBeanDefinitionRegistryPostProcessors，
//主要是执行ConfigurationClassPostProCessor
private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
        Iterator var2 = postProcessors.iterator();

        while(var2.hasNext()) {
            BeanDefinitionRegistryPostProcessor postProcessor = (BeanDefinitionRegistryPostProcessor)var2.next();
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }

    }
//ConfigurationClassPostProCessor的processConfigBeanDefinitions
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        //获取所有的beanName
        List<BeanDefinitionHolder> configCandidates = new ArrayList();
        String[] candidateNames = registry.getBeanDefinitionNames();
        String[] var4 = candidateNames;
        int var5 = candidateNames.length;

        for(int var6 = 0; var6 < var5; ++var6) {
            String beanName = var4[var6];
            //得到BeanDefinition
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            //判断是否解析过
            if (!ConfigurationClassUtils.isFullConfigurationClass(beanDef) && !ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
                //判断是否为配置类
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                    configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
                }
            } else if (this.logger.isDebugEnabled()) {
                this.logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            }
        }
        //解析配置类
        if (!configCandidates.isEmpty()) {
            Collections.sort(configCandidates, new Comparator<BeanDefinitionHolder>() {
                public int compare(BeanDefinitionHolder bd1, BeanDefinitionHolder bd2) {
                    int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
                    int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
                    return i1 < i2 ? -1 : (i1 > i2 ? 1 : 0);
                }
            });
            //是否单例
            SingletonBeanRegistry singletonRegistry = null;
            if (registry instanceof SingletonBeanRegistry) {
                singletonRegistry = (SingletonBeanRegistry)registry;
                  //....
                }
            }
     
            ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
            Set<BeanDefinitionHolder> candidates = new LinkedHashSet(configCandidates);
            HashSet alreadyParsed = new HashSet(configCandidates.size());

            do {
                parser.parse(candidates);
                parser.validate();
                Set<ConfigurationClass> configClasses = new LinkedHashSet(parser.getConfigurationClasses());
                configClasses.removeAll(alreadyParsed);
                if (this.reader == null) {
                    this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getImportRegistry());
                }
                //解析出来的类，注册到容器中
                this.reader.loadBeanDefinitions(configClasses);
                //.....
    }

refresh()-----registerBeanPostProcessors(beanFactory)

注册BeanPostProcessor。

  protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    }
-----------------------------------------------
 public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
        //获取所有的BeanPostProcessor
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
        beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
        //存放实现PriorityOrder接口的后置处理器
        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
        List<BeanPostProcessor> internalPostProcessors = new ArrayList();
        List<String> orderedPostProcessorNames = new ArrayList();
        List<String> nonOrderedPostProcessorNames = new ArrayList();
        String[] var8 = postProcessorNames;
        int var9 = postProcessorNames.length;
        //将所有的后知处理器按照优先级分别放入不同的容器
        String ppName;
        BeanPostProcessor pp;
        for(int var10 = 0; var10 < var9; ++var10) {
            ppName = var8[var10];
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                pp = (BeanPostProcessor)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);
            }
        }
        //把实现PriorityOrder的加入到容器中
        sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
        registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
        List<BeanPostProcessor> orderedPostProcessors = new ArrayList();
        Iterator var14 = orderedPostProcessorNames.iterator();

        while(var14.hasNext()) {
            String ppName = (String)var14.next();
            BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
            orderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        //把所有实现Order接口的PostProcessor加入到容器中
        sortPostProcessors(beanFactory, orderedPostProcessors);
        registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors);
        List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList();
        Iterator var17 = nonOrderedPostProcessorNames.iterator();

        while(var17.hasNext()) {
            ppName = (String)var17.next();
            pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
            nonOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        //注册我们普通的没有实现任何排序接口的
        registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
         //注册MergedBeanDefinitionPostProcessor类型的后置处理器
        sortPostProcessors(beanFactory, internalPostProcessors);
        registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
         //注册ApplicationListenerDetector应用监听器探测器的后置处理器
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

refresh()-----initMessageSource()

国际化的一些配置，先不管

refresh()-----initApplicationEventMulticaster()

初始化事件多播器，事件多播器采用典型的设计模式就是观察者模式，多播器作为的是一个被观察者。
作用就是维护所有的监听者对象，spring发生事件后，会获取多播器，然后通过多播器发送给所有的监听该事件的监听者。

protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        //判断容器中是否包含了applicationEventMulticaster事件多播器组件
        if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
            this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        } else {//容器中没有的话，直接new一个并且注入到容器中
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Unable to locate ApplicationEventMulticaster with name 'applicationEventMulticaster': using default [" + this.applicationEventMulticaster + "]");
            }
        }

    }

refresh()-----onRefresh()(重点)

但是Spring并未实现该方法，留给子类扩展，比如SpringBoot在该方法中实现spring容器启动的时候启动Tomcat服务器

refresh()-----registerListeners()

将事件监听器注册到事件多播器上。

protected void registerListeners() {
        //取出所有的事件监听器
        Iterator var1 = this.getApplicationListeners().iterator();

        while(var1.hasNext()) {
             //将所有监听器注册到事件多播器上
            ApplicationListener<?> listener = (ApplicationListener)var1.next();
            this.getApplicationEventMulticaster().addApplicationListener(listener);
        }
        //获取所有的监听器对象
        String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
        String[] var7 = listenerBeanNames;
        int var3 = listenerBeanNames.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String listenerBeanName = var7[var4];
            //将监听器的Name注册到事件多播器上
            this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }
        //获取早期事件
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        //广播所有的早期事件
        if (earlyEventsToProcess != null) {
            Iterator var9 = earlyEventsToProcess.iterator();

            while(var9.hasNext()) {
                ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
                this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

refresh()-----finishBeanFactoryInitialization(beanFactory)(重点)

该处实例化所有非懒加载的单例Bean对象。前面只是将XML或者注解配置的Bean读取到容器中，并封装为一个个的BeanDefinition，但并未实例化。实例化是在这里解决的。
https://www.cnblogs.com/toby-xu/p/11333479.html

refresh()-----finishRefresh()

最后一步，发布刷新事件(ContextRefreshedEvent)

  protected void finishRefresh() {
        //初始化声明周期处理器
        this.initLifecycleProcessor();
        //启动容器中所有Lifecycle类型的Bean
        this.getLifecycleProcessor().onRefresh();
        //发布ContextRefreshedEvent事件
        this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
        LiveBeansView.registerApplicationContext(this);
    }

2.1.2 使用

2.2通过注解加载的方式启动

大同小异，最大的不同是在创建BeanFactory时仅仅实现创建工厂，而不会去扫描XML文件了。

AnnotationConfigApplicationContext ioc2 = new AnnotationConfigApplicationContext(AppConfig.class);

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        this.register(annotatedClasses);
        this.refresh();
    }

public AnnotationConfigApplicationContext() {
        //初始化注解读取器
        this.reader = new AnnotatedBeanDefinitionReader(this);
        //扫描并加载classpath下的Bean，加载的Bean有@Respository、@Service、@Controller
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

//剩下的是调用refresh()，不过注意，创建BeanFactory时调用refreshBeanFactory()
//是父类GenericApplicationContext的，而不是AbstractApplicationContext。所以不会加载XML配置文件

详情，可以参照博客：
https://www.cnblogs.com/toby-xu/p/11324776.html

本文地址：https://blog.csdn.net/sinat_38705282/article/details/110007518