Android 小码蜂
Android 小码蜂

SpringBoot run()方法全链路解析(33)

SpringBoot run()方法全链路解析

一、SpringBoot启动流程概述

1.1 SpringBoot应用的入口点

SpringBoot应用的启动通常从main方法开始，其中最核心的是调用SpringApplication.run()方法：

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

这行简单的代码背后隐藏着复杂的启动流程，SpringApplication.run()方法是整个SpringBoot应用启动的核心入口，它负责创建并配置Spring应用上下文、启动嵌入式服务器等一系列关键操作。

1.2 启动流程的主要阶段

SpringBoot应用的启动流程可以大致分为以下几个主要阶段：

  1. 初始化阶段：创建SpringApplication实例，准备应用上下文环境
  2. 配置加载阶段：加载并解析应用配置，包括application.properties/yml文件、命令行参数等
  3. 自动配置阶段：基于类路径和配置信息，应用自动配置机制
  4. 上下文创建阶段：创建并刷新Spring应用上下文
  5. 嵌入式服务器启动阶段：启动嵌入式Web服务器，处理HTTP请求
  6. 应用就绪阶段：发布应用就绪事件，标志应用已成功启动

1.3 核心组件概述

在启动过程中，涉及到多个核心组件：

  • SpringApplication：启动SpringBoot应用的核心类，负责协调整个启动过程
  • ApplicationContext：Spring应用上下文，管理应用中的所有Bean
  • Environment：应用环境抽象，负责加载和管理配置属性
  • ApplicationEventPublisher：事件发布器，负责发布应用生命周期事件
  • AutoConfiguration：自动配置机制，基于条件注解自动配置应用

二、SpringApplication实例的创建

2.1 run()方法的重载形式

SpringApplication.run()方法有多种重载形式，最常用的是：

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);
}

可以看到，最终会创建一个SpringApplication实例并调用其run()方法。

2.2 SpringApplication构造函数

SpringApplication的构造函数会执行一系列初始化操作：

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();
}

2.3 应用类型的推断

在构造函数中，会通过WebApplicationType.deduceFromClasspath()方法推断应用类型：

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;
}

这里通过检查类路径中是否存在特定的类来判断应用类型：

  • REACTIVE：存在org.springframework.web.reactive.DispatcherHandler且不存在org.springframework.web.servlet.DispatcherServlet
  • SERVLET：存在javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext
  • NONE：既不是REACTIVE也不是SERVLET

2.4 初始化器和监听器的加载

SpringApplication会从META-INF/spring.factories文件中加载初始化器和监听器：

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;
}

SpringFactoriesLoader.loadFactoryNames()方法会从所有META-INF/spring.factories文件中查找指定类型的实现类：

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);
    }
}

2.5 主应用类的推断

SpringApplication会尝试推断主应用类：

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;
}

三、run()方法的核心流程

3.1 核心run()方法实现

SpringApplication实例创建完成后，会调用其run()方法：

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);
        
        // 打印Banner
        Banner 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);
        
        // 调用所有Runner
        callRunners(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;
}

3.2 启动监听器的初始化与启动

在run()方法开始时，会初始化并启动应用监听器：

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;
            });
}

SpringApplicationRunListener是SpringBoot应用启动过程中的核心监听器接口，它定义了应用启动各个阶段的回调方法。

3.3 应用参数与环境的准备

run()方法会创建并准备应用参数和环境：

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;
}

3.4 Banner的打印

SpringBoot应用启动时会打印Banner：

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);
    
    // 打印控制台Banner
    if (this.bannerMode == Banner.Mode.CONSOLE) {
        return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
    }
    
    // 打印日志Banner
    return bannerPrinter.print(environment, this.mainApplicationClass, logger);
}

Banner打印器会尝试从classpath下加载banner.txt或banner.gif等文件作为Banner：

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();
    
    // 添加文本Banner
    banners.addIfNotNull(getTextBanner(environment));
    
    // 添加图像Banner
    banners.addIfNotNull(getImageBanner(environment));
    
    // 如果没有找到任何Banner，使用默认Banner
    if (banners.hasAtLeastOneBanner()) {
        return banners;
    }
    
    // 返回默认Banner
    return this.fallbackBanner != null ? this.fallbackBanner : DEFAULT_BANNER;
}

3.5 应用上下文的创建与准备

run()方法会创建并准备应用上下文：

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);
    }
    
    // 添加单例Bean
    ConfigurableListableBeanFactory 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);
}

四、应用上下文的刷新

4.1 刷新上下文的核心方法

run()方法中调用的refreshContext(context)会触发应用上下文的刷新：

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

protected void refresh(ConfigurableApplicationContext context) {
    // 调用标准的上下文刷新方法
    context.refresh();
}

4.2 AbstractApplicationContext的refresh()方法

refresh()方法是Spring应用上下文的核心方法，定义在AbstractApplicationContext中：

@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();
            
            // 初始化其他特殊Bean
            onRefresh();
            
            // 检查并注册监听器
            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();
        }
    }
}

4.3 Bean工厂的准备与后置处理

在refresh()方法中，会准备并配置Bean工厂：

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()));
    }
    
    // 注册默认环境Bean
    if (!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());
    }
}

4.4 Bean工厂后置处理器的调用

