前面两讲讲到了应用上下文的初始化,比较重要的点就是在初始化Reader读取器时,会想spring的bean工厂添加6个beanDefinition对象。而register(componentClasses)也不过是将配置类转化为bd,交给spring的bean工厂。前面对于refresh()方法却讲解的比较少,今天我们就来详细讲解refresh()方法。
/**
* spring初始化spring环境
* @throws BeansException
* @throws IllegalStateException
*/
@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.
// 获取到spring的bean工厂,即DefaultListableBeanFactory对象
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
//配置其标准特征,比如bean工厂向上下文的加载器和BeanPostProcessor,设置一系列自动注入忽略的接口或是注解
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 将servletContext上下文进行设置到bean工厂,没什么实际内容
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 执行已经被注册到工厂中的beanFactory中的工厂后置处理器,其实只有ConfigurationClassPostProcessor
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();
}
}
}
由于方法众多,我就不一一介绍,下面仅仅按顺序介绍比较重要的方法。prepareBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
下面先看看prepareBeanFactory(beanFactory);
/**
* 配置beanFactory标准特征,使其具备某些能力,比如上下文的加载器和post-processors的回调
* Configure the factory's standard context characteristics,
* such as the context's ClassLoader and post-processors.
* 此处的beanFactory几乎等同于DefaultListableBeanFactory
* @param beanFactory the BeanFactory to configure
* 此处的入参beanFactory就是spring的bean工厂,它用来产生对象
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
// 告诉工厂需要使用的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 表达式解析器,为了能让beanFactory解析bean的表达式,能够在前台页面获取bean当中的属性。一般没用了,现在一般都是用EL表达式了
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加属性编辑器,如对象与String类型的转换,例如 <property name="newsDao" ref="newsDao" />
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 添加一个后置处理器,内部维护的list,类型是BeanPostProcessor.
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 下面都是忽略的接口,让它们不自动注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 这里是依赖的替换
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
/**
* 如果自定义的Bean中没有名为environment,systemProperties,systemEnvironment的Bean
* 则注册三个key为上面提到的三个到spring的bean工厂,他们就是系统配置和环境信息
*/
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
上面代码其实就是准备beanFactory,方法里主要给beanFactory设置类加载器,属性解析器,表达式解析器,以及向beanFactory添加了BeanPostProcessor后置处理器。
下面我们来看refresh()中比较重要的第二段代码----invokeBeanFactoryPostProcessors(beanFactory)做了哪些工作
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
//beanFactory当然属于BeanDefinitionRegistry类啦,所以下面肯定会执行
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor是继承关系,后者是子类,有扩展
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 自定义的beanFactoryPostProcessors,自定义的可能实现BeanDefinitionRegistryPostProcessor,
// 也可能实现BeanFactoryPostProcessor,没有手动添加就会不走下面的循环逻辑
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// 添加手动添加的实现了BeanDefinitionRegistryPostProcessor的工厂后置处理器
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
} else {
// 存放手动添加的实现了BeanFactoryPostProcessors
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// currentRegistryProcessors 存放spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的bean工厂后置处理器
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
/**
* getBeanNamesForType是spring工厂的一个方法,可以通过class类型获取到beanName,class类型是spring工厂维护的bd中的属性
* 为什么beanFactory中可以获取到BeanDefinitionRegistryPostProcessor.class的beanName呢?
* 那是因为在初始化reader的时候有新建,BeanFactoryPostProcessor对象,并将其放置入beanFactory
*/
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// postProcessorNames中应该只有ConfigurationClassPostProcessor(BeanDefinitionRegistryPostProcessor的实现类),
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 存放名字
processedBeans.add(ppName);
}
}
// 排序不重要,况且currentRegistryProcessors这里只有一个数据
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 合并list,不重要(为什么要合并呢?)
registryProcessors.addAll(currentRegistryProcessors);
/**
* 在方法内部调用postProcessBeanDefinitionRegistry(registry),
* 对postProcessBeanDefinitionRegistry是不是很熟悉??他就是我们在自定义beanFactoryPostProcessor时重写的方法
* 可以这么说,这就是回调啊,它会循环所有的BeanFactoryPostProcessor.当然了,循环的都是实现了
* BeanDefinitionRegistryPostProcessor的后置处理器
* 惊不惊喜?意不意外
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
上面只是粘贴出了源码的一部分,虽然不完整,但是这段代码已经能充分表示核心功能。
上面主要是做将自定义或者spring自身的BeanDefinitionRegistryPostProcessor的后置处理器循环遍历,查看是否处理过,没有处理便放入一个list集合,然后对这个集合进行排序,去重,最终调用后置处理器的重写的方法。主要是org.springframework.context.annotation.ConfigurationClassPostProcessor后置处理器(在初始化Reader添加的一个bd就是它)的processConfigBeanDefinitions()方法在完成处理工作。
下面是解析器解析后置处理器的代码:
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 这里会有7个元素,前6个是在初始化reader是新建并交给spring容器管理的,最后一个是register程序的入口处添加的配置类类
String[] candidateNames = registry.getBeanDefinitionNames();
/**
* 由于spring容器中有了程序的入口处添加配置类,那么refresh中肯定要解析它呀,不然怎么扫描注解类。。。
* 下面是遍历7个对象,然而解析的只有程序入口主类
*/
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 如果BD中的configurationClass属性为full或者lite,则意味着处理过了,直接跳过
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
/**
* 判断所有的bd类是否添加了@Controller,@Component,@Service等注解
* 只要程序入口主类上添加的配置有以上注解,都会被解析;这里不是解析业务的注解类哦
* 七个BD对象,只有我们自己的配置BD会被处理,其他6个都没有注解
* configCandidates中是添加了@Controller,@Component,@Service等注解的类的bd对象
*/
} else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
// 排序,根据顺序去解析
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
// 是否有重写beanName的生成器,没有则使用默认的
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class
// 实例化ConfigurationClassParser,为了解析各个配置类
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// candidates和alreadyParsed中都只会有一个,那就是程序的配置类的BD,用于去重
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// candidates都是加了注解@Configuration,@Component等
// 符合条件的只有一个,这里的作用是扫描我们的配置类
parser.parse(candidates);
parser.validate();
......
}
}
将spring的beanFactory中所有未处理过得BD而且有@Configuration, @Component,@ComponentScan,@Import,@ImportResource注解的拿出来,形成一个集合,然后排序,最后使用解析器去解析
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
// 肯定不会跳过
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
// ConfigurationClass只是进行了封装,封装了元数据和beanName
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
// 处理Import注解
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
// Otherwise ignore new imported config class; existing non-imported class overrides it.
return;
} else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
// 进行了封装或是转换了而已
SourceClass sourceClass = asSourceClass(configClass);
do {
//
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
最终调用链会走到下面这个方法:
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// Process any @ComponentScan annotations
// 拿到componentScan的属性,如basePackage,value。。。
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());
// 去解析扫描包,很重要,最终调用componentScanParser.parse
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// No superclass -> processing is complete
return null;
}
这里会根据bd的ComponentScan去扫描指定的包下的类,并且声称bd对象,置入spring的beanFactory。这样Spring的bean工厂便可以根据这些bd对象去创建对象了。