???????Set<BeanDefinitionHolder> scannedBeanDefinitions =
		this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

// 解析@ComponentScan注解，掃描注入bean
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String declaringClass) {
	ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
			componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
	// bean名稱生成器,在解析注冊BeanDefinition的時候用到
	Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
	boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
	scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
			BeanUtils.instantiateClass(generatorClass));
	// 掃描到@Component組件是是否生成代理以及生成代理方式
	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));
	}
	// 掃描路徑時規(guī)則
	scanner.setResourcePattern(componentScan.getString("resourcePattern"));
	// 如果一個對象如果不加上@Component注解，但是在掃描注解上加上該類的名稱，那么也會被掃描加載
	for (AnnotationAttributes includeFilterAttributes : componentScan.getAnnotationArray("includeFilters")) {
		List<TypeFilter> typeFilters = TypeFilterUtils.createTypeFiltersFor(includeFilterAttributes, this.environment,
				this.resourceLoader, this.registry);
		for (TypeFilter typeFilter : typeFilters) {
			scanner.addIncludeFilter(typeFilter);
		}
	}
	// 掃描到某個類時需要忽略它
	for (AnnotationAttributes excludeFilterAttributes : componentScan.getAnnotationArray("excludeFilters")) {
		List<TypeFilter> typeFilters = TypeFilterUtils.createTypeFiltersFor(excludeFilterAttributes, this.environment,
			this.resourceLoader, this.registry);
		for (TypeFilter typeFilter : typeFilters) {
			scanner.addExcludeFilter(typeFilter);
		}
	}
	// 標(biāo)識掃描注冊BeanDefinition后是否延遲初始化,默認(rèn)false
	boolean lazyInit = componentScan.getBoolean("lazyInit");
	if (lazyInit) {
		scanner.getBeanDefinitionDefaults().setLazyInit(true);
	}
	Set<String> basePackages = new LinkedHashSet<>();
	// 要掃描的路徑,如果為空,解析的時候會解析被@ComponentScan標(biāo)注類的包路徑
	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);
	}
	// 包路徑類,與basePackages互斥
	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);
		}
	});
	// 在指定的基本包中執(zhí)行掃描，返回注冊的bean定義。
	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包，獲取所有配置了@Component注解的bean
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			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);
				// 注冊@Component注解標(biāo)識的bean，將其放到beanDefinitionMap容器中
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
	if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
		return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
	}
	else {
		// 掃描@Component注解的類
		return scanCandidateComponents(basePackage);
	}
}
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
	// 搜集合適BeanDefinition的集合
	Set<BeanDefinition> candidates = new LinkedHashSet<>();
	try {
		// 包路徑 classpath*:com/sunpeiyu/visualweb/**/*.class
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				resolveBasePackage(basePackage) + '/' + this.resourcePattern;
		// 獲取包路徑下面的所有文件
		Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
		boolean traceEnabled = logger.isTraceEnabled();
		boolean debugEnabled = logger.isDebugEnabled();
		// 遍歷文件資源
		for (Resource resource : resources) {
			if (traceEnabled) {
				logger.trace("Scanning " + resource);
			}
			try {
				// 讀取資源的元信息，本身資源信息resource，元注解信息annotationMetadata
				MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
				if (isCandidateComponent(metadataReader)) {
					ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
					sbd.setSource(resource);
					// 判斷當(dāng)前資源是否為@Component注解標(biāo)識的類
					if (isCandidateComponent(sbd)) {
						if (debugEnabled) {
							logger.debug("Identified candidate component class: " + resource);
						}
						// 添加到搜集@Component注解的類的容器
						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 (FileNotFoundException ex) {
				if (traceEnabled) {
					logger.trace("Ignored non-readable " + resource + ": " + ex.getMessage());
				}
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to read candidate component class: " + resource, ex);
			}
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
	}
	return candidates;
}