BeanDefinition解析注册

自定义的Bean解析与注册是通过refresh()中invokeBeanFactoryPostProcessors()方法最终调用PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors方法，通过invokeBeanDefinitionRegistryPostProcessors调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法，对项目的包扫描，然后将所有的Bean解析成BeanDefinition然后注册到IoC容器中。

private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
   // 获取容器中ConfigurationClassPostProcessor后置处理器进行bean定义的扫描
   for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
      postProcessor.postProcessBeanDefinitionRegistry(registry);
   }
}
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); // 真正的解析BeanDefinition
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    // 获取IOC容器中目前所有BeanDefinition名称，仅包括之前内置的Bean和传入的配置类
    String[] candidateNames = registry.getBeanDefinitionNames();
    for (String beanName : candidateNames) { // 循环我们的上一步获取的所有BeanDefinition信息
        BeanDefinition beanDef = registry.getBeanDefinition(beanName); // 通过bean的名称来获取我们的bean定义对象
        // 判断是否有没有解析过
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) || ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
        } else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) { // 进行正在的解析判断是不是完全的配置类，还是一个非正式的配置类，这里是有我们传入的配置类MainConfig进入到改else中
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName)); // 加入到候选的配置类集合中
        }
    }
    if (configCandidates.isEmpty()) { // 若没有找到配置类 直接返回
        return;
    }
    configCandidates.sort((bd1, bd2) -> { // 对配置类进行Order排序
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });
    // 创建通过@CompentScan导入进来的bean name的生成器，创建通过@Import导入进来的bean的名称
    SingletonBeanRegistry sbr = null;
    if (registry instanceof SingletonBeanRegistry) {
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) {
            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
            if (generator != null) {
                // 设置@CompentScan导入进来的bean的名称生成器(默认类首字母小写）也可自己定义，一般不会
                this.componentScanBeanNameGenerator = generator;
                // 设置@Import导入进来的bean的名称生成器(默认类首字母小写）也可自己定义，一般不会
                this.importBeanNameGenerator = generator;
            }
        }
    }
    if (this.environment == null) {
        this.environment = new StandardEnvironment();
    }
    //创建一个配置类解析器对象
    ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
    // 用于保存配置类BeanDefinitionHolder放入上面筛选出来的配置类
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    // 用于保存已解析的配置类，长度默认为解析出来默认的配置类的集合长度
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do { //do while 会进行第一次解析
        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());
        }
        // 此处才把@Bean的方法和@Import 注册到BeanDefinitionMap中
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses); // 加入到已经解析的集合中

        candidates.clear();
        // 判断ioc容器中的BeanDefinition是否大于候选原始的BeanDefinition个数
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames(); // 获取所有的bean定义
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames)); //原始候选bean定义
            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);
                    // 判断有没有被解析过，则放入candidates集合，进行新一轮解析
                    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();
    }
}

ConfigurationClassPostProcessor中会把配置类BeanDefinition取出来；若配置类上存在@Component注解，则解析配置类中的内部类（若内部类也是配置类的话会递归解析）；若配置类上存在@PropertySource注解，则解析该注解并得到PropertySource对象，并添加到environment中去；若配置类上存在@ComponentScan注解则解析该注解进行扫描，扫描得到一系列的BeanDefinition对象，然后判断这些BeanDefinition是不是也是配置类BeanDefinition，只要存在@Component注解就是配置类，故基本上扫描出来的都是配置类，若继续解析该配置类；若配置类上存在@Import注解，则判断Import的类的类型，若是ImportSelector则调用执行selectImports方法得到类名，然后再把该类当做配置类进行解析；若是ImportBeanDefinitionRegistrar则生成一个ImportBeanDefinitionRegistrar实例对象，并添加到配置类对象ConfigurationClass的importBeanDefinitionRegistrars属性中；

若配置类上存在@ImportResource注解，则把导入进来的资源路径存在配置类对象中的importedResources属性中；若配置类中存在@Bean方法则把这些方法封装为BeanMethod对象，并添加到配置类对象中的beanMethods属性中；若配置类实现了某些接口，则看这些接口内是否定义了@Bean的默认方法，若配置类有父类，则把父类当做配置类进行解析；

若配置类对象ConfigurationClass是通过@Import注解导入进来的，则把该类生成一个BeanDefinition，同时解析该类上@Scope、@Lazy等注解信息，并注册BeanDefinition；若ConfigurationClass中存在一些BeanMethod即定义了一些@Bean则解析这些@Bean，并生成对应的BeanDefinition并注册；若ConfigurationClass中导入了一些资源文件如xml文件则解析这些xml文件，得到并注册BeanDefinition；若ConfigurationClass中导入了一些ImportBeanDefinitionRegistrar则执行对应的registerBeanDefinitions进行BeanDefinition的注册

