栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【Spring】二、SpringIOC Bean的初始化流程

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【Spring】二、SpringIOC Bean的初始化流程

上一篇:【Spring】一、Spring注解真的你会用吗

下一篇:【Spring】三、SpringIOC Bean的初始化流程-循环依赖

文章目录
  • 一、 Spring源码中对象的介绍
    • 1、IoC 和 DI
    • 2、bean
    • 3、BeanDefinition
    • 4、BeanFactory 和 ApplicationContext
    • 5、FactoryBean
  • 二、 SpringIOC源码分析
    • 1、宏观分析
    • 2、refresh()方法12个步骤分析
    • 3、IOC容器12步中的第5步剖析
    • 4、IOC容器12步中的第11步剖析
  • 三、 基于注解的Spring IOC容器宏观总结
  • 四、 画图总结

一、 Spring源码中对象的介绍

首先咱们先回顾一下spring的基础知识,

1、IoC 和 DI

IoC (Inversion of Control),即控制反转。这不是一种新的技术,而是 Spring 的一种设计思想。

在传统的程序设计,我们直接在对象内部通过 new 来创建对象,是程序主动去创建依赖对象;而在 Spring 中有专门的一个容器来创建和管理这些对象,并将对象依赖的其他对象注入到该对象中,这个容器我们一般称为 IoC 容器。

所有的类的创建、销毁都由 Spring 来控制,也就是说控制对象生存周期的不再是引用它的对象,而是 Spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被 Spring 控制,所以这叫控制反转。

DI(Dependency Injection),即依赖注入,由 Martin Fowler 提出。可以认为 IoC 和 DI 其实是同一个概念的不同角度描述。

依赖注入是指组件之间的依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。

通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

2、bean

官方概念:在 Spring 中,构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是一个由 Spring IoC 容器实例化,组装和管理的对象。

大白话:bean 可以认为是那些我们想注入到 Spring IoC 容器的 Java 对象实例的抽象。

我们经常会在 Service 上使用 @Service 注解,然后在要使用该 Service 的类中通过 @Autowire 注解来注入,这个 Service 就是一个 bean。在这个地方,@Service 注解相当于告诉 IoC 容器:这个类你需要帮我创建和管理;而 @Autowire 注解相当于告诉 IoC 容器:我需要依赖这个类,你需要帮我注入进来。

3、BeanDefinition

理解了 bean,BeanDefinition 就好理解了。BeanDefinition 是 bean 的定义,用来存储 bean 的所有属性方法定义。

4、BeanFactory 和 ApplicationContext

BeanFactory:基础类型 IoC 容器,提供完整的 IoC 服务支持。

ApplicationContext:BeanFactory 的子接口,在 BeanFactory 的基础上构建,是相对比较高级的 IoC 容器实现。包含 BeanFactory 的所有功能,还提供了其他高级的特性,比如:事件发布、国际化信息支持、统一资源加载策略等。正常情况下,我们都是使用的 ApplicationContext。
以电话来举例:
我们家里使用的 “座机” 就类似于 BeanFactory,可以进行电话通讯,满足了最基本的需求。

而现在非常普及的智能手机,iPhone、小米等,就类似于 ApplicationContext,除了能进行电话通讯,还有其他很多功能:拍照、地图导航、听歌等。

5、FactoryBean

一般情况下,我们将 bean 的创建和管理都交给 Spring IoC 容器,Spring 会利用 bean 的 class 属性指定的类来实例化 bean。

但是如果我们想自己实现 bean 的创建操作,可以实现吗?答案是可以的,FactoryBean 就可以实现这个需求。

FactoryBean 是一种特殊的 bean,它是个工厂 bean,可以自己创建 bean 实例,如果一个类实现了 FactoryBean 接口,则该类可以自己定义创建实例对象的方法,只需要实现它的 getObject() 方法即可。

FactoryBean 可能对于普通开发来说基本用不到也没去注意过,但是它其实应用的非常广,特别是在中间件中,如果你看过一些中间件的源码,一定会看到 FactoryBean 的身影。

二、 SpringIOC源码分析 1、宏观分析
1、ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

