Spring源码(十五)-Spring启动流程-ApplicationContext
站长
· 阅读数 45
日积月累，水滴石穿 😄
前言
Spring 中的 Ioc 容器，我们可以大致上分为两种：
- BeanFactory
- ApplicationContext
BeanFactory 是最最基础的 IoC 容器，它提供了一个 IoC 容器所需的基本功能。 BeanFactory 默认采用延迟初始化策略，即当容器启动时，并未完成 Bean 的初始化，只有当调用到该 Bean 的实例时，才会完成其初始化操作，并进行依赖注入。
ApplicationContext 是在 BeanFactory 的基础上实现的，BeanFactory 的功能它都有。ApplicationContext 在 BeanFactory 的基础上提供了事件发布、国际化等功能。同时，ApplicationContext 和 BeanFactory 还有一个很大的不同。在于 ApplicationContext 在容器启动时，就会完成所有单例非懒加载 Bean 的初始化。
ApplicationContext 有两个比较重要的实现类：
- AnnotationConfigApplicationContext
- ClassPathXmlApplicationContext
经过上述的介绍，各位小伙伴应该知道 BeanFactory肯定不是本文的主角。
本文小杰将带大家了解，在使用 AnnotationConfigApplicationContext容器时，它的底层干了些什么事情，了解了 AnnotationConfigApplicationContext，ClassPathXmlApplicationContext也就不在话下了。
AnnotationConfigApplicationContext
UML图
先来一张UML图
然后进行一些准备工作！
- AppApplication
创建一个 AppApplication类，在类上加入 ComponentScan
@ComponentScan(basePackages = {"com.gongj.annon"})
public class AppApplication {
}
- AppMain
使用 AnnotationConfigApplicationContext容器。
public class AppMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AppApplication.class);
}
}
就这一句话，所有单例懒加载的Bean就已经加入到容器中。所有的逻辑都在 new AnnotationConfigApplicationContext(AppApplication.class);
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
// 1. 创建BeanFactory
// 2. 生成AnnotatedBeanDefinitionReader
// 3. 生成ClassPathBeanDefinitionScanner
this();
// 利用reader把componentClasses注册为一个BeanDefinition
register(componentClasses);
// 调用AbstractApplicationContext的refresh()方法，模板模式，会启动ApplicationContext
refresh();
}
这个有参构造方法中就三行代码，代码都被进行封装。这种代码写法值得我们学习！
this
public AnnotationConfigApplicationContext() {
// 在执行这个构造方法之前，会先执行父类的无参构造方法，
// 会初始化一个beanFactory = new DefaultListableBeanFactory()
// 生成并注册5个BeanDefinition
// 1.ConfigurationClassPostProcessor
// 2.AutowiredAnnotationBeanPostProcessor
// 3.CommonAnnotationBeanPostProcessor
// 4.EventListenerMethodProcessor
// 5.DefaultEventListenerFactory
this.reader = new AnnotatedBeanDefinitionReader(this);
// 注册默认的includeFilter
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
this()就是调用本类的无参构造方法。方法里也就两行代码，但在具体执行这两个方法之前，会执行父类的无参构造方法，AnnotationConfigApplicationContext继承了 GenericApplicationContext。这个没得说的，隐式调用。而在父类的无参构造方法中，进行了一步非常重要的操作，构造了一个 BeanFactory 对象实例，为DefaultListableBeanFactory。
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
reader
我们先来看 reader的赋值逻辑。该方法位于AnnotatedBeanDefinitionReader类。
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
// Environment表示环境变量，包含了系统环境变量以及JVM启动参数
this(registry, getOrCreateEnvironment(registry));
}
- getOrCreateEnvironment
private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
//registry instanceof EnvironmentCapable 这个是成立的，注意开篇贴的 UML图
if (registry instanceof EnvironmentCapable) {
// 会调用AbstractApplicationContext的getEnvironment方法，在这个方法中会去创建Environment
// 创建出来的Environment对象也是 StandardEnvironment
return ((EnvironmentCapable) registry).getEnvironment();
}
return new StandardEnvironment();
}
然后调用了另外一个有参构造方法。
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry,
Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
this.registry = registry;
//@Conditional注解判断器，它的作用是按照指定的条件进行判断，满足条件才向容器注册bean
this.conditionEvaluator = new ConditionEvaluator(registry, environment,
null);
// 生成并注册5个BeanDefinition
// 1.ConfigurationClassPostProcessor
// 2.AutowiredAnnotationBeanPostProcessor
// 3.CommonAnnotationBeanPostProcessor
// 4.EventListenerMethodProcessor
// 5.DefaultEventListenerFactory
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
registerAnnotationConfigProcessors
重点看 registerAnnotationConfigProcessors方法呢！这时候来到了 AnnotationConfigUtils类。
public static Set < BeanDefinitionHolder > registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(
registry);
if(beanFactory != null) {
// 设置beanFactory的OrderComparator，为AnnotationAwareOrderComparator
// 它是一个Comparator，是一个比较器，可以用来进行排序，比如new ArrayList<>().sort(Comparator);
// @Priority、@Order 注解的排序都是由它来处理的
if(!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
// 设置自动装配候选者解析式（判断某个bean是不是可以用来进行进行自动注入）
// ContextAnnotationAutowireCandidateResolver 中的方法挺重要的，在后续的源码中经常出现
if(!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set < BeanDefinitionHolder > beanDefs = new LinkedHashSet < > (8);
// 向 beanDefinitionMap 中注册
// ConfigurationClassPostProcessor 是一个 BeanFactoryPostProcessor
// 注册 ConfigurationClassPostProcessor 类型的 BeanDefinition
if(!registry.containsBeanDefinition(
CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(
ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def,
CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册AutowiredAnnotationBeanPostProcessor类型的BeanDefinition
if(!registry.containsBeanDefinition(
AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(
AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def,
AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册CommonAnnotationBeanPostProcessor类型的BeanDefinition
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
if(jsr250Present && !registry.containsBeanDefinition(
COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(
CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def,
COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册PersistenceAnnotationBeanPostProcessor类型的BeanDefinition
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
if(jpaPresent && !registry.containsBeanDefinition(
PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(
PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch(ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " +
PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def,
PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 注册EventListenerMethodProcessor类型的BeanDefinition
if(!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(
EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def,
EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// 注册DefaultEventListenerFactory类型的BeanDefinition
if(!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(
DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def,
EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
构造 AnnotatedBeanDefinitionReader对象，主要作用是添加一些基础的PostProcessor，通过 reader 进行BeanDefinition的注册，还会对BeanFactory的属性进行设置。在无其他因素的影响下，会向beanDefinitionMap中注册五个类，分别如下：
- ConfigurationClassPostProcessor：解析配置类，会对
@Configuration、@Bean，@Component，@ComponentScan，@Import，@ImportResource注解进行解析。 - AutowiredAnnotationBeanPostProcessor：对
@Autowired、@Value等注解的解析 - CommonAnnotationBeanPostProcessor：对
@PostConstruct、@PreDestroy、@Resource等注解的解析 - EventListenerMethodProcessor：解析
@EventListener注解 - DefaultEventListenerFactory：封装有
@EventListener注解的方法为监听器
scanner
进入到ClassPathBeanDefinitionScanner类。
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}
调用另外一个有参构造方法：
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
再调用
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment) {
// registry instanceof ResourceLoader 这个是成立的，注意开篇贴的 UML图
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
再调用
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
// 添加includeFilters，Spring扫描的时候需要利用includeFilters
// Spring扫描到某个类时如果能通过includeFilters的验证就证明这个类是一个Bean
// 默认注册一个@Component注解对应的Filter
if(useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}
看看 registerDefaultFilters方法：
protected void registerDefaultFilters() {
//默认就添加 @Component
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
上面的代码看起来都不怎么绕。还是挺简单的。如果各位小伙伴看过小杰前面的源码，就会清楚源码中用到的对象的值是从哪里来的了。
上述代码构造了一个ClassPathBeanDefinitionScanner对象，并设置了以下值：
-
设置 this.includeFilters = AnnotationTypeFilter(Component.class)
-
设置 environment
-
设置 resourceLoade
register
@Override
public void register(Class<?>... componentClasses) {
Assert.notEmpty(componentClasses, "At least one component class must be specified");
this.reader.register(componentClasses);
}
- register
public void register(Class<?>... componentClasses) {
for (Class<?> componentClass : componentClasses) {
registerBean(componentClass);
}
}
还记得componentClasses的值的来源吗？这个值就是在构建AnnotationConfigApplicationContext对象时候传进来的参数。遍历componentClasses 调用registerBean方法。注册 componentClasses为BeanDefinition，类型为AnnotatedGenericBeanDefinition。
public void registerBean(Class<?> beanClass) {
doRegisterBean(beanClass, null, null, null, null);
}
doRegisterBean
doRegisterBean方法有五个参数，在本次调用中，除第一个参数有值之外，其余全为 null。参数含义如下：
- beanClass：表示bean的类型
- name：表示bean的名字
- qualifiers：资格限定器，比如某个类上没有写
@Lazy注解，但是在调用registerBean方法时传递了Lazy.class，那么则达到了一样的效果。 - supplier：函数式接口，实例提供器，如果指定了 supplier，那么 bean 的实例是由这个 supplier 生成的
- customizers：表示
BeanDefinition自定义器，可以通过customizers对BeanDefinition进行自定义修改
private < T > void doRegisterBean(Class < T > beanClass, @Nullable String name, @
Nullable Class <? extends Annotation > [] qualifiers, @Nullable Supplier <
T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
// 根据 beanClass 直接生成一个 AnnotatedGenericBeanDefinition
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(
beanClass);
// 判断当前 abd 是否被标注了@Conditional注解，并判断是否符合所指定的条件，如果不符合，则跳过，不进行注册
if(this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
// 设置supplier、scope属性，以及得到beanName
abd.setInstanceSupplier(supplier);
// 获得 @Scope 注解的元数据信息
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(
abd);
abd.setScope(scopeMetadata.getScopeName());
//如果有传入 name 则使用传递的值作为 beanName
//否则自动生成 beanName
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(
abd, this.registry));
// 获取Lazy、Primary、DependsOn、Role、Description 注解信息并设置给 abd
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if(qualifiers != null) {
for(Class <? extends Annotation > qualifier: qualifiers) {
if(Primary.class == qualifier) {
abd.setPrimary(true);
}
else if(Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
// 使用自定义器修改BeanDefinition
if(customizers != null) {
for(BeanDefinitionCustomizer customizer: customizers) {
customizer.customize(abd);
}
}
// BeanDefinition类中是没有beanName属性的
// 但是 BeanDefinitionHolder 中持有了BeanDefinition,beanName,alias
// 所以构建一个 BeanDefinitionHolder 对象
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd,
beanName);
// 解析 Scope 中的 ProxyMode 属性，默认为 no，不生成代理对象
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata,
definitionHolder, this.registry);
// 注册到registry中
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
将传进来的类注册到beanDefinitionMap中，作为一个 BeanDefinition，类型为 AnnotatedGenericBeanDefinition。
由于是一个类，类上可以写各种注解，将注解进行解析，将解析出来的值作为BeanDefinition的属性值。
refresh
那接下来就是 refresh方法，这也是最最最重要的方法了，该方法定义在AbstractApplicationContext抽象类中。AbstractApplicationContext是 AnnotationConfigApplicationContext的父类的父类。
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
//准备此上下文以进行刷新。
prepareRefresh();
// 刷新BeanFactory，得到一个 BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备BeanFactory
// 1. 设置BeanFactory的类加载器、表达式解析器、类型转化注册器
// 2. 添加两个BeanPostProcessor实例对象
// 3. 记录ignoreDependencyInterface
// 4. 记录ResolvableDependency
// 5. 添加三个单例Bean
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 子类可以对BeanFactory进行进一步初始化
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// BeanFactory准备好了之后，执行BeanFactoryPostProcessor，开始对BeanFactory进行处理
// 默认情况下:
// 此时beanFactory的beanDefinitionMap中有6个BeanDefinition，5个基础BeanDefinition+AppConfig的BeanDefinition
// 而这6个中只有一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor
// 这里会执行ConfigurationClassPostProcessor进行@Component等等注解的扫描，扫描得到BeanDefinition，并注册到beanFactory中
// 注意：扫描的过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些BeanFactoryPostProcessor也得在这一步执行
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 从BeanFactory找出扫描得到的BeanPostProcessor，实例化并注册到BeanFactory中
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 初始化MessageSource，如果配置了一个名字叫做“messageSource”的BeanDefinition
// 就会把这个Bean创建出来，并赋值给ApplicationContext的messageSource属性
// 这样ApplicationContext就可以使用国际化的功能了
initMessageSource();
// Initialize event multicaster for this context.
// 设置ApplicationContext的applicationEventMulticaster
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 执行子类的onRefresh方法
onRefresh();
// Check for listener beans and register them.
// 注册Listener
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 完成beanFactory的初始化（实例化非懒加载的单例bean）
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);
}
destroyBeans();
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
}
}
}
refresh方法中包括了好多子方法，接下来就是分析各个子方法的作用。
prepareRefresh
protected void prepareRefresh() {
//记录启动时间
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if(logger.isDebugEnabled()) {
if(logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
//initPropertySources:模板方法，可以允许子容器设置一些内容到Environment中 （key:value）
initPropertySources();
// 可以通过ApplicationContext设置一些Environment中必须要有的属性
// 如果设置 cxyxj 这个key为必须的，但是并没有提供 cxyxj 这个 key，启动时会报错
// 比如：applicationContext.getEnvironment().setRequiredProperties("cxyxj");
getEnvironment().validateRequiredProperties();
if(this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet <> (this.applicationListeners);
}
else {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
//将空集合赋值给 earlyApplicationEvents 属性
this.earlyApplicationEvents = new LinkedHashSet <> ();
}
obtainFreshBeanFactory
进行BeanFactory的刷新，在这里会去调用子类的refreshBeanFactory方法，具体子类是怎么刷新的得看子类，然后再调用子类的getBeanFactory方法，重新得到一个BeanFactory。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// refreshBeanFactory 方法 Spring 中就两个子类负责实现
// GenericApplicationContext 不支持刷新
// AbstractRefreshableApplicationContext 支持刷新
refreshBeanFactory();
return getBeanFactory();
}
为什么说 GenericApplicationContext不支持刷新呢，而AbstractRefreshableApplicationContext支持呢！先来看一个实例：
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AppApplication.class);
context.refresh();
}
我们再手动调用refresh，由于我们使用的是AnnotationConfigApplicationContext容器，而它是GenericApplicationContext的子类，是不支持重复刷新的，启动时就会报错。
我们来看 GenericApplicationContext中的具体实现吧！
@Override
protected final void refreshBeanFactory() throws IllegalStateException {
if(!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException(
"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once"
);
}
this.beanFactory.setSerializationId(getId());
}
代码很简单哈！使用 compareAndSet方法来进行判断！它两个作用：
- 一个是判断当前
refreshed的值是否是 false，如果是则返回 true，如果不是则返回 false。 - 第二个作用是如果
refreshed的值为 false, 则将refreshed的值更新为 true。
如果想测试一下可以刷新的，将容器换为AnnotationConfigWebApplicationContext，该容器是 AbstractRefreshableApplicationContext的子类。两个容器的区别也不是很大，只是创建 DefaultListableBeanFactory时机不一致，AnnotationConfigApplicationContext会在构造方法中让其父类初始化 BeanFactory，而 AnnotationConfigWebApplicationContext会在refreshBeanFactory中初始化 BeanFactory。
prepareBeanFactory
对 BeanFactory再进行一些准备工作。比如说：设置 beanFactory 的类加载器、设置表达式解析器、添加Bean的后置处理器。
准备BeanFactory，对BeanFactory其中的属性进行赋值。
// 如果一个属性对应的set方法在 ignoredDependencyInterfaces 接口中被定义了，
// 则该属性不会进行自动注入（Spring中的自动注入，说的是 byType、byName，不是@Autowired）
// 而是等到回调Aware接口时再来调用
// 各位可以去看 属性填充 那篇文章
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
上面添加的值在以下源码会有体现。
如果对其感到陌生，可以看看小杰写的属性填充那篇文章！
// 相当于直接把ApplicationContext对象放入Bean工厂中，当getBean(type)时
// 如果type就是这四个type，则直接返回所设置的实例
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,
this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//平常可以这样使用
@Autowired
ApplicationContext applicationContext;
上面这段代码是在以下这里被使用！位于 DefaultListableBeanFactory#findAutowireCandidates。
postProcessBeanFactory
子类可以对BeanFactory进一步初始化。
invokeBeanFactoryPostProcessors
在开始分析 invokeBeanFactoryPostProcessors方法之前，跟着小杰梳理一遍前面的方法都干了什么，在无外力的干扰下，BeanFactory 的情况如下：
- 生成并注册 5 个
BeanDefinition到beanDefinitionMap中
ConfigurationClassPostProcessor
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
EventListenerMethodProcessor
DefaultEventListenerFactory
- 2、将
new AnnotationConfigApplicationContext(AppApplication.class)的AppApplication类也注册到beanDefinitionMap中
上面两步一共会创建 6 个 BeanDefinition。
- 3、添加两个
BeanPostProcessor
ApplicationContextAwareProcessor
ApplicationListenerDetector
- 4、注册三个单例Bean到单例池
environment
systemProperties
systemEnvironment
- 5、记录
ignoreDependencyInterface，一共是 9 个，前面三个是在创建DefaultListableBeanFactory是加入的。 具体代码在AbstractAutowireCapableBeanFactory的无参构造方法中。AbstractAutowireCapableBeanFactory是DefaultListableBeanFactory的父类。
- 6、记录
ResolvableDependency，一共是 4 个。
梳理了一遍我们来看 invokeBeanFactoryPostProcessors方法。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 重点
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// LoadTimeWeaver 有兴趣的可以去百度了解
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
方法内部调用 invokeBeanFactoryPostProcessors，方法传入 beanFactory 和 getBeanFactoryPostProcessors（），getBeanFactoryPostProcessors方法会得到当前容器中的 BeanFactoryPostProcessor集合，这个集合大部分情况下都是空的，除非手动调用容器的addBeanFactoryPostProcessor方法。写法如下：
AnnotationConfigApplicationContext context2 =
new AnnotationConfigApplicationContext();
context2.register(AppApplication.class);
context2.addBeanFactoryPostProcessor(new MyBeanFactoryPostProcessor());
context2.refresh();
进入到invokeBeanFactoryPostProcessors方法中，方法体挺长的，但是代码逻辑挺清晰的。
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
// processedBeans：记录已经执行过的 BeanDefinitionRegistryPostProcessors
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// regularPostProcessors 常规后处理器
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
//记录实现了 BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 这个 beanFactoryPostProcessors 集合一般情况下都是空的，除非我们手动调用容器的addBeanFactoryPostProcessor方法
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// BeanDefinitionRegistryPostProcessor 是一个特殊的 BeanFactoryPostProcessor
// 需要先执行postProcessBeanDefinitionRegistry方法
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
//执行 postProcessBeanDefinitionRegistry 方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
//进行记录
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// 保存当前需要执行的实现了 BeanDefinitionRegistryPostProcessor 接口的后置处理器
// 分三种情况执行：实现了 PriorityOrdered 、实现了 Ordered，没有实现 PriorityOrdered、 Ordered的
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 先执行实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 方法
// 正常情况拿到的就是 6 个 BeanDefinition 中的 ConfigurationClassPostProcessor
// 因为还没开始扫描，所以只有一个 BeanDefinitionRegistryPostProcessor 类型 BeanDefinition
// 但如果是手动调用 addBeanFactoryPostProcessor 方法进行注册 BeanDefinitionRegistryPostProcessor 类型的BeanDefinition，
// 这里就会拿到多个 postProcessorName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判断这个类是否还实现了 PriorityOrdered 接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 这里调用了 getBean 方法，所以会生成一个 BeanDefinitionRegistryPostProcessor 类型 的 单例bean对象
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 执行 postProcessBeanDefinitionRegistry 方法
// 方法内部会进行扫描，扫描包路径下带有指定注解的类，得到 BeanDefinition，然后注册到 registry 中（就是BeanFactory中）
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空 currentRegistryProcessors 集合
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
// 这时候拿到的 BeanDefinitionRegistryPostProcessor 类型的 beanName 数量已经不确定了。因为上面已经进行过扫描了，
// 将扫描到的类注册到了 BeanDefinitionMap 中
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 注意 processedBeans.contains(ppName) 这个条件
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 执行其他普通的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
boolean reiterate = true;
// 在一个 BeanDefinitionRegistryPostProcessor 中可以注册另一个 BeanDefinitionRegistryPostProcessor 类型的 BeanDefinition，
// 所以需要递归找出所有的 BeanDefinitionRegistryPostProcessor。
// 如果一个没有实现 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor
// 如果在内部注册了一个实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor
// 那么就是没有实现 PriorityOrdered 接口的先执行
while (reiterate) {
reiterate = false;
// 这里会再一次拿到所有实现了 BeanDefinitionRegistryPostProcessor 接口的名称,
// 所以需要processedBeans进行过滤
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 注意 processedBeans.contains(ppName) 这个条件
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法
// 也就是执行 registryProcessors 集合对象中的 postProcessBeanFactory 方法
// 开始扫描 BeanDefinition 解析配置类（扫描，- @Bean, @Import），手动，接口， @Import
// 当然不一定会进行扫描，扫描前还有一个判断条件。
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 执行手动添加的 并且没有实现BeanDefinitionRegistryPostProcessor类型的Bean工厂后置处理器的 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// 如果beanFactory没有可以注册BeanDefinition的功能，则没有也就是没有实现 BeanDefinitionRegistryPostProcessor
// 则执行Bean工厂后置处理器的postProcessBeanFactory方法
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 总结一下上面的流程：
// 1. 如果beanFactory实现了BeanDefinitionRegistry接口，则表示可以通过BeanDefinitionRegistryPostProcessor接口来注册BeanDefinition
// 2. 因为现在是Spring启动过程中的比较早的阶段（还没有开始扫描@Component），所以只能获取Spring默认添加到BeanFactory中的bean工厂后置处理器，以及程序员手动添加的bean工厂后置处理器
// 3. 先执行手动添加进来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，这个过程中可能会向BeanFactory中注册其他的BeanDefinitionRegistryPostProcessor
// 4. 从BeanFactory中获取PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，并执行postProcessBeanDefinitionRegistry方法
// 5. 从BeanFactory中获取Ordered接口的BeanDefinitionRegistryPostProcessor，并执行postProcessBeanDefinitionRegistry方法
// 6. 在4,5步中都有可能注册新的BeanDefinitionRegistryPostProcessor
// 7. 从BeanFactory中获取普通的BeanDefinitionRegistryPostProcessor，并执行postProcessBeanDefinitionRegistry方法
// 8. 在7步中也有可能注册新的BeanDefinitionRegistryPostProcessor，所以第7步会递归，直到没有新的BeanDefinitionRegistryPostProcessor注册进来了
// 9. 在前面的步骤中都是执行BeanDefinitionRegistryPostProcessor中的postProcessBeanDefinitionRegistry方法，进行BeanDefinition的注册
// 10. BeanDefinition注册完了之后，因为BeanDefinitionRegistryPostProcessor本身也是一个BeanFactoryProcessor，所以最后再执行postProcessBeanFactory方法
// 11. 总结一句话就是：先通过BeanDefinitionRegistryPostProcessor注册BeanDefinition，再执行BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
// 在默认情况下，上面的步骤中只有一个BeanDefinitionRegistryPostProcessor会执行，就是ConfigurationClassPostProcessor，因为它是Spring默认在添加进去的
// BeanDefinitionRegistryPostProcessor 是特殊的 BeanFactoryPostProcessor，在上面的逻辑中都处理完了
// 所以接下来就是处理普通的 BeanFactoryPostProcessor
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 默认情况下会拿到两个，一个就是ConfigurationClassPostProcessor，一个就是 EventListenerMethodProcessor
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 保存直接实现了BeanFactoryPostProcessor接口和PriorityOrdered接口的后置处理器
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 保存直接实现了BeanFactoryPostProcessor接口和Ordered接口的后置处理器
List<String> orderedPostProcessorNames = new ArrayList<>();
// 保存直接实现了BeanFactoryPostProcessor接口的后置处理器，不包括那些实现了排序接口的类
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 把所有BeanFactoryPostProcessor进行分类
for (String ppName : postProcessorNames) {
// 拿到实现了的BeanFactoryPostProcessor 包括了 BeanDefinitionRegistryPostProcessor，所以要跳过
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.
// 再执行实现了Ordered接口的BeanFactoryPostProcessor
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 BeanFactoryPostProcessors.
// 最后执行普通的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 到此，所有的BeanFactoryPostProcessor都执行完了
// 对于BeanFactoryPostProcessor我们可以这么理解：它是去完善BeanFactory的，比如向BeanFactory中去注册BeanDefinition
// 就好比：BeanFactory是一张白纸，每个BeanFactoryPostProcessor都去这张白纸上去画上一笔，这个白纸就丰满了
// 所以这段代码，虽然内容很多，但是在默认情况下，主要就是执行了ConfigurationClassPostProcessor
// 1. 先执行了ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法，基本上就是去注册BeanDefinition
// 2. 然后执行了ConfigurationClassPostProcessor的postProcessBeanFactory方法
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
举例
上面提到过，在实现了 BeanDefinitionRegistryPostProcessor接口的内部可以注册其他的BeanDefinitionRegistryPostProcessor ，代码示例如下：
- MyBeanDefinitionRegistryPostProcessor
//@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory");
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry");
RootBeanDefinition rootBeanDefinition =new RootBeanDefinition(MyBeanDefinitionRegistryPostProcessor2.class,null);
//注册 BeanDefinition
//如果对应的 Bean 已经注册且在配置中配置了 bean 不允许被覆盖，
//则抛出异常,默认是 true，也就是允许覆盖
registry.registerBeanDefinition("myBeanDefinitionRegistryPostProcessor2",rootBeanDefinition);
}
}
- MyBeanDefinitionRegistryPostProcessor2
public class MyBeanDefinitionRegistryPostProcessor2 implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("执行 BeanDefinitionRegistryPostProcessor2 的 postProcessBeanFactory");
String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
System.out.println("当前容器中所有 beanDefinitionName = " );
for (String beanDefinitionName : beanDefinitionNames) {
System.out.println(beanDefinitionName);
}
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("执行 BeanDefinitionRegistryPostProcessor2 的 postProcessBeanDefinitionRegistry");
MutablePropertyValues mpvs = new MutablePropertyValues();
mpvs.add("name","cxyxj");
RootBeanDefinition rootBeanDefinition =new RootBeanDefinition(Test2.class,null,mpvs);
//注册 BeanDefinition
//如果对应的 Bean 已经注册且在配置中配置了 bean 不允许被覆盖，
//则抛出异常,默认是 true，也就是允许覆盖
registry.registerBeanDefinition("test2",rootBeanDefinition);
}
@Override
public int getOrder() {
return 555;
}
}
MyBeanDefinitionRegistryPostProcessor类上的注解被注释了，所以不会被扫描到，采用手动 add 的方式。当然两种方式都可以。
context.addBeanFactoryPostProcessor(new MyBeanDefinitionRegistryPostProcessor());
registerBeanPostProcessors
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取BeanPostProcessor类型的bean名称
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.
// 记录beanProcessor的数量
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 将实现 PriorityOrdered 的 BeanPostProcessor 放在一起
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 实现了 MergedBeanDefinitionPostProcessor 放在一起
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 将实现 Ordered 的 BeanPostProcessor 放在一起
List<String> orderedPostProcessorNames = new ArrayList<>();
// 没有实现其他接口的BeanPostProcessor(没有顺序)
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
// 将实现了 PriorityOrdered 的 BeanPostProcessor 添加到 priorityOrderedPostProcessors 集合中
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 调用 getBean 获取 bean 实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 实现了 MergedBeanDefinitionPostProcessor
internalPostProcessors.add(pp);
}
}
// 将实现了 Ordered 的 BeanPostProcessor 添加到 orderedPostProcessorNames 集合中
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
//无序，按照添加顺序执行
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先，注册实现PriorityOrdered的BeanPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 把priorityOrderedPostProcessors添加到beanFactory中
// 也是调用 AbstractBeanFactory 类中的 addBeanPostProcessor 方法
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 接下来，注册实现Ordered的BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
// 调用 getBean 获取 bean 实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 实现了 MergedBeanDefinitionPostProcessor
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
// 把orderedPostProcessors添加到beanFactory中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 现在，注册所有常规BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
// 调用 getBean 获取 bean 实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 实现了 MergedBeanDefinitionPostProcessor
internalPostProcessors.add(pp);
}
}
// 注册
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 最后，重新注册所有内部 BeanPostProcessor。也就是 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor
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).
//重新注册用于将内部bean检测的ApplicationListener的后处理器，
//将其移到处理器链的末尾（用于拾取代理等）。
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
initMessageSource
initMessageSource方法的作用是初始化 MessageSource对象，用来处理国际化问题。
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//工厂中是否定义了名称为 messageSource 的 bean 对象
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
//从工厂得到bean对象
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
//注册默认的 DelegatingMessageSource 对象作为 messageSource 的 Bean。
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
//将这个 messageSource 实例注册到 Bean工厂中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
方法挺简单的。判断beanFactory是否包含名为 messageSource的Bean，如果有则作为 messageSource 的 Bean。如果没有，则创建DelegatingMessageSource对象作为 messageSource 的 Bean，并注册到 Bean 工厂中。
使用
先在resources目录下创建 i18n文件夹，不是必须的。
然后点击 New - > Resource Bundle，会弹出一个窗口：
message 是基类名称，Locales to Add 里是语言类型。配置好之后点击 OK。
然后随便进入一个文件，点击 Resource Bundle，然后点击 +，进行编辑。
最终文件内容如下：
- message.properties
user.myName=程序员小杰
- message_en.properties
user.myName=cxyxj
文件的名字不是非常规范，一般来说是要带上语言类型的。
比如：message_en.properties，message_zh.properties。当然有一些还需要带上地域值，比如：message_en_US.properties，message_zh_CN.properties。
声明 MessageSource 对象
@Configuration
public class MessageSourceConfig {
@Bean(name = "messageSource")
public MessageSource getMessageSource() {
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setDefaultEncoding("UTF-8");
messageSource.addBasenames("i18n/message");
return messageSource;
}
}
测试
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AppApplication.class);
MessageSource messageSource = context.getBean(MessageSource.class);
String zhMessage = messageSource.getMessage("user.myName", null, null, Locale.CHINA);
String enMessage = messageSource.getMessage("user.myName", null, null, Locale.US);
System.out.println("zh = " + zhMessage);
System.out.println("en = " + enMessage);
}
结果：
zh = 程序员小杰
en = cxyxj
Locale区域表。如果你国际化文件名为 message_en_US.properties那就要使用 Locale.US，如果是 message_en.properties那就要使用 Locale.ENGLISH。
static public final Locale ENGLISH = createConstant("en", "");
static public final Locale US = createConstant("en", "US");
简单的使用就到这里了。具体的使用我结合Spring Boot进行使用。继续我们的 Spring 源码阅读。
initApplicationEventMulticaster
代码逻辑跟initMessageSource方法大体一致。先判断容器中有没有自定义的ApplicationEventMulticaster对象，如果有则使用；没有则就注册一个SimpleApplicationEventMulticaster对象。ApplicationEventMulticaster 可以用来发布事件以及事件监听器。
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 容器中是否包含名为 applicationEventMulticaster 的Bean
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
//创建 SimpleApplicationEventMulticaster 作为默认的
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
//注册到容器中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
onRefresh
模板方法，交给子类进行具体的实现，然后执行子类的 onRefresh方法。
registerListeners
注册监听器
protected void registerListeners() {
// Register statically specified listeners first.
// 注册静态指定的监听器，getApplicationListeners()就是获取 applicationListeners Set集合的值
// 调用 context.addApplicationListener();方法进行注册
// 放入 applicationListeners Set集合中
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 从容器中获得所有实现了 ApplicationListener 接口的 beanName
// 放入 applicationListenerBeans Set集合中
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// earlyApplicationEvents 不知道在什么情况下会有值
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
//将 earlyApplicationEvents 赋值为 null
this.earlyApplicationEvents = null;
// 发布早期的监听器
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
finishBeanFactoryInitialization
finishBeanFactoryInitialization这个方法就是将非懒加载的单例bean进行实例化，注册到容器中。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 如果BeanFactory中存在ConversionService,则设置BeanFactory的ConversionService属性
// ConversionService是用来进行类型转化的
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.
// 冻结所有已经注册了的BeanDefinition，后续不能被修改和处理
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有非懒加载的bean
beanFactory.preInstantiateSingletons();
}
重点看 preInstantiateSingletons方法，实例化所有非懒加载的单例bean这个操作，就是在这个方法完成的。该方法的具体实现位于 DefaultListableBeanFactory类。
@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...
// 循环bd，实例化单例bean
for (String beanName : beanNames) {
// 对 beanDefinition 进行合并，基于合并后的 BeanDefinition 去创建bean
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 需要是 非抽象，单例，非懒加载 的才能创建
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断是不是一个 FactoryBean
if (isFactoryBean(beanName)) {
// 如果是一个 FactoryBean，那么则获取本身实例对象，而不是 getObject方法返回的实例
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 {
// 判断这个 FactoryBean 是否属于 SmartFactoryBean 类型
// 并且 isEagerInit 方法是否返回 true，如果返回 true，则说明应该调用 getObject() 方法
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 根据beanName去生成FactoryBean中所生成的Bean对象
// 也就是要调用 getObject() 方法
getBean(beanName);
}
}
}
else {
// 根据beanName去创建bean
getBean(beanName);
}
}
}
// 创建完所有的单例 bean 之后，判断某个单例 bean 是不是 SmartInitializingSingleton
// 如果是执行 afterSingletonsInstantiated() 方法
// 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 {
//执行 afterSingletonsInstantiated 方法
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
是不是感觉豁然开朗，就是调用了 getBean方法。
finishRefresh
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
//为此上下文初始化生命周期处理器
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 默认调用 DefaultLifecycleProcessor 的 onRefresh 方法
// 找出 Lifecycle Bean 执行 start 方法，默认情况下是没有Lifecycle Bean的，需要自己定义
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 发布事件 ContextRefreshedEvent 是一个事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
initLifecycleProcessor
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//容器中是否包含名为 lifecycleProcessor 的 Bean
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isTraceEnabled()) {
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
//创建 DefaultLifecycleProcessor 作为默认的
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
//注册到容器中
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isTraceEnabled()) {
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}
跟 initMessageSource、initApplicationEventMulticaster方法类似。
onRefresh
publishEvent
见名知意，该方法就是用来发布事件的。注意该方法的入参：new ContextRefreshedEvent(this)，所以该方法发布的事件为 ContextRefreshedEvent。调用该方法就跟我们在代码中显式使用 applicationContext.publishEvent()是一致的。我们定义的事件叫自定义事件，而源码中发布的事件叫内置事件。
@Override
public void publishEvent(ApplicationEvent event) {
publishEvent(event, null);
}
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");
// Decorate event as an ApplicationEvent if necessary
// 如果有必要，可以将事件装饰为 ApplicationEvent
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
//一般都会进入这里
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
//这时候的 earlyApplicationEvents属性是为null的，在之前的 registerListeners()方法中，将其置为 null
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
// 使用事件广播器广播事件到相应的监听器
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
// 发布事件，parent 就是 ApplicationContext
//parent一般为 null
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}
然后我们再看一下 multicastEvent方法。来到 SimpleApplicationEventMulticaster类。
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
// 事件类型
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
Executor executor = getTaskExecutor();
// getApplicationListeners：根据事件、事件类型寻找事件监听器
for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
if (executor != null) {
executor.execute(() -> invokeListener(listener, event));
}
else {
// 执行监听器，执行 onApplicationEvent 方法
invokeListener(listener, event);
}
}
}
执行了上述代码，就会执行onApplicationEvent方法。
到此，Spring的启动流程就分析完成了。方法的逻辑都不是太复杂！
- 如你对本文有疑问或本文有错误之处，欢迎评论留言指出。如觉得本文对你有所帮助，欢迎点赞和关注。
转载自:https://juejin.cn/post/7091836837945147400