this.reader.loadBeanDefinitions(configClasses)这里才把@Bean方法和@Import注解中的类注册到BeanDefinitionMap中，典型的是对AOP的支持将AspectJAutoProxyRegistrar注册到BeanDefinitionMap中。

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    for (ConfigurationClass configClass : configurationModel) { // 注册配置类到容器中
        loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    }
}
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;
    }
    if (configClass.isImported()) { // 通过@Import导入进来的配置类的处理即@Configuration注解的类
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }
    for (BeanMethod beanMethod : configClass.getBeanMethods()) { // 通过@bean导入进来的组件
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }
    // 通过@ImportResources导入进来
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    // 通过ImportBeanDefinitionRegistrar注解导入进来
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

上面通过ConfigurationClassUtils工具类对注册的Bean进行标记，标记配置类是属于Full配置类，还是Lite配置类，当注册配置类时，若加了@Configuration注解，就称之为Full配置类，若直接使用@Component、@ComponentScan、@Import、@ImportResource等注解，Spring把这种配置类称之为Lite配置类。

abstract class ConfigurationClassUtils {
    private static final String CONFIGURATION_CLASS_FULL = "full";
    private static final String CONFIGURATION_CLASS_LITE = "lite";
    private static final Set<String> candidateIndicators = new HashSet<>(8);
    static {
        candidateIndicators.add(Component.class.getName());
        candidateIndicators.add(ComponentScan.class.getName());
        candidateIndicators.add(Import.class.getName());
        candidateIndicators.add(ImportResource.class.getName());
    }
    // 该方法通过传入的bean定义字段来判断当前bean是完全的配置类(标注了@Configuration注解)
    public static boolean isFullConfigurationClass(BeanDefinition beanDef) {
        /**
		 * 最终会通过方法checkConfigurationClassCandidate来设置CONFIGURATION_CLASS_ATTRIBUTE的属性是完全的配置类还是非正式的配置类
		 * 第一次进来的时候逻辑CONFIGURATION_CLASS_ATTRIBUTE属性CONFIGURATION_CLASS_ATTRIBUTE是为Null的
		 */
        return CONFIGURATION_CLASS_FULL.equals(beanDef.getAttribute(CONFIGURATION_CLASS_ATTRIBUTE));
    }
    // 该方法通过传入bean定义的字段来判断当前bean是非正式的配置类(没有标注了@Configuration注解,但该类配置了@Bean的配置类)
    public static boolean isLiteConfigurationClass(BeanDefinition beanDef) {
        return CONFIGURATION_CLASS_LITE.equals(beanDef.getAttribute(CONFIGURATION_CLASS_ATTRIBUTE));
    }

    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()) {
            Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
            metadata = new StandardAnnotationMetadata(beanClass, true);
        }
        else {
            try {
                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
                metadata = metadataReader.getAnnotationMetadata();
            } catch (IOException ex) {
                return false;
            }
        }
        // 判断是不是真正的配置类 就是判断当前的bean的class上有没有标注了@Configuration注解
        if (isFullConfigurationCandidate(metadata)) { // 设置标记
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
        }
        // 这里判断该配置类是一个非正式的配置类(Component ComponentScan Import ImportResource)
        else if (isLiteConfigurationCandidate(metadata)) {
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
        } else {
            return false;
        }
        //解析配置类上是否标注了@Order注解
        Integer order = getOrder(metadata);
        if (order != null) {
            beanDef.setAttribute(ORDER_ATTRIBUTE, order);
        }
        return true;
    }
}

Full配置类在getBean创建时会被被CGLib代理，而Lite配置类getBean创建时不会被代理。

