【spring源码】spring IOC容器底层源码分析

最新推荐文章于 2022-08-27 18:27:54 发布

wj-1024

最新推荐文章于 2022-08-27 18:27:54 发布

阅读量1.9w

点赞数 5

分类专栏： java 源码分析 spring 文章标签： spring java bean

本文链接：https://blog.csdn.net/aaa_bbb_ccc_123_456/article/details/103946874

版权

本文主要分析了Spring IOC容器的refresh()方法，从prepareRefresh()到finishRefresh()，详细探讨了BeanFactory的创建、预处理、BeanPostProcessor的注册与执行、MessageSource和ApplicationEventMulticaster的初始化等关键步骤，揭示了Spring容器初始化的核心流程。

摘要由CSDN通过智能技术生成

【spring源码】spring IOC容器底层源码分析

注：其他一些spring源码解读，如果有需要，可以参考：

1.入口

看源码也得找个入口
Demo:

    @Test
    public void test01(){
        //创建IOC容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig2.class);

        String[] definitionNames = applicationContext.getBeanDefinitionNames();
        for (String name : definitionNames) {
            System.out.println(name);
        }
    }

这是随便找的一个测试类，我们的入口就是该方法的第一行代码：new AnnotationConfigApplicationContext(MyConfig2.class);
MyConfig2.class是配置类，不用管，我们点进AnnotationConfigApplicationContext的构造方法看看：

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
        this();
        //解析配置类,注册bean
        this.register(annotatedClasses);
        //spring的核心，在这个方法里，Spring完成了容器的初始化
        this.refresh();
    }

register(annotatedClasses)解析配置类的，创建IOC容器的方法有多种，这里是用注解配置的方式，也就是 AnnotationConfigApplicationContext的方式来创建，除了这种还有其他方式，比如传统的xml方式：ClassPathXmlApplicationContext，大家应该不陌生，他们都有个共同的特点，先解析配置文件，先把你在配置文件中配置的bean注册起来（类信息，方法信息，依赖信息，是否单例等等。。只注册，不实例化和初始化）
这一步我们不细说，我们今天聊下面那个方法.refresh()

2.spring IOC核心refresh（）方法源码分析

熟悉Spring源码的对refresh（）这个方法应该不会陌生,spring的核心,我们点进去：

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            //容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等
            this.prepareRefresh();
            //获取新的beanFactory，销毁原有beanFactory、为每个bean生成BeanDefinition等
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
               //配置标准的beanFactory，设置ClassLoader，设置SpEL表达式解析器，添加忽略注入的接口，添加bean，添加bean后置处理器等
                this.postProcessBeanFactory(beanFactory);
                //模板方法，此时，所有的beanDefinition已经加载，但是还没有实例化。
                //允许在子类中对beanFactory进行扩展处理。比如添加ware相关接口自动装配设置，添加后置处理器等，是子类扩展 
                //prepareBeanFactory(beanFactory)的方法。
                // 实例化并调用所有注册的beanFactory后置处理器（实现接口BeanFactoryPostProcessor的bean，在beanFactory标准初始化之后执行）。
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //实例化和注册beanFactory中扩展了BeanPostProcessor的bean。
                this.registerBeanPostProcessors(beanFactory);
                //初始化国际化工具类MessageSource
                this.initMessageSource();
                //初始化事件广播器
                this.initApplicationEventMulticaster();
                //模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。
                this.onRefresh();
                //注册监听器，广播early application events
                this.registerListeners();
                //实例化所有剩余的（非懒加载）单例
                //实例化的过程各种BeanPostProcessor开始起作用。
                this.finishBeanFactoryInitialization(beanFactory);
                //refresh做完之后需要做的其他事情。
                //清除上下文资源缓存（如扫描中的ASM元数据）
                //初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）。
                //发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
                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();
            }

        }
    }

注释已经很详细了，接下来我们一个方法一个方法聊：

2.1 prepareRefresh()刷新前的预处理

protected void prepareRefresh() {
        //记录时间
		this.startupDate = System.currentTimeMillis();
		//容器状态，是否关闭：false
		this.closed.set(false);
		//是否激活：true
		this.active.set(true);

        //打印刷新日志
		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}

		//初始化一些属性设置;默认是个空的方法，等待子类自定义个性化的属性设置方法；
		initPropertySources();
		//检验属性的合法等
		getEnvironment().validateRequiredProperties();
		//保存容器中的一些早期的事件；
		this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
	}

 protected void initPropertySources() {
		// 这个方法是个空的，等待子类重写
	}

首先，设置容器状态
然后，initPropertySources();这是个空的方法，等待子类自定义个性化的属性设置方法；
再然后validateRequiredProperties();检验属性的合法等
最后new LinkedHashSet();创建一个放置早期监听事件的的容器，等待之后派发器创建好之后方便派发（派发器的创建在后面的其他方法内）

2.2 obtainFreshBeanFactory();获取BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //刷新【创建】BeanFactory；
		refreshBeanFactory();
		//返回刚才GenericApplicationContext创建的BeanFactory对象；
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		//将创建的BeanFactory【DefaultListableBeanFactory】返回
		return beanFactory;
	}

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

      private final DefaultListableBeanFactory beanFactory;
      public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	 }
	 
	 @Override
 	protected final void refreshBeanFactory() throws IllegalStateException {
 	    //CAS
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
  	}
  	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
		return this.beanFactory;
	}
// 省略了很多其他源码。。。

}

refreshBeanFactory();刷新BeanFactory，其实是到GenericApplicationContext 无参构造里new DefaultListableBeanFactory();，然后设置了一个序列化Id
getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；
最后将创建的BeanFactory【DefaultListableBeanFactory】返回；

2.3 prepareBeanFactory(beanFactory);BeanFactory的预准备工作

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、xxx；
		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
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		//添加BeanPostProcessor【ApplicationListenerDetector】
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 添加编译时的AspectJ；
		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)) {
			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());
		}
	}

上个的方法创建了BeanFactory,这个方法对BeanFactory进行一些设置
首先设置BeanFactory的类加载器、支持表达式解析器…
然后添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
然后设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
再然后注册可以解析的自动装配；我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
再再然后添加BeanPostProcessor【ApplicationListenerDetector】
然后添加编译时的AspectJ；
最后给BeanFactory中注册一些能用的组件；environment【ConfigurableEnvironment】、systemProperties【Map<String, Object>】、systemEnvironment【Map<String, Object>】

2.4 postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置.
到这里为止，以上是BeanFactory的创建及预准备工作

2.5 invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostP

最低0.47元/天解锁文章

wj-1024

关注

5
点赞
踩
36

收藏

觉得还不错? 一键收藏
0
评论
【spring源码】spring IOC容器底层源码分析

【spring源码】AOP底层源码分析1.入口2.spring IOC核心refresh（）方法源码分析2.1 prepareRefresh()刷新前的预处理2.2 obtainFreshBeanFactory();获取BeanFactory2.3 prepareBeanFactory(beanFactory);BeanFactory的预准备工作2.4 postProcessBeanFactory...
复制链接

扫一扫

专栏目录