深入理解 Spring IOC 底层实现机制（refresh 方法源码分析）

最新推荐文章于 2024-07-06 17:10:20 发布

码农爱java

最新推荐文章于 2024-07-06 17:10:20 发布

阅读量1.3k

点赞数 29

分类专栏：【Spring】文章标签： spring java 后端源码 IOC

本文链接：https://blog.csdn.net/weixin_42118323/article/details/138134630

版权

【Spring】专栏收录该内容

11 篇文章 0 订阅

订阅专栏

前言：

之前我们分析了 Spring Boot 的启动方法，分析到 refresh 的时候，没有继续往下分析了，我们知道调用的是 AbstractApplicationContext#refresh，refresh 方法是 Spring IOC 的核心方法，Spring 容器启动时会创建 IOC 容器，在创建容器时，会调用 refresh 方法完成所有的 bean 的创建以及初始化，本篇我们简单分析一下 refresh 方法。为什么要叫 refresh 呢，因为 ApplicationContext 可以重新创建，这样还会将原来的容器销毁，然后再执行一次初始化操作，这个操作就是刷新。

AbstractApplicationContext#refresh 方法源码分析：

refresh 方法源码分析：

//IOC 核心方法
public void refresh() throws BeansException, IllegalStateException {
	//防止 启动和销毁并发执行
	synchronized(this.startupShutdownMonitor) {
		//启动步骤记录
		StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
		//刷新准备工作
		this.prepareRefresh();
		//创建 beanFactory 将配置文件解析为 beandefiniton 对象 注册到 beanFactory 中
		//ConfigurableListableBeanFactory是一个接口 真正干活的是 DefaultListableBeanFactory
		ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
		//beanFactory 预处理 主要是设置 beanFactory 类加载器及忽略一些自动装配 设置一些默认bena
		this.prepareBeanFactory(beanFactory);

		try {
			//beanFactory 后置处理 准备完成后需要做的事情 默认是空实现 是一个扩展点 可以子类去实现
			this.postProcessBeanFactory(beanFactory);
			//启动 bean post-process 步骤记录
			StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
			//回调 beanFactory 后置处理器 beanFactoryPostProcessors 的 postProcessorsBeanFactory 方法   (也可以说是激活 beanFactoryPostPorcess)
			this.invokeBeanFactoryPostProcessors(beanFactory);
			//注册beanPostProcessors bean 后置处理器(注意上面是beanFactory后置处理器) 在bean 初始化之前之后执行
			this.registerBeanPostProcessors(beanFactory);
			//bean 后置处理器步骤结束
			beanPostProcess.end();
			//初始化国际化资源
			this.initMessageSource();
			//初始化应用程序事件多播器
			this.initApplicationEventMulticaster();
			//默认是空方法 可以子类重写  自己进行扩展
			this.onRefresh();
			//注册监听器
			this.registerListeners();
			//初始化单例bean(非懒加载)
			this.finishBeanFactoryInitialization(beanFactory);
			//完成后刷新 包括清空资源 发布事件等
			this.finishRefresh();
		} catch (BeansException var10) {
			if (this.logger.isWarnEnabled()) {
				this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
			}
			//销毁ben
			this.destroyBeans();
			//取消刷新
			this.cancelRefresh(var10);
			throw var10;
		} finally {
			this.resetCommonCaches();
			contextRefresh.end();
		}

	}
}

prepareRefresh 方法源码分析：

prepareRefresh 方法主要执行的是容器刷新前准备工作。

//刷新前准备工作
protected void prepareRefresh() {
	//记录起始时间
	this.startupDate = System.currentTimeMillis();
	//设置容器状态未关闭
	this.closed.set(false);
	//记录容器状态是活跃的
	this.active.set(true);
	if (this.logger.isDebugEnabled()) {
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("Refreshing " + this);
		} else {
			this.logger.debug("Refreshing " + this.getDisplayName());
		}
	}
	//初始化属性资源 默认实现是空的 如果需要在初始化 bean 之前加载某些资源 就可以自己实现这个方法
	this.initPropertySources();
	//校验环境变量
	this.getEnvironment().validateRequiredProperties();
	//监听器
	if (this.earlyApplicationListeners == null) {
		this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
	} else {
		this.applicationListeners.clear();
		this.applicationListeners.addAll(this.earlyApplicationListeners);
	}
	//初始化事件集合
	this.earlyApplicationEvents = new LinkedHashSet();
}

