protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); // 保存扫描到的bean, 扫描完后会返回
    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage); // 查找满足要求的bean并生成beanDefinition
        for (BeanDefinition candidate : candidates) { // 遍历beanDefinition

            // 获取bean的作用域元数据，与@Scope注解相关
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            // 设置bean的作用域
            candidate.setScope(scopeMetadata.getScopeName());

            // 生成bean的名称，与@Component等注解相关
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

            // 一般这里beanDefinition的类型是ScannedGenericBeanDefinition，间接继承了AbstractBeanDefinition，所以为true
            if (candidate instanceof AbstractBeanDefinition) {
                // 为beanDefinition设置一些默认属性
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            // 一般这里beanDefinition的类型是ScannedGenericBeanDefinition，实现了AnnotatedBeanDefinition接口，所以为true
            if (candidate instanceof AnnotatedBeanDefinition) {
                // 处理@Lazy、@DependsOn、@Role、@Description注解
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            if (checkCandidate(beanName, candidate)) { // 如果不存在同名bean
                // 将beanDefinition封装成beanDefinitionHolder
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                // 根据@Scope注解中的值为beanDefinition设置相应的代理模式，后续在处理AOP相关问题时会用到
                definitionHolder =
                        AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                // 添加扫描到的bean定义
                beanDefinitions.add(definitionHolder);
                // 把bean定义注册进工厂
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    // Spring5新增的一种扫描方式，用了索引，启动速度快，适合大型项目（这种方式不做重点分析）
    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 {
        /*
         * 根据包名生成扫描路径：
         * 其实包名中可以存在spEL表达式，resolveBasePackage会处理
         */
        // 解析后的路径形如：net.lzip.ant ----> classpath*:net/lzip/ant/**/*.class
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        /*
         * 会根据扫描路径获取到包下所有.class文件，并以resource对象来表示，
         * 这里之所以使用class文件而不是Class对象，是为了提高性能，
         * Spring会使用ASM（Java字节码处理框架）来处理class文件而不是靠JVM来加载类对象
         */
        Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        boolean traceEnabled = logger.isTraceEnabled();
        boolean debugEnabled = logger.isDebugEnabled();

        // 遍历所有的resource对象
        for (Resource resource : resources) {
            if (traceEnabled) {
                logger.trace("Scanning " + resource);
            }
            try {
                // 读取类的注解信息和类信息，并封装在MetadataReader中
                MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                /*
                 * 这里isCandidateComponent的逻辑是：
                 * 		先用excludeFilter去匹配，如果匹配上了，会返回false；否则继续执行
                 * 		再用includeFilter去匹配，如果匹配上了，会返回true；否则会返回false
                 */
                if (isCandidateComponent(metadataReader)) {

                    // 创建bean定义
                    ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                    sbd.setSource(resource);
                    /*
                     * 再次判断。注意，这里的isCandidateComponent是上面那个的重载方法
                     * 要求是具体类或抽象类，如果是抽象类则要求带有@Lookup注解
                     */
                    if (isCandidateComponent(sbd)) {
                        if (debugEnabled) {
                            logger.debug("Identified candidate component class: " + resource);
                        }
                        candidates.add(sbd); // 符合条件，则添加至candidate集合
                    }

                }
                else {

                }
            }

        }
    }

    // 返回beanDefinition集合
    return candidates;
}

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    // 先执行排除过滤器
    for (TypeFilter tf : this.excludeFilters) {
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            return false;
        }
    }
    // 再执行包含过滤器
    for (TypeFilter tf : this.includeFilters) {
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            // 进一步做条件匹配，会跳过哪些不满足条件的bean
            return isConditionMatch(metadataReader);
        }
    }
    return false;
}

private boolean isConditionMatch(MetadataReader metadataReader) {
    if (this.conditionEvaluator == null) {
        // 创建条件判断器
        this.conditionEvaluator =
                new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
    }
    // 执行条件判断
    return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
}

private final ScopedProxyMode defaultProxyMode;

protected Class<? extends Annotation> scopeAnnotationType = Scope.class;

// 解析bean的作用域
@Override
public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
    // 创建作用域元数据对象，默认的作用域名称是singleton
    ScopeMetadata metadata = new ScopeMetadata();
    if (definition instanceof AnnotatedBeanDefinition) {
        AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
        // 获取@Scope注解
        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
                annDef.getMetadata(), this.scopeAnnotationType);
        if (attributes != null) {
            // 将@Scope注解的value属性作为作用域名称设置到元数据对象中
            metadata.setScopeName(attributes.getString("value"));
            // 获取proxyMode字段的值
            ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
            // 判断是不是@Scope注解的proxyMode字段的默认值
            if (proxyMode == ScopedProxyMode.DEFAULT) {
                // 在ClasspathBeanDefinitionScanner中创建该类实例时，调用的是无参构造方法，所以这里的默认值是ScopedProxyMode.NO
                proxyMode = this.defaultProxyMode;
            }
            // 设置作用域代理模式
            metadata.setScopedProxyMode(proxyMode);
        }
    }
    return metadata;
}

@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    if (definition instanceof AnnotatedBeanDefinition) {
        // 从注解中获取bean的名称
        String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
        if (StringUtils.hasText(beanName)) {
            // Explicit bean name found.
            // 获取到则直接返回
            return beanName;
        }
    }
    // Fallback: generate a unique default bean name.
    // 构建bean的名称
    return buildDefaultBeanName(definition, registry);
}

