Spring Bean 生命周期源码系列
版本：Spring Framework 5.2.2.RELEASE
目录
Spring Bean生命周期---注册阶段
摘要：
注册阶段主要是调用DefaultListableBeanFactory的registerBeanDefinition方法，对Bean进行是否已经注册过然后是否允许覆盖等校验，把Bean名称、BeanDefinition放到beanDefinitionNames(ArrayList)，beanDefinitionMap(ConcurrentHashMap)中
源码入口：
DefaultListableBeanFactory#registerBeanDefinition
源码解析
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable{
/**
* 注册BeanDefinition
* @param beanName Bean名称
* @param beanDefinition 构造好的BeanDefinition
*/
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
//参数是否为空校验
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
//对BeanDefinition做进一步校验
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
/**
* this.beanDefinitionMap：ConcurrentHashMap类型，保存了该BeanFactory的所有注册的BeanDefinition
* 尝试在beanDefinitionMap中获取已经注册的BeanDefinition
*/
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
//如果在beanDefinitionMap找到的话
if (!isAllowBeanDefinitionOverriding()) {
//如果Spring配置了不允许BeanDefinition覆盖，已经注册过，现在该beanName又尝试注册就抛出BeanDefinitionOverrideException
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
/**
* BeanDefinition.role是Spring提供给用户自定义的字段
* 此处判断如果新覆盖的BeanDefinition角色>旧的BeanDefinition角色就输出一段info级别的日志
*/
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
//如果新覆盖的BeanDefinition与旧的BeanDefinition不相同就输出一段debug级别的日志
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
//输出一段该beanName被覆盖的trace级别日志
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
//进行覆盖
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
//如果在beanDefinitionMap找不到
if (hasBeanCreationStarted()) {
//如果有其他Bean在创建过程中，则需要加锁
synchronized (this.beanDefinitionMap) {
/**
* 分别把信息加入到beanDefinitionMap和beanDefinitionNames
* beanDefinitionMap：保存了所有Spring Bean的ConcurrentHashMap,因为是Map所以无法保证存放顺序
* beanDefinitionNames：保存所有Spring Bean的名称，ArrayList结构，因此是按注册先后有序的
*/
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
/**
* removeManualSingletonName的作用就是：
* 如果有单体对象(依赖来源的一种)跟这个BeanDefinition名称相同则在manualSingletonNames中remove掉这个单体对象
* 因为BeanDefinition和单体对象都是依赖来源，都可以通过beanName找到Bean，因此BeanDefinition和单体对象不能存在beanName相同的情况
*/
removeManualSingletonName(beanName);
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
/**
* 如果该BeanDefinition注册过，则在mergedBeanDefinitions中会有缓存
* 如果该beanName曾经是单体对象，上面只是remove manualSingletonNames,还需要清空singletonObjects等等，singletonObjects是Spring单例Bean的三层缓存中第一层，三层缓存可以解决循环依赖问题
* resetBeanDefinition就是负责清空这些
*/
resetBeanDefinition(beanName);
}
}
}Spring Bean生命周期---合并阶段
摘要
合并阶段主要是递归调用AbstractBeanFactory的getMergedBeanDinition，合并阶段的任务是把可能含有双亲Bean的GenericBeanDefinition，把双亲和当前Bean的属性合并后，返回一个代表没有双亲的RootBeanDefinition，针对当前Bean含有双亲(extends)的情况，获取到双亲BeanDefinition然后构造成RootBeanDefinition，然后结合当前Bean的BeanDefinition进行属性覆盖或添加。
源码入口
AbstractBeanFactory#getMergedBeanDefinition
源码解析
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory{
/**
* BeanDefinition合并入口
* @param name
*/
@Override
public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
//对name进行格式化，首字母小写的驼峰命名
String beanName = transformedBeanName(name);
//如果当前BeanFactory没有该beanName的BeanDefinition，则找去找双亲BeanFactory
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
//获取双亲BeanFactory并进入递归
return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
}
/**
* 来到该步要么当前BeanFactory含有这个beanName的BeanDefinition
* 要么双亲BeanFactory不是ConfigurableBeanFactory无法调用getMergedBeanDefinition进行递归
* 尝试去当前层的BeanFactory获取该BeanDefinition
*/
return getMergedLocalBeanDefinition(beanName);
}
/**
* 尝试在当前BeanFactory进行查找，如果BeanDefinition有继承有双亲BeanDefinition，会进行BeanDefinition的合并
* 小知识：
* RootBeanDefinition：根节点的BeanDefinition，即没有双亲的BeanDefinition
* GenericBeanDefinition：普通BeanDefinition，可能有双亲也可能没有双亲
*/
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
//先在mergedBeanDefinitions这个ConcurrentHashMap缓存中尝试查找
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
//如果找到，而且该BeanDefinition没有标志需要重新合并就直接返回
return mbd;
}
//如果找不到就进一步查找，getBeanDefinition是在beanDefinitionMap中查找返回
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
/**
* 我也不知道为什么Spring写这种套娃代码
*/
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
/**
* 尝试在当前BeanFactory进行查找并进行双亲BeanDefinition合并的真正的实现方法
* 找不到依然会在后续方法中往双亲BeanFactory继续找
*/
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
//再次尝试去缓存获取
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null || mbd.stale) {
//如果不出意外缓存依然获取不到的话
previous = mbd;
if (bd.getParentName() == null) {
//如果beanDefinitionMap查找出来的BeanDefinition没有双亲BeanDefinition
if (bd instanceof RootBeanDefinition) {
//如果该BeanDefinition是RootBeanDefinition则直接克隆一份副本返回
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
//如果不是RootBeanDefinition则把它变成RootBeanDefinition返回
mbd = new RootBeanDefinition(bd);
}
}
else {
//如果beanDefinitionMap查找出来的BeanDefinition有双亲BeanDefinition
BeanDefinition pbd;
try {
//首先获取双亲BeanDefinition的名称并格式化为驼峰命名
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
//如果双亲的名称跟自身的名称不相同，则正常去递归回第一个方法，再次进行BeanFactory层次性查找与BeanDefinition合并流程
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
//如果双亲的名称跟自身的名称相同
//如果双亲BeanDefinition名称是在双亲BeanFactory里面，则继续递归查找
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
//不然抛出NoSuchBeanDefinitionException
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
//把查出来的双亲BeanDefinition构造成RootBeanDefinition
mbd = new RootBeanDefinition(pbd);
//再在双亲BeanDefinition基础上，再结合当前BeanDefinition进行属性覆盖或添加
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
if (!StringUtils.hasLength(mbd.getScope())) {
//如果该BeanDefinition没有设置作用域，则设置成单例
mbd.setScope(SCOPE_SINGLETON);
}
//为了避免双亲的BeanDefinition的单例作用域在合并时继承到RootBeanDefinition，是不允许作用域继承的
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
//缓存合并好的BeanDefinition
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
//不知道干啥的
if (previous != null) {
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
}Spring Bean生命周期---实例化前阶段
摘要
实例化前阶段主要是通过添加BeanPostProcessor的子类InstantiationAwareBeanPostProcessor并实现postProcessBeforeInstantiation方法，来进行代理Bean，实例化的意思就是会在实例化整个大阶段通过反射的方式得到一个可能不完整的Object(属性还未赋值等等)
源码入口
AbstractAutowireCapableBeanFactory#createBean
实例化前代理Bean用法
class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass,String beanName) throws BeanException{
if(ObjectUtils.nullSafeEquals("user",beanName) && User.class.equals(beanClass)){
//如果beanName等于user,而且时User.class类型
//覆盖掉之前的Bean
return new User();
}else{
//返回空则不做任何处理
return null;
}
}
}源码解析
因为实例化前，实例化、实例化阶段代码都在AbstractAutowireCapableBeanFactory类里面，统一放到了实例化阶段
Spring Bean生命周期---Bean实例化阶段
摘要
实例化阶段主要是调用AbstractAutowireCapableBeanFactory的createBean->doCreateBean->createBeanInstance方法，其核心就是调用构造方法或工厂方法等获得一个Bean实例Object，如果没有使用函数式接口或工厂方法来创建Bean，则涉及到构造器的选择，如果是无参构造器来进行实例化的话，其本质就是Constructor.newInstance来创建对象，有参的话则涉及依赖注入
源码入口
AbstractAutowireCapableBeanFactory#createBean
源码解析
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory{
/**
* Spring Bean实例化的方法，里面有实例化前阶段处理代码和调用其他方法进行实例化
* @param beanName Bean名称
* @param mbd 合并好的BeanDefinition
* @param args 构造器参数
* @return 实例化好的Object
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
//打印一段trace级别的开始实例化日志
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
//mbd是经过合并阶段的BeanDefinition
RootBeanDefinition mbdToUse = mbd;
//因为BeanDefinition的beanClass一开始是String类型的
//resolveBeanClass的功能就是
//1.如果beanClass是String类型，则进行类加载dynamicLoader.loadClass(className)，
//最后返回ClassUtils.forName(className, dynamicLoader)的Class对象
//2.如果已经是Class类型则直接返回
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//为了不影响共享的合并后的BeanDefinition，所以深拷贝一份
mbdToUse = new RootBeanDefinition(mbd);
//把BeanDefinition Strinhg类型的beanClass改成Class类型的
mbdToUse.setBeanClass(resolvedClass);
}
//BeanDefinition重写方法的准备工作，也就是把需要重写的方法打上overloaded=false的标志
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//允许在Bean实例化前进行操作，代理原有的Bean
//方法就是定义一个BeanPostProcessor类实现IntantiationAwareBeanPostProcessor接口，重写postProcessBeforeIntantiation方法
//如果在postProcessBeforeIntantiation方法里面返回非空对象就会使用这个对象代理原来的Bean
//如果在postProcessBeforeIntantiation方法里面返回返回null则还是原来的Bean
//从下面这4行源码就可以看出
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 {
//如果没有上面的实例化前进行代理，
//则使用doCreateBean进行Bean实例化，这个方法后面详细说
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
//打印一段trace级别的实例化完成日志
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
/**
*
* @param beanName Bean名称
* @param mbd 合并后的BeanDefinition
* @param args 实例化构造器参数
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//BeanWrapper是Bean的一个包装类
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//如果这个BeanDefinition作用域是单例的话，就移除该beanName在实例化过程中的缓存，并把移除的元素赋值给instanceWrapper
//factoryBeanInstanceCache是一个ConcurrentHashMap
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//如果为空，则创建Bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
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;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like 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");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
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);
}
}
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.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
/**
* 创建Bean实例的方法
* @param beanName Bean名称
* @param mbd 合并后的BeanDefinition
* @param args 构造器参数
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//获取Bean的类对象
Class<?> beanClass = resolveBeanClass(mbd, beanName);
//判断BeanDefinition的类是否是public的，如果是非public则不允许创建
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());
}
//如果配置了jdk8函数式接口方式创建Bean则使用函数式接口
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//如果配置了工厂方法方式创建Bean则使用工厂方法
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//这段代码的作用是对于传进来构造器参数为null的情况可以少做下一大段的逻辑判断
//因为如果这个Bean实例化后，在BeanDefinition的字段会保存一些共享信息
//resolvedConstructorOrFactoryMethod保存了Bean实例化使用的构造器，也可能是无参构造器，实例化过就有
//constructorArgumentsResolved表示构造器的参数是否已经处理过
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) {
//如果构造器方式实例化，但是前面已经判断args为null因此构造器和构造器参数都传null
return autowireConstructor(beanName, mbd, null, null);
}
else {
//如果是普通无参构造器实例化
return instantiateBean(beanName, mbd);
}
}
//获取该Bean的所有候选构造方法，没写构造函数就会为null
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//如果候选构造为null 或着
//是autowing by constructor模式实例化 或者
//BeanDefinition定义的构造器参数不为null,如<contructor-arg /> 或者
//传进来的构造器参数不为空 则使用构造器方式实例化
return autowireConstructor(beanName, mbd, ctors, args);
}
//经过上面那一步判断，已经确定传进来的构造器参数arg为空
//Spring 5.1新增方法，获取首选/偏好 构造器
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
//如果有首选构造器，则使用首选构造器实例化
return autowireConstructor(beanName, mbd, ctors, null);
}
//最后如果上面都不符合就使用无参构造器创建Bean
return instantiateBean(beanName, mbd);
}
/**
* 无参构造器实例化Bean
* @param beanName Bean名称
* @param mbd 合并后的BeanDefinition
*/
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
//判断是否使用了Java安全机制，一般没有
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
//没有使用java安全机制则正常实例化，这句代码是使用InstantiationStrategy进行实例化
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
//使用实例化出来的Object进行构造出BeanWrapper
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
//当前BeanFactory对BeanWrapper进行一些初始化
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
}Spring Bean生命周期---实例化后阶段
摘要
实例化后回调主要是实现InstantiationAwareBeanPostProcessor并实现postProcessAfterInstantiation方法，如果return true则不做任何处理，如果return false使用方法内修改后的Bean
源码入口
AbstractAutowireCapableBeanFactory#populateBean
实例化后用法
class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
@Override
public boolean postProcessAfterInstantiation(Class<?> beanClass,String beanName) throws BeanException{
if(ObjectUtils.nullSafeEquals("user",beanName) && User.class.equals(beanClass)){
//如果beanName等于user,而且时User.class类型
//return false代表对象不允许属性赋值即xml元信息配置的那些
//还可以使用下面的代码进行替换
User user = (User)bean;
user.name = "sign";
return false;
}else{
//返回true则不做任何处理
return true;
}
}
}源码解析
因为实例化后回调跟属性赋值阶段的源码在一起，所以代码统一放到属性赋值阶段
Spring Bean生命周期---属性赋值前阶段
摘要
通过实现InstantiationAwareBeanPostProcessor接口的postProcessProperties方法(spring5.1)或者postProcessPropertyValues方法，如果return null则不做任何处理
源码入口
AbstractAutowireCapableBeanFactory#populateBean
使用例子
class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
@Override
public PropertyValues postProcessProperties(PropertyValues pvs,Object bean,String beanName){
if(ObjectUtils.nullSafeEquals("user",beanName) && User.class.equals(bean.getClass())){
//如果beanName等于user,而且时User.class类型
final MutablePropertyValues propertyValues;
if(pvs instanceof MutablePropertyValues){
propertyValues = (MutablePropertyValues)pvs;
}else{
propertyValues = new MutablePropertyValues();
}
//演示进行属性替换
if(propertyValues.contains("name")){
propertyValues.removePropertyValue("name");
propertyValues.addPropertyValue("name","sign");
}
return propertyValues;
}
//return null则正常属性赋值
return null;
}
}源码解析
因为属性赋值前阶段代码跟属性赋值阶段的源码在一起，所以代码统一放到属性赋值阶段
Spring Bean生命周期---属性赋值阶段
摘要
主要是对属性进行赋值、判断是否autowiring模式，是否需要依赖注入等
源码入口
AbstractAutowireCapableBeanFactory#populateBean
源码解析
/**
* 对实例化好的Bean进行属性赋值方法
* @param beanName Bean名称
* @param mbd 合并后的BeanDefinition
* @param bw 经过构造器实例化后的BeanWrapper
*/
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
//如果经过前面步骤后bw还是为null而且BeanDefinition里面有属性值则抛出异常
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
//实例化后阶段回调的代码逻辑
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//如果含有InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//if里面执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，默认是返回true
//如果重写了postProcessAfterInstantiation返回false,那么会直接return,不做后面的属性赋值工作
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//获取autowiring模式，默认是none
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
//如果autowiring 是by name或者by type模式则需要对属性根据Bean名称查找或者根据类型查找进行依赖注入
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
//经过依赖注入处理后赋值给pvs
pvs = newPvs;
}
//获取是否添加了InstantiationAwareBeanPostProcessor
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
//把BeanDinition的所有属性值赋值到pvs
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//如果bp是InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//调用postProcessProperties(spring 5.1)
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
//如果postProcessProperties返回的是null，接口里面default实现是返回null
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//则调用postProcessPropertyValues再次获取，接口里面default实现是返回BeanDefinition的propertyValues
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
//如果用户重写了postProcessPropertyValues并返回null则不做后面的属性赋值
return;
}
}
//如果通过postProcessProperties或postProcessPropertyValues获得的属性值不为null，则赋值给pvs
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
//经过前面的处理后最后进行Bean 属性赋值
applyPropertyValues(beanName, mbd, bw, pvs);
}
}Spring Bean生命周期---Aware接口回调阶段
摘要
-Aware主要是用来注入一些Bean，只能使用Spring提供的，无法扩展， 这里的Aware接口是指BeanNameAware、BeanClassLoaderAware、BeanFactoryAware，其实Aware接口还有很多，但是它们不属于Spring Bean生命周期，像EnvironmentAware是属于ApplicationContext生命周期
- Aware接口回调顺序是BeanNameAware->BeanClassLoaderAware->BeanFactoryAware
源码入口
AbstractAutowireCapableBeanFactory#invokeAwareMethods
使用示例
public cliass User implements BeanNameAware{
private int id;
private String name;
//getter、setter
//Aware依赖注入
private String beanName;
@Override
public void setBeanName(String beanName){
this.beanName = beanName;
}
}源码解析
/**
* 回调Aware接口方法
* @param beanName
* @param bean
*/
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
//有下面代码可以看出Spring Bean生命周期中，Aware接口回调顺序是：
//BeanNameAware->BeanClassLoaderAware->BeanFactoryAware
if (bean instanceof BeanNameAware) {
//调用用户重写Aware接口的setXXX方法
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}Spring Bean生命周期---初始化前阶段
摘要
通过实现BeanPostProcessor的postProcessBeforeInitialization方法可以对bean进行修改
源码入口
AbstractAutowireCapableBeanFactory#initializeBean
使用示例
class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
@Override
public PropertyValues postProcessBeforeInitialization(Object bean, String beanName) throws BeansException{
if(ObjectUtils.nullSafeEquals("user",beanName) && User.class.equals(bean.getClass())){
//如果beanName等于user,而且时User.class类型
//演示初始化前对Bean进行操作
User user = (User)bean;
user.setName("sign");
}
return bean;
}
}源码解析
/**
* Bean初始化方法
* @param beanName Bean名称
* @param bean 属性赋值完成的Object
* @param mbd BeanDefinition
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
//如果使用java安全机制单独处理
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//回调Aware接口
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//synthetic其实Spring都没有怎么使用，可以忽略
//这一句是Bean初始化前回调代码
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//@PostConstruct注解会在这句方法前就执行了
//@PostConstruct执行代码在InitDestroyAnnotationBeanPostProcessor类的postProcessBeforeInitialization方法里面
//其逻辑就是对加了@PostConstruct注解的方法进行invoke
//而invokeInitMethods方法则是对afterPropertiesSet和init-method进行回调
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//执行初始化后的回调方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}Spring Bean生命周期---初始化阶段
摘要
Bean初始化阶段主要涉及到3个回调方法：
它们的回调顺序是：@PostConstruct->afterPropertiesSet->init-method
@PostConstruct
InitializingBean接口的afterPropertiesSet()方法
<bean init-method="xxx"/>的自定义初始化方法
源码入口
AbstractAutowireCapableBeanFactory#initializeBean
源码解析
前面初始化前阶段的源码就是了
Spring Bean生命周期---初始化后阶段
摘要
通过实现BeanPostProcessor的postProcessAfterInitialization方法，可以对Bean进行修改，例如在此阶段进行自定义注解依赖注入，像RPC中需要注入代理对象
源码入口
AbstractAutowireCapableBeanFactory#initializeBean
使用示例
class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
@Override
public PropertyValues postProcessAfterInitialization(Object bean, String beanName) throws BeansException{
if(ObjectUtils.nullSafeEquals("user",beanName) && User.class.equals(bean.getClass())){
//如果beanName等于user,而且时User.class类型
//演示初始化前对Bean进行操作
User user = (User)bean;
user.setName("sign");
}
return bean;
}
}Spring Bean生命周期---初始化完成阶段
//TODO
Spring Bean生命周期---销毁前阶段
//TODO
Spring Bean生命周期---销毁阶段
//TODO
735
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
