@SpringBootApplication
public class SpringCloudDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudDemoApplication.class, args);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
  ...
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(ComponentScans.class) // 允许多次使用
public @interface ComponentScan {
    String[] value() default {}; // 指定基础扫描包路径
    String[] basePackages() default {}; // 等价于 value 属性
    Class<?>[] basePackageClasses() default {}; // 指定扫描包中的类作为基准
    Filter[] includeFilters() default {}; // 包含的过滤器
    Filter[] excludeFilters() default {}; // 排除的过滤器
    boolean lazyInit() default false; // 是否延迟初始化，true，则扫描到的 Bean 在第一次使用时才初始化
}

class ComponentScanAnnotationParser {
  ...
	public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(...);
    ...
    scanner.setBeanNameGenerator..
    scanner.setScopedProxyMode...
    scanner.setScopeMetadataResolver...
    scanner.setResourcePattern...
    scanner.addIncludeFilter...
    scanner.addExcludeFilter...
    scanner.getBeanDefinitionDefaults().setLazyInit...
    ...
		return scanner.doScan(StringUtils.toStringArray(basePackages));
	}
  ...
}

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
	...
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		// 遍历所有指定的包路径
		for (String basePackage : basePackages) {
			// 扫描包路径，并通过 isCandidateComponent 方法过滤出符合条件的类。
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				// 生成 Bean 的名称（通常是类名的简写或自定义名称）
				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，用于存储 BeanDefinition 和 Bean 的名称
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					// 如果需要，为 Bean 设置代理增强功能（例如 AOP 的作用）
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					// 将 BeanDefinitionHolder 添加到集合中
					beanDefinitions.add(definitionHolder);
					// 将当前 BeanDefinition 注册到 BeanFactory（核心注册步骤）
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}
  ...
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage // 自动注册基础包
@Import(AutoConfigurationImportSelector.class) // 导入自动配置选择器
public @interface EnableAutoConfiguration {
    String[] exclude() default {}; // 排除特定的自动配置类
    Class<?>[] excludeName() default {}; // 排除特定的自动配置类（通过类名）
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
	String[] basePackages() default {};
	Class<?>[] basePackageClasses() default {};
}

public abstract class AutoConfigurationPackages {
  ...
	static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
		}
    ...
	}
  ...
}

public class AutoConfigurationImportSelector implements ... {
	@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		// 检查自动配置功能是否启用
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		// 获取自动配置条目封装实体
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		// 返回自动配置条目，Spring会加载这些配置类
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}
	...
	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		// 获取自动配置条目
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		// 剔除掉重复的
		configurations = removeDuplicates(configurations);
		// 排除掉指定排除的
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		// 将条目封装 AutoConfigurationEntry 实体
		return new AutoConfigurationEntry(configurations, exclusions);
	}
	...
	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		// 加载配置类下面指定key的配置条目，key为EnableAutoConfiguration的全名（包括类路径）
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
				+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}
	...
  protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}
}

public final class SpringFactoriesLoader {
    ...
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        // 获取传入进来的factoryType的全名（包括类路径）
        String factoryTypeName = factoryType.getName();
        // 首先获取配所有的配置条目，然后取出factoryType的全名为key的配置值
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            Map<String, List<String>> result = new HashMap();

            try {
                // 获取到项目包及其所以依赖子包下面的 META-INF/spring.factories 文件
                Enumeration<URL> urls = classLoader.getResources("META-INF/spring.factories");
                // 解析这些文件下面的配置，并将结果缓存到 result 里面
                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Map.Entry<?, ?> entry = (Map.Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }
}

@Data
@ConfigurationProperties(prefix = "pay.ali")
public class AliProperties {

	/** 是否开启支付宝支付功能，不配置则默认不开启，参考AliPayConfiguration类上的@ConditionalOnProperty注解 */
	private Boolean enable;

	/** APPID */
	private String appId;
}

@Configuration
@EnableConfigurationProperties(AliProperties.class)
@ConditionalOnProperty(value = "pay.ali.enable", havingValue = "true")
public class AliPayConfiguration {

	private final AliProperties properties;

	public AliPayConfiguration(AliProperties properties) {
		this.properties = properties;
	}

	@Bean
	public AliPayClient aliStandardPayClient() {
		return new AliPayClientImpl(properties);
	}
}

public interface AliPayClient {
  Response createPayOrder(Request request);
}

public class AliPayClientImpl {

	private final AliProperties properties;

	public AliPayClientImpl(AliProperties properties) {
		this.properties = properties;
		// 初始化相关
	}

	public Response createPayOrder(Request request) {
		// 创建支付账单
	}
}