class ConfigurationClassParser { // 具体的解析过程
    public void parse(Set<BeanDefinitionHolder> configCandidates) {
        // 用于保存延时的ImportSelectors，最著名的代表SpringBoot自动装配的的类AutoConfigurationImportSelector
        this.deferredImportSelectors = new LinkedList<>();
        for (BeanDefinitionHolder holder : configCandidates) { // 循环配置类
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) { // 真正的解析bean定义，通过注解元数据解析
                    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);
            }
        }
        // 处理延时的DeferredImportSelectors，springboot就是通过这进行记载spring.factories文件中的自定装配的对象
        processDeferredImportSelectors();
    }
    // 第一步：把配置类源信息和beanName包装成一个ConfigurationClass对象
    protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
        processConfigurationClass(new ConfigurationClass(metadata, beanName));
    }
    protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
        if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
            return;
        }
        //获取处我们的配置类对象
        ConfigurationClass existingClass = this.configurationClasses.get(configClass);
        if (existingClass != null) {
            if (configClass.isImported()) { // 传入进来的配置类是通过其他配置类的Import导入进来的
                if (existingClass.isImported()) { // 需要合并配置
                    existingClass.mergeImportedBy(configClass);
                }
                return; // 故若通过@Import导入一个已存在的配置类 是不允许的，会忽略。
            } else {
                this.configurationClasses.remove(configClass);
                this.knownSuperclasses.values().removeIf(configClass::equals);
            }
        }
        // 递归处理配置类及其超类层次结构。
        SourceClass sourceClass = asSourceClass(configClass);
        do { // 真正的进行配置类的解析
            sourceClass = doProcessConfigurationClass(configClass, sourceClass);
        } while (sourceClass != null);
        this.configurationClasses.put(configClass, configClass);
    }
    protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
        // Recursively process any member (nested) classes first
        processMemberClasses(configClass, sourceClass);
        // 处理@propertySource注解
        for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) {
            if (this.environment instanceof ConfigurableEnvironment) {
                processPropertySource(propertySource);
            }
        }
        // 从配置类上解析出ComponentScans的对象集合属性
        Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            // 循环解析出AnnotationAttributes
            for (AnnotationAttributes componentScan : componentScans) {
                // 把我们扫描出来的类变为bean定义的集合，真正的解析
                Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                //循环处理我们包扫描出来的bean定义
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    // 判断当前扫描出来的bean定义是不是一个配置类,若是的话直接进行递归解析
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        // 递归解析，因为@Component算是lite配置类
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }
        // 处理@Import，@Import三种类：Import普通类、ImportSelector、ImportBeanDefinitionRegistrar
        processImports(configClass, sourceClass, getImports(sourceClass), true);
        // 处理 @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);
            }
        }
        // 处理@Bean方法获取配置类中所有标注了@Bean的方法，不是马上转换成BeanDefinition，而是先用一个set接收
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }
        processInterfaces(configClass, sourceClass); // 处理配置类接口 默认方法的@Bean
        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();
            }
        } 
        return null; // 没有父类解析完成
    }
}

真正进行扫描和解析的地方，可以明显看到这里并没有使用AnnotationConfigApplicationContext中的scanner而是重新new了一个ClassPathBeanDefinitionScanner。且会创建和添加默认的includeFilters。

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   this.registry = registry;
   // 设置默认的扫描规则为true的话 默认是扫描所有的  若使用 includeFilters 来表示只包含需要设置为false
   if (useDefaultFilters) {
      registerDefaultFilters();
   }
   setEnvironment(environment);  // 设置环境对象
   setResourceLoader(resourceLoader); //设置资源加载器
}
protected void registerDefaultFilters() {
    // 加入扫描@Component的TypeFilter
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try { // 加入扫描的JSR250规范的TypeFilter
        this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
    } catch (ClassNotFoundException ex) {}
    try { // 加入扫描JSR330规范的TypeFilter
        this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
    } catch (ClassNotFoundException ex) {}
}

ComponentScans指定扫描目标，除了最常用的basePackages，还可以指定basePackageClasses，就是指定多个类，只要是与这几个类同级的，或者在这几个类下级的都可以被扫描到，这种方式Spring比较推荐的，指定basePackages没有IDE的检查容易出错，但指定一个类有IDE的检查了，不容易出错，经常会用一个空的类来作为basePackageClasses ，还可以直接不指定，默认会把与配置类同级，或者在配置类下级的作为扫描目标。

