SpringBean注册之后置处理器BeanPostProcessor

这是一条海鱼

已于 2022-04-09 20:40:53 修改

阅读量584

点赞数

分类专栏： Spring-IOC 文章标签： Spring-IOC

于 2020-05-02 02:09:08 首次发布

本文链接：https://blog.csdn.net/qq_41071876/article/details/105390486

版权

Spring-IOC 专栏收录该内容

21 篇文章 2 订阅

订阅专栏

前言

注意两个单词，Instantiation 表示实例化,对象还未生成，Initialization 表示初始化,对象已经生成

本文重点研究spring中各种BeanPostProcessor和其调用时机。
在这里插入图片描述

public interface BeanPostProcessor {

	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

一、后置处理器实例化时机

地点：发生在refresh方法的registerBeanPostProcessors(beanFactory)模块中，其底层是PostProcessorRegistrationDelegate的registerBeanPostProcessors方法

final class PostProcessorRegistrationDelegate {

   public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		// 从所与Bean定义中提取出BeanPostProcessor类型的Bean名字
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		//储存实现PriorityOrdered接口的BeanPostProcessor
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		//储存MergedBeanDefinitionPostProcessor类型的BeanPostProcessor
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		//储存实现Ordered接口的BeanPostProcessor的名字
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			   //实例化并获取PriorityOrdered接口的BeanPostProcessor
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
				   //储存MergedBeanDefinitionPostProcessor类型的BeanPostProcessor
					internalPostProcessors.add(pp);
				}
			}
			//收集实现Ordered接口的BeanPostProcessor的名字
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			//收集没有实现Ordered和PriorityOrdered接口的BeanPostProcessor的名字
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 排序实现PriorityOrdered接口的BeanPostProcessor
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		//注册到beanPostProcessors池中
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 实例化并注册实现Ordered接口的BeanPostProcessor
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
			     //储存MergedBeanDefinitionPostProcessor类型的BeanPostProcessor
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 实例化并注册没有实现Ordered和PriorityOrdered接口的BeanPostProcessor
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
			   //储存MergedBeanDefinitionPostProcessor类型的BeanPostProcessor
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	    
	    //排序所有MergedBeanDefinitionPostProcessor类型的BeanPostProcessor
		sortPostProcessors(internalPostProcessors, beanFactory);
		//注册到beanPostProcessors池中
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		//注册一个ApplicationListenerDetector后置处理器到beanPostProcessors池中
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

1、实例化PriorityOrdered接口的BeanPostProcessor，并注册其到beanPostProcessors池中

2、实例化Ordered接口的BeanPostProcessor，并注册其到beanPostProcessors池中

3、实例化剩余的BeanPostProcessor，并注册其到beanPostProcessors池中

4、注册ApplicationListenerDetector到beanPostProcessors池中

二、BeanPostProcessor

该接口我们也叫Bean的后置处理器，作用是在Bean对象在实例化和依赖注入完毕后，在显示调用初始化方法的前后添加我们自己的逻辑。注意是Bean实例化完毕后及依赖注入完成后触发的。接口的源码如下

public interface BeanPostProcessor {

   //发生在调用构造器后，初始化方法前
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
    //初始化方法后
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

2.1、BeanPostProcessor调用时机

BeanPostProcessor的执行时机是在bean调用构造器后，这时候对象已经生成了

//初始化bean
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

		// 第一步：先执行所有的AwareMethods，具体如下代码，比较简单
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			// 执行所有的BeanPostProcessor#postProcessBeforeInitialization  初始化之前的处理器方法
			// 规则：只要谁返回了null，后面的就都不要执行了
			// 这里面实现postProcessBeforeInitialization 的处理器就很多了，有很多对Aware进行了扩展的，具体如下面的具体介绍吧
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			//这里就开始执行afterPropertiesSet（实现了InitializingBean接口）方法和initMethod
			// 备注：这里initMethod方法的名称不能是afterPropertiesSet，并且这个类不是 InitializingBean类型才会调用，需要特别注意
			//(然后该方法只有方法名，所以肯定是反射调用，效率稍微低那么一丢丢)
			// 由此可以见，实现这个接口的初始化方法，是在标注形如@PostConstruct之后执行的
			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()) {
			// 整个Bean都初始化完成了，就执行后置处理器的这个方法
		    // 执行所有的BeanPostProcessor#postProcessAfterInitialization
			// 规则：只要谁返回了null，后面的就都不要执行了
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

2.2、BeanPostProcessor2个方法的执行规则

postProcessBeforeInitialization和postProcessAfterInitialization执行规则一样，这里以postProcessBeforeInitialization为例

@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

注意：我们实现我们自己的BeanPostProcessor时，其方法返回不能返回null，否则使其他BeanPostProcessor失效

2.3、案例

@Component
public class Ball {

	public Ball(){System.out.println("执行Ball构造器完成");}

	@PostConstruct
	public void init(){System.out.println("Ball调用init方法完成");}	
}


@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

	public MyBeanPostProcessor(){
		System.out.println("MyBeanPostProcessor");
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("执行 postProcessBeforeInitialization 完成");
		return bean; 
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("执行 postProcessAfterInitialization 完成");
		return bean;
	}
}