obtainFreshBeanFactory 方法源码分析：

obtainFreshBeanFactory 方法主要是用来创建 beanFactory，创建的是 DefaultListableBeanFactory，DefaultListableBeanFactory 非常重要。

//获取 DefaultListableBeanFactory beanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//刷新 beanFactory
	this.refreshBeanFactory();
	//获取 beanFactory
	return this.getBeanFactory();
}

//刷新 beanFactory
protected final void refreshBeanFactory() throws BeansException {
	//beanFactory 判空
	if (this.hasBeanFactory()) {
	    //销毁单例bean
		this.destroyBeans();
		//关闭 beanFactory beanFactory 置为 null
		this.closeBeanFactory();
	}

	try {
	    //创建一个 beanFactory
		DefaultListableBeanFactory beanFactory = this.createBeanFactory();
		beanFactory.setSerializationId(this.getId());
		//设置一些属性 是否允许bean定义被覆盖 是否允许循环引用
		this.customizeBeanFactory(beanFactory);
		//加载beanBeanDefinition
		this.loadBeanDefinitions(beanFactory);
		this.beanFactory = beanFactory;
	} catch (IOException var2) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2);
	}
}

//获取 beanFactory 没什么特殊逻辑
public final ConfigurableListableBeanFactory getBeanFactory() {
	DefaultListableBeanFactory beanFactory = this.beanFactory;
	if (beanFactory == null) {
		throw new IllegalStateException("BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext");
	} else {
		return beanFactory;
	}
}

prepareBeanFactory方法源码分析：

postProcessBeanFactory 方法源码是空实现，是一个扩展点，由子类去实现，beanFactory 准备完成后需要做的事情，就可以通过这个扩展点去实现。

//对前一步获取到的beanFactory做预处理
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //设置 beanFactory 的类加载器
    beanFactory.setBeanClassLoader(this.getClassLoader());
    //是否忽略 spel
    if (!shouldIgnoreSpel) {
        //设置 Bean 表达式(spel)解析器
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    }
    //添加属性编辑器注册器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
    //添加bean 后置处理器 ApplicationContextAwareProcessor 应用程序上下文感知处理器
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    //有Bean依赖于以下接口的实现类 在自动装配的时候忽略
    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(ApplicationStartupAware.class);
    //如果bean 有依赖一下几个 就注入依赖
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    //添加后置处理器 ApplicationListenerDetector 应用程序监听器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    //
    if (!NativeDetector.inNativeImage() && beanFactory.containsBean("loadTimeWeaver")) {
        //添加后置处理器 LoadTimeWeaverAwareProcessor  Aspect AOP 的支持
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        //设置临时类加载器
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
    //注册单例bean environment
    if (!beanFactory.containsLocalBean("environment")) {
        beanFactory.registerSingleton("environment", this.getEnvironment());
    }
    //注册单例bean systemProperties
    if (!beanFactory.containsLocalBean("systemProperties")) {
        beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
    }
    //注册单例bean applicationStartup
    if (!beanFactory.containsLocalBean("applicationStartup")) {
        beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
    }
    //注册单例bean applicationStartup
    if (!beanFactory.containsLocalBean("applicationStartup")) {
        beanFactory.registerSingleton("applicationStartup", this.getApplicationStartup());
    }

}

invokeBeanFactoryPostProcessors 方法源码分析：

invokeBeanFactoryPostProcessors 方法执行 beanFactory 的 BeanFactoryPostProcessor 后置处理器方法，这里可以有非常多的 BeanFactoryPostProcessor ，注意 beanFactory 后置处理器 BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor 是不同的东西。

//执行 beanFactory 后置处理器 PostProcessor 的方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    //先执行入参的 BeanFactoryPostProcessor 排序执行
    //然后在执行 beanFactory 自己的 PostProcessor
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
    if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
        //beanFactory 中增加 Aspect/AOP PostProcessor
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        //设置临时类加载器
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

}

