当前位置：首页 > news >正文

Spring之生成Bean

news 文章来源：https://blog.csdn.net/m0_45164511/article/details/142668314 2024/12/28 0:59:28

Bean的生命周期：实例化->属性填充->初始化->销毁

核心入口方法：finishBeanFactoryInitialization-->preInstantiateSingletons

DefaultListableBeanFactory#preInstantiateSingletons用于实例化非懒加载的bean。

1.preInstantiateSingletons方法分析

作用：实例化非懒加载的bean

1.拿到所有BeanDefinitionName，遍历所有beanName

2.getMergedLocalBeanDefinition，将属性合并生成MergeBeanDefinition，如下图的属性

最终结果是：Map<beanName,RootBeanDefinition>，beanName对应合并后的BeanDefintion

如果存在父子BeanDefinition，则要合并，二合一会生成第三个BeanDefinition（新的）；否则，就直接返回自己的BeanDefinition。

如果该BeanDefinition是RootBeanDefinition，就直接cloneBeanDefinition，并返回。

同时，涉及到递归合并，合并的父亲又有父亲beanDefinition，就需要多次合并。（这段源码的含义）

// 子BeanDefinition的属性覆盖父BeanDefinition的属性，这就是合并
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);

3.会判断是不是懒加载、是不是单例Bean、是不是抽象BeanDefinition，如果都不是，则进入步骤4

4.如果是FactoryBean，则开始创建FactoryBean。FactoryBean对应两个bean对象，但是只有一个beanDefinition。核心代码如下：

for (String beanName : beanNames) {// 获取合并后的BeanDefinitionRootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);// isAbstract 抽象的BeanDefinition和抽象类无关if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {// 获取FactoryBean对象Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {FactoryBean<?> factory = (FactoryBean<?>) bean;boolean isEagerInit;// 判断是否打开了安全管理器if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else {// 实现了接口SmartFactoryBean，并且isEagerInit=true// 实现了接口FactoryBean，重写的getObject()方法 是在用户使用getBean的时候调用的// SmartFactoryBean可以指定在 bean创建的时候 调用getObject()方法isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {// 创建真正的Bean对象(getObject()返回的对象)getBean(beanName);}}}else {// 创建Bean对象getBean(beanName);}}
}

如果我们从单例池拿到了bean，那么就要判断是否和我们想要的bean类型一样（FactoryBean还是普通bean）。从Cache拿bean，getCachedObjectForFactoryBean（存放getObject生成的bean）

下面的代码：判断该bean是不是FactoryBean。

