Spring源码系列三--ConfigurationClassPostProcessor

上文我们讲解了refresh方法中的invokeBeanFactoryPostProcessors方法，但是对于其中的BeanDefinitionRegistryProcessor的实现类的方法还没有提及，本文将着重讲解Spring framework中对于该接口唯一的也是最为重要的实现类ConfigurationClassPostProcessor的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);
		}
		//上面两个if分别是判断当前的beanFactoryPostProcessor方法是否已经执行过了
		this.registriesPostProcessed.add(registryId);

		processConfigBeanDefinitions(registry);
	}

在上文中已经分析过对于接口BeanDefinitionRegistryPostProcessor和接口BeanFactoryPostProcessor的两个方法调用的时机是不同的，所以每次调用BeanDefinitionRegistryPostProcessor的方法时都会将生成的hashcode存储在集合中，防止被重复调用。下面就进入了方法的主要逻辑:

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		//获取AnnotationConfigApplicationContext中内置的bean(其中一个是AppConfig，其他5个才是真正spring的)
		String[] candidateNames = registry.getBeanDefinitionNames();

		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			//判断是否被解析过
			//full lite属性分别对应加了@Configuration的类和没有加@Configuration的类
			//isFullConfigurationClass(beanDef) 全配置类
			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
					ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
				//进入这个if语句块说明已经被解析过了，往BeanDefinition的attributes中put了一个key，value值
				//beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);全配置类的key-value值
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			//加了@Configuration的类会设置为full属性(后面会通过cglib生成代理对象)
			//判断一个类是不是配置类
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				//如果加了以上注解就将BeanDefinitionHolder放入到BeanDefinitionHolder的集合中去
				//因为加了以上注解就可以认为还需要进行解析 还有新的类需要注册到beanFactory中去
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// Return immediately if no @Configuration classes were found
		if (configCandidates.isEmpty()) {
			return;
		}

		//在上面的checkConfigurationClassCandidate方法中已经获取了bean的order值(如果加了这个注解的话，并将这个order值存放到了bean的attributes)
		// Sort by previously determined @Order value, if applicable
		//根据Order排序
		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;
			if (!this.localBeanNameGeneratorSet) {
				//为beanName生成策略赋值,但是这里调用getSingleton方法从单例池中获取，肯定是获取不到的，因为没有在哪里将这个bean实例化过
				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的目的是为了去除重复(用户传入的配置类可能有重复),利用了Set集合的特性
		//alreadyParsed用于判断是否处理过
		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
			//扫描包
			parser.parse(candidates);
			parser.validate();
			//取出上面parse方法中解析出的所有bean
			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());
			}
			//除了普通类(@Component注解的类)都通过这个方法注册beanFactory中去,到目前为止扫描出来的bd都已经放到BeanDefinitionMap中去了
			this.reader.loadBeanDefinitions(configClasses);
			alreadyParsed.addAll(configClasses);

			candidates.clear();
			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());

		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
		if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
			sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
		}

		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
			// Clear cache in externally provided MetadataReaderFactory; this is a no-op
			// for a shared cache since it'll be cleared by the ApplicationContext.
			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
		}
	}

首先获取所有的容器中的BeanDefinition的name值，在上文中已经分析过了，此时Spring beanFactory容器中除了Spring 自己添加的后置处理器以外，我们项目中自己的bd其实只有一个，就是在AnnotationConfigApplicationContext的构造方法或者调用register方法注册的我们的java-config配置类，在本例中是AppConfig。然后进入for循环遍历所有的BeanDefinitionNames的集合，因为其他几个bd都是Spring内置的都不符合后面的要求所以这里只有一个bd，也就是AppConfig，AppConfig中只有两个注解。在for循环中首先判断bd的attributes集合中是否已经包含存在了full或lite的值。

@ComponentScan("wjc.CircularReferences")
@Configuration
public class AppConfig {


}

关于bd的attribute属性在BeanDefinition一文中已经详细解释过了这里就不再赘述了，回归代码的流程，这里第一次进入一定不会为true，因为这个类并没有解析过，自然也不可能有值，接下来会去判断当前的类是不是一个配置类

public static boolean checkConfigurationClassCandidate(
			BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {

		String className = beanDef.getBeanClassName();
		if (className == null || beanDef.getFactoryMethodName() != null) {
			return false;
		}
	
		AnnotationMetadata metadata;
		
		if (beanDef instanceof AnnotatedBeanDefinition &&
				className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
		
			metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
		}
		else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
			// Check already loaded Class if present...
			// since we possibly can't even load the class file for this Class.
			Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
			metadata = new StandardAnnotationMetadata(beanClass, true);
		}
		else {
			try {
				MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
				metadata = metadataReader.getAnnotationMetadata();
			}
			catch (IOException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Could not find class file for introspecting configuration annotations: " +
							className, ex);
				}
				return false;
			}
		}

		if (isFullConfigurationCandidate(metadata)) {
			beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
		}
		
		else if (isLiteConfigurationCandidate(metadata)) {
			beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
		}
		else {
			return false;
		}

		// It's a full or lite configuration candidate... Let's determine the order value, if any.
		Integer order = getOrder(metadata);
		if (order != null) {
			beanDef.setAttribute(ORDER_ATTRIBUTE, order);
		}

		return true;
	}