//执行 beanFactory 后置处理器中的方法
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    Set<String> processedBeans = new HashSet();
    ArrayList regularPostProcessors;
    ArrayList registryProcessors;
    int var9;
    ArrayList currentRegistryProcessors;
    String[] postProcessorNames;
    //判断 beanFactory 是否是 BeanDefinitionRegistry
    //前文说了这里的 beanFactory 实际是 DefaultListableBeanFactory 而 DefaultListableBeanFactory 实现了 BeanDefinitionRegistry 接口 所以为 true
    if (beanFactory instanceof BeanDefinitionRegistry) {
        //强转为 BeanDefinitionRegistry
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
        //存放普通 beanFactory 后置处理器
        regularPostProcessors = new ArrayList();
        //存放 beanDefinitionRegistry 后置处理器
        registryProcessors = new ArrayList();
        //开始迭代遍历
        Iterator var6 = beanFactoryPostProcessors.iterator();

        while(var6.hasNext()) {
            //获取 beanFactoryPostProcessor
            BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
            //后置处理器是否是 BeanDefinitionRegistryPostProcessor
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                //是 BeanDefinitionRegistryPostProcessor 强转
                BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                //直接执行 BeanDefinitionRegistryPostProcessor 的postProcessBeanDefinitionRegistry方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                //添加到 beanDefinitionRegistry 后置处理器中
                registryProcessors.add(registryProcessor);
            } else {
                //添加到 regularPostProcessors 后置处理器中
                regularPostProcessors.add(postProcessor);
            }
        }
        //当前需要执行的 BeanDefinitionRegistryPostProcessor
        currentRegistryProcessors = new ArrayList();
        //找出  BeanDefinitionRegistryPostProcessor 后置处理器的 beanName
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        String[] var16 = postProcessorNames;
        var9 = postProcessorNames.length;

        int var10;
        String ppName;
        for(var10 = 0; var10 < var9; ++var10) {
            //后置处理器的 beanName
            ppName = var16[var10];
            //是否实现了排序接口
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                //添加到当前需要执行的 BeanDefinitionRegistryPostProcessor
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //暂存  后面做重复校验
                processedBeans.add(ppName);
            }
        }
        //排序 currentRegistryProcessors
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        //currentRegistryProcessors 添加到 registryProcessors
        registryProcessors.addAll(currentRegistryProcessors);
        //遍历执行 currentRegistryProcessors 执行 postProcessBeanDefinitionRegistry 方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        //执行完清空 currentRegistryProcessors
        currentRegistryProcessors.clear();
        //找出  BeanDefinitionRegistryPostProcessor 后置处理器的 beanName
        //这里再次执行一次的原因是上面执行完 BeanDefinitionRegistryPostProcessor 可能会新增 BeanDefinitionRegistryPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        var16 = postProcessorNames;
        var9 = postProcessorNames.length;

        for(var10 = 0; var10 < var9; ++var10) {
            ppName = var16[var10];
            //processedBeans 不包含 上面暂存的
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                //添加到当前要执行的 BeanDefinitionRegistryPostProcessor 中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //加进去防重复
                processedBeans.add(ppName);
            }
        }
        //排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        //currentRegistryProcessors 添加到 beanDefinitionRegistry 后置处理器中
        registryProcessors.addAll(currentRegistryProcessors);
        //遍历执行 currentRegistryProcessors 执行 postProcessBeanDefinitionRegistry 方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        //执行完成后清除
        currentRegistryProcessors.clear();
        boolean reiterate = true;
        //再次遍历 这里处理的是不排序的 PostProcessor
        while(reiterate) {
            reiterate = false;
            //获取 BeanDefinitionRegistryPostProcessor
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var19 = postProcessorNames;
            var10 = postProcessorNames.length;

            for(int var26 = 0; var26 < var10; ++var26) {
                String ppName = var19[var26];
                //上面暂存了的 就是已经执行了的
                if (!processedBeans.contains(ppName)) {
                    //添加到当前要执行的 BeanDefinitionRegistryPostProcessor 中 这里是不排序的
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    //暂存
                    processedBeans.add(ppName);
                    //进来这里表示有新的 BeanDefinitionRegistryPostProcessor
                    //后面新的 BeanDefinitionRegistryPostProcessor 执行可能会产生新的 BeanDefinitionRegistryPostProcessor 因此再执行一次
                    reiterate = true;
                }
            }
            //排序 好像没有什么意义
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            //currentRegistryProcessors 添加到 beanDefinitionRegistry 后置处理器中
            registryProcessors.addAll(currentRegistryProcessors);
            //遍历执行 currentRegistryProcessors 执行 postProcessBeanDefinitionRegistry 方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            //清理
            currentRegistryProcessors.clear();
        }
        //调用所有的 registryProcessors 执行 postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
        //调用所有的 regularPostProcessors 执行 postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    } else {
        //到这里说明不是 DefaultListableBeanFactory
        //调用所有的 beanFactoryPostProcessors 执行 postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    }
    //入参中的 PostProcessor 已经处理完毕了  开始处理容器 beanFactory 自己的 PostProcessor
    //获取所有 BeanFactoryPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    //普通的 BeanFactoryPostProcessor
    regularPostProcessors = new ArrayList();
    //BeanDefinitionRegistryPostProcessor
    registryProcessors = new ArrayList();
    //当前的 BeanDefinitionRegistryPostProcessor
    currentRegistryProcessors = new ArrayList();
    postProcessorNames = postProcessorNames;
    int var20 = postProcessorNames.length;

    String ppName;
    for(var9 = 0; var9 < var20; ++var9) {
        ppName = postProcessorNames[var9];
        if (!processedBeans.contains(ppName)) {
            //上面暂层中没有的 postProcessor
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                //添加实现了 PriorityOrdered 接口的
                regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                //添加实现了 Ordered 接口的
                registryProcessors.add(ppName);
            } else {
                //剩下的
                currentRegistryProcessors.add(ppName);
            }
        }
    }
    //排序
    sortPostProcessors(regularPostProcessors, beanFactory);
    //执行 regularPostProcessors 的 postProcessor 方法
    invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    //实现了 Ordered 接口的 PostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
    Iterator var21 = registryProcessors.iterator();

    while(var21.hasNext()) {
        String postProcessorName = (String)var21.next();
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    //排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    //执行 orderedPostProcessors 的 postProcessor 方法
    invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    //其他的 postProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
    Iterator var24 = currentRegistryProcessors.iterator();

    while(var24.hasNext()) {
        ppName = (String)var24.next();
        nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }
    //执行 nonOrderedPostProcessors 的 postProcessor 方法
    invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    //清除元数据缓存
    beanFactory.clearMetadataCache();
}

