在SpringBoot架构下类图怎么画 spring 类图

文章目录

• 前言
• 类图
• 源码主流程

• parse解析配置类

• 处理 @ComponentScan注解
• 处理 @Import注解

• ImportSelector
• ImportBeanDefinitionRegistrar
• @import普通类

前言

         前文学习了Spring容器启动的主流程分析，Spring会在AnnotatedBeanDefinitionReader加载几个类成为BeanDefinition，下面我们着重学习其中的一个类ConfigurationClassPostProcessor在context.refresh()时候具体干了些什么。

类图

       首先看一下类图，ConfigurationClassPostProcessor顾名思义就是与Configuration配置类，@Configuration等等与配置相关的注解有关的操作。它实现了BeanDefinitionRegistryPostProcessor接口，因此也有拓展方法postProcessBeanDefinitionRegistry，在源码中也是调用的此方法。下面看一看源码中是在哪调用的此方法，即：context.refresh里面的invokeBeanFactoryPostProcessors，debug跟进去会发现如下：

源码主流程

我们可以看到ConfigurationClassPostProcessor的拓展方法postProcessBeanDefinitionRegistry的核心逻辑为processConfigBeanDefinitions方法

@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);

		processConfigBeanDefinitions(registry);
	}

逻辑如下：

• 从容器取出所有的bean的名字
• 根据bean的名字筛选出所有配置类的BeanDefinition（加有@Configuration等注解的bean）
• 排序筛出的配置类的BeanDefinition
• 构造配置类解析器ConfigurationClassParser以及配置类BeanDefinition读取器ConfigurationClassBeanDefinitionReader
• 去重并循环解析每个配置类，处理配置类的各个注解（如@Component，@PropertySources，@ComponentScans，@import，@ImportResource等等）
• 把解析后的所有configClasses转变成BeanDefinition放入map

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		// app 提供的bean
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		// 获取容器中注册的所有bean的名字
		String[] candidateNames = registry.getBeanDefinitionNames();

		// 取出所有bd，bean的描述
		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			// 判断是否有Configuration类，是否加了@Configuration注解(@Configuration、@Import，@Compent)
			// 如果加了@Configuration，添加到一个List当中,把这个List传给下面的方法去解析  Appconfig类
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		if (configCandidates.isEmpty()) {
			return;
		}

		// 排序
		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;
		// DefaultListableBeanFactory是SingletonBeanRegistry的子类，这里会强转为SingletonBeanRegistry
		if (registry instanceof SingletonBeanRegistry) {
			sbr = (SingletonBeanRegistry) registry;
			// 是否有外部beanname名字生成器，没有的就使用默认的名称生成器
			if (!this.localBeanNameGeneratorSet) {
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
						AnnotationConfigUtils.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);

		// 实例化set  candidates，用于去重。因为可能存证多个相同加了@configurnation配置类
		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		// 存放已经解析的配置类
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
			// 解析
			parser.parse(candidates);
			parser.validate();

			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
			configClasses.removeAll(alreadyParsed);

			// Read the model and create bean definitions based on its content
			if (this.reader == null) {
				this.reader = new ConfigurationClassBeanDefinitionReader(
						registry, this.sourceExtractor, this.resourceLoader, this.environment,
						this.importBeanNameGenerator, parser.getImportRegistry());
			}
			this.reader.loadBeanDefinitions(configClasses);
			alreadyParsed.addAll(configClasses);
			processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

			candidates.clear();
			// 处理解析过程扫描包后新增的BeanDefinition
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set<String> alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				for (String candidateName : newCandidateNames) {
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
		}
		while (!candidates.isEmpty());
        .....
        .....
	}

parse解析配置类

@Configuration
@ComponentScan("com.demo")
public class AppConfig {

}

debug到这，我们发现candidates里面只有一个AppConfig，也就是我们一开始通过register注册进去的。下面我们看一看spring解析配置类AppConfig 干了些什么：

• 根据BeanDefinition 类型不同分别解析各种类型的类，AppConfig是context.register(AppConfig.class)注册进去的，属于AnnotatedBeanDefinition类型（可翻阅前一篇查询register源码可知）

public void parse(Set<BeanDefinitionHolder> configCandidates) {
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				// 如果加了注解
				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);
			}
		}

		this.deferredImportSelectorHandler.process();
	}

