1.spring的bean实例化的入口方法为getBean. 这个方法在AbstractBeanFactory类中,这个方法进一步调用doGetBean方法来获取实例。
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
2.AbstractBeanFactory.doGetBean
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//解析beanName 这个方法的作用主要是将别名转化成真的beanName和将factoryBeanName(&beanName)转化成真的beanName
final String beanName = transformedBeanName(name);
Object bean;
//检查singleton cache 这一步有很关键的意义:
//1.可以检测到手工注入的singleton
//2.可以检测到还没有完成populte的singleton(这个作用是用来协助依赖注入的)
//3.可以预先检测当前beanName的singleton是否已经完成new操作 防止重复创建
//4.prototype bean在这里会返回null
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//这一步主要是为factoryBean做的
//1.如果sharedInstance不是一个factoryBean return sharedInstance
//2.如果sharedInstance是一个factoryBean且name为&beanName的形式 return sharedInstance
//3.return ((FactoryBean<?>)sharedInstance).getObject(); 并且将返回结果缓存在了FactoryBeanRegistrySupport类的factoryBeanObjectCache实例域上
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//这里用了prototype bean的创建池 防止多件bean重复创建
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//如果bean definition在双亲容器中, 则将创建bean的任务委托给双亲容器
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//这里是一个MergedBeanDefinition的过程 主要是将BeanDefinition都包装成RootBeanDefinition并放到mergedBeanDefinitions里
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//保证当前bean dependsOn的bean都在当前bean创建之前完成初始化
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
//这里检测dependsOnBean是否depends-on beanName
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
registerDependentBean(dependsOnBean, beanName);
getBean(dependsOnBean);
}
}
//有以下代码可见不管是singlton,prototype还是scope都使用createBean来创建对象
//不同的是singlton有缓存 不用重复创建 而正因为singlton有缓存和提前暴露机制 singlton才得以解决循环依赖问题
//创建singleton
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//好 在这里完成了bean实例的真正的创建
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//创建prototype
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//创建指定scope
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; " +
"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
//检测requiredType和beanInstance的实际类型是否匹配
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type [" +
ClassUtils.getQualifiedName(requiredType) + "]", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
3.AbstractAutowireCapableBeanFactory.createBean
@Override
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
//这一步确保BeanDefinition上已经可以获取的到beanClass
resolveBeanClass(mbd, beanName);
//这一步是准备方法重写
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//**代理切入的位置(Step1.让 实现了InstantiationAwareBeanPostProcessor 有机会返回一个代理而不是目标 bean 实例。)**
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//创建bean的任务又委托给了doCreateBean
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
4.AbstractAutowireCapableBeanFactory.doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//继续创建实例// step2.创建bean通过反射构造器创建
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
//允许post-processors修改merged过的beanDefinition 也即是RootBeanDefinition
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
//Step3.让实现了MergedBeanDefinitionPostProcessor接口的类执行postProcessMergedBeanDefinition方法,允许修改合并的 bean 定义。
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
//这里暴露还没有populate的singleton 暴露到三级缓存里 协助循环引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
//step4.populateBean (自定义属性赋值,通过set方法)依赖注入发生的地方
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//step4.初始化bean的地方
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<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
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 " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
step7.初始化bean的地方将给定的 bean 添加到该工厂中的一次性 bean 列表中,注册其 DisposableBean 接口和/或给定的 destroy 方法,以便在工厂关闭时调用(如果适用)。仅适用于单例。
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
5.AbstractAutowireCapableBeanFactory.createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
//进一步确认beanClass
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());
}
//如果有instanceSupplier则从instanceSupplier上直接获取实例
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//如果有工厂方法 则走这一分支
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//1.这一步方法会访问beanDefinition上的构造器,工厂方法,构造器参数 的缓存 如果有 则直接根据缓存创建实例 构造器的依赖注入发生在这
//2.否则调用无参构造 如果存在方法重写 将会返回cglib生成的代理bean 这一步会构建构造器,工厂方法,构造器参数 的缓存 之所以构建缓存 是为了下次创建prototype可以直接利用缓存
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);
}
}
//step2.1如果存在SmartInstantiationAwareBeanPostProcessor,则使用determineCandidateConstructors方法返回的构造器创建Bean
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
//使用无参构造方法 创建bean 如果存在方法重写 将会返回cglib生成的代理bean
return instantiateBean(beanName, mbd);
}
6.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
step5.1 如果bean实现了Aware-通过Aware为bean注入属性(容器属性赋值)
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
step5.2 如果bean实现了BeanPostProcessors-执行BeanPostProcessors前置方法
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
step5.3 如何bean实现了isInitializingBean,执行操作,如果@Bean注解定义了init方法,执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
step5.4 如果bean实现了BeanPostProcessors-执行BeanPostProcessors后置方法
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
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 {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
boolean continueWithPropertyPopulation = true;
//step4.1 实现了InstantiationAwareBeanPostProcessor 执行postProcessAfterInstantiation
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.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);
}
}
bean的生命周期总结:
Step1 让实现了InstantiationAwareBeanPostProcessor接口的类,执行postProcessBeforeInstantiation直接返回一个bean,而不是经过doCreateBean流水创建bean
Step2 通过反射构造器创建bean
step2.1如果存在SmartInstantiationAwareBeanPostProcessor,则使用determineCandidateConstructors方法返回的构造器创建Bean
Step3.让实现了MergedBeanDefinitionPostProcessor接口的类执行postProcessMergedBeanDefinition方法,允许修改合并的 BeanDefinition(1.调用属性合并后置处理器, 进行属性合并(如果xml中也定义了依赖,@注解也定义了依赖,会进行合并) 2.这里会进行 一些注解 的扫描)。
Step4 populateBean (自定义属性赋值,通过set方法)依赖注入发生的地方
Step4.1 实现了InstantiationAwareBeanPostProcessor接口的类-执行postProcessAfterInstantiation方法(可以用于判断控制是否对Bean属性赋值进行跳过)
Step5 初始化bean的地方
Step5.1 如果bean实现了Aware-通过Aware为bean注入属性(容器属性赋值)
Step5.2 如果bean实现了BeanPostProcessors-执行postProcessBeforeInitialization前置方法
Step5.3 如何bean实现了isInitializingBean,执行初始化操作,如果@Bean注解定义了init方法,执行初始化方法
Step5.4 如果bean实现了BeanPostProcessors-执行postProcessAfterInitialization后置方法
Step6 使用bean
Step7 销毁bean
spring官方指定了三种初始化回调方法
1.1、@PostConstruct、@PreDestory
1.2、实现 InitializingBean DisposableBean 接口
1.3、设置init-method和destory-method( @Bean(initMethod=“init” , destroyMethod=“destroy”))
三种方式的优先级从高到低
1.1@PostConstruc 的调用
要将对象B注入到对象A,那么首先就必须得生成对象A和对象B,才能执行注入。
如果一个类A中有个成员变量b被@Autowried注解,那么@Autowired注入是发生在A的构造方法执行完之后的。
如果想在生成对象时完成某些初始化操作,而偏偏这些初始化操作又依赖于依赖注入,
那么就无法在构造函数中实现。
为此,可以使用@PostConstruct注解一个方法来完成初始化,
@PostConstruct注解的方法将会在依赖注入完成后被自动调用。
Component
public class A {
@Autowired
private B b;
public A(){
System.out.println("执行A的构造函数,此时b还未被注入,b=" + b);
}
@PostConstruct
public void init(){
System.out.println("@PostConstruct注解此方法,会在对象b注入完成之后自动调用此方法,b=" + b);
}
}
在上述Step3中调用CommonAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法,调用了buildLifecycleMetadata()方法
方法添加了@PostConstruct注解,就添加到currInitMethods,
方法添加了@PreDestory注解,就添加到currDestroyMethod中,
在上述Step5.2中在spring生命周期的第七个后置处理器方法中,org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization
会尝试先从lifecycleMetadataCache中根据class,获取到元对象,然后调用元对象的 invokeInitMethods()方法
1.2 InitializingBean 的调用在上述Step5.3中
1.3、设置init-method和destory-method( @Bean(initMethod=“init” , destroyMethod=“destroy”))的调用也在上述Step5.3中