registerBeanPostProcessors方法源码分析：

registerBeanPostProcessors 方法主要是注册 bean 的后置处理器 BeanPostProcessor，BeanPostProcessor 分別在 bean 初始化之前之后执行，需要注意 BeanPostProcessor 和 BeanFactoryPostProcessor 的区别。

//注册 bean 后置处理器
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

//注册 bean 后置处理器
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    //获取所有 beanFactory 所有 bean后置处理器 BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    //beanFactory 所有 bean后置处理器 BeanPostProcessor 总数量
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    //添加一个bean后置处理器
    beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    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;
    //遍历所有bean后置处理器后分类
    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);
        }
    }
    //处理 priorityOrderedPostProcessors 类型bean后置处理器
    //排序 priorityOrderedPostProcessors bean后置处理器
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    //注册 bean 后置处理器 就是添加后置处理器到 beanFactory中
    registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
    //处理 orderedPostProcessors 类型后置处理器
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList(orderedPostProcessorNames.size());
    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);
        }
    }
    //orderedPostProcessors 类型bean后置处理器排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    //注册 bean 后置处理器 就是添加后置处理器到 beanFactory中
    registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors);
    //处理 nonOrderedPostProcessors 类型bean后置处理器
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList(nonOrderedPostProcessorNames.size());
    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);
        }
    }
    //注册 bean 后置处理器 就是添加bean后置处理器到 beanFactory中
    registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
    //处理 internalPostProcessors 类型bean后置处理器
    sortPostProcessors(internalPostProcessors, beanFactory);
    //注册 bean 后置处理器 就是添加bean后置处理器到 beanFactory中
    registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
    //添加一个监听器类型的后置处理器 ApplicationListenerDetector
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

initMessageSource方法源码分析：

initMessageSource 方法的主要作用是国际化功能。