控制台输入如下：

posy
MyBeanPostProcessor
执行Ball构造器完成
执行 postProcessBeforeInitialization 完成
Ball调用init方法完成
执行 postProcessAfterInitialization 完成

三、InstantiationAwareBeanPostProcessor

参考文章： Spring之InstantiationAwareBeanPostProcessor接口介绍

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    //自身方法，是最先执行的方法，它在目标对象实例化之前调用，该方法的返回值类型是Object，我们可以返回任何类型的值。如果这个返回值不为bull,由于这个时候目标对象还未实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例(比如代理对象)，后续只有postProcessAfterInitialization方法会调用，其它方法不再调用；否则按照正常的流程走
	@Nullable
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}
  //在目标对象实例化之后调用，这个时候对象已经被实例化，但是该实例的属性还未被设置，都是null。因为它的返回值是决定要不要调用postProcessPropertyValues方法的其中一个因素（因为还有一个因素是mbd.getDependencyCheck()）；如果该方法返回false,并且不需要check，那么postProcessPropertyValues就会被忽略不执行；如果返回true，postProcessPropertyValues就会被执行
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		return true;
	}

    //对属性值进行修改，如果postProcessAfterInstantiation方法返回false，该方法可能不会被调用。可以在该方法内对属性值进行修改
	@Nullable
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
			throws BeansException {
		return null;
	}
   
	@Deprecated
	@Nullable
	default PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
		return pvs;
	}
}

3.1、InstantiationAwareBeanPostProcessor调用时机

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    @Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

	    //......忽略代码

		try {
		 //自身方法，是最先执行的方法，它在目标对象实例化之前调用，该方法的返回值类型是Object，我们可以返回任何类型的值。
		 //如果这个返回值不为bull,由于这个时候目标对象还未实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例(比如代理对象)，
		 //后续只有postProcessAfterInitialization方法会调用，其它方法不再调用；否则按照正常的流程走
			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 {
		    //这边开始创建bean
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

    @Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		     //只有InstantiationAwareBeanPostProcessor才会进入
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					// 先执行执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation回调方法
					// 需要注意的是，如果我们采用了AOP、声明式事务等等，这里就会有了，后面又会回来讲解这一块
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					// 我们可以看到，如果bean不为null，那就直接返回了  短路掉后面的After也就不执行了
					if (bean != null) {
					    //执行执行InstantiationAwareBeanPostProcessor的PostProcessorsAfterInitialization回调方法
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

}

如果postProcessBeforeInstantiation方法返回了Object是null;那么就直接返回，调用doCreateBean()方法创建对象;
如果postProcessBeforeInstantiation返回不为null;说明修改了bean对象;然后这个时候就立马执行postProcessAfterInitialization方法(注意这个是初始化之后的方法,也就是通过这个方法实例化了之后，直接执行初始化之后的方法;中间的实例化之后和初始化之前都不执行);
在调用postProcessAfterInitialization方法时候如果返回null;那么就直接返回，调用doCreateBean()方法创建对象;(初始化之后的方法返回了null,那就需要调用doCreateBean生成对象了)
在调用postProcessAfterInitialization时返回不为null;那这个bean就直接返回给ioc容器了初始化之后的操作是这里面最后一个方法了；

下面我们来看看这个doCreateBean(beanName, mbdToUse, args);方法，看看对象是如何创建的

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
				throws BeanCreationException {
	
			// 用BeanWrapper来持有创建出来的Bean对象
			BeanWrapper instanceWrapper = null;
			if (mbd.isSingleton()) {
				//如果是单例的话，则先把缓存中的同名bean清除（同名的）
				instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
			}
			//实际创建的交给createBeanInstance来完成，
			//bean的生成，这里会使用默认的类生成器，包装成BeanWrapperImpl类，为了下面的populateBean方法的属性注入做准备
			if (instanceWrapper == null) {
				//调用构造器
				instanceWrapper = createBeanInstance(beanName, mbd, args);
			}
			final Object bean = instanceWrapper.getWrappedInstance();
			Class<?> beanType = instanceWrapper.getWrappedClass();
			//如果不是NullBean，则将resolvedTargetType 属性设置为当前的WrappedClass
			if (beanType != NullBean.class) {
				mbd.resolvedTargetType = beanType;
			}
	
			synchronized (mbd.postProcessingLock) {
				if (!mbd.postProcessed) {
					try {
						//调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
						// 主要是处理@PostConstruct,@Autowire,@Value,@Resource，@PreDestory等这些注解。
						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是单例，且支持循环依赖，且当前bean正在创建，通过往singletonFactories添加一个objectFactory，这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean
			//getEarlyBeanReference可以对返回的bean进行修改，这边目前除了可能会返回动态代理对象 其他的都是直接返回bean
			boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
					isSingletonCurrentlyInCreation(beanName));
			if (earlySingletonExposure) {
				if (logger.isTraceEnabled()) {
					logger.trace("");
				}
				// 这里面主要是解决循环引用问题~~~~~~~~~借助了这个工厂
				//这里主要是调用处理器：SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference方法去寻找到前期的Bean们（若存在这种处理器的话）
				addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
			}
	
			// 这个Obj，就是最终要返回的对象了
			Object exposedObject = bean;
			try {
				// 这又是非常非常重要的一步：给已经初始化的属性们赋值==============对bean进行填充，在这里面完成依赖注入的相关内容
				// 啥都不说了，看下面的详解吧,只有这段代码和本文章主题有关，所以其他代码可以忽略
				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("");
						}
					}
				}
			}
	
			// 如果有需要，就注册DisposableBean，这样Bean销毁的时候此种后置处理器也会生效了
			try {
				registerDisposableBeanIfNecessary(beanName, bean, mbd);
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
			}
	
			return exposedObject;
		}



  //赋值属性方法
   protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		
		 //忽略代码

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					 /// 此处执行 postProcessAfterInstantiation方法
					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);
						}
						// 调用 postProcessPropertyValues方法
						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);
		}
	}
}

