我研究和阅读Spring Cloud Stream源码已经有一个多月了，但是由于自己的Spring基础知识不是很充足，所以导致很多地方都没有融会贯通，并且相关的文章一直无从下手。于是我先整理了当时阅读代码时的知识点记录，算是源码分析之前的基础知识储备吧，整理的有些杂乱，希望大家理解。
本文涉及的Spring知识如下：
- Spring Boot的
@Import用法和原理,与Configuration和ImportBeanDefinitionRegistrar相关 - Bean初始化各个周期的回调，比如
InitializingBean,BeanPostProcessor,SmartInitializingSingleton -
FactoryBean和MethodInterceptor -
Aware系列回调 -
Lifecycle和SmartLifecycle和DefaultLifecycleProcessor
BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor实现了BeanFactoryPostProcessor接口，是Spring框架的BeanDefinitionRegistry的后处理器，用来注册额外的BeanDefinition。postProcessBeanDefinitionRegistry方法会在所有的BeanDefinition已经被加载了，但是所有的Bean还没有被创建前调用。BeanDefinitionRegistryPostProcessor经常被用来注册BeanFactoryPostProcessor的BeanDefinition。
ImportBeanDefinitionRegistrar
@Import注解用来支持在Configuration类中引入其他的配置类，包括Configuration类，ImportSelector和ImportBeanDefinitionRegistrar的实现类。ImportBeanDefinitionRegistrar在ConfigurationClassPostProcessor处理Configuration类期间被调用，用来生成该Configuration类所需要的BeanDefinition。而ConfigurationClassPostProcessor正实现了BeanDefinitionRegistryPostProcessor接口。下面我们就来看一下其processConfigBeanDefinitions方法到底是如何处理Configuration类的。
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
//第一步：先把所有Configuration的beanDefinition找到。
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//利用AnnotationMetadata是否有@Configuration这个注解。需要注意的是
//Configuration是一个元注解，它是可以使用在其他注解上的，被这些注解注释的类也被认为是Configuration
if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
//第二步：通过Order注解的值来排序，定义了Configuration的先后顺序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
});
//..... 此处有省略
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//第三步：通过BeanDefinition来读取ConfigurationClass
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//第四步：重点，通过ConfigurationClass来获得BeanDefinition
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
//第五步：由于在loadBeanDefinitions过程中会向registry中添加BeanDefinition,所以这里需要把新的Definition
//在重新检测一遍，先看是否是Configuration类，如果是的那么还要再进行一次处理。
if (registry.getBeanDefinitionCount() > candidateNames.length) {
//.....此处有省略，大致逻辑就是通过registry多出的BeanDefinition获得新的candidateNames
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
//.....此处有省略
}
接着我们直接到ConfigurationClassBeanDefinitionReader类中查看loadBeanDefinition函数的实现。它会调用loadBeanDefinitionsForConfigurationClass函数。在该函数中会处理所有和Configuration相关的BeanDefinition,其中就会调用loadBeanDefinitionsFromRegistrars来通过ImportBeanDefinitionRegistrar加载BeanDefinition。
看到这里，大家可能会有个疑问，多个Configuration和多个ImportBeanDefinitionRegistrar存在的情况下，它们之间的对应关系是如何确定的呢？
ConfigurationClassParser的parse方法会将Configuration类相关的配置信息全部解析出来。我们可以看其doProcessConfigurationClass方法的源码。通过@Import注解将Configuration类和相应的ImportBeanDefinitionRegistrar联系在一起。
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
//首先处理内部成员类的情况
processMemberClasses(configClass, sourceClass);
// 处理 @PropertySource 注解
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
}
// 处理 @ComponentScan 注解
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
if (ConfigurationClassUtils.checkConfigurationClassCandidate(
holder.getBeanDefinition(), this.metadataReaderFactory)) {
parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
}
}
}
}
// 处理 @Import 注解
processImports(configClass, sourceClass, getImports(sourceClass), true);
// 处理 @ImportResource 注解
if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// 处理configuration中的 @Bean 函数
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
//......有省略
return null;
}
InitializingBean，FactoryBean，MethodInterceptor
Spring Cloud Stream的BindableProxyFactory类实现了上述接口。
BindableProxyFactory implements MethodInterceptor, FactoryBean<Object>, Bindable, InitializingBean
其中，InitializingBean接口有一个afterPropertiesSet方法，该方法在bean所有的属性都被赋值后调用。bean的属性被初始化是在初始化的时候做的，与BeanPostProcessor结合来看，afterPropertiesSet方法在postProcessBeforeInitialization和postProcessAfterInitialization之间被调用。
Spring中有两个类型的Bean,普通Bean和工厂Bean。FactoryBean有三个接口，分别是:
- Object getObject():返回FactoryBean创建的对象实例。
- boolean isSingleton():表示FactoryBean返回的对象实例是否为单例。
- Class getObjectType():返回FactoryBean返回的对象类型。
我们可以看一下BindableProxyFactory的相关实现，这里会和MethodInterceptor配合。MethodInterceptor是AOP相关的接口，用于在调用对象接口时进行切片注入或在直接实现接口。
@Override
public synchronized Object getObject() throws Exception {
//使用AOP的ProxyFactory类，由于该类本身也是先了MethodInterceptor接口
//所以这样配合使用，直接返回ProxyFactory类。
if (this.proxy == null) {
ProxyFactory factory = new ProxyFactory(this.type, this);
this.proxy = factory.getProxy();
}
return this.proxy;
}
@Override
public Class<?> getObjectType() {
return this.type;
}
@Override
public boolean isSingleton() {
return true;
}
BeanPostProcessor，ApplicationContextAware，BeanFactoryAware，SmartInitializingSingleton
Spring Cloud Stream的StreamListenerAnnotationBeanPostProcessor实现了如下接口
public class StreamListenerAnnotationBeanPostProcessor
implements BeanPostProcessor, ApplicationContextAware, BeanFactoryAware, SmartInitializingSingleton,
InitializingBean
BeanPostProcessor是bean的后处理器，通过它我们可以在Bean初始化前后进行处理。它的postProcessBeforeInitialization方法在Bean初始化之前被调用，而postProcessAfterInitialization在Bean初始化后被调用。相关原理涉及到Spring创建Bean的流程，这个之后有时间再研究吧。
Aware系列接口
Spring中提供了一些Aware相关的接口，像是BeanFactoryAware,ApplicationContextAware等。当一个类实现了这些接口之后，Aware接口的Bean在初始化之后，可以取得相应的资源的实例。比如StreamListenerAnnotationBeanPostProcessor对象就实现了ApplicationContextAware和BeanFactoryAware接口来获取ConfigurableApplicationContext与BeanFactory实例。
SmartInitializingSingleton
当所有的singleton的bean都初始化完成之后才会调用这个接口
的afterSingletonsInstantiated函数
SmartLifecycle
之前介绍的接口都是在Bean的生命周期内的某个阶段中被调用，如果我们希望在容器本身的生命周期事件上做一些事情该怎麽办呢？Spring容器提供了Lifecycle接口。当ApplicationContext接口启动或在关闭时，它会调用本容器内所有的Lifecycle接口。
public interface Lifecycle {
//启动该组件
void start();
//停止组件
void stop();
//查看组件是否正在运行
boolean isRunning();
}
如果两个对象有依赖关系，希望某一个bean先初始化完成，完成一些工作之后，再初始化另一个bean。在这个场景下，可以使用SmartLifecycle接口，该接口的getPhase方法返回一个整型数字，表明执行顺序。如果其getPhase()方法返回Integer.MIN_VALUE,那么该对象最先启动，最后停止；如果返回Integer.MAX_VALUE,那么该对象最后启动，最先停止。在Spring容器里，有DefaultLifecycleProcessor这个类来处理所有的Lifecycle的bean。在AbstractApplicationContext的finishRefresh函数中会调用到该processer的onRefresh函数，从其调用其本身的startBeans函数。
private void startBeans(boolean autoStartupOnly) {
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
//遍历所有的Lifecycle,按照phase分成不同的LifecycleGroup
for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
Lifecycle bean = entry.getValue();
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
int phase = getPhase(bean);
LifecycleGroup group = phases.get(phase);
if (group == null) {
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
phases.put(phase, group);
}
group.add(entry.getKey(), bean);
}
}
if (!phases.isEmpty()) {
//按照phase排序，然后启动
List<Integer> keys = new ArrayList<Integer>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}
网友评论