获取注解上的信息，然后判断该类是否声明了@Configuration注解，Spring在处理是否加了@Configuration注解的类上有不同的处理，这要涉及到ConfigurationClassPostProcessor实现BeanFactoryPostProcessor接口的方法，等到下文再来讲解，如果加了@Configuration注解后会向bd的attribute中存放一个键值对数据

如果当前的bd所描述的类上没有声明@Configuration注解。那么就去判断当前的bd是否是一个可能存在注解信息的类，这里会根据是否存在@Bean方式注入其他的bd，或者是否声明需要解析的注解

public static boolean isLiteConfigurationCandidate(AnnotationMetadata metadata) {
		if (metadata.isInterface()) {
			return false;
		}

		//candidateIndicators集合会在静态代码块中赋值
		for (String indicator : candidateIndicators) {
			if (metadata.isAnnotated(indicator)) {
				return true;
			}
		}

		try {
			//如果上述的注解都没有，那么还会再判断当前的bd中是否存在@Bean注解的方法，因为这也是代表是否需要解析的一个属性
			return metadata.hasAnnotatedMethods(Bean.class.getName());
		}
		catch (Throwable ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
			}
			return false;
		}
	}

满足上述判断要求的bd就会被加入方法最开始创建的configCandidates集合，for循环遍历完成后会去判断集合是否为空，若为空则说明不存在需要解析的配置类，就直接返回，否则会先调用排序方法对bd进行排序，排序的原则就是根据bd的Order值，这个值会根据Order注解注入(如果有的话)

接下来就到了扫描包的方法

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
		//处理Imported的情况，就是判断当前这个注解类有没有被别的类import
		//configurationClasses扫描出来的bean会放到这个集合中(这个集合中的bean还没有放入到容器中)
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			//处理Imported的情况 判断当前类是否已经被处理过了(因为当前类可能被别的类通过@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.
		//进行类型转换，封装了parser解析器，注解信息，class信息
		//sourceClass - AppConfig.class 这里是为了获取当前BeanDefinition的类信息
 		SourceClass sourceClass = asSourceClass(configClass);	//configClass中封装了beanName,该资源的路径、注解信息等数据
		do {
			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
		}
		while (sourceClass != null);

		//普通类(加@Component的类)在扫描出来的时候就被注册进了BeanDefinitionMap中去，而ImportSelector、ImportBeanDefinitionRegistrar、@Bean都会在parser.parse方法结束后
		//去调用loadBeanDefinition的方法来处理这些类
		this.configurationClasses.put(configClass, configClass);
	}

