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

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {return run(new Class<?>[] { primarySource }, args);
}public static ConfigurableApplicationContext run(Class<?>[] primarySources, String... args) {return new SpringApplication(primarySources).run(args);
}

public SpringApplication(Class<?>... primarySources) {this(null, primarySources);
}@SuppressWarnings({ "unchecked", "rawtypes" })
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {// 设置资源加载器this.resourceLoader = resourceLoader;Assert.notNull(primarySources, "PrimarySources must not be null");this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));// 判断应用类型（REACTIVE, SERVLET, NONE）this.webApplicationType = WebApplicationType.deduceFromClasspath();// 设置初始化器setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));// 设置监听器setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));// 推断主应用类this.mainApplicationClass = deduceMainApplicationClass();
}

static WebApplicationType deduceFromClasspath() {// 判断是否存在REACTIVE相关类if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {return WebApplicationType.REACTIVE;}// 判断是否存在SERVLET相关类for (String className : SERVLET_INDICATOR_CLASSES) {if (!ClassUtils.isPresent(className, null)) {return WebApplicationType.NONE;}}return WebApplicationType.SERVLET;
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {return getSpringFactoriesInstances(type, new Class<?>[] {});
}private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {ClassLoader classLoader = getClassLoader();// 从META-INF/spring.factories加载指定类型的类Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));// 实例化这些类List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);// 排序AnnotationAwareOrderComparator.sort(instances);return instances;
}

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {String factoryTypeName = factoryType.getName();return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {MultiValueMap<String, String> result = cache.get(classLoader);if (result != null) {return result;}try {// 查找所有META-INF/spring.factories资源Enumeration<URL> urls = (classLoader != null ?classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));result = new LinkedMultiValueMap<>();// 解析每个spring.factories文件while (urls.hasMoreElements()) {URL url = urls.nextElement();UrlResource resource = new UrlResource(url);Properties properties = PropertiesLoaderUtils.loadProperties(resource);for (Map.Entry<?, ?> entry : properties.entrySet()) {String factoryTypeName = ((String) entry.getKey()).trim();String[] factoryImplementationNames =StringUtils.commaDelimitedListToStringArray((String) entry.getValue());for (String factoryImplementationName : factoryImplementationNames) {result.add(factoryTypeName, factoryImplementationName.trim());}}}cache.put(classLoader, result);return result;}catch (IOException ex) {throw new IllegalArgumentException("Unable to load factories from location [" +FACTORIES_RESOURCE_LOCATION + "]", ex);}
}

private Class<?> deduceMainApplicationClass() {try {// 获取当前线程的堆栈轨迹StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();for (StackTraceElement stackTraceElement : stackTrace) {if ("main".equals(stackTraceElement.getMethodName())) {// 返回包含main方法的类return Class.forName(stackTraceElement.getClassName());}}}catch (ClassNotFoundException ex) {// 忽略异常}return null;
}

public ConfigurableApplicationContext run(String... args) {// 记录启动开始时间long startTime = System.nanoTime();// 创建默认的应用上下文和异常报告器DefaultBootstrapContext bootstrapContext = createBootstrapContext();ConfigurableApplicationContext context = null;// 配置无头模式configureHeadlessProperty();// 获取并启动应用监听器SpringApplicationRunListeners listeners = getRunListeners(args);listeners.starting(bootstrapContext, this.mainApplicationClass);try {// 创建应用参数容器ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 准备环境ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);// 配置忽略的Bean信息configureIgnoreBeanInfo(environment);// 打印BannerBanner printedBanner = printBanner(environment);// 创建应用上下文context = createApplicationContext();// 设置引导上下文context.setBootstrapContext(bootstrapContext);// 准备上下文prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);// 刷新上下文refreshContext(context);// 刷新后的处理afterRefresh(context, applicationArguments);// 计算并记录启动时间Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);// 记录启动完成日志if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);}// 发布应用就绪事件listeners.started(context, timeTakenToStartup);// 调用所有RunnercallRunners(context, applicationArguments);}catch (Throwable ex) {// 处理启动异常handleRunFailure(context, ex, listeners);throw new IllegalStateException(ex);}try {// 发布应用运行中事件Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);listeners.ready(context, timeTakenToReady);}catch (Throwable ex) {// 处理就绪异常if (context != null) {context.close();throw new IllegalStateException("Application run failed", ex);}throw new IllegalStateException("Application run failed", ex);}// 返回应用上下文return context;
}

private SpringApplicationRunListeners getRunListeners(String... args) {Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };return new SpringApplicationRunListeners(logger,getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),this.applicationStartup);
}// SpringApplicationRunListeners类
public void starting(DefaultBootstrapContext bootstrapContext, @Nullable Class<?> mainApplicationClass) {doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),(step) -> {if (mainApplicationClass != null) {step.tag("mainApplicationClass", mainApplicationClass.getName());}return step;});
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {// 创建并配置环境ConfigurableEnvironment environment = getOrCreateEnvironment();configureEnvironment(environment, applicationArguments.getSourceArgs());// 应用属性转换服务ConfigurationPropertySources.attach(environment);// 发布环境准备就绪事件listeners.environmentPrepared(bootstrapContext, environment);// 绑定应用参数bindToSpringApplication(environment);// 确保是标准环境if (!this.isCustomEnvironment) {environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,deduceEnvironmentClass());}// 配置属性源ConfigurationPropertySources.attach(environment);return environment;
}

private Banner printBanner(ConfigurableEnvironment environment) {if (this.bannerMode == Banner.Mode.OFF) {return null;}// 获取资源加载器ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader: new DefaultResourceLoader(getClassLoader());// 创建Banner打印器SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);// 打印控制台Bannerif (this.bannerMode == Banner.Mode.CONSOLE) {return bannerPrinter.print(environment, this.mainApplicationClass, System.out);}// 打印日志Bannerreturn bannerPrinter.print(environment, this.mainApplicationClass, logger);
}

public Banner print(Environment environment, Class<?> sourceClass, PrintStream out) {Banner banner = getBanner(environment);banner.printBanner(environment, sourceClass, out);return banner;
}private Banner getBanner(Environment environment) {Banners banners = new Banners();// 添加文本Bannerbanners.addIfNotNull(getTextBanner(environment));// 添加图像Bannerbanners.addIfNotNull(getImageBanner(environment));// 如果没有找到任何Banner，使用默认Bannerif (banners.hasAtLeastOneBanner()) {return banners;}// 返回默认Bannerreturn this.fallbackBanner != null ? this.fallbackBanner : DEFAULT_BANNER;
}

protected ConfigurableApplicationContext createApplicationContext() {// 根据应用类型创建不同的上下文Class<?> contextClass = this.applicationContextClass;if (contextClass == null) {try {switch (this.webApplicationType) {case SERVLET:contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);break;case REACTIVE:contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);break;default:contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);}}catch (ClassNotFoundException ex) {throw new IllegalStateException("Unable to create a default ApplicationContext, please specify an ApplicationContextClass",ex);}}// 实例化上下文return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments, Banner printedBanner) {// 设置环境context.setEnvironment(environment);// 应用上下文后置处理器postProcessApplicationContext(context);// 应用初始化器applyInitializers(context);// 发布上下文准备就绪事件listeners.contextPrepared(context);// 加载资源if (this.logStartupInfo) {logStartupInfo(context.getParent() == null);logStartupProfileInfo(context);}// 添加单例BeanConfigurableListableBeanFactory beanFactory = context.getBeanFactory();beanFactory.registerSingleton("springApplicationArguments", applicationArguments);if (printedBanner != null) {beanFactory.registerSingleton("springBootBanner", printedBanner);}// 设置懒加载if (beanFactory instanceof DefaultListableBeanFactory) {((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);}// 加载主资源if (this.lazyInitialization) {context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());}// 加载所有资源Set<Object> sources = getAllSources();Assert.notEmpty(sources, "Sources must not be empty");// 加载主配置类load(context, sources.toArray(new Object[0]));// 发布上下文加载完成事件listeners.contextLoaded(context);
}

private void refreshContext(ConfigurableApplicationContext context) {// 如果需要刷新，则刷新上下文if (this.registerShutdownHook) {try {// 注册关闭钩子，确保应用优雅关闭context.registerShutdownHook();}catch (AccessControlException ex) {// 忽略安全管理器异常}}// 刷新上下文refresh(context);
}protected void refresh(ConfigurableApplicationContext context) {// 调用标准的上下文刷新方法context.refresh();
}

@Override
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 准备刷新上下文prepareRefresh();// 获取并刷新Bean工厂ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 配置Bean工厂prepareBeanFactory(beanFactory);try {// 允许Bean工厂后置处理器对Bean定义进行后置处理postProcessBeanFactory(beanFactory);// 调用所有注册的Bean工厂后置处理器invokeBeanFactoryPostProcessors(beanFactory);// 注册所有Bean后置处理器registerBeanPostProcessors(beanFactory);// 初始化消息源initMessageSource();// 初始化应用事件多播器initApplicationEventMulticaster();// 初始化其他特殊BeanonRefresh();// 检查并注册监听器registerListeners();// 实例化所有剩余的（非懒加载）单例finishBeanFactoryInitialization(beanFactory);// 完成刷新，发布相应事件finishRefresh();}catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);}// 销毁已创建的单例以避免资源悬空destroyBeans();// 重置"active"标志cancelRefresh(ex);// 传播异常到调用者throw ex;}finally {// 重置公共缓存resetCommonCaches();}}
}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// 设置Bean工厂的类加载器beanFactory.setBeanClassLoader(getClassLoader());// 设置Bean表达式解析器beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));// 添加属性编辑器注册器beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));// 添加Bean后置处理器beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));// 设置忽略的自动装配接口beanFactory.ignoreDependencyInterface(EnvironmentAware.class);beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);beanFactory.ignoreDependencyInterface(MessageSourceAware.class);beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);// 注册可解析的依赖beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);// 添加ApplicationListener探测器beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));// 添加LoadTimeWeaver探测器if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));// 设置临时类加载器进行类型匹配beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// 注册默认环境Beanif (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());}// 注册系统属性和环境变量if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());}// 注册系统环境if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());}
}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// 调用BeanDefinitionRegistryPostProcessor类型的处理器PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());// 检测LoadTimeWeaver并准备编织器if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}
}

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// 保存已经处理的处理器名称，避免重复处理Set<String> processedBeans = new HashSet<>();// 处理BeanDefinitionRegistry类型的工厂if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;// 区分普通的BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessorList<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();// 首先处理传入的BeanFactoryPostProcessorfor (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;registryProcessor.postProcessBeanDefinitionRegistry(registry);registryProcessors.add(registryProcessor);}else {regularPostProcessors.add(postProcessor);}}// 现在，处理在上下文中定义的BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();// 首先，调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessorString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}// 排序并调用sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();// 接下来，调用实现Ordered接口的BeanDefinitionRegistryPostProcessorpostProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}// 排序并调用sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();// 最后，调用所有其他的BeanDefinitionRegistryPostProcessor，直到不再有新的处理器出现boolean reiterate = true;while (reiterate) {reiterate = false;postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);reiterate = true;}}// 排序并调用sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();}// 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);// 调用普通的BeanFactoryPostProcessorinvokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else {// 如果不是BeanDefinitionRegistry类型的工厂，直接调用所有BeanFactoryPostProcessorinvokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// 现在，调用在上下文中定义的所有BeanFactoryPostProcessorString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);// 分离实现PriorityOrdered、Ordered和其他的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (processedBeans.contains(ppName)) {// 跳过已处理的处理器}else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// 首先，调用实现PriorityOrdered接口的BeanFactoryPostProcessorsortPostProcessors(priorityOrderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// 接下来，调用实现Ordered接口的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}sortPostProcessors(orderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// 最后，调用所有其他的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// 清除缓存的合并Bean定义，因为后处理器可能修改了原始元数据beanFactory.clearMetadataCache();
}

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {// 获取所有Bean后置处理器的名称String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);// 注册BeanPostProcessorChecker，用于记录信息int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));// 分离实现PriorityOrdered、Ordered和其他的BeanPostProcessorList<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// 首先，注册实现PriorityOrdered接口的BeanPostProcessorsortPostProcessors(priorityOrderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// 接下来，注册实现Ordered接口的BeanPostProcessorList<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);orderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}sortPostProcessors(orderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, orderedPostProcessors);// 然后，注册所有其他的BeanPostProcessorList<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String ppName : nonOrderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);nonOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);// 最后，注册所有内部BeanPostProcessorsortPostProcessors(internalPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, internalPostProcessors);// 添加ApplicationListenerDetector以检测ApplicationListener BeanbeanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

protected void initMessageSource() {ConfigurableListableBeanFactory beanFactory = getBeanFactory();// 检查是否存在用户定义的messageSource Beanif (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);// 如果messageSource是HierarchicalMessageSource类型，设置父消息源if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;if (hms.getParentMessageSource() == null) {// 只有在没有父消息源的情况下设置，避免覆盖用户设置hms.setParentMessageSource(getInternalParentMessageSource());}}if (logger.isTraceEnabled()) {logger.trace("Using MessageSource [" + this.messageSource + "]");}}else {// 创建并注册默认的DelegatingMessageSourceDelegatingMessageSource dms = new DelegatingMessageSource();dms.setParentMessageSource(getInternalParentMessageSource());this.messageSource = dms;beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);if (logger.isTraceEnabled()) {logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");}}
}protected void initApplicationEventMulticaster() {ConfigurableListableBeanFactory beanFactory = getBeanFactory();// 检查是否存在用户定义的applicationEventMulticaster Beanif (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {this.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);if (logger.isTraceEnabled()) {logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");}}else {// 创建并注册默认的SimpleApplicationEventMulticasterthis.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);if (logger.isTraceEnabled()) {logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");}}
}

protected void onRefresh() throws BeansException {// 对于Web应用上下文，这里会初始化Servlet上下文// 子类可以重写此方法以初始化其他特殊Bean
}

protected void registerListeners() {// 注册静态指定的监听器for (ApplicationListener<?> listener : getApplicationListeners()) {getApplicationEventMulticaster().addApplicationListener(listener);}// 从Bean工厂中获取所有ApplicationListener Bean并注册String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);for (String listenerBeanName : listenerBeanNames) {getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);}// 发布早期应用事件Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;this.earlyApplicationEvents = null;if (earlyEventsToProcess != null) {for (ApplicationEvent earlyEvent : earlyEventsToProcess) {getApplicationEventMulticaster().multicastEvent(earlyEvent);}}
}protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// 初始化类型转换器if (beanFactory.containsBean(TYPE_CONVERTER_BEAN_NAME)) {beanFactory.addPropertyEditorRegistrar(new BeanFactoryTypeConverter(beanFactory.getBean(TYPE_CONVERTER_BEAN_NAME, TypeConverter.class)));}// 初始化LoadTimeWeaverAware Beanif (!beanFactory.getTempClassLoader().getClass().getName().contains("ContextTypeMatchClassLoader")) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// 冻结所有Bean定义，表明注册的Bean定义不会被修改或进一步后处理beanFactory.freezeConfiguration();// 实例化所有剩余的（非懒加载）单例beanFactory.preInstantiateSingletons();
}protected void finishRefresh() {// 清除资源缓存clearResourceCaches();// 初始化生命周期处理器initLifecycleProcessor();// 注册生命周期处理器的回调getLifecycleProcessor().onRefresh();// 发布ContextRefreshedEvent事件publishEvent(new ContextRefreshedEvent(this));// Participate in LiveBeansView MBean, if active.LiveBeansView.registerApplicationContext(this);
}