refresh()方法会调用所有注册的Bean工厂后置处理器：

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()));
    }
}

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法会处理所有BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor：

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
    // 保存已经处理的处理器名称，避免重复处理
    Set<String> processedBeans = new HashSet<>();
    
    // 处理BeanDefinitionRegistry类型的工厂
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        
        // 区分普通的BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
        
        // 首先处理传入的BeanFactoryPostProcessor
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }
        
        // 现在，处理在上下文中定义的BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
        
        // 首先，调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
        String[] 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接口的BeanDefinitionRegistryPostProcessor
        postProcessorNames = 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);
        
        // 调用普通的BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }
    else {
        // 如果不是BeanDefinitionRegistry类型的工厂，直接调用所有BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }
    
    // 现在，调用在上下文中定义的所有BeanFactoryPostProcessor
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
    // 分离实现PriorityOrdered、Ordered和其他的BeanFactoryPostProcessor
    List<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接口的BeanFactoryPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
    // 接下来，调用实现Ordered接口的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
    // 最后，调用所有其他的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    
    // 清除缓存的合并Bean定义，因为后处理器可能修改了原始元数据
    beanFactory.clearMetadataCache();
}

4.5 Bean后置处理器的注册

refresh()方法会注册所有Bean后置处理器：

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

PostProcessorRegistrationDelegate.registerBeanPostProcessors()方法会注册并排序所有Bean后置处理器：

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和其他的BeanPostProcessor
    List<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接口的BeanPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    
    // 接下来，注册实现Ordered接口的BeanPostProcessor
    List<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);
    
    // 然后，注册所有其他的BeanPostProcessor
    List<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);
    
    // 最后，注册所有内部BeanPostProcessor
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
    // 添加ApplicationListenerDetector以检测ApplicationListener Bean
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

4.6 消息源与事件多播器的初始化

refresh()方法会初始化消息源和事件多播器：

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    
    // 检查是否存在用户定义的messageSource Bean
    if (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 {
        // 创建并注册默认的DelegatingMessageSource
        DelegatingMessageSource 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 Bean
    if (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 {
        // 创建并注册默认的SimpleApplicationEventMulticaster
        this.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() + "]");
        }
    }
}

4.7 特殊Bean的初始化与刷新完成

refresh()方法会调用onRefresh()方法初始化特殊Bean：

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 Bean
    if (!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);
}

五、嵌入式服务器的启动

5.1 嵌入式服务器的创建与启动

在应用上下文刷新完成后，SpringBoot会启动嵌入式服务器：

// 在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) {
        // 获取ServletWebServerFactory
        ServletWebServerFactory 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 Bean
    return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

5.2 ServletWebServerFactory的实现

SpringBoot提供了多种嵌入式服务器的实现，如Tomcat、Jetty和Undertow：

// 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和Host
    configureEngine(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);
    
    // 配置Session
    if (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);
}

5.3 嵌入式服务器的配置与定制

嵌入式服务器的配置可以通过多种方式进行定制：

// 通过配置属性定制
@Configuration
public class WebServerCustomizationConfiguration {
    
    @Bean
    public 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);
            });
        };
    }
    
    @Bean
    public WebServerFactoryCustomizer<JettyServletWebServerFactory> jettyCustomizer() {
        return factory -> {
            // 定制Jetty服务器
            factory.addServerCustomizers(server -> {
                // 配置Jetty服务器
                server.setStopAtShutdown(true);
                server.setStopTimeout(5000);
            });
            
            // 配置连接器
            factory.addConnectorCustomizers(connector -> {
                connector.setIdleTimeout(30000);
            });
        };
    }
    
    @Bean
    public WebServerFactoryCustomizer<UndertowServletWebServerFactory> undertowCustomizer() {
        return factory -> {
            // 定制Undertow服务器
            factory.addBuilderCustomizers(builder -> {
                // 配置Undertow构建器
                builder.setIoThreads(4);
                builder.setWorkerThreads(20);
            });
            
            // 添加Servlet容器定制器
            factory.addDeploymentInfoCustomizers(deploymentInfo -> {
                deploymentInfo.setSessionTimeout(30);
            });
        };
    }
}

六、应用事件与监听器机制

6.1 应用事件的类型与发布

SpringBoot应用在启动过程中会发布多种事件：

// 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);
}

6.2 事件监听器的注册与处理

应用事件监听器可以通过多种方式注册：

// 通过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 {
    
    @Bean
    public ApplicationListener<ApplicationReadyEvent> readyListener() {
        return event -> {
            // 应用准备就绪后的处理逻辑
            System.out.println("Application is ready!");
        };
    }
    
    @Bean
    public ApplicationListener<ContextRefreshedEvent> refreshedListener() {
        return event -> {
            // 上下文刷新后的处理逻辑
            System.out.println("Context is refreshed!");
        };
    }
}

// 通过@Component和@EventListener注解注册
@Component
public class MyApplicationListener {
    
    @EventListener
    public void handleContextRefreshed(ContextRefreshedEvent event) {
        // 处理上下文刷新事件
        System.out.println("Context refreshed: " + event.getApplicationContext());
    }
    
    @EventListener
    public void handleApplicationReady(ApplicationReadyEvent event) {
        // 处理应用就绪事件
        System.out.println("Application ready: " + event.getApplicationContext());
    }
    
    @EventListener
    public void handleApplicationFailed(ApplicationFailedEvent event) {
        // 处理应用失败事件
        System.out.println("Application failed: " + event.getException().getMessage());
    }
}

