private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        // 获取资源文件，扫描所有文件资源
        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);
            }
            if (resource.isReadable()) {
                try {
                    // 元数据读取器，读取当前类的基本信息（ASM技术）
                    MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                    // excludeFilters和includeFilters判断
                    if (isCandidateComponent(metadataReader)) {
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        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;
}

// 遍历BeanDefinition,对其属性进行赋值
for (BeanDefinition candidate : candidates) {
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    // 赋值scope
    candidate.setScope(scopeMetadata.getScopeName());
    String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    if (candidate instanceof AbstractBeanDefinition) {
        postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    }
    if (candidate instanceof AnnotatedBeanDefinition) {
        // 解析@lazy、@Primary、@DependsOn、@Role、@Description
        AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    }
    if (checkCandidate(beanName, candidate)) {
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
        definitionHolder =
            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        beanDefinitions.add(definitionHolder);
        registerBeanDefinition(definitionHolder, this.registry);
    }
}

// 生成默认的beanName，在生成默认的beanName之前会先判断自定义类的注解中是否有手动设置beanName
protected String buildDefaultBeanName(BeanDefinition definition) {
    String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    String shortClassName = ClassUtils.getShortName(beanClassName);
    // 判断首字母大写，但是字符开始有多个大写时不做操作
    // 例如  User --> user URL --> URL
    return Introspector.decapitalize(shortClassName);
}

// 注意：下面这个方法是jdk中自带的方法，并不是spring中所提供的
public static String decapitalize(String name) {
    if (name == null || name.length() == 0) {
        return name;
    }
    if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
        Character.isUpperCase(name.charAt(0))){
        return name;
    }
    char chars[] = name.toCharArray();
    chars[0] = Character.toLowerCase(chars[0]);
    return new String(chars);
}

//循环我们所有的bean定义名称
for (String beanName : beanNames) {
    //获得合并后的bean定义，这个合并的RootBeanDefinition是判断当前的bean是不是存在父子关系的bean，
    // 如果存在父bean那就会继承父类中的属性，但是如果自己本身也有定义的还是会使用自身配置的属性
    // 子类和父类合并后会生成一个新的BeanDefinition
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    /**
     * 根据bean定义判断是不是抽象的&& 不是单例的 &&不是懒加载的
     * 此处判断的是BeanDefinite是不是抽象的，和Bean没有关系
     * 这个是在xml文件配置的时候，设置abstract="true",如果有以上配置那对应的beanDefinite将会是抽象的
     * 抽象bean的作用，如果是抽象的，首先是不会去创建bean对象的
     * 还有一个就是抽象的beanDefinite自己不会创建Bean对象，但是可以集成给别的bean去用，xml配置文件中配置parent=“xxx抽象bean定义”
     */
    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        //是不是工厂bean
        if (isFactoryBean(beanName)) {
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            //是的话 给beanName+前缀&符号
            if (bean instanceof FactoryBean) {
                FactoryBean<?> factory = (FactoryBean<?>) bean;
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = AccessController.doPrivileged(
                        (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
                }
                else {
                    // 判断是否实现了SmartFactoryBean，如果实现了这个接口，就可以重写isEagerInit()返回true,在Spring容器创建的过程中就可以做一些事情
                    isEagerInit = (factory instanceof SmartFactoryBean &&
                                   ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                //调用真正的getBean的流程
                if (isEagerInit) {
                    getBean(beanName);
                }
            }
        }
        else {
            //非工厂Bean 就是普通的bean
            getBean(beanName);
        }
    }
}

//所有的bean的名称
// 到这里所有的单实例的bean已经记载到单实例bean到缓存中
for (String beanName : beanNames) {
    //从单例缓存池中获取所有的对象
    Object singletonInstance = getSingleton(beanName);
    //判断当前的bean是否实现了SmartInitializingSingleton接口
    // sunfy- 这个也是Spring提供的一个扩展点之一，在所有的非懒加载的单例bean都创建完成之后会调用的方法
    if (singletonInstance instanceof SmartInitializingSingleton) {
        SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
        // 安全管理器
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                smartSingleton.afterSingletonsInstantiated();
                return null;
            }, getAccessControlContext());
        }
        else {
            //触发实例化之后的方法afterSingletonsInstantiated
            smartSingleton.afterSingletonsInstantiated();
        }
    }
}

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

if (mbd.hasBeanClass()) {
	return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
	return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
		doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
	}
else {
	return doResolveBeanClass(mbd, typesToMatch);
}
public boolean hasBeanClass() {
	return (this.beanClass instanceof Class);
}