往后面跟进可进入processConfigurationClass方法看到核心逻辑方法doProcessConfigurationClass

• 首先校验当前类是否被其他类通过@import注解注入了，这里是没有的所有existingClass 为null
• configClass转换为SourceClass，就是一个对象的转换
• doProcessConfigurationClass核心逻辑处理各个注解

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}

		// 处理imported的情况
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			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.
		// configClass转换为SourceClass
		SourceClass sourceClass = asSourceClass(configClass, filter);
		do {
			// 核心类
			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
		}
		while (sourceClass != null);

		this.configurationClasses.put(configClass, configClass);
	}

核心方法doProcessConfigurationClass：

• 处理@Component注解，处理内部类
• 处理@PropertySource注解，获取@PropertySources属性信息
• 处理@ComponentScan注解，获取@ComponentScans里面的属性信息，解析扫描包，解析扫描的一些基本信息，比如是否过滤，比如是否加入新的包，懒加载等等
• 处理@import注解，如实现ImportSelector，ImportBeanDefinitionRegistrar接口动态添加bean到BeanDefinitionMap
• 处理@ImportResource注解

@Nullable
	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {

		// 处理Component注解，处理内部类
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			processMemberClasses(configClass, sourceClass, filter);
		}

		// Process any @PropertySource annotations
		// 处理@PropertySource注解，获取@PropertySources属性信息
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// Process any @ComponentScan annotations
		// 处理@ComponentScan注解，获取@ComponentScans里面的属性信息
		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();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
		// 处理是否有@import注解
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

		// Process any @ImportResource annotations
		// 处理是否有@ImportResource注解
		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;
	}

下面着重看一下解析过程中如何处理 @ComponentScan和@import注解的

处理 @ComponentScan注解

首先想一想扫描是为了做什么？？？就是为了把包路径的类加载到容器里面，也就是转换为BeanDefinition。

处理@ComponentScan注解流程如下：

• 判断是否有外部的名字生成器，有就用外部的，无则用默认的。这一步目的在于需要新生成BeanDefinition就需要新生成name，所以需要名字生成器
• 判断这个类是否是代理scopedProxy
• 匹配表达式
• 遍历需要排除过滤的类
• 懒加载相关处理。设置为默认true
• scanner.doScan开始扫描包

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

		// 判断是否有外部的名字生成器
		Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
		boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
		scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
				BeanUtils.instantiateClass(generatorClass));

		// 判断这个类是否是代理scopedProxy
		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));
		}

		// 匹配表达式
		scanner.setResourcePattern(componentScan.getString("resourcePattern"));

		for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
				scanner.addIncludeFilter(typeFilter);
			}
		}
		for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
				scanner.addExcludeFilter(typeFilter);
			}
		}

		// 懒加载相关处理
		boolean lazyInit = componentScan.getBoolean("lazyInit");
		if (lazyInit) {
			scanner.getBeanDefinitionDefaults().setLazyInit(true);
		}

		Set<String> basePackages = new LinkedHashSet<>();
		String[] basePackagesArray = componentScan.getStringArray("basePackages");
		for (String pkg : basePackagesArray) {
			String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
					ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
			Collections.addAll(basePackages, tokenized);
		}
		for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}
		if (basePackages.isEmpty()) {
			basePackages.add(ClassUtils.getPackageName(declaringClass));
		}

		scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
			@Override
			protected boolean matchClassName(String className) {
				return declaringClass.equals(className);
			}
		});
		/**
		 * 开始扫描
		 */
		return scanner.doScan(StringUtils.toStringArray(basePackages));
	}

doScan：扫描basePackages包路径下的类，并转化为BeanDefinition类型

doScan流程分析：