6.3 事件处理的顺序与优先级

事件监听器可以通过实现Ordered接口或使用@Order注解来指定处理顺序：

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

// 使用@Order注解
@Component
@Order(Ordered.HIGHEST_PRECEDENCE + 20)
public class MyAnnotatedListener implements ApplicationListener<ApplicationReadyEvent> {
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        // 处理应用就绪事件
        System.out.println("MyAnnotatedListener: Application is ready!");
    }
}

七、自动配置机制解析

7.1 自动配置的核心原理

SpringBoot的自动配置是基于条件注解实现的：

// 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会从META-INF/spring.factories文件中加载所有自动配置类：

// 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);
}

7.2 条件注解的应用

SpringBoot使用多种条件注解来控制自动配置的生效条件：

// 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;
}

7.3 自动配置类的结构

自动配置类通常包含多个@Bean方法，并使用条件注解控制这些方法的生效条件：

// DataSourceAutoConfiguration类
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public 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
        @ConditionalOnMissingBean
        public 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
        @ConditionalOnMissingBean
        public DataSource dataSource(DataSourceProperties properties) {
            // 创建连接池数据源
            return properties.initializeDataSourceBuilder().build();
        }
    }
    
    // 其他内部配置类和方法...
}

八、命令行参数处理

8.1 命令行参数的解析

SpringBoot应用启动时会解析命令行参数：

// 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);
    }
    
    @Override
    public 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);
    }
    
    @Override
    public boolean containsProperty(String name) {
        return getOptionNames().contains(name);
    }
    
    @Override
    public Object getProperty(String name) {
        return getOptionValues(name);
    }
}

8.2 命令行参数的优先级

命令行参数的优先级高于其他配置源：

// 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);
        }
    }
}

8.3 自定义命令行参数处理器

开发者可以通过实现ApplicationRunner或CommandLineRunner接口来处理命令行参数：

// 实现CommandLineRunner接口
@Component
public class MyCommandLineRunner implements CommandLineRunner {
    
    @Override
    public 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 {
    
    @Override
    public 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);
        }
        
        // 可以在这里执行应用启动后的初始化操作
    }
}

九、应用启动错误处理

9.1 启动异常的捕获与处理

SpringBoot应用启动过程中的异常会被捕获并处理：

// 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);
            }

9.1 启动异常的捕获与处理

在handleRunFailure方法中，除了发布应用失败事件和关闭上下文外，reportFailure方法负责将异常信息以更友好的方式呈现。Spring Boot通过SpringBootExceptionReporter接口的实现类来完成这一任务，常见的实现包括DefaultErrorPageExceptionReporter等。

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);
        }
    }
}

上述代码中，会依次尝试让每个SpringBootExceptionReporter处理异常。如果有任何一个报告器处理成功（即reportException方法返回true），则认为异常已被妥善处理；若所有报告器都无法处理，且日志级别允许记录错误，就会直接记录异常信息到日志中。

以DefaultErrorPageExceptionReporter为例，它主要用于Web应用场景，会尝试生成一个包含错误信息的HTML页面。在生成错误页面时，它会获取异常的详细堆栈信息、错误类型等内容，并结合Spring Boot默认的错误页面模板，将这些信息渲染到页面上。当应用启动过程中出现异常时，若满足一定条件（如在Web环境下），用户访问应用时就能看到这个详细的错误页面，而不是晦涩难懂的堆栈跟踪信息。

9.2 异常报告器的工作机制

FailureAnalyzers类在异常分析过程中扮演着关键角色。它负责从类路径中加载所有实现了FailureAnalyzer接口的类，并按照一定顺序对异常进行分析。

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;
    }
}

首先，在构造函数中，FailureAnalyzers通过SpringFactoriesLoader从META-INF/spring.factories文件中加载所有的FailureAnalyzer实现类，并使用AnnotationAwareOrderComparator进行排序，确保按照优先级顺序处理。

在analyze方法中，它会先找到异常的根本原因，然后依次让每个FailureAnalyzer尝试分析该根本原因。每个FailureAnalyzer实现类都有自己的分析逻辑，比如判断异常类型是否是自己能处理的，如果是，则根据异常信息生成一个FailureAnalysis对象，该对象包含了错误描述和解决建议。一旦有FailureAnalyzer成功生成FailureAnalysis对象，就会立即返回，不再继续尝试其他分析器。

例如，DataSourceUnavailableFailureAnalyzer专门用于分析数据库连接相关的异常。当应用启动时无法连接到数据库，抛出SQLException等异常时，DataSourceUnavailableFailureAnalyzer会判断异常是否属于数据库连接失败相关类型。如果是，它会从异常信息中提取出数据库URL、用户名等关键信息，并生成包含错误原因（如“无法连接到指定的数据库URL”）和解决建议（如“检查数据库URL是否正确，确保数据库服务已启动”）的FailureAnalysis对象，帮助开发者快速定位和解决问题。

9.3 常见启动错误及解决方案

9.3.1 Bean定义冲突

当Spring容器中存在多个相同类型或名称的Bean定义时，就会引发Bean定义冲突问题。主要有两种常见情况：

  • 类型冲突：多个@Component、@Service、@Repository等注解标注的类，或通过@Bean方法定义的Bean，它们的类型相同。例如，定义了两个UserService类：
