上一篇:【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的基础知识,
1、IoC 和 DIIoC (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 和 ApplicationContextBeanFactory:基础类型 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容器宏观总结
- 创建AnnotationConfigApplicationContext;
- 创建AnnotationConfigApplicationContext的时候会先创建DefaultListableBeanFactory;
- 创建好DefaultListableBeanFactory之后,解析和扫描类上的注解并将所有Bean封装成BeanDefinition对象,该BeanDefinition对象封装了Spring所有bean的相关定义描述信息;
- 对Spring配置的所有bean做实例化,根据BeanDefinition对象的信息,底层采用反射创建具体的bean对象;
- 将实例化的bean对象放入到一个Map中,后续应用程序就能从该Map中获取到bean对象,该Map也就是我们的ioc容器;



