目录
7、Bean的生命周期
7.1、生命周期流程
- Spring容器启动后，获取配置文件，注册配置的 Bean
-
资源定位：通过ResourceLoader进行资源定位，可以通过class的全限定名确定Bean的位置
-
元信息解析：BeanDefinitionReader读取定位到所有Bean，将每一个Bean都解析成一个
BeanDefinition对象(包含Bean的各种信息：class名、作用域、懒加载、FactoryBean、构造函数、属性值、描述以及bean的来源等)，并加载到内存中。（XmlBeanDefinationReader读取XML配置信息、PropertiesBeanDefinitionReader读取properties配置文件、AnnotatedBeanDefinitionReader读取注解配置元信息） -
元信息注册：Spring将这些BeanDefinition对象都保存到 BeanDefinitionRegistry(Bean定义注册表)的ConcurrentHashMap集合中。
-
BeanDefinition合并：Spring通过BeanFactoryPostProcessor将这些BeanDefinition对象进行整理合并（子类覆盖父类属性，占位符替换成真实数据等等），然后生成一个RootBeanDefinition对象（继承了AbstractBeanDefinition，而AbstractBeanDefinition实现了BeanDefinition）。
RootBeanDefinition 本质上是 Spring BeanFactory 运行时统一的 BeanDefinition 视图，Spring在获取Bean是就是获取这个对象，通过次对象获取相应的Bean
-
通过 getMergedLocalBeanDefinition(beanName) 获取注册信息，并检查bean之间的依赖关系，确保bean初始化前，它所依赖的其他bean已经被初始化
-
准备实例化
- 获取 scope属性的值，根据不同的值，选择不同的创建方式。（缓存中、单例、原型、其他）
- 在实例化前进行一些必要的处理
- 间接引用替换成直接引用
- 查是否存在覆盖方法
- 执行前置处理器，做进一步的检查
- 开始 实例化、初始化Bean对象
- 实例化Bean对象，并创建一个BeanWrapper对象，将Bean对象注入
- 处理循环依赖问题
- 开始属性注入
- 调用初始化方法
- 查看是否实现了Aware相关的接口
- 初始化前置处理方法
- 初始化方法
- 初始化后置处理方法
-
初始化完成，Bean对象创建成功
-
根据不同的bean在不同的时机销毁bean对象
7.2、源码分析
7.2.1、doGetBean
在 ApplicationContext 类型容器的内部持有一个BeanFactory类型的容器，所有的bean实际是存放在这个内置容器中的。ApplicationContext类型的容器在启动的过程中会自动创建所有单例类型的bean，实际是调用了getBean(beanName)这个方法，此方法就是调用的 doGetBean 方法。
所以说研究Bean的生命周期，离不开doGetBean方法。
//ApplicationContext下的getBean
Object getBean(String name) throws BeansException;
//AbstractBeanFactory实现的getBean方法
@Override
public Object getBean(String name) throws BeansException {
//调用doGetBean
return doGetBean(name, null, null, false);
}
/*参数：
name要获取的bean名
requiredType要获取的bean的类型
args使用显式参数创建 bean 实例时使用的参数（仅在创建新实例而不是检索现有实例时应用）
typeCheckOnly是否获取实例进行类型检查，而不是实际使用
*/
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
//返回 bean 名称，必要时去除工厂取消引用前缀，并将别名解析为规范名称
String beanName = transformedBeanName(name);
//bean实例
Object beanInstance;
//1、检查缓存中是否有手动注册的单例，如果缓存中有，则直接从缓存中加载
Object sharedInstance = getSingleton(beanName);
//从缓存中获取到了
if (sharedInstance != null && args == null) {
//跟踪启用
if (logger.isTraceEnabled()) {
//此 bean 当前是否正在创建中
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//获取创建好的Bean实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
//2、如果缓存中没有对应bean，需要通过父类工厂加载Bean的一些配置信息
else {
//如果是目前正在创建的原型，则出错。
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
//获取到了父工厂，且自身工厂内不存在该bean（双亲委派机制）
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//获取原始 bean 名称，将本地定义的别名解析为规范名称。
String nameToLookup = originalBeanName(name);
//根据doGetBean的四个参数进行判断
//父工厂是AbstractBeanFactory的实例，调用父工厂的doGetBean
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
//用显式参数委托给父对象。.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// 没有参数 -> 委托给标准的getBean方法。
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//是否获取实例进行类型检查，将指定的 bean 标记为已创建（或即将创建）。
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
//应用程序启动指标，创建一个新步骤并标记它的开始。
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
//bean的类型不为空
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
// 从bean 名称映射中返回一个合并的 RootBeanDefinition，存放的整合的Bean信息
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查给定的合并 bean 定义，可能会引发验证异常
checkMergedBeanDefinition(mbd, beanName, args);
//初始化依赖的bean。返回此 bean 所依赖的 bean 名称。
String[] dependsOn = mbd.getDependsOn();
//不为null。表示Bean中依赖了其他的Bean
if (dependsOn != null) {
for (String dep : dependsOn) {
//如果此依赖已注册为依赖项
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//为bean注册依赖
registerDependentBean(dep, beanName);
try {.
//递归（注册的bean可能还依赖了其他bean，需要递归）
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//3、到了此处开始创建bean，如果是单列的
if (mbd.isSingleton()) {
// 第二个参数的回调接口，接口是接口实现的方法是 createBean(beanName, mbd, args)
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 显式地从单例缓存中删除实例:它可能已经放在那里了
// 由创建过程触发，以允许循环引用解析
// 删除接收到该bean临时引用的所有bean。
destroySingleton(beanName);
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName,mbd);
}
//4、如果非单例
else if (mbd.isPrototype()) {
// 这是一个原型 -> 创建一个新实例
Object prototypeInstance = null;
try {
//建原型之前的回调。默认实现将原型注册为当前正在创建中
beforePrototypeCreation(beanName);
//开始创建原型模式
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//创建原型后的回调。默认实现将原型标记为不再处于创建状态
afterPrototypeCreation(beanName);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//5、不是单例，又不是原型
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
return adaptBeanInstance(name, beanInstance, requiredType);
}
方法内包含了获取Bean信息，到获取Bean对象等一系列步骤：
先检查缓存，缓存中存在单例的Bean则从缓存中实例化
如果缓存中不存在，需要通过父类工厂加载Bean的一些配置信息
加载完成后开始创建，先判断是否为单例，是创建单例Bean，再判断是否为原型，是就创建原型的Bean如果两者都不是则获取Scope属性。
最后再获取Bean的实例对象（贯穿始终的，每次加载创建的Bean都需要获取）
7.2.2、Bean信息注册
在Spring启动后，框架首先开始对配置的Bean进行资源整合。SpringIOC容器会为我们管理所需的一些Bean，而Spring需要获取到这些Bean的全部信息，才能在容器中生成并进行管理。这一步主要是通过XML文件、注解等获取我们已经配置的Bean的一些信息。
-
资源定位：通过ResourceLoader进行资源定位，可以通过class的全限定名确定Bean的位置
-
元信息解析：BeanDefinitionReader读取定位到所有Bean，将每一个Bean都解析成一个`BeanDefinition对象，并加载到内存中。
-
元信息注册：Spring将这些BeanDefinition对象都保存到 BeanDefinitionRegistry(Bean定义注册表)的ConcurrentHashMap集合中。
-
BeanDefinition合并：Spring通过BeanFactoryPostProcessor将这些BeanDefinition对象进行整理合并（子类覆盖父类属性，占位符替换成真实数据等等），然后生成一个RootBeanDefinition对象
//信息注册，并返回注册的信息
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
/*
beanName – bean 定义的名称
bd – 原始 bean 定义
containsBd – 如果是顶级 bean， 则为null
*/
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
// 说明是顶级bean，直接获取 RootBeanDefinitio
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
//不是顶级bean，RootBeanDefinition为null，会进行创建
if (mbd == null || mbd.stale) {
previous = mbd;
//如果此BeanDefinition对象没有父bean
if (bd.getParentName() == null) {
// bd是RootBeanDefinition类型的则进行复制，如果不是则进行创建
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
//有父bean，会进行子类覆盖的合并，然后生成一个RootBeanDefinition对象
else {
// 子bean定义：需要与父合并。
BeanDefinition pbd;
try {
//获取父 bean，必要时去除工厂取消引用前缀，并将别名解析为规范名称
String parentBeanName = transformedBeanName(bd.getParentName());
//bean的名字和父bean的名字不相同
if (!beanName.equals(parentBeanName)) {
//返回给定 bean 名称的“合并”BeanDefinition，如有必要，将子 bean 定义与其父 bean 合并。
pbd = getMergedBeanDefinition(parentBeanName);
}
///bean的名字和父bean的名字相同
else {
//获取父工厂
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// 具有覆盖值的深拷贝。
mbd = new RootBeanDefinition(pbd);
//从给定的 bean 定义覆盖此 bean 定义中的设置（可能是从父子继承关系复制的父节点）。
mbd.overrideFrom(bd);
}
// 未配置scope属性，则默认为单例。
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(SCOPE_SINGLETON);
}
//设置了scope属性，则获取值
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
//将BeanDefinition信息注册到 RootBeanDefinition
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
if (previous != null) {
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
//返回给定 bean 名称的“合并”BeanDefinition，如有必要，将子 bean 定义与其父 bean 合并。
public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
String beanName = transformedBeanName(name);
//检查该工厂中是否存在bean定义
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
}
// 在本地解析合并的 bean 定义。
return getMergedLocalBeanDefinition(beanName);
}
//BeanDefinition合并，进行覆盖
public void overrideFrom(BeanDefinition other) {
if (StringUtils.hasLength(other.getBeanClassName())) {
setBeanClassName(other.getBeanClassName());
}
if (StringUtils.hasLength(other.getScope())) {
setScope(other.getScope());
}
setAbstract(other.isAbstract());
if (StringUtils.hasLength(other.getFactoryBeanName())) {
setFactoryBeanName(other.getFactoryBeanName());
}
if (StringUtils.hasLength(other.getFactoryMethodName())) {
setFactoryMethodName(other.getFactoryMethodName());
}
setRole(other.getRole());
setSource(other.getSource());
copyAttributesFrom(other);
if (other instanceof AbstractBeanDefinition) {
AbstractBeanDefinition otherAbd = (AbstractBeanDefinition) other;
if (otherAbd.hasBeanClass()) {
setBeanClass(otherAbd.getBeanClass());
}
if (otherAbd.hasConstructorArgumentValues()) {
getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
}
if (otherAbd.hasPropertyValues()) {
getPropertyValues().addPropertyValues(other.getPropertyValues());
}
if (otherAbd.hasMethodOverrides()) {
getMethodOverrides().addOverrides(otherAbd.getMethodOverrides());
}
Boolean lazyInit = otherAbd.getLazyInit();
if (lazyInit != null) {
setLazyInit(lazyInit);
}
setAutowireMode(otherAbd.getAutowireMode());
setDependencyCheck(otherAbd.getDependencyCheck());
setDependsOn(otherAbd.getDependsOn());
setAutowireCandidate(otherAbd.isAutowireCandidate());
setPrimary(otherAbd.isPrimary());
copyQualifiersFrom(otherAbd);
setInstanceSupplier(otherAbd.getInstanceSupplier());
setNonPublicAccessAllowed(otherAbd.isNonPublicAccessAllowed());
setLenientConstructorResolution(otherAbd.isLenientConstructorResolution());
if (otherAbd.getInitMethodName() != null) {
setInitMethodName(otherAbd.getInitMethodName());
setEnforceInitMethod(otherAbd.isEnforceInitMethod());
}
if (otherAbd.getDestroyMethodName() != null) {
setDestroyMethodName(otherAbd.getDestroyMethodName());
setEnforceDestroyMethod(otherAbd.isEnforceDestroyMethod());
}
setSynthetic(otherAbd.isSynthetic());
setResource(otherAbd.getResource());
}
else {
getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
getPropertyValues().addPropertyValues(other.getPropertyValues());
setLazyInit(other.isLazyInit());
setResourceDescription(other.getResourceDescription());
}
}
7.2.3、获取注册信息
在Spring将Bean的信息注册成一个个的BeanDefinition对象后，IOC容器需要去获取这些注册的信息。
- 如果该对象配置成懒加载，那么直到我们向Spring要依赖对象实例之前，都是以一个个的BeanDefination的形式存在。
- 如果不是选择懒加载的方式，容器启动阶段完成之后，其中有一个步骤 finishBeanFactoryInitialization()，在这一步将立即启动Bean实例化阶段，通过隐式的调用所有依赖对象的getBean方法来实例化所有配置的Bean，完成类的加载。
在doGet方法中，检测了缓存中不存在单例bean后，就会创建父工厂，获取bena的一些信息
// 获取父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
...........
try {
.........
// 返回一个合并的 RootBeanDefinition，存放的整合的Bean信息
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查给定的合并 bean 定义，可能会引发验证异常
checkMergedBeanDefinition(mbd, beanName, args);
}
获取RootBeanDefinition中的注册信息
//bean 名称映射
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
//返回一个合并的 RootBeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
//从map集合中根据beanName获取RootBeanDefinition（缓存中）
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
//获取到后直接返回
if (mbd != null && !mbd.stale) {
return mbd;
}
//未获取到，则此事还没有RootBeanDefinition，进行信息注册（getBeanDefinition(beanName)
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
protected RootBeanDefinition getMergedBeanDefinition( String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
//mergedBeanDefinitions缓存上锁，避免出现并发问题
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
//重复获取BeanDefinition信息，并发情况考虑
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null || mbd.stale) {
previous = mbd;
//当前bean不存在继承情况的处理，
if (bd.getParentName() == null) {
// 是RootBeanDefinition类型的，就使用给定根 bean 定义的副本，否则新创建
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
//当前bean存在继承情况的处理，
else {
//子bean定义：需要与父合并
BeanDefinition pbd;
try {
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
//获取当前BeanDefinition中parentName对应的父BeanDefinition信息
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
//parentName和当前beanName相同时，在父工厂中获取父类BeanDefinition对象
pbd = ((ConfigurableBeanFactory)parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// 根据父类BeanDefinition信息创建新对象。
mbd = new RootBeanDefinition(pbd);
//父类对象继承当前BeanDefinition核心属性
mbd.overrideFrom(bd);
}
// 如果之前未配置，则设置默认单例范围。
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(SCOPE_SINGLETON);
}
// 非单例
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 选择性将新建的mergedBeanDefinition信息添加到 mergedBeanDefinitions缓存中
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
//将缓存的BeanDefinition部分信息复制到新创建的BeanDefinition信息中
if (previous != null) {
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
7.2.4、检查依赖关系
Spring在获取了注册的信息后，会检查获取Bean之间的依赖关系。
doGetBean中的这段代码就是初始化依赖的bean。返回此 bean 所依赖的 bean 名称。
//初始化依赖的bean。返回此 bean 所依赖的 bean 名称。
String[] dependsOn = mbd.getDependsOn();
//不为null。表示Bean中依赖了其他的Bean
if (dependsOn != null) {
for (String dep : dependsOn) {
//如果此依赖已注册为依赖项
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//为bean注册依赖
registerDependentBean(dep, beanName);
try {.
//递归（注册的bean可能还依赖了其他bean，需要递归）
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
-
判断该bean是否已经注入过了
//beanName – 要检查的 bean 的名称 dependentBeanName – 依赖 bean 的名称 protected boolean isDependent(String beanName, String dependentBeanName) { synchronized (this.dependentBeanMap) { return isDependent(beanName, dependentBeanName, null); } } //依赖 bean 名称之间的映射：bean 名称到依赖 bean 名称集 private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64); private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) { //如果alreadySeen不为空，且内含有beanName if (alreadySeen != null && alreadySeen.contains(beanName)) { return false; } //确定原始名称，将别名解析为规范名称 String canonicalName = canonicalName(beanName); //从依赖 bean 名称之间的映射集中获取依赖的Bean Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName); //没有获取到，返回false if (dependentBeans == null) { return false; } //包含依赖 bean 的名称，已经注册过了返回true if (dependentBeans.contains(dependentBeanName)) { return true; } //遍历获取到的结果集 for (String transitiveDependency : dependentBeans) { //创建alreadySeen，将bean 的名称添加进去 if (alreadySeen == null) { alreadySeen = new HashSet<>(); } //递归检查依赖 alreadySeen.add(beanName); if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { return true; } } return false; } -
注入Bean
//依赖 bean 名称之间的映射：bean 名称到 bean 依赖项的 bean 名称集 private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64); //依赖 bean 名称之间的映射：bean 名称到依赖 bean 名称集 private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64); public void registerDependentBean(String beanName, String dependentBeanName) { //确定原始名称，将别名解析为规范名称 String canonicalName = canonicalName(beanName); // synchronized (this.dependentBeanMap) { Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8)); if (!dependentBeans.add(dependentBeanName)) { return; } } synchronized (this.dependenciesForBeanMap) { Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8)); dependenciesForBean.add(canonicalName); } }
7.2.5、判断Scope
Spring会判断Scope属性，然后根据其属性决定怎么实例化Bean（从缓存中获取、创建单例、创建原型、其他）
1、缓存中获取
如果缓存中有，从缓存中获取单例 bean，通过方法：getSingleton(String beanName, boolean allowEarlyReference)
//1、检查缓存中是否有手动注册的单例，如果缓存中有，则直接从缓存中加载
Object sharedInstance = getSingleton(beanName);
//从缓存中获取到了
if (sharedInstance != null && args == null) {
//跟踪启用
if (logger.isTraceEnabled()) {
//此 bean 当前是否正在创建中
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//获取创建好的Bean实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
返回在给定名称下注册的单例对象。
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
//单例对象的缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//早期单例对象的缓存
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 单例工厂的缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//返回在给定名称下注册的（原始）单例对象。beanName – 要查找的 bean 的名称 allowEarlyReference – 是否应该创建早期引用
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从单例对象的缓存中检查是否存在该实例
Object singletonObject = this.singletonObjects.get(beanName);
// 如果缓存中没有，再判断是否正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//从早期单例对象的缓存中检查是否存在该实例
singletonObject = this.earlySingletonObjects.get(beanName);
//如果早期单例对象中没有，且可以创建
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// 在完整的单例锁中一致地创建早期引用(继续从缓存中判断)
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
//从单例工厂的缓存获取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
//获取成功
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
//将其添加到单例对象缓存和早期单例对象缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
2、创建单例Bean
如果缓存中没有则判断为单例，创建单例的 BeangetSingleton(String beanName, ObjectFactory<?> singletonFactory)
if (mbd.isSingleton()) {
// 返回以给定名称注册的（原始）单例对象，如果尚未注册，则创建并注册一个新对象
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 显式地从单例缓存中删除实例:它可能已经放在那里了
// 由创建过程触发，以允许循环引用解析
// 删除接收到该bean临时引用的所有bean。
destroySingleton(beanName);
throw ex;
}
});
//获取给定 bean 实例的对象，bean 实例本身或其创建的对象（如果是 FactoryBean）。
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName,mbd);
}
//指示对象当前是否在销毁中的标志。
private boolean singletonsCurrentlyInDestruction = false;
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
//beanName不能为空
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//再次检查是否已经被加载了,如果加载了直接复用
Object singletonObject = this.singletonObjects.get(beanName);
//为空则表示之前没有被加载过
if (singletonObject == null) {
//对象在销毁状态，则不能创建
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
//调试
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//初始化前操作，校验是否 beanName 是否有别的线程在初始化，并记录beanName的初始化状态
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//调用createBean方法实例化bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
//单例对象是否在此期间隐式出现？如果是，继续执行，因为异常表示该状态。
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//创建后，移除初始化状态
afterSingletonCreation(beanName);
}
//创建完了，将其加入到缓存中
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
3、创建原型Bean
如果缓存中没有，且判断为原型，创建原型的Bean
else if (mbd.isPrototype()) {
//原型实例
Object prototypeInstance = null;
try {
//在原型创建之前的回调，默认实现将原型注册为当前正在创建中
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException;
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 确保此时实际解析了 bean 类，并克隆 bean 定义，以防动态解析的 Class 无法存储在共享的合并 bean 定义中。
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 准备方法覆盖。
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),beanName,
"Validation of method overrides failed", ex);
}
try {
// 让 BeanPostProcessors 有机会返回一个代理而不是目标 bean 实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
//检测到的异常已经具有正确的 bean 创建上下文，或者要与 DefaultSingletonBeanRegistry 通信的非法单例状态。
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
4、其他
既不是单例，也不是原型，则获取Scope
else {
//获取 Scope 的取值
String scopeName = mbd.getScope();
//没有为 bean 定义范围名称
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
//没有为作用域名称注册作用域
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//从底层范围返回具有给定名称的对象，如果在底层存储机制中找不到，则creating it
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
7.2.6、实例化前准备
在判断完Scope属性后，就会针对不同的模式创建不同的Bean对象，创建对象使用了createBean这个方法，这个方法就是进行Bean的实例化，其中在实例化开始前会有一些准备工作（解析引用，检查方法的覆盖，前置处理方法）
//AbstractAutowireCapableBeanFactory类
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
// 保存了Bean的元信息
RootBeanDefinition mbdToUse = mbd;
//确保此时实际解析了 bean 类，并克隆 bean 定义，以防动态解析的 Class 无法存储在共享的合并 bean 定义中。
//将 bean 类名称解析为 Class 引用，并将解析的 Class 存储在 bean 定义中以供进一步使用。
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//准备方法重写
try {
//验证并准备为此 bean 定义的方法覆盖。检查具有指定名称的方法是否存在
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//前置方法处理：解析指定bean，给BeanPostProcessors一个机会返回一个代理而不是目标bean实例。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
//如果代理成功创建 bean 后，直接返回
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//开始创建Bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
//先前检测到的异常已经具有正确的 bean 创建上下文，或者要与 DefaultSingletonBeanRegistry 通信的非法单例状态。
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
1、引用问题
间接引用替换成直接引用
protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)throws CannotLoadBeanClassException {
try {
//返回此定义是否指定了一个 bean 类,指定了直接返回
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
//获取系统范围的安全管理器
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
}
else {
return doResolveBeanClass(mbd, typesToMatch);
}
}
catch (PrivilegedActionException pae) {
ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (LinkageError err) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
}
}
2、方法覆盖
检查是否存在覆盖方法：获取类的重载方法列表，然后遍历，一个一个进行处理
//验证并准备为此 bean 定义的方法覆盖。检查具有指定名称的方法是否存在
mbdToUse.prepareMethodOverrides();
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// 检查查找的方法是否存在，并确定它们的重载状态。
if (hasMethodOverrides()) {
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
3、前置处理
前置处理：执行了两个关键方法，前置拦截器和后置拦截器。
//前置方法处理：解析指定bean，给BeanPostProcessors一个机会返回一个代理而不是目标bean实例。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
//如果代理成功创建 bean 后，直接返回
return bean;
}
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 确保此时实际解析了 bean 类
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 执行前置拦截器的操作
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 执行后置拦截器的操作
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
return null;
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
7.2.7、实例化初始化
准备完成后，就开始创建对象了，在createBean方法中，完成了前面的准备工作后，调用doCreateBean(beanName, mbdToUse, args)创建实例：
try {
//开始创建Bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
到了这一步，就开始真正创建bean对象了：
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
// 实例化 bean,返回BeanWrapper。
BeanWrapper instanceWrapper = null;
//如果bean是单例，就先清除缓存中的bean信息
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//根据指定bean使用对应的策略实例化bean
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取包装实例
Object bean = instanceWrapper.getWrappedInstance();
//返回包装的 bean 实例的类型。
Class<?> beanType = instanceWrapper.getWrappedClass();
//如果类型不为空，RootBeanDefinition的类型就是此类型
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 后置处理器修改合并后的 bean 定义：Autowired 注解正式通过此方法实现诸如类型的预解析
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//依赖处理，提前暴露bean的引用，提前解决循环依赖的问题
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//第二个参数是回调接口，实现的功能是将切面动态织入 bean
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 初始化 bean 实例
Object exposedObject = bean;
//将各个属性值注入，如果存在对其它 bean 的依赖，将会递归初始化依赖的 bean
try {
//属性注入
populateBean(beanName, mbd, instanceWrapper);
//调用初始化方法，例如 init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
//循环依赖的检查
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
// 只有在检测到有循环依赖的情况下才不为空
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// bean 创建后，它所依赖的 bean 一定也已经创建了，此时actualDependentBeans也就位空了，但如果 actualDependentBeans 不为空，表示还有依赖的 bean 没有初始化完成，也就是存在循环依赖
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 注册 DisposableBean, destroy-method 属性,以便在销毁对象时调用。
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
1、BeanWrapper
创建BeanWrapper对象，将新创建的Bean对象注入：BeanWrapper是Spring封装的一个对象，通过BeanFactory等隐式调用，是对反射相关API的简单封装，它和bean的关系，就像是父类和子类一样，如果要调用某个bean的方法，可以用BeanWrapper直接代替Bean来调用其方法。
（BeanWrapper使Srping不必关心Bean的类型，只需要使用BeanWrapper，就能分析和操作标准 JavaBean ，获取和设置属性值（单独或批量）、获取属性描述符以及查询属性的可读性/可写性的能力。）
//createBeanInstance():一种是工厂方法，另一种就是构造函数（如果存在工厂方法则使用工厂方法进行初始化，不存在工厂则使用有参构造，都不存在则使用默认的构造）
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 确保此时实际解析了 bean 类
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if(beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) &&!mbd.isNonPublicAccessAllowed()){
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
//如果实例供应商存在，此功能供应商获取
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//获取工厂方法名称不为空,使用工厂方法实例化
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//重新创建同一个bean时的快捷方式...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 如果一个类有多个构造函数，每个构造函数都有不同的参数，调用前需要进行判断对应的构造函数或者工厂方法
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果已经解析过，不需要再次解析
if (resolved) {
if (autowireNecessary) {
// 构造函数自动注入
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 使用默认的构造函数
return instantiateBean(beanName, mbd);
}
}
// 自动装配的候选构造函数？
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
//默认构造的首选构造函数？
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// 没有特殊处理：只需使用无参数构造函数
return instantiateBean(beanName, mbd);
}
//使用其默认构造函数实例化给定的 bean
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(
(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
}
//创建BeanWrapper对象，将实例化的Bean注入其中
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
2、实例化Bean
若想获取BeanWrapper 这个对象，需要通过反射机制调用bean的构造函数进行创建bean对象，然后将bean对象传递给 BeanWrapper 。
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// 如果没有覆盖，请不要使用 CGLIB 覆盖该类
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
//获取构造函数
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
//反射
final Class<?> clazz = bd.getBeanClass();
//指定的类是一个接口，出现异常
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
//通过反射获取构造函数
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
return BeanUtils.instantiateClass(constructorToUse);
}
获取到了构造函数，使用给定构造函数实例化类
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
//构造函数不能为空
Assert.notNull(ctor, "Constructor must not be null");
try {
//反射工具，获取访问的权限
ReflectionUtils.makeAccessible(ctor);
//存在定是否存在 Kotlin 反射，且给定的Class是 Kotlin 类型（默认构造）
if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
return KotlinDelegate.instantiateClass(ctor, args);
}
//自定义的构造
else {
//获取参数的类型
Class<?>[] parameterTypes = ctor.getParameterTypes();
//不能指定比构造函数参数更多的参数
Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
//具有默认值的 args
Object[] argsWithDefaultValues = new Object[args.length];
for (int i = 0 ; i < args.length; i++) {
if (args[i] == null) {
Class<?> parameterType = parameterTypes[i];
argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
}
else {
argsWithDefaultValues[i] = args[i];
}
}
//返回新的实例
return ctor.newInstance(argsWithDefaultValues);
}
}
catch (InstantiationException ex) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
}
catch (IllegalAccessException ex) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
}
catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
}
catch (InvocationTargetException ex) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
}
}
3、处理循环依赖
某些对象可能会出现循环依赖的情况，所以需要进行处理
//依赖处理，提前暴露bean的引用,即使被 BeanFactoryAware 等生命周期接口触发，也急切地缓存单例以解决循环引用。
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//第二个参数是回调接口，实现的功能是将切面动态织入 bean
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
4、属性注入
属性注入，获取Bean中各个属性的值，开始对值进行注入
//将各个属性值注入，如果存在对其它 bean 的依赖，将会递归初始化依赖的 bean
try {
populateBean(beanName, mbd, instanceWrapper);
}
//用 bean 定义中的属性值填充给定 BeanWrapper 中的 bean 实例。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//实例为空
if (bw == null) {
//具有属性值，抛出异常。没有属性值直接跳过
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// 跳过空实例的属性填充阶段
return;
}
}
//RootBeanDefinition不是合成的。且具有实例化感知 Bean 后处理器，则获取实例化后的后处理
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
//获取属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//获取自动装配的方式
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
// 根据名称或者根据类型自动装配
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
//可变属性值
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 根据名称自动装配属性值(byName)
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 根据类型添加基于自动装配的属性值。(byType)
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//是否具有实例化感知 Bean 后处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
//是否需要深度检查（深度的依赖）
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
//属性描述符
PropertyDescriptor[] filteredPds = null;
//如果有后置处理器，进行后置的处理
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
//属性值
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
//需要深度检查，，检查深度依赖
if (needsDepCheck) {
//过滤依赖检查的属性描述符
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//检查依赖项
checkDependencies(beanName, mbd, filteredPds, pvs);
}
//应用属性值
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
-
byName
protected void autowireByName( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { //属性名 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); //遍历属性 for (String propertyName : propertyNames) { //如果有这个属性 if (containsBean(propertyName)) { Object bean = getBean(propertyName); pvs.add(propertyName, bean); //注册依赖 Bean registerDependentBean(propertyName, beanName); if (logger.isTraceEnabled()) { logger.trace("Added autowiring by name from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + propertyName + "'"); } } else { if (logger.isTraceEnabled()) { logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + "' by name: no matching bean found"); } } } } -
byType
protected void autowireByType( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { //获取自定义类型转换器 TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } //自动装配的 Bean 名称 Set<String> autowiredBeanNames = new LinkedHashSet<>(4); //属性名称 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { try { //获取属性描述符 PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); // 不要尝试为 Object 类型按类型自动装配： if (Object.class != pd.getPropertyType()) { //获取写入方法参数 MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); // 在优先后处理器的情况下，不允许使用 Eager init 进行类型匹配 boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered); //按类型依赖描述符自动装配 DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager); //解决依赖,自动装配参数 Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); //不为null，直接添加 if (autowiredArgument != null) { pvs.add(propertyName, autowiredArgument); } for (String autowiredBeanName : autowiredBeanNames) { //注册依赖的bean registerDependentBean(autowiredBeanName, beanName); if (logger.isTraceEnabled()) { logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + autowiredBeanName + "'"); } } autowiredBeanNames.clear(); } } catch (BeansException ex) { throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex); } } }
5、调用初始化方法
此时开始调用Bean的初始化方法，进行初始化
//调用初始化方法，例如 init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
//初始化给定的 bean 实例，应用工厂回调以及 init 方法和 bean 后处理器。
//从createBean调用传统定义的 bean，从initializeBean调用现有 bean 实例
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
//1、处理Aware接口
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 对特殊的 bean 处理：Aware/ BeanClassLoader / BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
//2、执行BeanPostProcessor前置处理：
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//在初始化之前应用 Bean 后处理器
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
//3、开始初始化
try {
//调用初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
//4、执行BeanPostProcessor后置处理
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
检查Aware接口
查看是否实现了Aware相关的接口，通过这些接口可以获取Spring相关资源。比如：
- 获取Bean的名称：如果Bean实现了BeanNameAware接口，就会调用实现方法setBeanName(String)，传递的为Bean的ID值
- 资源路径：BeanClassLoaderAware 的setBeanClassLoader
- 获取BeanFactory：如果Bean实现了BeanFactoryAware接口，就会调用实现方法setBeanFactory(BeanFactory)，传递的是Spring工厂自身
private void invokeAwareMethods(String beanName, Object bean) {
//看是否属于Aware
if (bean instanceof Aware) {
//实现了BeanNameAware
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
//实现了BeanClassLoaderAware
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
//实现了BeanFactoryAware
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
初始化前置方法
预初始化(初始化前的前置处理)：如果Bean实现了BeanPostProcessor接口，spring将调用他们的postProcessBeforeInitialization(Object bean, String beeanName)方法。
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//调用postProcessBeforeInitialization(Object bean, String beeanName)方法
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
开始初始化
进行初始化（BeanFactory管理的Bean是在使用到Bean的时候才会实例化Bean，ApplicantContext管理的Bean在容器初始化的时候就会完成Bean实例化）
如果实现了 InitializingBean 接口，则执行 afterPropertiesSet 方法。
如果配置了 init-method 还会在afterPropertiesSet之后在执行 init-method。
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
//是否实现InitializingBean接口
boolean isInitializingBean = (bean instanceof InitializingBean);
//实现了InitializingBean，且 mbd不为null或不为外部管理的初始化方法
if (isInitializingBean&&(mbd==null||!mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
//执行afterPropertiesSet方法
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null && bean.getClass() != NullBean.class) {
//获取初始化方法名称
String initMethodName = mbd.getInitMethodName();
//如果存在自定义的初始化方法则执行自定义的初始化方法
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
初始化后置方法
调用BeanPostProcessor的初始化后的方法(初始化后的后置处理)：如果Bean实现了BeanPostProcessor接口，spring就将调用他们的postprocessAfterInitialization(Object bean, String beanName)方法
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
6、注册销毁方法
根据不同的 scope 进行 disposableBean 的注册，同时也会注册用户自定义的销毁逻辑：（1）DisposableBean接口的destory()；（2）destory-method参数配置的方法。
// 注册 DisposableBean, destroy-method 属性,以便在销毁对象时调用。
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
//将给定的 bean 注册其 DisposableBean 接口和/或在工厂关闭时调用的给定销毁方法（如果适用）。仅适用于单例。
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
//是单例
if (mbd.isSingleton()) {
// 注册一个为给定 bean 执行所有销毁工作的 DisposableBean 实现：DestructionAwareBeanPostProcessors、DisposableBean 接口、自定义销毁方法。
registerDisposableBean(beanName, new DisposableBeanAdapter(
bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
}
//不是单例
else {
// 具有自定义范围的 bean...
Scope scope = this.scopes.get(mbd.getScope());
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
}
scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
}
}
}
7.2.8、实例化完成
Bean实例化完成，可以使用，在销毁前一直驻留在上下文应用中，最后获取Bean的实例对象：getObjectForBeanInstance，此方法贯穿doGetBean，用于获取Bean对象。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
//验证 bean 类型：判断是否是工厂bean
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
//现在我们有了bean实例，它可能是一个普通bean或一个FactoryBean。如果它是一个FactoryBean，我们使用它来创建一个bean实例,对非 FactoryBean 不做处理。
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
//从工厂返回bean实例
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
//缓存从FactoryBean获取的对象，如果它是单例。
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
7.2.9、销毁
在bean创建完成后，就会对这个bean注册一个销毁的Adapter对象。DisposableBeanAdapter对象（实现了DisposableBean）调用destory()方法销毁Bean（此对象收集 bean是否实现了 DisposableBean 接口，是否配置 destroy-method 属性，过滤了 DestructionAwareBeanPostProcessor 类型的接口）销毁bean的顺序是如下：
- 添加了@PreDestroy注解的bean，通过beanpostProcessor实现类 InitDestroyAnnotationBeanPostProcessor处理；
- 实现了DisposableBean接口的bean，调用那个其实现的destroy()方法
- bean配置了destroy-method，调用destroy-method
Bean会根据其scope属性去销毁
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