// 在ServletWebServerApplicationContext类中
@Override
protected void onRefresh() {super.onRefresh();try {// 创建并启动Web服务器createWebServer();}catch (Throwable ex) {throw new ApplicationContextException("Unable to start web server", ex);}
}private void createWebServer() {WebServer webServer = this.webServer;ServletContext servletContext = getServletContext();if (webServer == null && servletContext == null) {// 获取ServletWebServerFactoryServletWebServerFactory factory = getWebServerFactory();// 创建Web服务器this.webServer = factory.getWebServer(getSelfInitializer());}else if (servletContext != null) {try {// 如果已经有Servlet上下文，初始化它getSelfInitializer().onStartup(servletContext);}catch (ServletException ex) {throw new ApplicationContextException("Cannot initialize servlet context", ex);}}// 初始化属性源initPropertySources();
}protected ServletWebServerFactory getWebServerFactory() {// 获取ServletWebServerFactory Bean名称String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);if (beanNames.length == 0) {throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing " +"ServletWebServerFactory bean.");}if (beanNames.length > 1) {throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple " +"ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));}// 获取并返回ServletWebServerFactory Beanreturn getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

// TomcatServletWebServerFactory类
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {// 创建Tomcat实例Tomcat tomcat = new Tomcat();// 配置基本目录File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");tomcat.setBaseDir(baseDir.getAbsolutePath());// 配置连接器Connector connector = new Connector(this.protocol);tomcat.getService().addConnector(connector);customizeConnector(connector);tomcat.setConnector(connector);tomcat.getHost().setAutoDeploy(false);// 配置Engine和HostconfigureEngine(tomcat.getEngine());for (Connector additionalConnector : this.additionalTomcatConnectors) {tomcat.getService().addConnector(additionalConnector);}// 准备上下文prepareContext(tomcat.getHost(), initializers);// 返回Web服务器包装器return getTomcatWebServer(tomcat);
}// JettyServletWebServerFactory类
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {// 创建Server实例Server server = new Server();// 配置连接器ServerConnector connector = new ServerConnector(server);if (this.port != null) {connector.setPort(this.port);}server.addConnector(connector);// 配置处理程序configureHandler(server);// 配置Sessionif (this.session != null && this.session.getTimeout() != null) {Duration timeout = this.session.getTimeout();long seconds = timeout.getSeconds();if (seconds >= 0) {this.sessionTimeout = (int) seconds;}}// 准备上下文ServletContextHandler contextHandler = prepareContext(server, initializers);// 返回Web服务器包装器return new JettyWebServer(server, this.autoStart, contextHandler);
}// UndertowServletWebServerFactory类
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {// 创建Undertow构建器Undertow.Builder builder = createBuilder(getPort());// 创建Servlet容器DeploymentInfo servletBuilder = getDeploymentInfo(initializers);DeploymentManager manager = defaultContainer.addDeployment(servletBuilder);manager.deploy();// 获取Servlet上下文try {ServletContext context = manager.start();configureContext(context, initializers);}catch (ServletException ex) {throw new WebServerException("Unable to start embedded Undertow server", ex);}// 添加Servlet部署到构建器builder.deploy(servletBuilder);// 创建并启动Undertow服务器Undertow undertow = builder.build();startDaemonAwaitThread(undertow);// 返回Web服务器包装器return new UndertowWebServer(undertow, this.autoStart, getPort() >= 0);
}

// 通过配置属性定制
@Configuration
public class WebServerCustomizationConfiguration {@Beanpublic WebServerFactoryCustomizer<TomcatServletWebServerFactory> tomcatCustomizer() {return factory -> {// 定制Tomcat服务器factory.addConnectorCustomizers(connector -> {// 配置连接器connector.setPort(8080);connector.setMaxThreads(200);connector.setMaxConnections(8192);});// 配置Tomcat引擎factory.addEngineCustomizers(engine -> {engine.setRealm(new MemoryRealm());});// 配置上下文factory.addContextCustomizers(context -> {context.setSessionTimeout(30);});};}@Beanpublic WebServerFactoryCustomizer<JettyServletWebServerFactory> jettyCustomizer() {return factory -> {// 定制Jetty服务器factory.addServerCustomizers(server -> {// 配置Jetty服务器server.setStopAtShutdown(true);server.setStopTimeout(5000);});// 配置连接器factory.addConnectorCustomizers(connector -> {connector.setIdleTimeout(30000);});};}@Beanpublic WebServerFactoryCustomizer<UndertowServletWebServerFactory> undertowCustomizer() {return factory -> {// 定制Undertow服务器factory.addBuilderCustomizers(builder -> {// 配置Undertow构建器builder.setIoThreads(4);builder.setWorkerThreads(20);});// 添加Servlet容器定制器factory.addDeploymentInfoCustomizers(deploymentInfo -> {deploymentInfo.setSessionTimeout(30);});};}
}

// SpringApplicationRunListeners类
public void starting(DefaultBootstrapContext bootstrapContext, @Nullable Class<?> mainApplicationClass) {doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),(step) -> {if (mainApplicationClass != null) {step.tag("mainApplicationClass", mainApplicationClass.getName());}return step;});
}public void environmentPrepared(DefaultBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {doWithListeners("spring.boot.application.environment-prepared",(listener) -> listener.environmentPrepared(bootstrapContext, environment),(step) -> step.tag("configLocations", getConfigLocations(environment)));
}public void contextPrepared(ConfigurableApplicationContext context) {doWithListeners("spring.boot.application.context-prepared",(listener) -> listener.contextPrepared(context), null);
}public void contextLoaded(ConfigurableApplicationContext context) {doWithListeners("spring.boot.application.context-loaded",(listener) -> listener.contextLoaded(context), null);
}public void started(ConfigurableApplicationContext context, Duration timeTaken) {doWithListeners("spring.boot.application.started",(listener) -> listener.started(context, timeTaken), null);
}public void running(ConfigurableApplicationContext context, Duration timeTaken) {doWithListeners("spring.boot.application.running",(listener) -> listener.running(context, timeTaken), null);
}public void failed(ConfigurableApplicationContext context, Throwable exception) {doWithListeners("spring.boot.application.failed",(listener) -> listener.failed(context, exception), null);
}

// 通过META-INF/spring.factories注册
# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener// 通过@Bean方法注册
@Configuration
public class MyApplicationConfiguration {@Beanpublic ApplicationListener<ApplicationReadyEvent> readyListener() {return event -> {// 应用准备就绪后的处理逻辑System.out.println("Application is ready!");};}@Beanpublic ApplicationListener<ContextRefreshedEvent> refreshedListener() {return event -> {// 上下文刷新后的处理逻辑System.out.println("Context is refreshed!");};}
}// 通过@Component和@EventListener注解注册
@Component
public class MyApplicationListener {@EventListenerpublic void handleContextRefreshed(ContextRefreshedEvent event) {// 处理上下文刷新事件System.out.println("Context refreshed: " + event.getApplicationContext());}@EventListenerpublic void handleApplicationReady(ApplicationReadyEvent event) {// 处理应用就绪事件System.out.println("Application ready: " + event.getApplicationContext());}@EventListenerpublic void handleApplicationFailed(ApplicationFailedEvent event) {// 处理应用失败事件System.out.println("Application failed: " + event.getException().getMessage());}
}

// 实现Ordered接口
@Component
public class MyOrderedListener implements ApplicationListener<ApplicationReadyEvent>, Ordered {@Overridepublic void onApplicationEvent(ApplicationReadyEvent event) {// 处理应用就绪事件System.out.println("MyOrderedListener: Application is ready!");}@Overridepublic int getOrder() {// 返回优先级，值越小优先级越高return Ordered.HIGHEST_PRECEDENCE + 10;}
}// 使用@Order注解
@Component
@Order(Ordered.HIGHEST_PRECEDENCE + 20)
public class MyAnnotatedListener implements ApplicationListener<ApplicationReadyEvent> {@Overridepublic void onApplicationEvent(ApplicationReadyEvent event) {// 处理应用就绪事件System.out.println("MyAnnotatedListener: Application is ready!");}
}

// EnableAutoConfiguration注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";/*** 排除特定的自动配置类*/Class<?>[] exclude() default {};/*** 排除特定的自动配置类名*/String[] excludeName() default {};
}

// AutoConfigurationImportSelector类
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {if (!isEnabled(annotationMetadata)) {return NO_IMPORTS;}// 获取自动配置元数据AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);// 获取自动配置类AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata);// 返回自动配置类名数组return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,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 = filter(configurations, autoConfigurationMetadata);// 触发自动配置导入事件fireAutoConfigurationImportEvents(configurations, exclusions);// 返回自动配置条目return new AutoConfigurationEntry(configurations, exclusions);
}

// ConditionalOnClass注解
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {/*** 指定类必须存在于类路径上*/Class<?>[] value() default {};/*** 指定类名必须存在于类路径上*/String[] name() default {};
}// ConditionalOnMissingBean注解
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnBeanCondition.class)
public @interface ConditionalOnMissingBean {/*** 指定必须不存在的Bean类型*/Class<?>[] value() default {};/*** 指定必须不存在的Bean名称*/String[] name() default {};/*** 指定查找Bean的搜索范围*/SearchStrategy search() default SearchStrategy.ALL;
}// ConditionalOnProperty注解
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnPropertyCondition.class)
public @interface ConditionalOnProperty {/*** 指定属性名前缀*/String prefix() default "";/*** 指定属性名*/String[] name() default {};/*** 指定属性值必须等于的值*/String havingValue() default "";/*** 指定当属性不存在时是否匹配*/boolean matchIfMissing() default false;
}

// DataSourceAutoConfiguration类
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {@Bean@ConditionalOnMissingBeanpublic DataSourceInitializerInvoker dataSourceInitializerInvoker(DataSource dataSource, DataSourceProperties properties) {// 创建数据源初始化调用器return new DataSourceInitializerInvoker(dataSource, properties);}@Configuration(proxyBeanMethods = false)@Conditional(EmbeddedDatabaseCondition.class)@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")static class EmbeddedDatabaseConfiguration {@Bean@ConditionalOnMissingBeanpublic DataSource dataSource(DataSourceProperties properties) {// 创建嵌入式数据源return properties.initializeDataSourceBuilder().build();}}@Configuration(proxyBeanMethods = false)@Conditional(PooledDataSourceCondition.class)@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")@Import({ Hikari.class, Tomcat.class, Dbcp2.class, OracleUcp.class,Generic.class, DataSourceJmxConfiguration.class })static class PooledDataSourceConfiguration {@Bean@ConditionalOnMissingBeanpublic DataSource dataSource(DataSourceProperties properties) {// 创建连接池数据源return properties.initializeDataSourceBuilder().build();}}// 其他内部配置类和方法...
}

// DefaultApplicationArguments类
public DefaultApplicationArguments(String... args) {Assert.notNull(args, "Args must not be null");this.source = new Source(args);this.args = args;
}private static class Source extends SimpleCommandLinePropertySource {Source(String[] args) {super(args);}@Overridepublic String[] getPropertyNames() {synchronized (this) {if (this.propertyNames == null) {// 初始化属性名数组this.propertyNames = extractPropertyNames(getOptionNames());}return this.propertyNames.clone();}}private String[] extractPropertyNames(Set<String> optionNames) {// 提取属性名return StringUtils.toStringArray(optionNames);}@Overridepublic boolean containsProperty(String name) {return getOptionNames().contains(name);}@Overridepublic Object getProperty(String name) {return getOptionValues(name);}
}

// ConfigFileApplicationListener类
private void addCommandLineProperties(ConfigurableEnvironment environment, String[] args) {if (args.length > 0) {// 创建命令行属性源String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;CommandLinePropertySource<?> source = new SimpleCommandLinePropertySource(args);// 移除默认的命令行属性源if (environment.getPropertySources().contains(name)) {environment.getPropertySources().replace(name, source);}else {// 添加命令行属性源，优先级最高environment.getPropertySources().addFirst(source);}}
}

// 实现CommandLineRunner接口
@Component
public class MyCommandLineRunner implements CommandLineRunner {@Overridepublic void run(String... args) throws Exception {// 处理命令行参数System.out.println("Command line arguments:");for (String arg : args) {System.out.println("- " + arg);}// 可以在这里执行应用启动后的初始化操作}
}// 实现ApplicationRunner接口
@Component
public class MyApplicationRunner implements ApplicationRunner {@Overridepublic void run(ApplicationArguments args) throws Exception {// 处理应用参数System.out.println("Application arguments:");// 获取非选项参数List<String> nonOptionArgs = args.getNonOptionArgs();System.out.println("Non-option arguments: " + nonOptionArgs);// 获取选项参数Set<String> optionNames = args.getOptionNames();for (String optionName : optionNames) {List<String> optionValues = args.getOptionValues(optionName);System.out.println("Option '" + optionName + "': " + optionValues);}// 可以在这里执行应用启动后的初始化操作}
}

// SpringApplication类
private void handleRunFailure(ConfigurableApplicationContext context, Throwable ex,SpringApplicationRunListeners listeners) {try {try {// 发布应用失败事件if (listeners != null) {listeners.failed(context, ex);}}catch (Throwable ex2) {logger.error("Error handling failed event", ex2);}// 记录启动失败日志if (context != null) {context.close();}// 报告异常reportFailure(getExceptionReporters(context), ex);}catch (Throwable ex3) {logger.error("Unable to close ApplicationContext", ex3);}// 重新抛出异常ReflectionUtils.rethrowRuntimeException(ex);
}private void reportFailure(Collection<SpringBootExceptionReporter> exceptionReporters, Throwable failure) {try {// 尝试使用异常报告器报告异常if (!exceptionReporters.isEmpty()) {boolean reported = false;for (SpringBootExceptionReporter reporter : exceptionReporters) {if (reporter.reportException(failure)) {reported = true;break;}}// 如果没有报告器处理异常，记录错误日志if (!reported && logger.isErrorEnabled()) {logger.error("Application run failed", failure);}

private void reportFailure(Collection<SpringBootExceptionReporter> exceptionReporters, Throwable failure) {try {if (!exceptionReporters.isEmpty()) {boolean reported = false;for (SpringBootExceptionReporter reporter : exceptionReporters) {if (reporter.reportException(failure)) {reported = true;break;}}if (!reported && logger.isErrorEnabled()) {logger.error("Application run failed", failure);}}} catch (Throwable ex) {if (logger.isDebugEnabled()) {logger.debug("Error reporting failure", ex);}if (logger.isErrorEnabled()) {logger.error("Application run failed", failure);}}
}

public class FailureAnalyzers {private final List<FailureAnalyzer> analyzers;private final Log logger;public FailureAnalyzers(ClassLoader classLoader, Log logger) {this(classLoader, null, logger);}public FailureAnalyzers(ClassLoader classLoader, List<FailureAnalyzer> analyzers, Log logger) {this.logger = logger;List<FailureAnalyzer> loadedAnalyzers = (analyzers != null) ? new ArrayList<>(analyzers): SpringFactoriesLoader.loadFactories(FailureAnalyzer.class, classLoader);AnnotationAwareOrderComparator.sort(loadedAnalyzers);this.analyzers = Collections.unmodifiableList(loadedAnalyzers);}public FailureAnalysis analyze(Throwable failure) {Throwable rootFailure = findRootCause(failure);if (rootFailure != null) {for (FailureAnalyzer analyzer : this.analyzers) {try {FailureAnalysis analysis = analyzer.analyze(rootFailure);if (analysis != null) {return analysis;}} catch (Throwable ex) {if (this.logger.isDebugEnabled()) {String message = ex.getMessage();message = (message != null) ? message : "no error message";this.logger.debug("FailureAnalyzer " + analyzer.getClass().getName()+ " failed to analyze cause: " + message, ex);}}}}return null;}private Throwable findRootCause(Throwable failure) {Throwable root = failure;Throwable cause;while ((cause = root.getCause()) != null) {root = cause;}return root;}
}

@Service
public class UserService {// 业务逻辑
}@Service
public class AnotherUserService implements UserService {// 另一种实现的业务逻辑
}

@Configuration
public class AppConfig {@Bean("commonBean")public Object bean1() {return new Object();}@Bean("commonBean")public Object bean2() {return new Object();}
}

@Service
@Primary
public class UserService {// 业务逻辑
}

@Service
public class UserService {// 业务逻辑
}@Service
public class AnotherUserService {// 业务逻辑
}@Service
public class UserController {private final UserService userService;@Autowiredpublic UserController(@Qualifier("userService") UserService userService) {this.userService = userService;}
}

server.port=8081

server:port: 8081

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

@Configuration
public class MyDataSourceConfig {@Bean@ConditionalOnMissingBean(DataSource.class)public DataSource customDataSource() {// 自定义数据源创建逻辑}
}

<dependency><groupId>com.example</groupId><artifactId>example-dependency</artifactId><version>1.0.0</version><exclusions><exclusion><groupId>冲突依赖的groupId</groupId><artifactId>冲突依赖的artifactId</artifactId></exclusion></exclusions>
</dependency>

<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.13.0</version>
</dependency>

<dependencyManagement><dependencies><dependency><groupId>com.example</groupId><artifactId>common-dependency</artifactId><version>1.0.0</version></dependency></dependencies>
</dependencyManagement>

spring:datasource:
url: jdbc:mysql://localhost:3306/mydb
username: root
password: 123456

myapp:max-connections: "ten"

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Positive;import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;@ConfigurationProperties(prefix = "myapp")
@Validated
public class MyAppConfig {@NotBlankprivate String name;@NotNull@Positiveprivate int age;// 省略getter和setter
}

spring:datasource:url: jdbc:mysql://192.168.1.100:3307/mydbusername: rootpassword: 123456

<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.26</version> <!-- 根据实际情况选择合适的版本 -->
</dependency>

systemctl status mysql

systemctl start mysql

spring:datasource:url: jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;public class DatabaseConnectionTest {public static void main(String[] args) {String url = "jdbc:mysql://localhost:3306/mydb";String username = "root";String password = "123456";try (Connection connection = DriverManager.getConnection(url, username, password)) {System.out.println("数据库连接成功！");} catch (SQLException e) {System.out.println("数据库连接失败：" + e.getMessage());e.printStackTrace();}}
}

@SpringBootApplication
@ComponentScan(basePackages = "com.example.myapp")
public class MyApplication {public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}
}

@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.REGEX, pattern = "com.example.myapp.excluded.*")
})

@Configuration
public class AppConfig {@Beanpublic MyService myService() {return new MyService();}
}

@Service
public class ServiceA {@Autowiredprivate ServiceB serviceB;// 构造函数或方法使用serviceB
}@Service
public class ServiceB {@Autowiredprivate ServiceA serviceA;// 构造函数或方法使用serviceA
}

@Service
public class ServiceA {private final ServiceB serviceB;@Autowiredpublic ServiceA(@Lazy ServiceB serviceB) {this.serviceB = serviceB;}
}

@Service
public class MyService {// 业务逻辑
}@Service
public class MyController {@Autowiredprivate AnotherService myService; // 类型不匹配，AnotherService与MyService不兼容
}

@Service
public class MyService {@Autowiredprivate MyRepository repository; // 容器中没有MyRepository类型的Bean
}

mvn dependency:tree

gradle dependencies

<dependencyManagement><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.18</version></dependency></dependencies>
</dependencyManagement>

<dependency><groupId>com.example</groupId><artifactId>example-library</artifactId><version>1.0.0</version><exclusions><exclusion><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></exclusion></exclusions>
</dependency>

@Service
public class MyService implements InitializingBean {@Overridepublic void afterPropertiesSet() throws Exception {// 初始化逻辑，确保不会抛出异常}
}

@Service
@DependsOn("dataSource")
public class MyService {// 业务逻辑
}

logging.level.root=INFO
logging.level.org.springframework=DEBUG

logging:level:root: INFOorg.springframework: DEBUG

java -jar myapp.jar --debug

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class MyApplication {public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}
}

@SpringBootApplication
public class MyApplication {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);Environment env = context.getEnvironment();System.out.println("Active profiles: " + Arrays.asList(env.getActiveProfiles()));System.out.println("Application properties: " + env.getPropertySources());}
}