public static final AnnotationBeanNameGenerator INSTANCE = new AnnotationBeanNameGenerator();

private static final String COMPONENT_ANNOTATION_CLASSNAME = "org.springframework.stereotype.Component";

private final Map<String, Set<String>> metaAnnotationTypesCache = new ConcurrentHashMap<>();

@Nullable
protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
    // 获取注解信息
    AnnotationMetadata amd = annotatedDef.getMetadata();
    // 获取注解集合
    Set<String> types = amd.getAnnotationTypes();
    String beanName = null;
    // 遍历注解
    for (String type : types) {
        // 获取注解的属性
        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
        if (attributes != null) {
            // 获取注解的元注解的名称
            Set<String> metaTypes = this.metaAnnotationTypesCache.computeIfAbsent(type, key -> {
                // 获取注解的元注解类型
                Set<String> result = amd.getMetaAnnotationTypes(key);
                return (result.isEmpty() ? Collections.emptySet() : result);
            });
            /*
             * 判断注解是不是模板注解且属性不是null以及注解中包含value属性
             * 这里一般都不会设置其value属性，比如开发中一般都是直接用@Controller、@Service等注解修饰类，而不会设置其value属性。
             */
            if (isStereotypeWithNameValue(type, metaTypes, attributes)) {
                // 获取注解的value字段的值
                Object value = attributes.get("value");
                if (value instanceof String) {
                    // 强转为字符串
                    String strVal = (String) value;
                    if (StringUtils.hasLength(strVal)) {
                        // 判断bean是不是存在多个名称
                        if (beanName != null && !strVal.equals(beanName)) {
                            // 如果是则抛出异常
                            throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
                                    "component names: '" + beanName + "' versus '" + strVal + "'");
                        }
                        beanName = strVal;
                    }
                }
            }
        }
    }
    // 返回bean的名称
    return beanName;
}

protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    return buildDefaultBeanName(definition);
}

protected String buildDefaultBeanName(BeanDefinition definition) {
    // 获取bean的类名称
    String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    // 获取bean的类型的短名称
    String shortClassName = ClassUtils.getShortName(beanClassName);
    // 将首字母变为小写
    return Introspector.decapitalize(shortClassName);
}

protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName) {
    // 应用BeanDefinition模板，可以通过模板来配置需要应用在多个bean定义中的自定义配置
    beanDefinition.applyDefaults(this.beanDefinitionDefaults);
    if (this.autowireCandidatePatterns != null) {
        // 设置该bean是否是其他bean自动装配时的候选bean，
        beanDefinition.setAutowireCandidate(PatternMatchUtils.simpleMatch(this.autowireCandidatePatterns, beanName));
    }
}

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
    processCommonDefinitionAnnotations(abd, abd.getMetadata());
}

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
    // 获取并处理@Lazy注解
    AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
    if (lazy != null) {
        abd.setLazyInit(lazy.getBoolean("value"));
    }
    else if (abd.getMetadata() != metadata) {
        lazy = attributesFor(abd.getMetadata(), Lazy.class);
        if (lazy != null) {
            abd.setLazyInit(lazy.getBoolean("value"));
        }
    }

    // 处理@Primary注解
    if (metadata.isAnnotated(Primary.class.getName())) {
        abd.setPrimary(true);
    }
    // 获取并处理@DependOn注解
    AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
    if (dependsOn != null) {
        abd.setDependsOn(dependsOn.getStringArray("value"));
    }

    // 获取并处理@Role注解
    AnnotationAttributes role = attributesFor(metadata, Role.class);
    if (role != null) {
        abd.setRole(role.getNumber("value").intValue());
    }
    // 获取并处理@Description注解
    AnnotationAttributes description = attributesFor(metadata, Description.class);
    if (description != null) {
        abd.setDescription(description.getString("value"));
    }
}

protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
    // 如果bean工厂中不存在该名称的bean，说明没有重复的bean，则直接返回true
    if (!this.registry.containsBeanDefinition(beanName)) {
        return true;
    }
    // 获取已经存在的bean的定义
    BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);
    BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();
    if (originatingDef != null) {
        existingDef = originatingDef;
    }
    // 判断能不能容忍出现同名bean
    if (isCompatible(beanDefinition, existingDef)) {
        return false;
    }
    // 如果不能容忍则抛出异常
    throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +
            "' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +
            "non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");
}

protected boolean isCompatible(BeanDefinition newDefinition, BeanDefinition existingDefinition) {
    // 当前类扫描的bean定义都是ScannedGenericBeanDefinition类型的，其他地方注册的bean定义不抛出冲突异常，只是不会注册新bean而已。
    return (!(existingDefinition instanceof ScannedGenericBeanDefinition) ||  // explicitly registered overriding bean
            // 扫描了同一个类文件两次
            (newDefinition.getSource() != null && newDefinition.getSource().equals(existingDefinition.getSource())) ||  // scanned same file twice
            // 扫描了同一个类两次，这里区分类文件和类，或许是因为类文件中有可能存在多个类吧
            newDefinition.equals(existingDefinition));  // scanned equivalent class twice
}

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
    // 注册bean定义
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}