SpringBoot 优先加载指定 Bean 的实现

谈谈1974

2024-04-13 帮助1人

1. 背景

SpringBoot 框架在启动时可以自动将托管的 Bean 实例化，一般情况下它的依赖注入特性可以正确处理 Bean 之间的依赖关系，无需手动指定某个 Bean 优先创建实例。但是一些特殊的需求确实需要某个 Bean 优先实例化，要实现这样的需求就要对 Bean 对象的创建顺序有一定了解

2. Bean 对象的创建顺序分析

首先我们要知道，SpringBoot 源码中 Bean 对象的实例化都是从 AbstractApplicationContext#refresh() 方法开始的。这个方法包含了容器中对象创建的主流程，主要分为以下几步：

BeanFactory 对象工厂的获取及内置配置

BeanFactory 对象工厂的后置处理，主要是通过 BeanFactoryPostProcessor 添加、修改注册到容器中的 BeanDefinition，BeanFactoryPostProcessor 的子类实现 BeanDefinitionRegistryPostProcessor在执行顺序上优先级更高

BeanDefinitionRegistryPostProcessor 的来源分为两类，一类是直接 new 创建后添加到容器，这种在执行顺序上优先级更高；另一类是框架内部封装为 BeanDefinition 后通过对象工厂使用反射创建，典型如 ConfigurationClassPostProcessor

对于通过 @Component 等注解托管给容器的类，主要由ConfigurationClassPostProcessor 这个 Bean 工厂后置处理器将其扫描封装为 BeanDefinition 并注册，有兴趣的读者可参考 SpringBoot 注解 @Import 的原理-ConfigurationClassPostProcessor 源码解析

BeanPostProcessor 对象后置处理器的实例化

Bean 对象创建及其 BeanPostProcessor 后置处理器在创建对象时的切面应用，这部分逻辑主要在 AbstractApplicationContext#finishBeanFactoryInitialization() 方法中

 @Override
 public void refresh() throws BeansException, IllegalStateException {
 	synchronized (this.startupShutdownMonitor) {
 		// Prepare this context for refreshing.
 		prepareRefresh();

 		// Tell the subclass to refresh the internal bean factory.
 		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

 		// Prepare the bean factory for use in this context.
 		prepareBeanFactory(beanFactory);

 		try {
 			// Allows post-processing of the bean factory in context subclasses.
 			postProcessBeanFactory(beanFactory);

 			// Invoke factory processors registered as beans in the context.
 			invokeBeanFactoryPostProcessors(beanFactory);

 			// Register bean processors that intercept bean creation.
 			registerBeanPostProcessors(beanFactory);

 			// Initialize message source for this context.
 			initMessageSource();

 			// Initialize event multicaster for this context.
 			initApplicationEventMulticaster();

 			// Initialize other special beans in specific context subclasses.
 			onRefresh();

 			// Check for listener beans and register them.
 			registerListeners();

 			// Instantiate all remaining (non-lazy-init) singletons.
 			finishBeanFactoryInitialization(beanFactory);

 			// Last step: publish corresponding event.
 			finishRefresh();
 		}

 		catch (BeansException ex) {
 			if (logger.isWarnEnabled()) {
 				logger.warn("Exception encountered during context initialization - "  
 						"cancelling refresh attempt: "   ex);
 			}

 			// Destroy already created singletons to avoid dangling resources.
 			destroyBeans();

 			// Reset 'active' flag.
 			cancelRefresh(ex);

 			// Propagate exception to caller.
 			throw ex;
 		}

 		finally {
 			// Reset common introspection caches in Spring's core, since we
 			// might not ever need metadata for singleton beans anymore...
 			resetCommonCaches();
 		}
 	}
}

AbstractApplicationContext#finishBeanFactoryInitialization() 方法的核心是调用 DefaultListableBeanFactory#preInstantiateSingletons() 方法实例化 Bean 对象

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
 	// Initialize conversion service for this context.
 	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
 			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
 		beanFactory.setConversionService(
 				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
 	}

 	// Register a default embedded value resolver if no bean post-processor
 	// (such as a PropertyPlaceholderConfigurer bean) registered any before:
 	// at this point, primarily for resolution in annotation attribute values.
 	if (!beanFactory.hasEmbeddedValueResolver()) {
 		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
 	}

 	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
 	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
 	for (String weaverAwareName : weaverAwareNames) {
 		getBean(weaverAwareName);
 	}

 	// Stop using the temporary ClassLoader for type matching.
 	beanFactory.setTempClassLoader(null);

 	// Allow for caching all bean definition metadata, not expecting further changes.
 	beanFactory.freezeConfiguration();

 	// Instantiate all remaining (non-lazy-init) singletons.
 	beanFactory.preInstantiateSingletons();
}

