SpringIOC容器创建过程源码解析

最新推荐文章于 2022-04-20 19:19:19 发布

KISSING_MONSTER

最新推荐文章于 2022-04-20 19:19:19 发布

阅读量315

点赞数 1

分类专栏： SpringBoot 文章标签： spring java ioc bean aop

本文链接：https://blog.csdn.net/woshizouqi/article/details/110209833

版权

SpringBoot 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

前言

1、prepareRefresh();预处理刷新

2、ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

3、prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）；

4、postProcessBeanFactory(beanFactory);

5、invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法；

6、registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（Bean的后置处理器）（用于拦截bean的创建）

7.initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

8、initApplicationEventMulticaster();初始化事件派发器；

9、onRefresh();留给子容器（子类）

10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；

11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean；

12、finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成；

前言

接近三天三夜的时间探究了一下Spring的源码，阅读的时候可以打开源码跟着一步一步往下走，总能想清楚到其中方法的含义。这样下来大体能对IOC容器的加载过程、以及Bean的创建过程等有一个思路和印象，之后再慢慢琢磨其设计的思想以及内涵。温故而知新，知识需要一遍一遍的反复推敲，相信每读一遍都能带来不一样的感悟。希望这篇文章能给读者带来帮助。

以AnnotationConfigApplicationContext加载应用上下文为例，它的构造方法：

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

其中refresh方法的具体实现是在AbstractApplicationContext中实现，通过这个方法创建了IOC容器。接下来具体分析以下refresh()到底做了什么。

这段话与下面代码对应，先大体看一下每个方法的作用。

1、2、3、4是BeanFactory的创建和预准备。

6 是Bean的后置处理器注册；

7 是国际化功能等组件的初始化；

8 是事件派发器初始化；

9 是留给子类的扩展方法

10 是事件监听器的注册

11是Bean的实例化过程

12 是BeanFactory的完成BeanFactory的初始化创建工作，至此，IOC容器创建完成!

public abstract class AbstractApplicationContext extends DefaultResourceLoader
      implements ConfigurableApplicationContext {}中的refresh()方法
@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

            //1、刷新预处理
            prepareRefresh();

            //2、获取BeanFactory工厂及装载Bean信息
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            //3、BeanFactory的预准备工作（BeanFactory进行一些设置）；
            prepareBeanFactory(beanFactory);
            
                //4、BeanFactory准备工作完成后进行的后置处理工作；
                postProcessBeanFactory(beanFactory);

                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // 5、执行BeanFactoryPostProcessor的方法；（BeanFactory后置处理器）
                invokeBeanFactoryPostProcessors(beanFactory);

                // 6、注册BeanPostProcessor（Bean的后置处理器,拦截Bean的创建）
                registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();

                // 7、初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
                initMessageSource();

                // 8、初始化事件派发器；
                initApplicationEventMulticaster();

                // 9、给子容器（子类），子类重写这个方法，在容器刷新的时候可以自定义逻辑；
                onRefresh();

                // 10、给容器中将所有项目里面的ApplicationListener注册进来；
                registerListeners();

                // 11、初始化所有剩下的单实例bean；
                finishBeanFactoryInitialization(beanFactory);

                // 12、完成BeanFactory的初始化创建工作；IOC容器就创建完成；
                finishRefresh();

        }
    }

1、prepareRefresh();预处理刷新

1）、initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法；

2）、getEnvironment().validateRequiredProperties();检验属性的合法等

3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；

protected void prepareRefresh() {
   // Switch to active.
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   this.active.set(true);

   if (logger.isDebugEnabled()) {
      if (logger.isTraceEnabled()) {
         logger.trace("Refreshing " + this);
      }
      else {
         logger.debug("Refreshing " + getDisplayName());
      }
   }

    //这里➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤
   initPropertySources();

    //这里➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤
   getEnvironment().validateRequiredProperties();

    //这里➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤➤
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
   }
   else {
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
   }
   this.earlyApplicationEvents = new LinkedHashSet<>();
}

2、ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

1）、refreshBeanFactory();刷新【创建】BeanFactory；创建了一个this.beanFactory = new DefaultListableBeanFactory(); 设置id；

2）、getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；

3）、将创建的BeanFactory【DefaultListableBeanFactory】返回；

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   return getBeanFactory();
}

来看他调用的refreshBeanFactory();方法：可以得知默认创建的beanFactory是DefaultListableBeanFactory

@Override
protected final void refreshBeanFactory() throws BeansException {
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      //protected DefaultListableBeanFactory createBeanFactory() {
      //return new DefaultListableBeanFactory(getInternalParentBeanFactory());
      //}  
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      customizeBeanFactory(beanFactory);
      loadBeanDefinitions(beanFactory);
      this.beanFactory = beanFactory;
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

方法中的loadBeanDefinitions(beanFactory);方法，分别由四个子类实现：

AbstractXmlApplicationContext
AnnotationConfigWebApplicationContext
GroovyWebApplicationContext
XmlWebApplicationContext

这个方法的作用是通过委托给一个或多个bean定义读取器，将bean定义加载到给定的bean工厂中。

@Override
protected final void refreshBeanFactory() throws BeansException {
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      customizeBeanFactory(beanFactory);
      loadBeanDefinitions(beanFactory);
      this.beanFactory = beanFactory;
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

至此，已经完成了BeanFactory的创建，并且已经将Bean的信息加载到BeanFactory中。

3、prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）；

1）、设置BeanFactory的类加载器、支持表达式解析器...

2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】

3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；

4）、注册可以解析的自动装配，我们能在代码中直接注入这几个组件： BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext

5）、添加BeanPostProcessor【ApplicationListenerDetector】

6）、添加编译时的AspectJ；

7）、给BeanFactory中注册一些能用的组件； environment【ConfigurableEnvironment】、 systemProperties【Map<String, Object>】、 systemEnvironment【Map<String, Object>】

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // Tell the internal bean factory to use the context's class loader etc.
   beanFactory.setBeanClassLoader(getClassLoader());
   if (!shouldIgnoreSpel) {
      beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   }
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // Configure the bean factory with context callbacks.
   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.ignoreDependencyInterface(ApplicationStartup.class);

   // BeanFactory interface not registered as resolvable type in a plain factory.
   // MessageSource registered (and found for autowiring) as a 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.
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // Detect a LoadTimeWeaver and prepare for weaving, if found.
   if (!IN_NATIVE_IMAGE && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // Set a temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   // Register default environment beans.
   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());
   }
   if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
      beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
   }
}