环境:Spring5.3.3
三种Bean处理器
- BeanFactoryPostProcessor
- BeanPostProcessor
- InstantiationAwareBeanPostProcessor
1 BeanFactoryPostProcessor
所有Bean在未初始化前执行,同时可以去修改常规Bean的相关定义信息,比如修改Bean的属性信息。
准备类:
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
/*BeanDefinition beanDefinition = beanFactory.getBeanDefinition("person") ;
beanDefinition.getPropertyValues().addPropertyValue("name", "CNM") ;*/
System.out.println("BeanFactoryPostProcessor") ;
}
}
public class CustomBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println(beanName + ", 初始化之前执行" + bean) ;
return bean ;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println(beanName + ", 初始化之后执行" + bean) ;
return bean ;
}
}
@Bean
public Person person() {
return new Person() ;
}
先简单说下Spring容器启动执行流程中BeanFactoryPostProcessor的执行
1.1 实例化容器
public AnnotationConfigApplicationContext(String... basePackages) {
this();
// 该方法会扫描指定包下的所有类,将符合条件的类通过BeanDefinition进行定义。
scan(basePackages);
// 刷新;核心方法这种信息的初始化(事件,国际化,Bean等的初始化)
refresh();
}
1.2 执行BeanFactoryPostProcessor方法
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// ...other code
}
}
refresh方法中的
nvokeBeanFactoryPostProcessors方法调用用来执行BeanFactoryPostProcessor的方法。
1.3 获取BeanFactoryPostProcessor
执行过程中进入到
PostProcessorRegistrationDelegate类中的invokeBeanFactoryPostProcessors方法
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 获取所有BeanFactoryPostProcessor类型的Bean
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 首先,执行实现了PriorityOrdered接口的BeanFactoryPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 执行所有实现了Orderd接口的BeanFactoryPostProcessors
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessor.
// 如果你的BeanFactoryPostProcessors没有实现Orderd接口或者是实现PriorityOrdered接口,那就会在这里执行
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 根据我们自定义的BeanFactoryPostProcessor,该方法的执行会在这里执行。
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
private static void invokeBeanFactoryPostProcessors(
Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
for (BeanFactoryPostProcessor postProcessor : postProcessors) {
StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process")
.tag("postProcessor", postProcessor::toString);
postProcessor.postProcessBeanFactory(beanFactory);
postProcessBeanFactory.end();
}
}
到这里时我们相应的BeanFactoryPostProcessor中的postProcessBeanFactory方法都已经执行完毕了。
示例:
2 BeanPostProcessor
BeanPostProcessor初始化过程
2.1 注册BeanPostProcessor
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Invoke factory processors registered as beans in the context.
registerBeanPostProcessors(beanFactory);
// ...other code
}
}
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
2.2 获取BeanPostProcessor
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先将所有实现了PriorityOrdered接口的BeanPostProcessor添加到beanPostProcessors(List)集合中
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 接着将所有实现了Ordered接口的BeanPostProcessor添加到beanPostProcessors(List)集合中
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 最后将没有实现PriorityOrdered和Ordered接口的所有BeanPostProcessor添加到beanPostProcessors(List)集合中
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
到此已经知道了BeanFactoryPostProcessor在所有Bean初始化(未实例化)前就已经执行了,而BeanPostProcessor则只是进行了注册(将所有的BeanPostProcessor)都添加到了AbstractBeanFactory(
DefaultListableBeanFactory的父类)类中的beanPostProcessors属性的List集合中。
接下来查看BeanPostProcessor中方法的执行
2.3 BeanPostProcessor执行
按照Spring容器的初始化流程进入到如下方法对Bean进行实例化
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有剩余的单例Bean(此Bean是非延迟初始化的)
finishBeanFactoryInitialization(beanFactory);
// ...other code
}
}
进入
AbstractApplicationContext中
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// ... other code
beanFactory.preInstantiateSingletons();
}
进入
DefaultListableBeanFactory中
public void preInstantiateSingletons() throws BeansException {
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// ...
}
// 进入else中getBean
else {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
// 当所有的单例Bean都初始化完成以后会执行所有Bean实现了 SmartInitializingSingleton接口的afterSingletonsInstantiated方法。
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
}
注意:这里的getBean方法内部就是执行BeanPostProcessor相关方法的地方。这里我们就以Person为例进入到getBean方法中。
getBean执行流程,这里省略不重要的部分,直接进入到doCreateBean方法
getBean方法—》doGetBean方法—》createBean方法—》doCreateBean方法
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object beanInstance;
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建Bean核心方法
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
return adaptBeanInstance(name, beanInstance, requiredType);
}
doCreateBean核心方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建Bean的实例,这里通过反射(获取Constructor对象)实例化
// 执行流程:createBeanInstance---》instantiateBean---》getInstantiationStrategy().instantiate(mbd, beanName, this)---》 // BeanUtils.instantiateClass(constructorToUse)
// 最后将实例化后的对象包装到BeanWrapperImpl对象中
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// ... other code
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// ... other code
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean,在这里会执行BeanPostProcessor对应的方法了
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);
}
}
// ... other code
// Register bean as disposable.
// ... other code
return exposedObject;
}
进入initializeBean方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 如果当前Bean实现了相关的*Aware接口那么就会在这注入相应的*(ApplicationContenxt等对象)
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 这里将会执行BeanPostProcessor对应的postProcessBeforeInitialization方法,如下:引用1
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 执行初始化方法了;(实现了InitializingBean(afterPropertiesSet)或是自定义了初始化方法)
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()) {
// 这里将执行BeanPostProcessor对应的postProcessAfterInitialization方法,如下:引用2
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
引用1:
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;
}
引用2:
@Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) { return result; }
result = current;
}
return result;
}
在整个initializeBean方法中我们也就知道了,当一个单例Bean通过反射实例化后,将会执行如下流程:
实例化—》执行
BeanPostProcessor.postProcessBeforeInitialization方法—》执行初始化方法InitializingBean.afterPropertiesSet(如果有)或者自定义初始化方法(如果有)—》执行BeanPostProcessor.applyBeanPostProcessorsAfterInitialization放。
示例:
3 InstantiationAwareBeanPostProcessor
该Bean有如下3个方法
3.1 postProcessBeforeInstantiation
该方法会在Bean实例化之前被执行,也就是在createBean方法中先执行然后才会执行doCreateBean方法。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 执行InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
}
示例:
3.2 postProcessAfterInstantiation
该方法会在Bean实例化后,属性填充之前执行。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
// 如果存在InstantiationAwareBeanPostProcessor那么就会在实例化Bean后,填充属性前执行postProcessAfterInstantiation方法
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
示例:
3.3 postProcessProperties
该方法在实例化Bean后填充属性的时候执行
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
// 处理Bean的属性
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
pvs = pvsToUse;
}
}
}
示例:
总结:
BeanFactoryPostProcessor:
在Bean实例化前执行(当前容器只是将所有的Bean定义为BeanDefinition),在这个时候我们可以在该类中获取对应的BeanDefinition修改属性等操作。
BeanPostProcessor:
postProcessBeforeInitialization方法会在Bean实例化后并且属性填充完以后执行;
postProcessAfterInitialization方法会在Bean实例化后属性填充完并且相应初始化方法执行完以后执行。
InstantiationAwareBeanPostProcessor:
postProcessBeforeInstantiation方法在实例化Bean之前执行;
postProcessAfterInstantiation方法在实例化Bean之后属性填充之前执行;
postProcessProperties方法在实例化Bean后填充属性的时候执行。
完毕!!!
给个关注+转发呗谢谢
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/80001.html