@Service
public class UserService {
    // 业务逻辑
}

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

当在其他类中通过@Autowired注入UserService时，Spring容器无法确定应该注入哪一个，就会抛出NoUniqueBeanDefinitionException异常。

  • 名称冲突：即使Bean类型不同，但如果通过@Bean方法显式指定了相同的Bean名称，也会产生冲突。比如：
@Configuration
public class AppConfig {
    @Bean("commonBean")
    public Object bean1() {
        return new Object();
    }

    @Bean("commonBean")
    public Object bean2() {
        return new Object();
    }
}

此时会抛出BeanDefinitionOverrideException异常。

解决方案：

  • 使用@Primary注解：在多个同类型Bean中，将其中一个标注为@Primary，表示该Bean为首选注入对象。例如，在上述UserService的例子中，可以将其中一个UserService类标注为@Primary：
@Service
@Primary
public class UserService {
    // 业务逻辑
}

这样在注入UserService时，Spring会优先选择带有@Primary注解的Bean。

  • 使用@Qualifier注解：通过@Qualifier指定具体的Bean名称或限定条件。在注入时明确指出要使用的Bean，如：
@Service
public class UserService {
    // 业务逻辑
}

@Service
public class AnotherUserService {
    // 业务逻辑
}

@Service
public class UserController {
    private final UserService userService;

    @Autowired
    public UserController(@Qualifier("userService") UserService userService) {
        this.userService = userService;
    }
}

这里通过@Qualifier("userService")指定了要注入的具体UserService Bean。

  • 检查并移除重复定义：仔细检查代码，删除不必要的重复Bean定义，确保每个Bean在容器中具有唯一性。
  • 设置spring.main.allow-bean-definition-overriding=true：在application.properties或application.yml中设置该属性，允许Bean定义覆盖。但这种方式可能会导致一些难以排查的问题，不建议在生产环境中使用，仅用于开发调试阶段临时解决冲突。
9.3.2 端口占用

当Spring Boot应用使用嵌入式服务器（如Tomcat、Jetty、Undertow）启动时，会尝试绑定到指定的端口。如果该端口已经被其他进程占用，就会抛出类似于Address already in use: bind的异常。例如，默认情况下，Spring Boot的Web应用会尝试绑定到8080端口，如果8080端口已被其他Web服务占用，应用启动就会失败。

解决方案：

  • 修改端口配置：在application.properties或application.yml文件中，通过server.port属性指定其他未被占用的端口。如在application.properties中设置：
server.port=8081

或在application.yml中设置：

server:
  port: 8081
  • 关闭占用端口的进程：通过系统命令（如在Windows下使用netstat -ano | findstr :端口号查看占用端口的进程ID，然后使用taskkill /pid 进程ID /f关闭进程；在Linux下使用lsof -i :端口号查看进程，使用kill -9 进程ID关闭进程）找到并关闭占用该端口的应用程序。
  • 使用随机端口：将server.port设置为0，此时Spring Boot会随机分配一个可用的端口。不过这种方式在需要明确访问端口的场景下不太适用，一般用于测试环境或对端口没有固定要求的情况。
9.3.3 自动配置冲突

Spring Boot的自动配置机制会根据类路径下的依赖和配置属性，自动配置应用所需的各种组件。但当多个自动配置类都尝试配置同一组件，或者自动配置类与开发者自定义配置产生冲突时，就会出现自动配置冲突问题。例如，同时引入了两个不同的数据访问框架依赖，它们各自的自动配置类都想配置数据源相关组件，就可能导致冲突。

解决方案：

  • 使用@SpringBootApplication的exclude属性：在@SpringBootApplication注解中，通过exclude属性排除不需要的自动配置类。比如，不想使用Spring Boot默认的数据库连接池自动配置，可以这样写：
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
  • 使用条件注解控制：利用@ConditionalOnMissingBean、@ConditionalOnClass、@ConditionalOnProperty等条件注解，明确指定Bean创建的条件，避免冲突。例如，只有当类路径中不存在特定的数据源实现类时，才创建自定义的数据源Bean：
@Configuration
public class MyDataSourceConfig {
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource customDataSource() {
        // 自定义数据源创建逻辑
    }
}
  • 检查并排除冲突依赖：查看项目的依赖树，找出导致冲突的依赖项，通过exclusions排除不必要的依赖。例如，在Maven项目中：
<dependency>
    <groupId>com.examplegroupId>
    <artifactId>example-dependencyartifactId>
    <version>1.0.0version>
    <exclusions>
        <exclusion>
            <groupId>冲突依赖的groupIdgroupId>
            <artifactId>冲突依赖的artifactIdartifactId>
        exclusion>
    exclusions>
dependency>
9.3.4 类路径问题

类路径问题主要包括缺少必要的依赖类，或者依赖类的版本不兼容，从而导致ClassNotFoundException或NoClassDefFoundError等异常。例如，项目中使用了某个第三方库的特定功能，但没有引入对应的依赖；或者引入的多个依赖之间存在版本冲突，导致某些类无法正确加载。

解决方案：

  • 检查并添加缺失依赖：仔细查看异常信息中提示缺失的类，确定对应的依赖库，然后在项目的构建文件（如Maven的pom.xml或Gradle的build.gradle）中添加正确的依赖。比如，在Maven项目中添加Jackson依赖：