• 扫描basePackages包路径下的类，并转化为ScannedGenericBeanDefinition类型
• 循环解析各个类的scope属性,给ScannedGenericBeanDefinition设置解析出来的scope属性
• beanNameGenerator名字生成器生成bean的name
• 给ScannedGenericBeanDefinition设置一些默认值，比如lazy，init，destory
• 检查并处理常用的注解。如扫描出的当前类有@lazy，@Description等注解，则依次给ScannedGenericBeanDefinition设置值
• 注册ScannedGenericBeanDefinition。放入至BeanDefinitionHolder和BeanDefinitionMap

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) {
			// 扫描basePackages包路径下的类，并转化为BeanDefinition类型
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				// 解析scope属性
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				// 生成beanname
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					// 如果这个类是AbstractBeanDefinition的子类，则设置一些默认值，比如lazy，init，destory
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					// 检查并处理常用的注解，把常用注解值放入AnnotatedBeanDefinition中
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				// 注册bd
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

简单看一看其中几步的源码：

1.扫描basePackages包路径下的类，并转化为ScannedGenericBeanDefinition类型

2.设置lazy，init，destory等默认值

3.检查并处理相关注解

处理 @Import注解

配置类是否有@import注解，有的话核心逻辑如下：

• 若没有@Import直接返回
• 处理ImportSelector接口的情况添加一个BeanDefinition
• 处理ImportBeanDefinitionRegistrar接口的情况添加一个BeanDefinition
• 处理默认@import情况添加一个BeanDefinition

对@Import注解用法不了解可查阅：【Spring注解】@Import注解

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {

		// 没有import注解，则返回
		if (importCandidates.isEmpty()) {
			return;
		}

		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		}
		else {
			// 如果有import注解，@import注解可以放入参数，参数为普通类，ImportSelector.class,ImportBeanDefinitionRegistrar.class
			// ImportBeanDefinitionRegistrar这个类可以动态往BeanDefinitionMap中添加BeanDefinition。暴露了spring的BeanDefinitionMap，可以往里面动态添加
			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					if (candidate.isAssignable(ImportSelector.class)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class<?> candidateClass = candidate.loadClass();
						ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);
						Predicate<String> selectorFilter = selector.getExclusionFilter();
						if (selectorFilter != null) {
							exclusionFilter = exclusionFilter.or(selectorFilter);
						}
						if (selector instanceof DeferredImportSelector) {
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						}
						else {
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
						}
					}
					// ImportBeanDefinitionRegistrar动态添加BeanDefinition
					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 =
								ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
										this.environment, this.resourceLoader, this.registry);
						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
					}
					else {
						// 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), exclusionFilter);
					}
				}
			}
			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();
			}
		}
	}

ImportSelector

看一看源码，我们可以看到ImportSelector的方式添加BeanDefinition逻辑如下：

• 通过反射new出实现了ImportSelector接口的类的对象
• 如果这个对象属于DeferredImportSelector，则后续会使用Order接口来进行排序
• 如果这个对象不属于DeferredImportSelector，则调用selectImports方法返回实际需要添加的类的名字数组
• 转换返回的名字数组为SourceClass
• 递归调用processImports，处理新添加的类是否含有@import注解的情况

处理完注意一点：

返回上一层processConfigurationClass方法中，我们可以看到最后把处理完的类放入configurationClasses，此时还未放入BeanDefinitionMap

ImportBeanDefinitionRegistrar

看一看源码，我们可以看到逻辑如下：

• 通过反射实例化ImportBeanDefinitionRegistrar
• 把ImportBeanDefinitionRegistrar放入importBeanDefinitionRegistrars

注意一下，此时还未放入新添加的bean的BeanDefinition到BeanDefinitionMap

@import普通类

由源码可以看到，这里又调用的之前处理配置类的入口，进去后又处理各种注解。最终把解析的类放入configurationClasses，此时依旧未注册到BeanDefinitionMap

那么spring是在哪里注册通过@import新添加的bean的BeanDefinition到BeanDefinitionMap呢？？？

看如下：

回到parse的地方，往下看，会发现一个this.reader.loadBeanDefinitions(configClasses);通过@import注解新加的则是在这里注册在BeanDefinitionMap：

this.reader.loadBeanDefinitions(configClasses);

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}

private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

		// 如果map已经有被注解的bean则跳过
		if (trackedConditionEvaluator.shouldSkip(configClass)) {
			String beanName = configClass.getBeanName();
			if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
			}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
		}

		// 如果一个类是@import，则会被spring标记。这里注册@import情况的普通类和ImportSelector的情况
		if (configClass.isImported()) {
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}

		// 处理类中@bean的类
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}

		// xml
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

		// 注册在之前处理import注解中ImportBeanDefinitionRegistrar的情况的类
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}

上一篇： Spring源码学习（二） | 主流程分析