2、new AnnotationConfigApplicationContext(SpringConfig.class);--> {
     2.1、this();-->{
	    //spring内部加载了5个BeanDefinition:就是对bean的描述;
	    2.1.1、this.reader = new AnnotatedBeanDefinitionReader(this);
	    //放置了@Compment注解
	    2.1.2、this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
     2.2、register(componentClasses); {
	//把componentClasses(SpringConfig)变成bean的描述:BeanDefinition;
	//然后把BeanDefinition包装成BeanDefinitionHolder;
	//然后取出BeanDefinitionHolder里面的BeanDefinition;
	//注册到Map beanDefinitionMap中;
}
    2.3、refresh();//参考下面的具体步骤
}

3、refresh(); {
    //该方法总共有12个步骤,重点看第5步和第11步,宏观上的步骤是:
    //根据项目中的bean(@Service、@Compment...注解的bean)得到BeanDefinition
   //把BeanDefinition放入(注册)beanDefinitionMap中
    //把beanDefinitionMap里面的BeanDefinition拿出来,依次创建所对应的对象;
}
}
2、refresh()方法12个步骤分析
   
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		//线程同步
		synchronized (this.startupShutdownMonitor) {
			// 1、预准备刷新上下文
			// Prepare this context for refreshing.
			prepareRefresh();

			// 2、TODO 告诉子类去刷新内部的bean factory,获得刷新的bean factory,最终得到是DefaultListableBeanFactory,并且加载bean的定义
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 3、预处理bean工厂,为在上下文中使用,注册systemEnvironment,environment,systemProperties几个bean
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				//4、由子类覆盖该方法做额外的处理,默认spring框架什么也没有做
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				//TODO 注解开发的时候,对包扫描的得到bean定义在此步骤完成的,底层就是扫描注解得到bean的定义,然后放入到bean定义的Map中
				//5、激活各种BeanFactory处理器,目前BeanFactory没有注册任何BeanFactoryPostProcessor,此处相当于不做操作
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				//6、注册拦截Bean创建的Bean处理器,如果没有bean processors,此步骤什么也不做
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				//7、在上下文初始化注册messageSource的bean,不同语言环境信息,国际化处理
				// Initialize message source for this context.
				initMessageSource();

				//8、在上下文初始化注册applicationEventMulticaster的bean,应用消息广播
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				//9、初始化其他的bean,默认情况下Spring框架什么也不做
				// Initialize other special beans in specific context subclasses.
				onRefresh();

				//10、在所有bean中查找listener bean并注册到消息广播中,没有的话就什么也不做;
				// Check for listener beans and register them.
				registerListeners();

				//11、TODO 初始化所有剩下的非延迟初始化的单例bean对象
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				//12、完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知相关事件
				// Last step: publish corresponding event.
				//TODO 如果是spring mvc,里面会调用spring mvc dispatcherServlet的九大初始化
				finishRefresh();

			} catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			} finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

在以上的12个步骤中,只有第5步和第11步是非常重要的,是我们源码阅读重点需关注的,其他步骤可以略读,下面我们分别剖析一下这两个步骤,首先剖析第5步:

3、IOC容器12步中的第5步剖析
  • 第五步方法代码
	
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

		//TODO 对所有的BeanDefinitionRegistryPostProcessors 、手动注册的BeanFactoryPostProcessor
		// 以及通过配置文件方式的BeanFactoryPostProcessor按照 PriorityOrdered、Ordered、no ordered三种方式分开处理、调用
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

主要调用链路方法解析

1、调用BeanFactoryPostProcessors
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

2、调用PostProcessors,里面处理bean的定义
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

//3、BeanDefinition的注册
postProcessor.postProcessBeanDefinitionRegistry(registry);

4、处理配置类的bean的定义
processConfigBeanDefinitions(registry);

5、解析每一个带有@Configuration注解的类
ConfigurationClassParser parser = new ConfigurationClassParser(...);

//对配置类中注解进行处理
parser.parse(candidates);

6、加载bean的定义: 把BeanDefinition放入到一个Map中
this.reader.loadBeanDefinitions(configClasses);

7、注册bean的定义
this.registry.registerBeanDefinition(beanName, beanDefToRegister);

8、注册bean定义,即把beanDefinition放入Map中
this.beanDefinitionMap.put(beanName, beanDefinition);

上面是第5步的主要流程,要基于该流程反复断点调试跟几轮代码,潜移默化中提升源码的阅读能力,此能力需要坚持一个过程和一段时间,非一蹴而就;

4、IOC容器12步中的第11步剖析

- 第11步方法

	
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

		// Initialize conversion service for this context.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {

			//设置conversionService的bean,与类型转换相关的bean
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		//如果没有内嵌的值解析器
		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			//给beanfactory添加一个值解析器
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 初始化运行时的代码织入,为AspectJ的支持
		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 停止使用临时的ClassLoader
		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// 缓存所有的bean definition元信息,不希望未来发生变化
		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// TODO 实例化所有剩下的非延迟加载的单例bean
		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}
  • 11步主要调链条
//1、初始化所有剩下的非延迟初始化的单例bean对象
finishBeanFactoryInitialization(beanFactory);

//2、实例化所有剩下的非延迟加载的单例bean
beanFactory.preInstantiateSingletons();

//3、获取bean,底层初始化bean对象,并对bean对象赋值和依赖注入
getBean(beanName);

//4、获取一个bean实例
return doGetBean(name, null, null, false);

//5、创建单例的bean实例
return createBean(beanName, mbd, args);

//6、创建bean实例
Object beanInstance = doCreateBean(beanName, mbdToUse, args);

//7、创建bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args); {
// TODO 实例化bean实例
return instantiateBean(beanName, mbd);

//TODO 此处真正地创建了 bean 的实例对象,底层依然是反射
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

//TODO 根据构造器实例化对象
return BeanUtils.instantiateClass(constructorToUse);
}

//8、填充bean的属性值,给bean赋值和注入依赖,如果当前bean依赖了其他的bean,则会递归调用beanFactory.getBean()方法尝试获取目标bean
populateBean(beanName, mbd, instanceWrapper);
三、 基于注解的Spring IOC容器宏观总结
  1. 创建AnnotationConfigApplicationContext;
  2. 创建AnnotationConfigApplicationContext的时候会先创建DefaultListableBeanFactory;
  3. 创建好DefaultListableBeanFactory之后,解析和扫描类上的注解并将所有Bean封装成BeanDefinition对象,该BeanDefinition对象封装了Spring所有bean的相关定义描述信息;
  4. 对Spring配置的所有bean做实例化,根据BeanDefinition对象的信息,底层采用反射创建具体的bean对象;
  5. 将实例化的bean对象放入到一个Map中,后续应用程序就能从该Map中获取到bean对象,该Map也就是我们的ioc容器;
四、 画图总结

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/943790.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号