<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.13.0version>
dependency>
  • 解决依赖版本冲突：使用dependencyManagement统一管理依赖版本，避免不同依赖引入不一致的版本。例如，在Maven的pom.xml中：
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.examplegroupId>
            <artifactId>common-dependencyartifactId>
            <version>1.0.0version>
        dependency>
    dependencies>
dependencyManagement>

或者通过exclusions排除冲突版本的依赖，再手动引入正确版本的依赖。

  • 清理并重建项目：有时类路径问题可能是由于项目构建缓存导致的，可以尝试清理项目的构建缓存（如在IDEA中使用File -> Invalidate Caches / Restart），然后重新构建项目，确保类路径正确更新。
9.3.5 配置错误

配置错误涵盖多种情况，包括配置文件格式错误、属性值类型不匹配、属性名拼写错误、配置层级结构混乱等。在Spring Boot中，配置信息通常从application.properties、application.yml等文件加载，并通过@ConfigurationProperties等机制绑定到Java类中。

例如，在application.yml文件中，错误地缩进配置层级：

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

这里url、username、password的缩进与datasource同级，不符合YAML格式要求，会导致解析错误。

又如，属性值类型不匹配的情况：

myapp:
  max-connections: "ten"

假设MyAppConfig类中max-connections对应的属性是int类型，那么将字符串"ten"绑定到int类型属性时就会失败。

解决方案：

  • 检查配置文件格式：确保application.properties和application.yml文件的格式正确。对于application.yml，严格遵循YAML的缩进规则，每个层级的缩进保持一致；对于application.properties，属性名和值之间使用正确的=分隔，且不包含非法字符。可以借助IDE的语法检查功能，及时发现格式错误。
  • 验证属性值类型：仔细核对配置文件中的属性值类型是否与配置类中定义的属性类型相匹配。如果需要进行类型转换，确保转换的可行性。例如，将字符串转换为Date类型时，可以使用@DateTimeFormat注解进行格式化转换。
  • 修正属性名拼写：认真检查属性名的拼写，确保与配置类中的@ConfigurationProperties注解的prefix和属性名一致。对于复杂的配置类，可以使用IDE的重构功能修改属性名，避免手动修改导致的拼写错误。
  • 使用配置验证：利用@Validated注解对配置类进行验证。在配置类的属性上添加验证注解，如@NotNull、@Min、@Max等，在配置绑定完成后，Spring会自动对配置进行验证，若不满足验证条件，则会抛出异常，提示配置错误信息。例如：
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 {
    @NotBlank
    private String name;
    @NotNull
    @Positive
    private int age;

    // 省略getter和setter
}

这样当配置中的name为空字符串，或者age为负数或null时，就会在启动时抛出验证异常，帮助开发者快速定位配置错误。

9.3.6 数据库连接失败

数据库连接失败是Spring Boot应用启动时常见的问题之一，主要原因包括数据库URL错误、用户名密码错误、数据库驱动版本不兼容、数据库服务未启动等。

例如，数据库URL中的IP地址、端口号、数据库名称写错：

spring:
  datasource:
    url: jdbc:mysql://192.168.1.100:3307/mydb
    username: root
    password: 123456

如果实际的数据库IP是192.168.1.101，或者端口是3306，就会导致连接失败。

又或者使用的数据库驱动版本与数据库不兼容，比如使用较旧的MySQL驱动连接新版本的MySQL数据库，可能会出现不支持的协议等问题。

解决方案：

  • 检查数据库配置：仔细核对application.properties或application.yml中的数据库连接配置，确保数据库URL、用户名、密码正确无误。可以尝试使用数据库客户端工具（如Navicat、DBeaver）连接数据库，验证配置信息是否能正常连接。
  • 更新数据库驱动：根据所使用的数据库版本，选择合适的数据库驱动版本。在Maven或Gradle项目中，更新对应的依赖版本。例如，对于MySQL数据库，在Maven项目中：

解决方案：

  • 更新数据库驱动：根据所使用的数据库版本，选择合适的数据库驱动版本。在Maven或Gradle项目中，更新对应的依赖版本。例如，对于MySQL数据库，在Maven项目中：
<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>8.0.26version> 
dependency>

如果使用的是HikariCP连接池（Spring Boot默认），确保其版本与数据库驱动兼容。例如，HikariCP 4.x版本与MySQL Connector/J 8.x兼容。

  • 检查数据库服务状态：确认数据库服务已启动且正常运行。可以通过系统服务管理工具（如Windows服务、Linux的systemctl命令）检查数据库服务状态。例如，在Linux上检查MySQL服务状态：
systemctl status mysql

如果服务未启动，使用相应命令启动服务：

systemctl start mysql

  • 验证网络连接：确保应用服务器能够访问数据库服务器，检查网络连接是否正常，防火墙是否放行数据库端口。例如，MySQL默认使用3306端口，需要确保该端口在防火墙中是开放的。

  • 配置连接属性：在数据库URL中添加必要的连接参数，如字符集、时区等。例如，对于MySQL：

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

其中，useUnicode和characterEncoding确保字符集正确，useSSL设置是否使用SSL连接，serverTimezone设置时区以避免时间相关问题。

  • 使用连接测试工具：可以编写简单的测试代码，单独测试数据库连接，排除Spring Boot应用本身的问题。例如：
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();
        }
    }
}
9.3.7 组件扫描问题