class ComponentScanAnnotationParser {
    public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
        // 为扫描器设置beanName的生成器对象
        Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
        boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
        scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator : BeanUtils.instantiateClass(generatorClass));

        // 解析@Scope的ProxyMode属性，该属性可以将Bean创建问jdk代理或cglib代理
        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"));
        // 设置CompentScan对象的includeFilters 包含的属性
        for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
            for (TypeFilter typeFilter : typeFiltersFor(filter)) {
                scanner.addIncludeFilter(typeFilter);
            }
        }
        // 设置CompentScan对象的excludeFilters 包含的属性
        for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
            for (TypeFilter typeFilter : typeFiltersFor(filter)) {
                scanner.addExcludeFilter(typeFilter);
            }
        }
        // 是否懒加载，此懒加载为componentScan延迟加载所有类
        boolean lazyInit = componentScan.getBoolean("lazyInit");
        if (lazyInit) {
            scanner.getBeanDefinitionDefaults().setLazyInit(true);
        }
        // 包路径配置类中componentScan设置的路径
        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));  // 真正的进行扫描解析
    }
}

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
       Assert.notEmpty(basePackages, "At least one base package must be specified");
       // 创建bean定义的holder对象用于保存扫描后生成的bean定义对象
       Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
       for (String basePackage : basePackages) { // 循环包路径集合
          // 到候选的Components
          Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
          for (BeanDefinition candidate : candidates) {
             ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
             candidate.setScope(scopeMetadata.getScopeName());
             // 设置beanName
             String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
             //这是默认配置 autowire-candidate
             if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
             }
             // 取@Lazy @DependsOn等注解的数据设置到BeanDefinition中
             if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
             }
             // 解析出来的组件bean定义注册到我们的IOC容器中（容器中没有才注册）
             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;
    }
}

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
   if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
      return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
   } else {
      return scanCandidateComponents(basePackage);
   }
}

Spring支持component索引技术，需要引入一个组件，大部分项目没有引入这个组件，所以会进入scanCandidateComponents方法。注意这里的Bean是包装成一个ScannedGenericBeanDefinition，与内置的和配置类的都是区别开的。

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
   Set<BeanDefinition> candidates = new LinkedHashSet<>();
   try {
      // 把包路径转为资源路径 cn/test/MainConfig
      String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern;
      // 扫描指定包路径下面的所有.class文件
      Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
      boolean traceEnabled = logger.isTraceEnabled();
      boolean debugEnabled = logger.isDebugEnabled();
      for (Resource resource : resources) { // 需要resources集合
         //判断当的是不是可读的
         if (resource.isReadable()) {
            try {
               MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
               if (isCandidateComponent(metadataReader)) { // 是不是候选的组件
                  // 包装成为一个ScannedGenericBeanDefinition
                  ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                  sbd.setResource(resource); // 并且设置class资源
                  sbd.setSource(resource);
                  if (isCandidateComponent(sbd)) {
                     candidates.add(sbd); // 加入到集合中
                  }
               }
            } 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; //返回
}

@Import解析

这里会将@Import注解中的信息解析出来，然后根据类型分别进行处理，Spring AOP的支持就是在该处解析出来的，在@EnableAspectJAutoProxy注解上有@Import(AspectJAutoProxyRegistrar.class)注解，这里的AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口，但这里不会直接调用ImportBeanDefinitionRegistrar的registerBeanDefinitions方法，而是等数据都解析完了才会去调用。

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
   if (importCandidates.isEmpty()) {
      return;
   }
   if (checkForCircularImports && isChainedImportOnStack(configClass)) {
      this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
   } else {
      this.importStack.push(configClass);
      try {
         for (SourceClass candidate : importCandidates) { // 获取我们Import导入进来的所有组件
            if (candidate.isAssignable(ImportSelector.class)) { // 判断该组件是不是实现了ImportSelector
               // Candidate class is an ImportSelector -> delegate to it to determine imports
               Class<?> candidateClass = candidate.loadClass();
               // 实例化我们的SelectImport组件
               ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
               // 调用相关的aware方法
               ParserStrategyUtils.invokeAwareMethods(selector, this.environment, this.resourceLoader, this.registry);
               // 判断是不是延时的DeferredImportSelectors，是这个类型 不进行处理
               if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
                  this.deferredImportSelectors.add(new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
               } else { // 不是延时的， 调用selector的selectImports
                  String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                  // 所以递归解析-- 直到成普通组件
                  Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                  processImports(configClass, currentSourceClass, importSourceClasses, false);
               }
            }
            // 判断导入的组件是不是ImportBeanDefinitionRegistrar，这里不直接调用，只是解析
            else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
               Class<?> candidateClass = candidate.loadClass();
               // 实例化ImportBeanDefinitionRegistrar对象
               ImportBeanDefinitionRegistrar registrar = BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
               ParserStrategyUtils.invokeAwareMethods(registrar, this.environment, this.resourceLoader, this.registry);
               // 保存ImportBeanDefinitionRegistrar对象currentSourceClass=所在配置类
               configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
            } else {
               // 当做配置类再解析，注意这里会标记：importedBy，表示这是Import的配置的类，再执行之前的processConfigurationClass()方法 ，
               this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
               processConfigurationClass(candidate.asConfigClass(configClass));
            }
         }
      } 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();
      }
   }
}