//资源国际化
protected void initMessageSource() {
    //获取 beanFactory
    ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
    //beanFactory 中是否有个 messageSource 的bean
    if (beanFactory.containsLocalBean("messageSource")) {
        //如果有 messageSource 就等于这个bean
        this.messageSource = (MessageSource)beanFactory.getBean("messageSource", MessageSource.class);
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource)this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(this.getInternalParentMessageSource());
            }
        }

        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    } else {
        //没有就创建一个 DelegatingMessageSource
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(this.getInternalParentMessageSource());
        this.messageSource = dms;
        //DelegatingMessageSource 注册到 beanFactory 中
        beanFactory.registerSingleton("messageSource", this.messageSource);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("No 'messageSource' bean, using [" + this.messageSource + "]");
        }
    }

}

initApplicationEventMulticaster方法源码分析：

initApplicationEventMulticaster 主要作用就是初始化事件派发器、多播器。

//初始化一个事件多播器
protected void initApplicationEventMulticaster() {
    //获取 beanFactory
    ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
    //beanFactory 中是否有 应用程序事件多播器
    if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
        //有直接赋值
        this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    } else {
        //没有就创建一个 应用程序事件多播器
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        //应用程序事件多播器 注册到 beanFactory 中
        beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("No 'applicationEventMulticaster' bean, using [" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }

}

onRefresh方法源码分析：

onRefresh 方法源码是空实现，是一个扩展点，可以自己实现子类重写这个方法，在容器刷新时去做一些自己想要的操作。

registerListeners方法源码分析：

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];
        //往 应用程序事件多播器 中添加监听器
        this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    //早期要处理的事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        //有早期需要处理的事件
        Iterator var9 = earlyEventsToProcess.iterator();
        //遍历派发出去
        while(var9.hasNext()) {
            ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
            //使用 应用程序事件多播器 将事件派发出去
            this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }

}

finishBeanFactoryInitialization方法源码分析：

finishBeanFactoryInitialization 方法主要是用来初始化单例 bean，给 beanFactory 设置值解析器，冻结 BeanDefinition 等。

//beanFactory 创建完成 初始化单例bean
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //给 beanFactory 设置 ConversionService
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }
    //给 beanFactory 设置 值解析器
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }
    //获取所有的 LoadTimeWeaverAware 织入  Aspect AOP  相关
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        //初始化 LoadTimeWeaverAware  bean
        this.getBean(weaverAwareName);
    }
    //设置临时类加载器为 null
    beanFactory.setTempClassLoader((ClassLoader)null);
    //冻结BeanDefinition
    beanFactory.freezeConfiguration();
    //预实例化单例非懒加载 lazy-init 的 bean
    beanFactory.preInstantiateSingletons();
}

finishRefresh方法源码分析：

finishRefresh 主要是在 beanFactory 加载完成后做一些操作，包括清空资源发布事件等。

//完成后刷新
protected void finishRefresh() {
    //清除资源缓存
    this.clearResourceCaches();
    //初始化生命周期处理器
    this.initLifecycleProcessor();
    //将刷新完成事件广播到 生命周期处理器
    this.getLifecycleProcessor().onRefresh();
    //广播容器刷新完成事件
    this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
    if (!NativeDetector.inNativeImage()) {
        //注册 ApplicationContext 到 LiveBeansView 内部的 applicationContexts 中
        LiveBeansView.registerApplicationContext(this);
    }

}

总结：本篇简单只是分析了 AbstractApplicationContext#refersh 方法的执行流程，也就是 IOC 的流程，希望可以对 IOC 流程有一个大概的理解，对于 bean 的创建 doCreateBean 并没有去分析，后续会针对这块去进行详细分析，希望可以帮助到有需要的伙伴。

欢迎提出建议及对错误的地方指出纠正。

码农爱java

关注

29
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
深入理解 Spring IOC 底层实现机制（refresh 方法源码分析）

/IOC 核心方法//防止启动和销毁并发执行//启动步骤记录//刷新准备工作//创建 beanFactory 将配置文件解析为 beandefiniton 对象注册到 beanFactory 中//ConfigurableListableBeanFactory是一个接口真正干活的是 DefaultListableBeanFactory//beanFactory 预处理主要是设置 beanFactory 类加载器及忽略一些自动装配设置一些默认benatry {
复制链接

扫一扫