Spring Boot通过组件扫描（Component Scanning）自动发现并注册应用中的组件（如@Component、@Service、@Repository等注解标注的类）。当组件扫描配置不正确时，可能导致组件未被正确注册，从而在运行时出现NoSuchBeanDefinitionException等异常。

常见原因：

  • 组件类不在@SpringBootApplication（或@ComponentScan）指定的扫描包路径下。默认情况下，Spring Boot会扫描@SpringBootApplication所在类的同级包及其子包。
  • 自定义了@ComponentScan注解，排除了需要扫描的包或类。
  • 使用了错误的包名或类名。

解决方案：

  • 调整扫描路径：确保组件类位于@SpringBootApplication所在类的同级包或子包中，或者通过@ComponentScan显式指定扫描路径。例如：
@SpringBootApplication
@ComponentScan(basePackages = "com.example.myapp")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

这里指定了扫描com.example.myapp包及其子包。

  • 检查排除配置：如果使用了@ComponentScan的excludeFilters属性，确保没有错误地排除了需要的组件。例如：
@ComponentScan(excludeFilters = {
    @ComponentScan.Filter(type = FilterType.REGEX, pattern = "com.example.myapp.excluded.*")
})

确保正则表达式或其他过滤条件不会意外排除关键组件。

  • 使用明确的组件注册：对于无法通过组件扫描自动发现的组件，可以通过@Configuration类和@Bean方法手动注册。例如：
@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}
9.3.8 依赖注入问题

依赖注入是Spring框架的核心特性之一，但在实际应用中可能会遇到各种问题，如循环依赖、注入类型不匹配、找不到合适的Bean等。

常见问题及解决方案：

  • 循环依赖：当两个或多个Bean之间存在循环依赖关系时，Spring容器在创建这些Bean时会陷入无限循环，导致BeanCurrentlyInCreationException异常。例如：
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;

    // 构造函数或方法使用serviceB
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;

    // 构造函数或方法使用serviceA
}

解决方案：

  • 重构代码：重新设计类的结构，消除循环依赖。例如，提取公共逻辑到一个新的类中，让两个类都依赖于这个新类。
  • 使用Setter注入或字段注入：将构造函数注入改为Setter注入或字段注入，允许Spring在Bean创建后再设置依赖。不过这种方法只是掩盖了设计问题，并没有真正解决它。
  • 使用@Lazy注解：在其中一个依赖上使用@Lazy注解，延迟加载该依赖，直到实际使用时才创建。例如：
@Service
public class ServiceA {
    private final ServiceB serviceB;

    @Autowired
    public ServiceA(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}
  • 注入类型不匹配：当注入的目标类型与实际Bean的类型不匹配时，会抛出BeanNotOfRequiredTypeException异常。例如：
@Service
public class MyService {
    // 业务逻辑
}

@Service
public class MyController {
    @Autowired
    private AnotherService myService; // 类型不匹配，AnotherService与MyService不兼容
}

解决方案：

  • 检查注入点的类型声明，确保与实际Bean的类型一致。

  • 如果需要注入接口的实现类，确保实现类正确实现了该接口，并且在容器中注册为该接口类型的Bean。

  • 找不到合适的Bean：当没有找到符合条件的Bean时，会抛出NoSuchBeanDefinitionException异常。例如：

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

解决方案：

  • 确保MyRepository类被正确标注为@Repository或其他组件注解，并且在组件扫描路径内。
  • 检查是否存在拼写错误或包路径问题。
  • 如果是自定义的Bean，确保在配置类中通过@Bean方法正确注册。
9.3.9 版本冲突问题

在Spring Boot应用中，版本冲突是常见的问题，特别是当引入多个第三方依赖时，可能会导致依赖库的不同版本之间存在兼容性问题。例如，不同的依赖可能引用了同一库的不同版本，导致类加载冲突或方法调用异常。

常见症状：

  • NoClassDefFoundError或ClassNotFoundException：表示找不到某个类，可能是因为依赖版本不一致导致某些类被覆盖或缺失。
  • NoSuchMethodError：表示调用了不存在的方法，通常是由于依赖库版本不兼容，方法签名发生了变化。
  • 运行时异常：如IllegalArgumentException、NullPointerException等，可能是由于不同版本的库行为不一致导致的。

解决方案：

  • 查看依赖树：使用Maven或Gradle的依赖树命令查看项目的依赖结构，找出冲突的依赖。例如，在Maven中使用：
mvn dependency:tree

在Gradle中使用：

gradle dependencies
  • 统一依赖版本：使用dependencyManagement（Maven）或resolutionStrategy（Gradle）统一管理依赖版本，确保同一库只使用一个版本。例如，在Maven的pom.xml中：
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-coreartifactId>
            <version>5.3.18version>
        dependency>
    dependencies>
dependencyManagement>
  • 排除冲突依赖：在依赖声明中排除冲突的传递依赖。例如：
<dependency>
    <groupId>com.examplegroupId>
    <artifactId>example-libraryartifactId>
    <version>1.0.0version>
    <exclusions>
        <exclusion>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-coreartifactId>
        exclusion>
    exclusions>
dependency>
  • 使用Spring Boot的依赖管理：Spring Boot的spring-boot-starter-parent提供了一组默认的依赖版本，这些版本经过了测试，相互兼容。尽量使用Spring Boot推荐的版本，避免手动指定版本号，除非必要。
9.3.10 初始化Bean失败

当Bean的初始化过程中发生错误时，会导致应用启动失败。常见的原因包括：