这里有人可能会奇怪明明我们传入了AppConfig类需要解析，为什么Spring上来就要先判断当前的类是不是被别的类通过Import注解注入的，其实试想一下我们扫描出来的类有可能也是一个配置类，或者带有配置信息又导入了其它的类，这里就涉及到递归扫描、解析了，所以才会方法开始就判断当前的bd是否由其他的bd注入的。

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {

		//传入的参数configClass一定是加了ComponentScan,Component,Configuration。。等注解的类,否则前面就不会将当前的configClass放到集合中
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			//有内部类的话 处理内部类,里面调用了sourceClass.getDeclaredClasses() -- 得到该类所有的内部类，除去父类的
			processMemberClasses(configClass, sourceClass);
		}

		// Process any @PropertySource annotations
		//处理所有的@PropertySources注解的类
		//@PropertySource注解可以在java-config类中导入proerties配置文件
		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可以包含多个ComponentScan,一般很少使用)
		//ComponentScan中除了配置value(扫描包的路径)以外还可以配置很多属性
		//比如includeFilters、excludeFilters等
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			//ComponentScan注解中的value是一个数组 所以这里要for循环
			//这个for循环先扫描ComponentScan注解下包路径的所有类,存放到集合中
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				//解析、扫描包下我们定义的交给spring管理的类
				//这里扫描出来了所有@Component、@Service。。等注解的类
				//扫描出来以后同时注册到beanFactory中,所以以下这行parse方法执行完以后就往beanFactory中加入了扫描路径下的bean,但是bean中的注解信息并没有解析，比如import..
				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
				//检查扫描出来的类当中是否还含有configuration
				//这个for循环是对外层for循环扫描的类进行解析判断是否还有配置类
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					//判断bean是不是BeanDefinitionResource
					//BeanDefinitionResource和BeanDefinitionHolder获取BeanDefinition的方法不一样
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					//以上这几行代码就是为了获取BeanDefinition
					/*
						*   判断是否加了以下注解
						*	candidateIndicators.add(Component.class.getName());
							candidateIndicators.add(ComponentScan.class.getName());
							candidateIndicators.add(Import.class.getName());
							candidateIndicators.add(ImportResource.class.getName());
							metadata.hasAnnotatedMethods(Bean.class.getName())
						* */
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						//如果componentScan下扫描出来的类中还有配置类再次去解析配置类并扫描注册到beanFactory中
						//从这里进入processImports方法其实是处理扫描出来的通过Import注解注入的类
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		/*
		* 	上面的代码就是解析配置类中的ComponentScan注解然后去扫描包下普通类 @Component 并注册到map中去
		*	并且以上代码将basePackages下所有的类 进行判断是否加了Import注解 如果加了Import注解已经将其解析完毕了
		* */

		// Process any @Import annotations
		//解析配置类中的@Import注解
		//Import可以传入三种类
		//1.普通的bean
		//2.ImportBeanDefinitionRegistrar(spring的扩展点之一) ---- 实现这个类以后可以获取到DefaultListableBeanFactory中的存放bean的Map
		//		我们可以动态得修改这个Map,可以参与将一个类变成BeanDefinition的过程
		//		往bean工厂的map中添加一个bd有三种方式1.调用register方法 2.调用scan方法 3.实现以上接口
		//3.ImportSelector
		/*
		* 	getImports获取注解Import中的内容
		* 	从这里执行processImports方法其实是为了解析AppConfig中的Import注解
		*  	因为通过AppConfig的ComponentScan注解扫描进来的类上的Import在上面的for循环中调用parse(bdCand.getBeanClassName(), holder.getBeanName());方法已经解析好了
		* */
		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
		//解析配置类中的@Bean注解注入的类,但是这里不会注册bean 会将BeanMethod放到集合中在外部调用load方式时统一处理@Bean和@Import
		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注解中配置的全路径后调用parse方法进行解析

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
		//spring初始化时候的扫描用的是这里new的scanner而不是实例化AnnotationConfigApplicationContext构造方法中实例化的那个对象
		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
		//获取beanName的生成器
		//问题:我们没有自定义beanName的生成器什么时候会给这个生成器赋一个默认值
		//ComponentScan注解中nameGenerator有默认值
		Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
		boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
		scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
				BeanUtils.instantiateClass(generatorClass));

		//spring mvc会对此进行处理
		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"));

		//遍历过滤器在AnnotationConfigApplicationContext构造方法中实例化reader的时候会传入过滤器的默认值
		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);
			}
		}


		//获取AppConfig类的@ComponentScan注解中是否配置了全局懒加载
		boolean lazyInit = componentScan.getBoolean("lazyInit");
		//如果设置了懒加载 就将默认设置为true
		//相当与设置了一个全局变量(因为这个时候只解析了AppConfig类还没有beanDefinition)与xml中的<beans>标签中配置懒加载的效果一样
		//之后解析的每个bean都会设置这个默认值
		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));
	}

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) {
			//扫描basePackage下的java文件
			//并转化为BeanDefinition类型
			//真正做扫描的方法findCandidateComponents
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//解析scope属性
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					//通过scan扫描的bean都是实现了AbstractBeanDefinition的
					//因为扫描以后用ScannedGenericBeanDefinition封装了类,而AbstractBeanDefinition继承了GenericBeanDefinition
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
					//设置默认属性LazyInit、AutoWireMode等
				}
				//如果这个类加了注解就将注解上的值设置到bean中去
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//判断map中是否已经存在当前的bean
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					//将扫描的符合条件的bean添加到factory的map中去
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

mybatis中就是利用了这个doScan方法来实现mapper接口的扫描

这里也可以看到在扫描包路径的时候并不是通过在AnnotationConfigApplicationContext中创建的那个scanner，而是重新实例化了一个，再解析完毕以后会将put到configurationClasses集合中的所有bd都去遍历，处理Import、@Bean、xml方式注入的bd

private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

		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注解注入进来的
		//因为如果是加了@Component注解的普通类在扫描的时候就完成了注册 configClass.isImported()会返回false
		//所以判断当前类只要存在注入它的类就当作是普通类在这里解析
		if (configClass.isImported()) {
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
		//配置类中的@Bean注解中返回的对象在这里解析处理
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}
		//xml
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
		//注册registrar
		//在解析Import时,对于实现了BeanDefinitionRegistrar接口的实现类会被放入到importBeanDefinitionRegistrars中
		//然后在这里执行我们自己的BeanDefinitionRegistrar实现类相应的方法
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

		//如果不是以上几种情况,说明这个类已经注入了(比如某个了加了@Component注解,但是同时又加了@Import注解在之前解析的时候也被会放入到这个集合中。或者只加了@Component注解的类也会在这个集合中)
		//但是这种情况就不会对该bd进行任何处理,因为在beanFactory中其实已经有这个bd存在了
	}