spring创建bean过程
一.前言
spring作为JAVAEE最核心的框架,是每一个java开发者所必须掌握的,非常重要,本篇从一个简单例子入手,由浅入深的分析spring创建bean的全过程,目标在于彻底搞懂spring原理,方便以后整合其他框架
二.测试代码
/**
* * * @author zc
* @Date 2022/4/3 0003 14:45
*/
@Lazy
public class CreateBean {
private String name;
private int age;
public CreateBean() {
}
public CreateBean(int age) {
this.age = age;
}
public CreateBean(String name) {
this.name = name;
}
public CreateBean(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "CreateBean{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- 一个交给spring管理的bean,为了好debug,加了一个懒加载属性
@Test
void doCreateBean(){
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(CreateBean.class);
Object bean = context.getBean("createBean", "chuan", 24);
System.out.println(bean);
}
- 一个启动类,getBean是入口,开始创建bean
三. 开始获取bean:getBean()
@Override
public T getBean(String name, Class requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, requiredType);
}
1. 判断容器的活动状态:assertBeanFactoryActive()
容器在启动的时候会设置这个状态值,具体在:AbstractApplicationContext#prepareRefresh()
2.获取beanFactory:getBeanFactory()
从beanFactory中获取bean,默认这个beanFactory是DefaultListableBeanFactory,因为AnnotationConfigApplicationContext继承了GenericApplicationContext,通过他的构造器可以发现
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
3.getBean(name, requiredType)
通过bean的名称获取bean,第二个参数是bean的类型,如果传了后面会做类型转换,否则就是Object
@Override
public T getBean(String name, Class requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
getBean:这个类有很多getBean方法,这是使用重载的表现,但是最终都会调用doGetBean,这个方法有四个参数,分别是bean的名称name,bean的类型,创建bean时构造参数的值
四.真正获取Bean的方法:doGetBean()
protected T doGetBean(
String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object beanInstance;
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
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 + "'");
}
}
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
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 + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
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);
}
这个方法很复杂,但是可以简要分为以下几个步骤
1. 获取bean名称
transformedBeanName()
因为可能会有前缀&,获取FactoryBean的情况,所以需要在这解析
2.尝试从缓存中获取bean
getSingleton()
3.判断这个bean是否在创建中
isPrototypeCurrentlyInCreation(beanName)
这一步目的是为了防止循环依赖
4.标记为正在创建中
markBeanAsCreated(beanName):将这个bean
5.合并Definition
getMergedLocalBeanDefinition(beanName)
通过parentName的值来判断是否有父definition,合并的目的在于保证definition的正确性,spring在每次要用definition的时候都会进行一次合并,因为有很多扩展点可以修改definition
6.检查合并后的Definition
checkMergedBeanDefinition(mbd, beanName, args);
7.获取依赖的Bean
mbd.getDependsOn();
如果不为空则会先创建依赖的bean
8.获取真正需要的Bean
getSingleton(beanName,()->{return createBean(beanName, mbd, args);})
获取一个注册好的bean,如果没有,会使用参数FactoryBean注册一个,非常重要,真正创建bean的入口,下面会详细会讲创建过程
getObjectForBeanInstance(sharedInstance, name, beanName, mbd);,如果name有前缀&,那么会返回FactoryBean的实例,如果注册的是一个FactoryBean,这里会调用getObject来返回真正的bean对象
adaptBeanInstance(name, beanInstance, requiredType);最后一步类型转换
五.获取Bean的过程: getSingleton()
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
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 + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
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;
}
}
1.尝试从一级缓存中获取Bean
Object singletonObject = this.singletonObjects.get(beanName);
我们这里肯定是没有的,如果有则会直接返回
2.将这个Bean标记为创建中
beforeSingletonCreation(beanName);
里面主要操作就是将这个beanName添加进singletonsCurrentlyInCreation数组中,这个数组里面存的都是正在创建的Bean名称
3.创建Bean
singletonObject = singletonFactory.getObject();
singletonFactory是上面传过来的参数,所以这会去调用上面传过来的的createBean方法,这里使用了@FunctionalInterface函数接口,非常精髓,下面会详细分析createBean的过程
4.将这个Bean标记为已创建
afterSingletonCreation(beanName);
对应上面第二步,删除singletonsCurrentlyInCreation的这个beanName,标记他已经创建完成
5.注册Bean
addSingleton(beanName, singletonObject)
注册bean,把上面第三步创建出来的singletonObject添加进一级缓存singletonObjects和单例缓存registeredSingletons中,删除三级缓存singletonFactories和二级缓存earlySingletonObjects中key为beanName的值
六.开始创建Bean: createBean(beanName, mbd, args)
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
try {
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var10) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
try {
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
throw var7;
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
1.加载类
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
2.标记override的属性
mbdToUse.prepareMethodOverrides();
其实就是lookup-method和replace-method两个属性,如果没有重载会记录下来,后面就不会根据参数判断是哪一个具体的方法,减少了系统开销
3,实例化之前后置处理器
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
调用所有实现了InstantiationAwareBeanPostProcessor接口的类的postProcessBeforeInstantiation方法,如果返回不为null,会接着调用所有实现了BeanPostProcessor接口的类的postProcessAfterInitialization方法,然后返回,aop就是在此处实现的,我们这里所有实现了InstantiationAwareBeanPostProcessor接口的类都是默认的,返回的都是null,所以不会执行后置处理器的after方法,会返回一个null,下面是参考代码
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Class targetType = this.determineTargetType(beanName, mbd);
if (targetType != null) {
bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = bean != null;
}
return bean;
}
4.判断第三步返回的bean是否为空
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
这一步比较重要,因为如果不为空会直接返回,这代表着不会执行spring创建bean的方法,比如后面的属性注入,aware接口回调,初始化前,初始化,初始化后都不会执行
5.创建Bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
真正开始创建bean的方法,spring真正干活的方法都是以do开头的,我认为这是一种很好的方法命名规则
七.真正开始创建Bean: doCreateBean(beanName, mbdToUse, args)
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
this.populateBean(beanName, mbd, instanceWrapper);
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
1.创建bean实例
createBeanInstance(beanName, mbd, args)
2.执行Definition的后置处理器
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)
spring在这一步实现了对元注解的解析
如果这个bean是单例的且正在创建中,则会加入三级缓存中,目的是暴露bean的引用,解决循环依赖:this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
})
3.属性填充
populateBean(beanName, mbd, instanceWrapper);
4.初始化bean
initializeBean(beanName, exposedObject, mbd);
5.注册Bean的销毁方法
registerDisposableBeanIfNecessary(beanName, bean, mbd)
到这才真正开始进入创建bean的流程,流程中的每一步都非常复杂,建议还是很模糊的同学自重，避免走火入魔想对我人身攻击的。下面就每个方法重要的点一一解析，严格按照方法的执行先后顺序来说明
1.1 创建Bean实例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
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);
}
// Shortcut when re-creating the same 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);
}
}
// Candidate constructors for autowiring?
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
1. 通过Supplier接口创建Bean实例
Supplier instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
我们这里没有使用这个方式,这种方式需要在注册的时候提供如下
public class C implements Supplier {
@Override
public C get() {
System.out.println("Supplier");
return new C();
}
}
/**
* 自定义实例化方法{@link java.util.function.Supplier#get}
* 源码调用{@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance}
*/@Test
void supplier(){
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.registerBean(C.class,new C());
context.refresh();
context.getBean("c");
}
2. 通过静态工厂或实例工厂创建Bean实例
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
我们这没有使用工厂的方式,这两种使用方式如下:
实例工厂:
public class FactoryBeanService {
private static Bean bean = new Bean();
private FactoryBeanService() {}
public Bean createInstance() {
System.out.println("实例工厂方法实例化bean");
return bean;
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="serviceLocator"
class="com.youlai.laboratory.spring.create.FactoryBeanService"
/>
<bean id="factoryBeanService"
factory-bean="serviceLocator"
factory-method="createInstance"
/>
beans>
@Test
void factoryBean(){
ClassPathXmlApplicationContext xmlApplicationContext = new ClassPathXmlApplicationContext("classpath:spring/create/FactoryBean.xml");
}
静态工厂:
public class FactoryClassService {
private static Bean bean = new Bean();
private FactoryClassService() {}
public static Bean createInstance() {
System.out.println("静态工厂方法实例化bean");
return bean;
}
}
@Test
void factoryMethod(){
ClassPathXmlApplicationContext xmlApplicationContext = new ClassPathXmlApplicationContext("classpath:spring/create/FactoryClass.xml");
}
3. 推断可用的构造器
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName)
这一步比较重要,下面会详细分析
@Override
@Nullable
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
throws BeanCreationException {
// Let's check for lookup methods here...
if (!this.lookupMethodsChecked.contains(beanName)) {
if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
try {
Class<?> targetClass = beanClass;
do {
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Lookup lookup = method.getAnnotation(Lookup.class);
if (lookup != null) {
Assert.state(this.beanFactory != null, "No BeanFactory available");
LookupOverride override = new LookupOverride(method, lookup.value());
try {
RootBeanDefinition mbd = (RootBeanDefinition)
this.beanFactory.getMergedBeanDefinition(beanName);
mbd.getMethodOverrides().addOverride(override);
}
catch (NoSuchBeanDefinitionException ex) {