  • Bean的构造函数或初始化方法抛出异常。
  • Bean依赖的其他组件未正确初始化。
  • Bean的配置属性无效或不完整。

解决方案：

  • 检查初始化方法：确保@PostConstruct注解的方法或InitializingBean接口的afterPropertiesSet方法没有抛出异常。例如：
@Service
public class MyService implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑，确保不会抛出异常
    }
}

  • 检查依赖组件：确保Bean依赖的其他组件已经正确初始化。可以通过日志或调试工具查看初始化顺序，找出依赖关系中的问题。

  • 验证配置属性：确保注入到Bean中的配置属性有效且完整。可以使用@Validated注解和JSR-303验证注解对配置属性进行验证。

  • 使用@DependsOn注解：如果Bean之间存在隐式依赖关系，可以使用@DependsOn注解显式指定依赖顺序。例如：

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

这里确保dataSource Bean在MyService之前初始化。

9.4 调试技巧

当遇到Spring Boot应用启动失败的问题时，可以使用以下调试技巧来快速定位和解决问题：

9.4.1 启用调试日志

在application.properties或application.yml中添加以下配置，启用Spring的调试日志：

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

或在application.yml中：

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

这样可以获得更详细的启动过程日志，帮助分析问题所在。

9.4.2 使用断点调试

在IDE中设置断点，逐步调试应用的启动过程。特别是在SpringApplication.run()方法和关键组件的初始化方法中设置断点，观察变量值和执行流程，找出异常发生的位置。

9.4.3 使用--debug参数

在启动应用时添加--debug参数，可以启用调试模式，输出更多的调试信息：

java -jar myapp.jar --debug
9.4.4 禁用自动配置

如果怀疑某个自动配置类导致了问题，可以使用@SpringBootApplication的exclude属性暂时禁用该自动配置类，观察应用是否能正常启动：

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
9.4.5 使用条件断点

在复杂的应用中，可以使用条件断点，只在满足特定条件时暂停执行。例如，在异常抛出的代码行设置条件断点，当特定的异常类型或条件满足时触发断点。

9.4.6 检查环境配置

确保应用运行的环境配置正确，包括系统变量、环境变量、配置文件等。可以使用以下代码在应用启动时打印当前的环境配置：

@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());
    }
}

9.5 总结

Spring Boot应用启动失败可能由多种原因导致，包括配置错误、依赖问题、组件扫描问题、数据库连接问题等。通过深入理解Spring Boot的启动机制和常见错误模式，结合有效的调试技巧，可以快速定位和解决启动问题。

在排查问题时，建议按照以下步骤进行：

  1. 查看详细的错误日志，确定异常类型和错误信息。
  2. 分析可能的原因，如配置错误、依赖冲突、组件缺失等。
  3. 使用调试工具和技巧，逐步定位问题所在。
  4. 针对具体问题，采取相应的解决方案，如修正配置、调整依赖版本、修改代码结构等。
  5. 验证解决方案的有效性，确保应用能够正常启动。

通过不断积累经验和掌握有效的排查方法，可以更加高效地解决Spring Boot应用启动过程中遇到的各种问题。

