Spring通过源码分析了解这3种Bean处理器的执行过程

导读:本篇文章讲解 Spring通过源码分析了解这3种Bean处理器的执行过程,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com

环境:Spring5.3.3


三种Bean处理器

  1. BeanFactoryPostProcessor
  2. BeanPostProcessor
  3. 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方法都已经执行完毕了。

示例:

Spring通过源码分析了解这3种Bean处理器的执行过程

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放。

示例:

Spring通过源码分析了解这3种Bean处理器的执行过程

Spring通过源码分析了解这3种Bean处理器的执行过程

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;
    }
   
}

示例:

Spring通过源码分析了解这3种Bean处理器的执行过程

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;
            }
        }
    }
}

示例:

Spring通过源码分析了解这3种Bean处理器的执行过程

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;
        }
    }
}

示例:

Spring通过源码分析了解这3种Bean处理器的执行过程

总结:

BeanFactoryPostProcessor

在Bean实例化前执行(当前容器只是将所有的Bean定义为BeanDefinition),在这个时候我们可以在该类中获取对应的BeanDefinition修改属性等操作。

BeanPostProcessor

postProcessBeforeInitialization方法会在Bean实例化后并且属性填充完以后执行;

postProcessAfterInitialization方法会在Bean实例化后属性填充完并且相应初始化方法执行完以后执行。

InstantiationAwareBeanPostProcessor

postProcessBeforeInstantiation方法在实例化Bean之前执行;

postProcessAfterInstantiation方法在实例化Bean之后属性填充之前执行;

postProcessProperties方法在实例化Bean后填充属性的时候执行。

完毕!!!

给个关注+转发呗谢谢

Spring通过源码分析了解这3种Bean处理器的执行过程
Spring Security记住我功能实现及源码分析

Spring Security 自定义登录成功后的逻辑

Spring Boot Security防重登录及在线总数

Spring注解@Qualifier这种用法你知道吗?

使用Spring Boot Admin实时监控你的系统

Spring Cloud Nacos 开启权限验证

Spring中Aware接口实现原理解析

Spring AOP动态代理失效的解决方法@Transactional为何会失效

SpringMVC参数统一验证方法

Spring通过源码分析了解这3种Bean处理器的执行过程

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/80001.html

(0)

相关推荐

半码博客——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!