DefaultListableBeanFactory#preInstantiateSingletons() 方法会遍历容器内部的 beanDefinitionNames列表 进行 Bean 实例化，也就说这个列表的顺序就决定了 Bean 的创建顺序，而实际上 beanDefinitionNames列表 中的元素是 BeanDefinition 注册到 BeanDefinitionRegistry 时产生的

在本节步骤1第2步中，笔者提到通过 @Component 等注解托管给容器的类主要由 ConfigurationClassPostProcessor 扫描注册，那么要想让指定的 Bean 优先加载，只需要在 ConfigurationClassPostProcessor 扫描之前注册指定 Bean 即可

	@Override
 public void preInstantiateSingletons() throws BeansException {
 	if (logger.isTraceEnabled()) {
 		logger.trace("Pre-instantiating singletons in "   this);
 	}

 	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
 	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
 	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)) {
 				Object bean = getBean(FACTORY_BEAN_PREFIX   beanName);
 				if (bean instanceof FactoryBean) {
 					final FactoryBean<?> factory = (FactoryBean<?>) bean;
 					boolean isEagerInit;
 					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
 						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
 										((SmartFactoryBean<?>) factory)::isEagerInit,
 								getAccessControlContext());
 					}
 					else {
 						isEagerInit = (factory instanceof SmartFactoryBean &&
 								((SmartFactoryBean<?>) factory).isEagerInit());
 					}
 					if (isEagerInit) {
 						getBean(beanName);
 					}
 				}
 			}
 			else {
 				getBean(beanName);
 			}
 		}
 	}

 	// Trigger post-initialization callback for all applicable beans...
 	for (String beanName : beanNames) {
 		Object singletonInstance = getSingleton(beanName);
 		if (singletonInstance instanceof SmartInitializingSingleton) {
 			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
 			if (System.getSecurityManager() != null) {
 				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
 					smartSingleton.afterSingletonsInstantiated();
 					return null;
 				}, getAccessControlContext());
 			}
 			else {
 				smartSingleton.afterSingletonsInstantiated();
 			}
 		}
 	}
 }

3. 实现方式

经过上一节分析，我们知道只要找到一个切入点，在 ConfigurationClassPostProcessor 扫描注册 Bean 之前注册指定 Bean 到容器中就能实现优先加载。SpringBoot 提供了不少这样的切入点，本文主要涉及如下两个：

ApplicationContextInitializer

ApplicationListener

3.1 实现 ApplicationListener 监听初始化事件

该方式实现的步骤如下：

在 SpringBoot 主类中调用 SpringApplication#addListeners() 方法添加一个 ContextInitializedListener 监听器

ContextInitializedListener 监听 ApplicationContextInitializedEvent事件，在事件触发的时候往容器中注册指定的 BeanDefinitionRegistryPostProcessor 后置处理器

BeanDefinitionRegistryPostProcessor 后置处理器实现类在 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry() 方法中将指定 Bean 注册到容器中，从而实现优先加载

@SpringBootApplication()
public class ApiApplication {

    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(ApiApplication.class);
        application.addListeners(new ContextInitializedListener());
        application.run(args);
    }


    static class ContextInitializedListener implements ApplicationListener<ApplicationContextInitializedEvent>, BeanDefinitionRegistryPostProcessor {

        @Override
        public void onApplicationEvent(ApplicationContextInitializedEvent event) {
            AbstractApplicationContext context = (AbstractApplicationContext) event.getApplicationContext();
            context.addBeanFactoryPostProcessor(this);
        }

        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            registry.registerBeanDefinition("example", new RootBeanDefinition(ContentDTO.class));
        }

        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

        }
    }
}

3.2 实现 ApplicationContextInitializer

该方式实现的原理与事件监听类似，不再赘述

@SpringBootApplication()
public class ApiApplication {

    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(ApiApplication.class);
        application.addInitializers(new MyApplicationContextInitializer());
        application.run(args);
    }


    static class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext>, BeanDefinitionRegistryPostProcessor {

        @Override
        public void initialize(ConfigurableApplicationContext applicationContext) {
            applicationContext.addBeanFactoryPostProcessor(this);
        }

        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            registry.registerBeanDefinition("example", new RootBeanDefinition(ContentDTO.class));
        }

        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

        }
    }
}

这篇好文章是转载于：学新通技术网

SpringBoot 优先加载指定 Bean 的实现

1. 背景

2. Bean 对象的创建顺序分析

3. 实现方式

3.1 实现 ApplicationListener 监听初始化事件

3.2 实现 ApplicationContextInitializer

photoshop保存的图片太大微信发不了怎么办

《学习通》视频自动暂停处理方法

word里面弄一个表格后上面的标题会跑到下面怎么办

Android 11 保存文件到外部存储，并分享文件

photoshop扩展功能面板显示灰色怎么办

微信公众号没有声音提示怎么办

excel下划线不显示怎么办

excel打印预览压线压字怎么办

TikTok加速器哪个好免费的TK加速器推荐

怎样阻止微信小程序自动打开