你可能感兴趣的:(SpringBoot框架详解,spring,boot,后端,java,spring,restful)

  • 移动端城市区县二级联动选择功能实现包 good2know
    本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
  • SpringMVC执行流程（原理），通俗易懂 国服冰 SpringMVCspringmvc
    SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
  • 深入解析JVM工作原理：从字节码到机器指令的全过程
    一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
  • Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程 倾听铃的声 后端springjavamvc开发语言分布式
    前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
  • JVM 内存模型深度解析：原子性、可见性与有序性的实现 练习时长两年半的程序员小胡 JVM深度剖析：从面试考点到生产实践jvmjava内存模型
    在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
  • Flowable 高级扩展：自定义元素与性能优化实战 练习时长两年半的程序员小胡 Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
    在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
  • Java | 多线程经典问题 - 售票 Ada54
    一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
  • SpringMVC的执行流程
    1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
  • 2018-09-27 aop相关 蒋超_58dc
    1.静态织入，需要使用aspectj专用的compilermaven工程可以采用：https://www.mojohaus.org/aspectj-maven-plugin/2.动态织入，配合spring，创建代理来执行3.
  • JAVA接口机结构解析 秃狼 SpringBoot八股文Javajava学习
    什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
  • 最新阿里四面面试真题46道：面试技巧+核心问题+面试心得 风平浪静如码
    前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
  • LVS+Keepalived实现高可用和负载均衡 2401_84412895 程序员lvs负载均衡运维
    2、开启网卡子接口配置VIP[root@a~]#cd/etc/sysconfig/network-scripts/[root@anetwork-scripts]#cp-aifcfg-ens32ifcfg-ens32:0[root@anetwork-scripts]#catifcfg-ens32:0BOOTPROTO=staticDEVICE=ens32:0ONBOOT=yesIPADDR=10.1
  • 图论算法经典题目解析：DFS、BFS与拓扑排序实战 周童學 数据结构与算法深度优先算法图论
    图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
  • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge 本本本添哥 002-进阶开发能力java
    一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五) bug菌¹ Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
  • Java 队列 tryxr java开发语言队列
    队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
  • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
    在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
  • 代码随想录算法训练营第三十五天
    01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
  • Android 应用权限管理详解
    文章目录1.权限类型2.权限请求机制3.权限组和分级4.权限管理的演进5.权限监控和SELinux强制访问控制6.应用权限审核和GooglePlayProtect7.开发者最佳实践8.用户权限管理9.Android应用沙箱模型10.ScopedStorage（分区存储）11.背景位置权限（BackgroundLocationAccess）12.权限回收和自动清理13.权限请求的用户体验设计14.G
  • uniapp微信小程序 - 详解微信小程序平台用户授权登录全流程，uniapp v3版本中小程序端开发下用户点击登录后获取手机号/昵称/性别/头像等信息完成登录（提供完整示例代码，一键复制开箱即用） 十一猫咪爱养鱼 前端组件与功能(开箱即用)uniapp常见问题解决uniappvue3uniapp3小程序授权登录微信小程序登录获取用户信息教程获取用户昵称手机号头像信息登录vue3版本小程序平台授权登录uniap小程序端用户登录流程uni完整的小程序平台登录源码
    效果图在uniapp微信小程序端开发中，超详细实现用户授权登录完整功能源码，用户授权后获取手机号/昵称/头像/性别等，提供完整思路流程及逻辑讲解。uniappVue3和Vue2都能用，你也可以直接复制粘贴，然后改下参数放到你的项目中去就行。整体思路做功能之前，先来看一下整体流程是
  • Selenium 特殊控件操作与 ActionChains 实践详解 小馋喵知识杂货铺 selenium测试工具
    1.下拉框单选操作(a)使用SeleniumSelect类（标准HTML标签）Selenium提供了内置的Select类用于操作标准下拉框，这种方式简单且直观。fromselenium.webdriver.support.uiimportSelect#定位下拉框dropdown=Select(driver.find_element("id","dropdown_id"))#通过以下三种方式选择单个
  • DPDK 技术详解：榨干网络性能的“瑞士军刀”
    你是否曾感觉，即使拥有顶级的服务器和万兆网卡，你的网络应用也总是“喂不饱”硬件，性能总差那么一口气？传统的网络处理方式，就像在高速公路上设置了太多的收费站和检查点，限制了数据包的“奔跑”速度。今天，我们要深入探讨一个能够打破这些瓶颈，让你的网络应用快到飞起的“黑科技”——DPDK(DataPlaneDevelopmentKit，数据平面开发套件)。这不仅仅是一个工具包，更是一种全新的网络处理哲学。
  • 微信公众号回调java_处理微信公众号消息回调 weixin_39607620 微信公众号回调java
    1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
  • Anaconda 和 Miniconda：功能详解与选择建议 古月฿ python入门pythonconda
    Anaconda和Miniconda详细介绍一、Anaconda的详细介绍1.什么是Anaconda？Anaconda是一个开源的包管理和环境管理工具，在数据科学、机器学习以及科学计算领域发挥着关键作用。它以Python和R语言为基础，为用户精心准备了大量预装库和工具，极大地缩短了搭建数据科学环境的时间。对于那些想要快速开展数据分析、模型训练等工作的人员来说，Anaconda就像是一个一站式的“数
  • [spring6: Mvc-网关]-源码解析
    推荐阅读：[spring6:Mvc-函数式编程]-源码解析GatewayServerMvcAutoConfiguration@AutoConfiguration(after={HttpClientAutoConfiguration.class,RestTemplateAutoConfiguration.class,RestClientAutoConfiguration.class,FilterAu
  • 学C++的五大惊人好处
    为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
  • Android 基础知识：Android 应用权限详解 流水mpc android
    这篇文章为大家系统的梳理一下Android权限相关的知识，在日常开发中，我们都用过权限，但是对于权限的一些细节我们可能掌握的还不够全面，这篇文章会全面的为大家介绍权限相关的知识。当然，本篇文章依然是参考了Google的官方文档：应用权限。本文目录一、认识Android权限（一）Android系统为什么需要权限？Android系统设置权限的目的是保护Android用户的隐私。对于用户的敏感数据And
  • 面试必考题：Android Binder 机制详解 大模型大数据攻城狮 androidbinder面试reactnativekotlindalvikretrofit
    目录第一章：Binder的基本概念什么是Binder？多角度解读Binder第二章：Binder的工作机制Binder的整体流程服务注册：从零到有的第一步服务查询：找到目标的“地图”服务调用：请求与响应的旅程Binder驱动的幕后功劳为什么Binder这么快？第三章：Binder在系统架构中的角色Activity：界面背后的通信枢纽Binder的角色实例分析Service：后台任务的跨进程支柱Bi
  • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】 Tony666688888 javawindows开发语言
    针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
  • 用代码生成艺术字：设计个性化海报的秘密
    本文围绕“用代码生成艺术字：设计个性化海报的秘密”展开，先概述代码生成艺术字在海报设计中的独特价值，接着介绍常用的代码工具（如HTML、CSS、JavaScript等），详细阐述从构思到实现的完整流程，包括字体样式设计、动态效果添加等，还分享了提升艺术字质感的技巧及实际案例。最后总结代码生成艺术字的优势，为设计师提供打造个性化海报的实用指南，助力提升海报设计的独特性与吸引力，符合搜索引擎SEO标准
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他