欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Spring框架核心流程

程序员文章站 2022-04-29 17:30:25
一、IOC二、AOP...

一、Spring的使用

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

XML方式使用ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext

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

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

二、核心流程

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完成注册。

Spring框架核心流程

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配置文件

Spring框架核心流程
详情,可以参照博客:
https://www.cnblogs.com/toby-xu/p/11324776.html

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