pringboot2.0.6启动解析(十)刷新应用程序上下文-IoC容器的初始化
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
......//省略
// 调用 beanFactory 后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
......//省略
}
}
invokeBeanFactoryPostProcessors
该方法中完成IoC容器的初始化。具体步骤以下java
- Resource定位
- 咱们知道在SpringBoot中包扫描默认是从主类所在的包开始扫描的，在准备应用上下文时，即在prepareContext()方法中会先将主类解析成BeanDefinition，而后在refresh方法中调用invokeBeanFactoryPostProcessors方法，其解析主类的BeanDefinition获取basePackage的路径，完成扫描路径的定位。其次SpringBoot的starter是经过SPI扩展机制实现的自动装配，SpringBoot的自动装配一样也是在invokeBeanFactoryPostProcessors方法中触发实现的。还另外在SpringBoot中还有不少的@EnableXXX注解，查看得知其底层是@Import注解，在invokeBeanFactoryPostProcessors方法中也实现了对该注解指定的配置类的定位加载。
- 常规的在SpringBoot中有四种实现定位
- 主类所在包的
- @ComponentScan指定扫描目录
- SPI扩展机制实现的自动装配（好比各类starter）
- @Import注解指定的类。（对于很是规的不说了）
- BeanDefinition的载入
- 找到了扫描包的位置，定位后紧接着要作的就是将BeanDefinition的分别载入。所谓的载入就是经过上面的定位获得的basePackage的路径拼接成“classpath*:org/springframework/boot/demo/**/*.class”这样的形式，PathMatchingResourcePatternResolver类会将该路径下全部的 .class 文件都加载进来，而后遍历判断是否有@Component注解，若是有的话其就是咱们要装载的BeanDefinition。
- 注意@Configuration，@Controller，@Service等注解底层都是@Component注解，只不过包装了一层罢了
- 注册BeanDefinition
- 这个过程是经过调用前文中提到的BeanDefinitionRegister接口的实现来完成。其把载入过程当中解析获得的BeanDefinition向IoC容器进行注册，即在IoC容器中将BeanDefinition注入到一个ConcurrentHashMap中，IoC容器就是经过这个HashMap来持有这些BeanDefinition数据的。好比DefaultListableBeanFactory 中的beanDefinitionMap属性。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
进入PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors方法spring
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
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.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
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.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
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.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 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);
// 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.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
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 invokeBeanDefinitionRegistryPostProcessors(
Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
invokeBeanFactoryPostProcessors看着挺长其实里面的内容仍是比较好理解的。其主要就是对BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的bean进行处理。springboot
- BeanDefinitionRegistryPostProcessor
- 首先判断传入的beanFactory是否是BeanDefinitionRegistry的实例。
-
beanFactory是BeanDefinitionRegistry，咱们开始处理BeanFactoryPostProcessor，即遍历每个对象，验证是否是BeanDefinitionRegistryPostProcessor(BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口)的实例。是将其强制类型转换，而后执行BeanDefinitionRegistryPostProcessor的生命周期方法postProcessBeanDefinitionRegistry，而且将这个BeanFactoryPostProcessor放入到registryPostProcessors集合中。不是则直接放入到regularPostProcessors集合中。它们都放入集合中以后咱们就能够处理集合中的属于BeanDefinitionRegistryPostProcessor类型的Bean了。app
获取BeanDefinitionRegistryPostProcessor类型的Bean的集合，处理这些bean，即遍历每个对象，验证是否是PriorityOrdered类型的，是放入currentRegistryProcessors集合中并把bean名称放入processedBeans(已经处理过的Bean的集合)集合中，防止重复执行，而后排序，把该集合加入registryProcessors集合中。在invokeBeanDefinitionRegistryPostProcessors方法中，处理currentRegistryProcessors集合，即遍历每个对象，执行BeanDefinitionRegistryPostProcessor的生命周期方法postProcessBeanDefinitionRegistry。在用用一样的方法处理rdered类型的Bean。在用一样的方法处理剩余的bean直到全部的bean都处理完。而后在执行BeanFactoryPostProcessor的生命周期方法postProcessBeanFactory处理 registryProcessors 和 regularPostProcessors两个集合。ide
-
beanFactory不是BeanDefinitionRegistry咱们则直接BeanFactoryPostProcessor的生命周期方法postProcessBeanFactory将BeanFactoryPostProcessor处理掉。post
- BeanFactoryPostProcessor
其处理的方式与BeanDefinitionRegistryPostProcessor相同，即先处理完PriorityOrdered，再处理Ordered，最后统一处理普通的，这里要注意的是，由于BeanDefinitionRegistryPostProcessor也是BeanFactoryPostProcessor，因此在这里须要过滤掉不处理了。ui
下面咱们来分析一些其核心方法invokeBeanDefinitionRegistryPostProcessors看看他是如何实现的this
private static void invokeBeanDefinitionRegistryPostProcessors(
Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
在PostProcessorRegistrationDelegate类的invokeBeanDefinitionRegistryPostProcessors方法进入ConfigurationClassPostProcessor类的postProcessBeanDefinitionRegistry方法lua
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
...
processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
...
do {
parser.parse(candidates);
parser.validate();
...
}
...
}
在processConfigBeanDefinitions中进入ConfigurationClassParser类的parse方法spa
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
// 在SpringBoot项目中，bd其实就是前面主类封装成的 AnnotatedGenericBeanDefinition（AnnotatedBeanDefinition接口的实现类）
if (bd instanceof AnnotatedBeanDefinition) {
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
} else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
} else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
// 加载默认的配置（这里就是自动装配的入口了）
processDeferredImportSelectors();
}
咱们已经在前面文章《springboot2.0.6启动解析(八)准备上下文》中详细介绍了SpringBoot项目的主类是如何一步步的封装成AnnotatedGenericBeanDefinition，并注册进IoC容器的beanDefinitionMap中的。也在前面文章《springboot2.0.6启动解析(一)自动配置》中对processDeferredImportSelectors进行了详细讲解。
跟进parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName())方法，进入ConfigurationClassParser类的processConfigurationClass方法
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
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);
}
}
// 递归处理配置类及其弗雷层次结构
SourceClass sourceClass = asSourceClass(configClass);
do {
// 递归处理Bean，直到顶层父类
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
进入asSourceClass方法
private SourceClass asSourceClass(ConfigurationClass configurationClass) throws IOException {
AnnotationMetadata metadata = configurationClass.getMetadata();
if (metadata instanceof StandardAnnotationMetadata) {
return asSourceClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
}
return asSourceClass(metadata.getClassName());
}
进入doProcessConfigurationClass方法
/* SpringBoot的包扫描的入口方法（重点）*/
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// Recursively process any member (nested) classes first
//递归处理内部类，（主类通常没有内部类）
processMemberClasses(configClass, sourceClass);
// Process any @PropertySource annotations
// ① 处理 @PropertySource 注解的属性配置
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
} else {
logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
// ② 根据 @ComponentScan 注解，扫描项目中的Bean（SpringBoot 主类上可能有该注解）
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) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
// 判断是不是ConfigurationClass（有configuration、component两个注解），是则递归查找该类相关联的配置类(@Configuration中的@Bean定义的bean。或者在有@Component注解的类上继续存在@Import注解等都是相关的配置类)。
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
//眼熟把，眼熟就对了这进行了对贵调用(由于当Spring扫描到须要加载的类会进一步判断每个类是否知足是@Component、@Configuration注解的类，知足则会递归调用parse()方法，查找其相关的类即其外层的if判断语句)
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
// ④ 递归处理@Import注解（SpringBoot中的各类@Enable***注解底层基本都是封装的@Import）
processImports(configClass, sourceClass, getImports(sourceClass), true);
// Process any @ImportResource annotations
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
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);
}
}
// Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
}
① 获取主类上的@PropertySource注解进行解析并将该注解指定的properties配置文件中的值存储到Spring的 Environment 中，Environment 接口提供方法去读取配置文件中的值，参数是 properties 文件中定义的key值。
② 解析主类上的@ComponentScan注解，获取注解值，扫描解析详情请看③中分析。
③ 遍历处理componentScans,解析注解并进行包扫描
④ 解析主类上的@Import注解，并加载该注解指定的配置类。
1. 定位扫描路径进行 IoC 初始化
关键具体处理在ComponentScanAnnotationParser类的parse方法，咱们进入该方法
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
//设置BeanNameGenerator
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
//设置ScopedProxyMode
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
} else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
//设置ResourcePattern
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
//设置IncludeFilter
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
//设置ExcludeFilter
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
//设置LazyInit
boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
Set<String> basePackages = new LinkedHashSet<>();
//获取@ComponentScan注解设置的扫描路径集合
String[] basePackagesArray = componentScan.getStringArray("basePackages");
//遍历处理把扫描路径添加到basePackages集合中
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
// 根据 clazz 获取扫描路径（SpringBoot项目则参数为主类的全路径名）
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
// 当basePackages为控值时，根据 declaringClass 获取扫描路径（SpringBoot项目则参数为主类的全路径名）添加到basePackages集合中
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
//设置AbstractTypeHierarchyTraversingFilter类型的ExcludeFilter
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
// 根据basePackages扫描类
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
到这里咱们就找到了装配的扫描路径，即完成了Resource定位。通过分析咱们获得在主类上有@ComponentScan注解的话扫描路径为其指定的路径。没有的化话就是主类所在的包。
完成了扫描路径的定位，下面让进入ClassPathBeanDefinitionScanner类的都Scan方法看看其是如何进行扫描的
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
// 从指定的包中扫描须要装载的Bean
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//将该 Bean 注册进 IoC容器（beanDefinitionMap）
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
分析该类得知findCandidateComponents方法从basePackage中扫描类并解析成BeanDefinition，拿到全部符合条件的类后registerBeanDefinition方法将该类注册进IoC容器。也就是说在方法doScan中完成了IoC容器初始化过程的第载入和注册，即BeanDefinition的载入，和BeanDefinition的注册
进入ClassPathScanningCandidateComponentProvider类的findCandidateComponents方法
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
//拼接扫描路径，好比：classpath*:com/xds/test/demo/controller/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
//从 packageSearchPath 路径中扫描全部的类
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//判断metadataReader类是否是 被@Component 注解标注且不是须要排除掉的类
if (isCandidateComponent(metadataReader)) {
//将该类封装成 ScannedGenericBeanDefinition(BeanDefinition接口的实现类)
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
在scanCandidateComponents方法中先将basePackage拼接成classpath类型的扫描路径packageSearchPath。再调用getResources(packageSearchPath)方法，扫描到了该路径下的全部的类。而后遍历扫描获取到的类的集合，判断其是否是 被@Component 注解标注且不是须要排除掉的类。知足添加则将扫描到的类，解析成ScannedGenericBeanDefinition，该类是BeanDefinition接口的实现类。到这里IoC容器的BeanDefinition载入就结束了。换句话scanCandidateComponents方法完成了BeanDefinition载入。
下面咱们进入registerBeanDefinition方法看看其实如何完成BeanDefinition注册的
protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}
查看registerBeanDefinition方法。BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry)这段代码很眼熟，咱们在在前面介绍prepareContext()方法时，已经详细介绍了主类的BeanDefinition是怎么一步一步的注册进DefaultListableBeanFactory的beanDefinitionMap中的。而完成了BeanDefinition的注册，就完成了IoC容器的初始化过程。此时，在使用的IoC容器DefaultListableFactory中已经创建了整个Bean的配置信息，而这些BeanDefinition已经能够被容器使用了。由于它们都在BeanbefinitionMap这个集合里被检索和使用。容器的做用就是对这些信息进行处理和维护。固然这些信息是容器创建依赖反转的基础。
2. @Import注解解析过程
前面说到过SpringBoot中的各类@EnableXXX注解，很大一部分都是对@Import的二次封装（目的其实就是为了解耦）。
首先咱们看看getImports方法，看看如何递归遍历解析@Import，获取其引用的类
private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
Set<SourceClass> imports = new LinkedHashSet<>();
Set<SourceClass> visited = new LinkedHashSet<>();
collectImports(sourceClass, imports, visited);
return imports;
}
因为是@EnableAutoConfiguration注解中引用了@AutoConfigurationPackage注解而@AutoConfigurationPackage注解有使用@Import注解指定了“AutoConfigurationPackages.Registrar.class”类，而且@EnableAutoConfiguration自己使用@Import注解指定了“AutoConfigurationImportSelector.class”类。因此递归处理获取@import引用获取到的imports集合有两个值。
接下来让咱们来看看ConfigurationClassParser类的doProcessConfigurationClass方法的中的processImports(configClass, sourceClass, getImports(sourceClass), true)方法，注意中configClass和sourceClass参数都是主类相对应的值
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
// 进行循环依赖的检查
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}else {
this.importStack.push(configClass);
try {
//@Import的value能够指定三种类型：带有@Configuration的类、ImportSelector实现、ImportBeanDefinitionRegistrar实现
for (SourceClass candidate : importCandidates) {
// 判断candidate是否是ImportSelector.class类型
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
// 获取ImportSelector对象
ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
ParserStrategyUtils.invokeAwareMethods(
selector, this.environment, this.resourceLoader, this.registry);
// 当前类是DeferredImportSelector 的实现,则加入到deferredImportSelectors，到全部配置类都解析后处理
if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
this.deferredImportSelectors.add(
new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
}else {
// 不是则调用processImports 进行处理
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
}else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
ParserStrategyUtils.invokeAwareMethods(
registrar, this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}else {// 加入到importStack后调用processConfigurationClass 进行处理
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass));
}
}
}catch (BeanDefinitionStoreException ex) {
throw ex;
}catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
}finally {
this.importStack.pop();
}
}
}
该方法解析@Import注解，并加载该注解指定的配置类，有好多注解都是一层一层封装的，好比@EnableXXX就是对@Import注解的二次封装。
自动配置AutoConfigurationImportSelector类的selectImports方法在处启用。
相关文章
- 1. IoC容器初始化过程(下)
- 2. ioc容器的初始化
- 3. IOC 容器的初始化
- 4. Spring IoC容器的初始化过程
- 5. 2.3 IoC容器的初始化过程
- 6. spring IOC 容器初始化
- 7. spring-ioc-容器初始化(上)
- 8. Spring IoC - IoC 容器初始化 源码解析
- 9. 【Spring】- IOC容器初始化过程
- 10. Spring源码解析一 (IOC容器初始化深度解析)
- 更多相关文章...
- • ionic 下拉刷新 - ionic 教程
- • XML 应用程序 - XML 教程
- • Docker容器实战(七) - 容器眼光下的文件系统
- • Docker容器实战(六) - 容器的隔离与限制
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. python的安装和Hello，World编写
- 2. 重磅解读：K8s Cluster Autoscaler模块及对应华为云插件Deep Dive
- 3. 鸿蒙学习笔记2（永不断更）
- 4. static关键字 和构造代码块
- 5. JVM笔记
- 6. 无法启动 C/C++ 语言服务器。IntelliSense 功能将被禁用。错误: Missing binary at c:\Users\MSI-NB\.vscode\extensions\ms-vsc
- 7. 【Hive】Hive返回码状态含义
- 8. Java树形结构递归（以时间换空间）和非递归（以空间换时间）
- 9. 数据预处理---缺失值
- 10. 都要2021年了，现代C++有什么值得我们学习的？
欢迎关注本站公众号,获取更多信息
相关文章