@Override
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {String beanName = transformedBeanName(name);Object beanInstance = getSingleton(beanName, false);if (beanInstance != null) {return (beanInstance instanceof FactoryBean);}// No singleton instance found -> check bean definition.// 去父beanFactory找 是否有该beanNameif (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {// No bean definition found in this factory -> delegate to parent.return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);}return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}

注意：如果FactoryBean类实现了SmartFactoryBean，并且重写了isEagerInit()方法，则在bean生命周期中就会创建FactoryBean，否则在getBean的时候才会创建FactoryBean。

5.不是FactoryBean且是非懒加载的bean

调用getBean，创建Bean

6.所有的非懒加载单例Bean都创建完了后，getSingleton(beanName);拿出所有单例Bean，看其是否实现了SmartInitializingSingleton接口，如果实现了这个接口，就执行重写后的方法：afterSingletonsInstantiated。

afterSingletonsInstantiated的调用时机：所有非懒加载的bean都创建完了之后，调用它

2.getBean

首先，getBean有三种调用方式：

name, name+type(验证类型，可类型转换)，name+args[](args[]用于推断构造方法)

getBean的核心方法是doGetBean

1.transformedBeanName

拿到BeanName，transformedBeanName就是去掉&符号，以及将别名转换为主名。

示例1：@Bean({{"userService","userService1", "userService2"}):第一个名字是名字，后面的都是别名

示例2：&factoryBeanName是拿factoryBeanName；而factoryBeanName是拿getObject的bean。（比如UserBean）

2.getSingleton

先去单例池拿bean，拿到了就检查符不符合我们的需求(原型也走这一步)

3.拿不到，则进入else分支，创建bean

4.进入这行代码，parentBeanFactory != null && !containsBeanDefinition(beanName)

检查当前是否存在这个beanName的BeanDefinition，也要检查父BeanFactory有没有BeanDefinition，有就返回bean

5.核心开始，getMergedLocalBeanDefinition，拿到合并的BeanDefinition

6.checkMergedBeanDefinition

检查BeanDefinition是不是Abstract的，如果是，则不能创建bean（抽象的beanDefinition不能创建bean）

7.getDependsOn

处理@DepondsOn注解。检查依赖，将其挂载到该bean的依赖属性上，然后创建依赖的bean，如果创建失败，则会抛出异常。

存在一些依赖，就将依赖关系存入map（使用registerDependentBean方法），然后getBean（创建所依赖的bean，此时也会判断是否存在循环依赖的关系）

[比如类A上加了@DepondsOn("B")，则在创建A之前必须把B创建出来。如果类B也通过这种方式依赖了A，那么就产生了循环依赖，这种情况的循环依赖会直接抛出异常，无法解决！]

源码如下：

            // Guarantee initialization of beans that the current bean depends on.String[] dependsOn = mbd.getDependsOn();if (dependsOn != null) {// dependsOn表示当前beanName所依赖的，当前Bean创建之前dependsOn所依赖的Bean必须已经创建好了for (String dep : dependsOn) {// beanName是不是被dep依赖了，如果是则出现了循环依赖if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}// dep被beanName依赖了，存入dependentBeanMap中，dep为key，beanName为valueregisterDependentBean(dep, beanName);// 创建所依赖的beantry {getBean(dep);}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}}

8.判断bean是单例、原型、还是其他，然后进入不同if分支

创建单例Bean，执行Lambda表达式，创建Bean后需要放到单例池；之后还会创建factoryBean

创建原型Bean，不会将其放到单例池，仅仅是简单的创建；之后还会创建factoryBean

对于request、session、application，例如，在同一个request中，同一个BeanName拿到的是用一个Bean。主要通过这两个方法，request.getAttribute，获取bean；request.setAttribute，设置bean。SpringMVC在启动的时候，会将Scope注册到容器中，之后就可以直接拿到scope的值。

9.核心是创建单例Bean

sharedInstance = getSingleton(beanName, () -> {...})

从单例池找Bean，如果没有找到Bean，就使用Lambda表达式创建Bean。addSingleton（并添加到单例池）

核心方法：createBean

执行Lambda的核心代码：getSingleton

try {singletonObject = singletonFactory.getObject(); // 执行Lambda表达式newSingleton = true;
}

3.createBean

1.resolveBeanClass

马上就要实例化Bean了，确保beanClass被加载了

// 如果beanClass被加载了
if (mbd.hasBeanClass()) {return mbd.getBeanClass();
}// 如果beanClass没有被加载
if (System.getSecurityManager() != null) {return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
}
else {return doResolveBeanClass(mbd, typesToMatch);// 加载类
}

2.resolveBeforeInstantiation

实例化前，执行实例化前的PostProcessor。

如果bean实现了InstantiationAwareBeanPostProcessor接口，并重写了invokeAwareMethods，可以在这里直接返回Bean，终止Spring创建该Bean（可以进行人工干预来创建bean）。如果在实例化前就返回了Bean，那么他需要做初始化后的操作。（和AOP有关）

3.doCreateBean

实例化，主要流程是下面的步骤

4.createBeanInstance

实例化Bean

5.applyMergedBeanDefinitionPostProcessors

该后置处理器的执行时机：实例化后，初始化前；作用：后置处理合并后的BeanDefinition

6.解决循环依赖

7.populateBean

作用：属性填充

在里面执行实例化后的方法（postProcessAfterInstantiation），

然后执行Spring自带的属性注入（ByType和ByName），

然后执行(InstantiationAwareBeanPostProcessor中的) AutowiredAnnotationBeanPostProcessor.postProcessProperties()，处理@Autowired注解。（处理属性注入的，@Autowired注解就是通过实现这个接口实现的依赖注入）

注意：在属性赋值之前，如果程序员已经为一些属性赋值了，那么就不会再重复赋值

byName 还是 byType导致注入太灵活，只要是个set方法就会被注入，容易出问题吧。

8.initializeBean

作用：初始化Bean

核心流程：

8.1invokeAwareMethods（包含设置beanName，bean类加载器、bean工厂：setBeanName、setBeanClassLoader、setBeanFactory）

8.2执行applyBeanPostProcessorsBeforeInitialization：初始化前的PostProcessor，包含使用@PostContruct注解和实现回调接口两种方法

初始化前有很多PostProcessor，比如下面这些

8.3invokeInitMethods：判断有无实现对应接口，执行初始化操作（是否实现InitializingBean）

8.4applyBeanPostProcessorsAfterInitialization：执行初始化后PostProcessor

9.判断初始化后的bean的依赖关系有没有改变，如果有改变，则可能会报错

和AOP有关，如果AOP之后产生新的bean，但是注入给其他bean的是原来的bean，并非最终生成的bean，那么在这里就会抛出异常

10.registerDisposableBeanIfNecessary

销毁Bean，判断bean是否有bean销毁的逻辑

4.bean销毁

销毁Bean的两个核心方法：

registerDisposableBeanIfNecessary：向Adapter中设置销毁逻辑。（适配器模式）

context.close()：调用Adpter的销毁逻辑。
实现Bean销毁的方法：

1.实现DisposableBean接口，重写destroy方法；

2.使用PreDestroy注解

4.1.registerDisposableBeanIfNecessary

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()) {// Register a DisposableBean implementation that performs all destruction// work for the given bean: DestructionAwareBeanPostProcessors,// DisposableBean interface, custom destroy method.registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));}else {// A bean with a custom scope...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));}}}

1.判断有没有指定销毁的方法

2.hasDestroyMethod

有无实现接口DisposableBean、AutoCloseable

3.hasDestructionAwareBeanPostProcessors

有没有实现DestructionAwareBeanPostProcessor，有没有重写requiresDestruction，重写了这个接口的方法，返回true，就需要销毁。

4.registerDisposableBean

把销毁逻辑存到disposableBeans，他是一个Map,Map<beanName,Adapter>。

这里用到适配器模式：new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc)

DisposableBeanAdapter中的核心方法：destroy

4.2.context.close()

/*** Close this application context, destroying all beans in its bean factory.* <p>Delegates to {@code doClose()} for the actual closing procedure.* Also removes a JVM shutdown hook, if registered, as it's not needed anymore.* @see #doClose()* @see #registerShutdownHook()*/@Overridepublic void close() {synchronized (this.startupShutdownMonitor) {doClose();// If we registered a JVM shutdown hook, we don't need it anymore now:// We've already explicitly closed the context.if (this.shutdownHook != null) {try {Runtime.getRuntime().removeShutdownHook(this.shutdownHook);}catch (IllegalStateException ex) {// ignore - VM is already shutting down}}}}

核心方法是：doClose，调用Adpter的销毁逻辑

1.publishEvent

发布关闭事件

2.this.lifecycleProcessor.onClose();

关闭Spring容器的生命周期

3.destroyBeans

销毁Bean，以下步骤都是这个方法的操作。

4.destroySingletons-->destroySingleton

从单例池中移除掉Bean，如果存在依赖关系，则也要进行相应销毁

比如，A依赖B，那么B如果需要销毁，那么先销毁A，再销毁B

在这个方法中，会调用bean.destroy()，这里就进到了Adpter的销毁逻辑

5.遍历有销毁逻辑的Bean

this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();

执行clearSingletonCache，包含以下内容：

this.singletonObjects.clear(); 单例池
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
this.singletonsCurrentlyInDestruction = false;