这个postProcessAfterInstantiation返回值要注意，因为它的返回值是决定要不要调用postProcessPropertyValues方法的其中一个因素（因为还有一个因素是mbd.getDependencyCheck());如果该方法返回false,并且不需要check，那么postProcessPropertyValues就会被忽略不执行；如果返true，postProcessPropertyValues就会被执行

三、SmartInstantiationAwareBeanPostProcessor

这个接口主要是spring框架内部来使用

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

	@Nullable
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}
	
	@Nullable
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
			throws BeansException {
		return null;
	}

	default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

四、MergedBeanDefinitionPostProcessor

在这里插入图片描述

用来将merged BeanDefinition暴露出来的回调

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {

	
	void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);

	
	default void resetBeanDefinition(String beanName) {
	}

}

其执行时机在赋值方法populateBean()执行前。

```java
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
				throws BeanCreationException {
	
			// 用BeanWrapper来持有创建出来的Bean对象
			BeanWrapper instanceWrapper = null;
			if (mbd.isSingleton()) {
				//如果是单例的话，则先把缓存中的同名bean清除（同名的）
				instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
			}
			//实际创建的交给createBeanInstance来完成，
			//bean的生成，这里会使用默认的类生成器，包装成BeanWrapperImpl类，为了下面的populateBean方法的属性注入做准备
			if (instanceWrapper == null) {
				//调用构造器
				instanceWrapper = createBeanInstance(beanName, mbd, args);
			}
			final Object bean = instanceWrapper.getWrappedInstance();
			Class<?> beanType = instanceWrapper.getWrappedClass();
			//如果不是NullBean，则将resolvedTargetType 属性设置为当前的WrappedClass
			if (beanType != NullBean.class) {
				mbd.resolvedTargetType = beanType;
			}
	
			synchronized (mbd.postProcessingLock) {
				if (!mbd.postProcessed) {
					try {
						//调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
						// 主要是处理@PostConstruct,@Autowire,@Value,@Resource，@PreDestory等这些注解。
						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是单例，且支持循环依赖，且当前bean正在创建，通过往singletonFactories添加一个objectFactory，这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean
			//getEarlyBeanReference可以对返回的bean进行修改，这边目前除了可能会返回动态代理对象 其他的都是直接返回bean
			boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
					isSingletonCurrentlyInCreation(beanName));
			if (earlySingletonExposure) {
				if (logger.isTraceEnabled()) {
					logger.trace("");
				}
				// 这里面主要是解决循环引用问题~~~~~~~~~借助了这个工厂
				//这里主要是调用处理器：SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference方法去寻找到前期的Bean们（若存在这种处理器的话）
				addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
			}
	
			// 这个Obj，就是最终要返回的对象了
			Object exposedObject = bean;
			try {
				// 这又是非常非常重要的一步：给已经初始化的属性们赋值==============对bean进行填充，在这里面完成依赖注入的相关内容
				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("");
						}
					}
				}
			}
	
			// 如果有需要，就注册DisposableBean，这样Bean销毁的时候此种后置处理器也会生效了
			try {
				registerDisposableBeanIfNecessary(beanName, bean, mbd);
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
			}
	
			return exposedObject;
		}
}

五、DestructionAwareBeanPostProcessor

关于处理对象销毁的前置回调

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {


	void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;

	
	default boolean requiresDestruction(Object bean) {
		return true;
	}

}

这是一条海鱼

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringBean注册之后置处理器BeanPostProcessor

前言本文重点研究spring中各种BeanPostProcessor的实例化和调用时机一、BeanPostProcessor的实例化地点：发生在refresh方法的registerBeanPostProcessors(beanFactory)模块中final class PostProcessorRegistrationDelegate { public static void r...
复制链接

扫一扫