服务端开发

Appearance

SpringApplication：Spring Boot 应用的启动引擎 🚀 ​

什么是 SpringApplication？ ​

SpringApplication 是 Spring Boot 的核心启动类，它就像是一个智能的应用程序启动器。想象一下，如果你要开一家餐厅，你需要准备食材、安排厨师、布置餐桌、开启营业灯牌等等。SpringApplication 就是那个帮你统筹安排这一切的总管，让你的 Spring Boot 应用能够顺利启动并开始工作。

NOTE

SpringApplication 不仅仅是一个简单的启动工具，它是 Spring Boot "约定优于配置"哲学的完美体现，帮助开发者用最少的代码启动功能完整的应用程序。

为什么需要 SpringApplication？ ​

在传统的 Spring 应用中，启动一个应用需要：

  • 手动创建 ApplicationContext
  • 配置各种环境参数
  • 处理异常情况
  • 管理应用生命周期

这些繁琐的工作现在都由 SpringApplication 来处理，让开发者可以专注于业务逻辑。

基础用法：一行代码启动应用 ​

最简单的使用方式就是调用静态方法 SpringApplication.run()：

kotlin
@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    SpringApplication.run(MyApplication::class.java, *args) 
}
kotlin
@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) 
}

当应用启动时，你会看到类似这样的输出：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

 :: Spring Boot ::                (v3.5.0)

2025-05-22T20:16:15.517Z  INFO 135939 --- [main] MyApplication : Starting MyApplication...
2025-05-22T20:16:23.155Z  INFO 135939 --- [main] MyApplication : Started MyApplication in 10.558 seconds

启动失败处理：智能错误诊断 🔍 ​

Spring Boot 内置了智能的错误分析器（FailureAnalyzer），当应用启动失败时，会提供清晰的错误信息和解决建议。

端口冲突示例 ​

***************************
APPLICATION FAILED TO START
***************************

Description:
Embedded servlet container failed to start. Port 8080 was already in use.

Action:
Identify and stop the process that is listening on port 8080 or configure this application to listen on another port.

TIP

如果内置的错误分析器无法处理异常，你可以通过启用 debug 模式来获取更详细的信息：

bash
java -jar myproject-0.0.1-SNAPSHOT.jar --debug

懒加载初始化：提升启动速度 ⚡ ​

懒加载是一种优化策略，让 Bean 在真正需要时才创建，而不是在应用启动时全部创建。

配置懒加载 ​

properties
spring.main.lazy-initialization=true
yaml
spring:
  main:
    lazy-initialization: true

懒加载的利弊分析 ​

优势

  • 启动速度更快：减少启动时需要初始化的 Bean 数量
  • 内存占用更少：只加载必要的组件

注意事项

  • 问题发现延迟：配置错误的 Bean 可能在运行时才暴露
  • 内存规划：需要确保 JVM 有足够内存容纳所有 Bean
  • 不适合生产环境：建议仅在开发阶段使用

选择性禁用懒加载 ​

kotlin
@Component
@Lazy(false) 
class CriticalService {
    // 这个服务会在启动时立即初始化
}

自定义 Banner：个性化启动画面 🎨 ​

自定义 Banner 文件 ​

在 src/main/resources 目录下创建 banner.txt 文件：

 __  __         _                _ _           _   _             
|  \/  |_   _  / \   _ __  _ __ | (_) ___ __ _| |_(_) ___  _ __  
| |\/| | | | |/ _ \ | '_ \| '_ \| | |/ __/ _` | __| |/ _ \| '_ \ 
| |  | | |_| / ___ \| |_) | |_) | | | (_| (_| | |_| | (_) | | | |
|_|  |_|\__, /_/   \_\ .__/| .__/|_|_|\___\__,_|\__|_|\___/|_| |_|
        |___/        |_|   |_|                                   

应用版本: ${application.version}
Spring Boot 版本: ${spring-boot.version}
变量描述
${application.version}应用程序版本号
${application.formatted-version}格式化的版本号 (v1.0)
${spring-boot.version}Spring Boot 版本
${Ansi.NAME}ANSI 颜色代码

程序化控制 Banner ​

kotlin
@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) {
        setBannerMode(Banner.Mode.OFF) 
        // Banner.Mode.CONSOLE - 控制台输出
        // Banner.Mode.LOG - 日志输出  
        // Banner.Mode.OFF - 关闭
    }
}

SpringApplication 自定义配置 ⚙️ ​

基础自定义 ​

kotlin
@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    val application = SpringApplication(MyApplication::class.java)
    
    // 关闭 Banner
    application.setBannerMode(Banner.Mode.OFF) 
    
    // 设置默认配置文件
    application.setDefaultProperties(mapOf( 
        "server.port" to "9090",
        "spring.profiles.active" to "dev"
    ))
    
    // 启用懒加载
    application.setLazyInitialization(true) 
    
    application.run(*args)
}

使用 Kotlin DSL 风格 ​

kotlin
fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) { 
        setBannerMode(Banner.Mode.OFF)
        setLazyInitialization(true)
        setDefaultProperties(mapOf(
            "server.port" to "9090"
        ))
    }
}

Fluent Builder API：链式配置 🔗 ​

对于复杂的应用场景，可以使用 SpringApplicationBuilder 提供的流式 API：

kotlin
fun main(args: Array<String>) {
    SpringApplicationBuilder() 
        .sources(MyApplication::class.java)
        .bannerMode(Banner.Mode.OFF)
        .profiles("dev", "local")
        .properties("server.port=9090")
        .run(*args)
}

创建应用上下文层次结构 ​

kotlin
// 父子上下文结构
SpringApplicationBuilder()
    .sources(ParentConfig::class.java) 
    .child(ChildConfig::class.java)    
    .bannerMode(Banner.Mode.OFF)
    .run(*args)

WARNING

在创建上下文层次结构时，Web 组件必须包含在子上下文中，父子上下文使用相同的 Environment。

应用可用性状态管理 💓 ​

Spring Boot 提供了应用健康状态管理，特别适用于容器化部署（如 Kubernetes）。

生存状态（Liveness State） ​

生存状态表示应用是否能够正常工作或自我恢复：

kotlin
@Component
class MyLocalCacheVerifier(
    private val eventPublisher: ApplicationEventPublisher
) {
    
    fun checkLocalCache() {
        try {
            // 检查本地缓存
            performCacheCheck()
        } catch (ex: CacheCompletelyBrokenException) {
            // 发布生存状态变更事件 - 应用已损坏
            AvailabilityChangeEvent.publish( 
                eventPublisher, 
                ex, 
                LivenessState.BROKEN
            )
        }
    }
    
    private fun performCacheCheck() {
        // 缓存检查逻辑
    }
}

就绪状态（Readiness State） ​

就绪状态表示应用是否准备好处理流量：

kotlin
@Component
class MyReadinessStateExporter {
    
    @EventListener
    fun onStateChange(event: AvailabilityChangeEvent<ReadinessState>) { 
        when (event.state) {
            ReadinessState.ACCEPTING_TRAFFIC -> {
                // 创建健康检查文件
                createHealthFile("/tmp/healthy") 
            }
            ReadinessState.REFUSING_TRAFFIC -> {
                // 删除健康检查文件  
                removeHealthFile("/tmp/healthy") 
            }
        }
    }
    
    private fun createHealthFile(path: String) {
        // 创建文件逻辑
    }
    
    private fun removeHealthFile(path: String) {
        // 删除文件逻辑
    }
}

应用状态时序图 ​

应用事件和监听器 📡 ​

Spring Boot 在应用启动过程中会发布一系列事件，开发者可以监听这些事件来执行自定义逻辑。

应用启动事件序列 ​

自定义事件监听器 ​

kotlin
@Component
class ApplicationEventListener {
    
    @EventListener
    fun handleApplicationReady(event: ApplicationReadyEvent) { 
        println("🎉 应用已就绪，可以开始处理请求了！")
        // 执行应用就绪后的初始化工作
        initializeExternalConnections()
    }
    
    @EventListener  
    fun handleApplicationFailed(event: ApplicationFailedEvent) { 
        println("❌ 应用启动失败：${event.exception.message}")
        // 记录失败日志，发送告警等
        notifyAdministrators(event.exception)
    }
    
    private fun initializeExternalConnections() {
        // 初始化外部连接
    }
    
    private fun notifyAdministrators(exception: Throwable) {
        // 通知管理员
    }
}

早期事件监听器注册 ​

对于在 ApplicationContext 创建之前触发的事件，需要手动注册监听器：

kotlin
class EarlyEventListener : ApplicationListener<ApplicationStartingEvent> {
    override fun onApplicationEvent(event: ApplicationStartingEvent) {
        println("🚀 应用开始启动...")
    }
}

fun main(args: Array<String>) {
    val application = SpringApplication(MyApplication::class.java)
    application.addListeners(EarlyEventListener()) 
    application.run(*args)
}

Web 环境自动检测 🌐 ​

SpringApplication 会根据类路径中的依赖自动决定创建哪种类型的 ApplicationContext：

kotlin
// SpringApplication 的智能检测逻辑
when {
    // 如果存在 Spring MVC
    isSpringMvcPresent() -> AnnotationConfigServletWebServerApplicationContext()
    
    // 如果存在 Spring WebFlux（但没有 MVC）
    isSpringWebFluxPresent() -> AnnotationConfigReactiveWebServerApplicationContext()
    
    // 否则创建普通的应用上下文
    else -> AnnotationConfigApplicationContext()
}

手动指定 Web 应用类型 ​

kotlin
fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) {
        setWebApplicationType(WebApplicationType.NONE) 
        // WebApplicationType.SERVLET - Servlet Web 应用
        // WebApplicationType.REACTIVE - 响应式 Web 应用  
        // WebApplicationType.NONE - 非 Web 应用
    }
}

TIP

在 JUnit 测试中，通常建议设置 WebApplicationType.NONE 以提高测试速度。

访问应用参数 📝 ​

使用 ApplicationArguments ​

kotlin
@Component
class MyBean(private val args: ApplicationArguments) {
    
    @PostConstruct
    fun processArguments() {
        // 检查是否包含调试选项
        val debug = args.containsOption("debug") 
        
        // 获取非选项参数（文件名等）
        val files = args.nonOptionArgs 
        
        if (debug) {
            println("调试模式已启用，处理文件：$files")
        }
        
        // 如果使用 "--debug logfile.txt" 启动
        // 输出：调试模式已启用，处理文件：[logfile.txt]
    }
}

使用 @Value 注解 ​

kotlin
@Component
class ConfigComponent {
    
    @Value("\${app.name:MyApp}")  
    private lateinit var appName: String
    
    @Value("\${server.port:8080}") 
    private var serverPort: Int = 0
    
    fun printConfig() {
        println("应用名称：$appName")
        println("服务端口：$serverPort")
    }
}

启动时执行任务 🏃‍♂️ ​

CommandLineRunner vs ApplicationRunner ​

kotlin
@Component
class MyCommandLineRunner : CommandLineRunner {
    
    override fun run(vararg args: String) { 
        println("执行启动任务，参数：${args.contentToString()}")
        // 执行数据库初始化、缓存预热等任务
        initializeDatabase()
        warmupCache()
    }
    
    private fun initializeDatabase() {
        // 数据库初始化逻辑
    }
    
    private fun warmupCache() {
        // 缓存预热逻辑
    }
}
kotlin
@Component  
class MyApplicationRunner : ApplicationRunner {
    
    override fun run(args: ApplicationArguments) { 
        if (args.containsOption("init-data")) {
            println("检测到 init-data 参数，开始初始化数据...")
            initializeTestData()
        }
        
        val profiles = args.getOptionValues("spring.profiles.active")
        println("当前激活的配置文件：$profiles")
    }
    
    private fun initializeTestData() {
        // 测试数据初始化
    }
}

控制执行顺序 ​

kotlin
@Component
@Order(1) 
class FirstRunner : CommandLineRunner {
    override fun run(vararg args: String) {
        println("第一个执行的任务")
    }
}

@Component
@Order(2) 
class SecondRunner : CommandLineRunner {
    override fun run(vararg args: String) {
        println("第二个执行的任务")
    }
}

IMPORTANT

CommandLineRunner 和 ApplicationRunner 在应用启动完成但开始接受流量之前执行，非常适合执行初始化任务。

应用退出处理 🔚 ​

自定义退出码 ​

kotlin
@SpringBootApplication
class MyApplication {
    
    @Bean
    fun exitCodeGenerator() = ExitCodeGenerator { 42 } 
}

fun main(args: Array<String>) {
    exitProcess(SpringApplication.exit( 
        runApplication<MyApplication>(*args)
    ))
}

异常退出码 ​

kotlin
class CustomException(message: String) : RuntimeException(message), ExitCodeGenerator {
    override fun getExitCode(): Int = 1
}

@Component
class SomeService {
    fun doSomething() {
        if (criticalErrorOccurred()) {
            throw CustomException("严重错误发生") 
        }
    }
    
    private fun criticalErrorOccurred(): Boolean = true
}

管理功能和启动跟踪 📊 ​

启用管理功能 ​

properties
spring.application.admin.enabled=true

这会暴露 SpringApplicationAdminMXBean，允许远程管理应用。

应用启动跟踪 ​

kotlin
@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) {
        // 使用缓冲启动跟踪器
        applicationStartup = BufferingApplicationStartup(2048) 
    }
}

获取启动信息 ​

kotlin
@RestController
class StartupController(
    private val bufferingApplicationStartup: BufferingApplicationStartup
) {
    
    @GetMapping("/startup")
    fun getStartupInfo(): Map<String, Any> { 
        val steps = bufferingApplicationStartup.drainBufferedTimeline()
        return mapOf(
            "totalSteps" to steps.size,
            "steps" to steps.map { 
                mapOf(
                    "name" to it.name,
                    "duration" to it.duration.toMillis()
                )
            }
        )
    }
}

虚拟线程支持 🧵 ​

NOTE

虚拟线程是 Java 21+ 的新特性，可以显著提高并发性能。

启用虚拟线程 ​

properties
spring.threads.virtual.enabled=true
spring.main.keep-alive=true  # 防止 JVM 退出

虚拟线程注意事项 ​

重要提醒

  • 守护线程特性：虚拟线程是守护线程，可能导致 JVM 意外退出
  • 线程池配置失效：启用虚拟线程后，传统的线程池配置将不再生效
  • 性能监控：使用 JFR 或 jcmd 监控"固定虚拟线程"问题
kotlin
@Component
class VirtualThreadExample {
    
    @Async
    fun asyncTask() {
        // 这个方法将在虚拟线程中执行
        println("当前线程：${Thread.currentThread()}")
        // 输出类似：VirtualThread[#21]/runnable@ForkJoinPool-1-worker-1
    }
    
    @Scheduled(fixedRate = 5000) 
    fun scheduledTask() {
        // 定时任务也会在虚拟线程中执行
        println("定时任务执行中...")
    }
}

最佳实践总结 ✅ ​

1. 生产环境配置 ​

kotlin
@SpringBootApplication
class ProductionApplication

fun main(args: Array<String>) {
    runApplication<ProductionApplication>(*args) {
        // 生产环境建议关闭懒加载
        setLazyInitialization(false) 
        
        // 启用启动信息跟踪
        applicationStartup = BufferingApplicationStartup(1024) 
        
        // 设置默认配置
        setDefaultProperties(mapOf(
            "spring.main.log-startup-info" to "true",
            "spring.main.keep-alive" to "true"
        ))
    }
}

2. 开发环境配置 ​

kotlin
fun main(args: Array<String>) {
    runApplication<DevelopmentApplication>(*args) {
        // 开发环境可以启用懒加载提高启动速度
        setLazyInitialization(true) 
        
        // 自定义 Banner
        setBannerMode(Banner.Mode.CONSOLE) 
        
        setDefaultProperties(mapOf(
            "spring.profiles.active" to "dev",
            "logging.level.org.springframework" to "DEBUG"
        ))
    }
}

3. 测试环境配置 ​

kotlin
@TestConfiguration
class TestConfig {
    
    @Bean
    @Primary
    fun testSpringApplication(): SpringApplication {
        return SpringApplication().apply {
            setWebApplicationType(WebApplicationType.NONE) 
            setBannerMode(Banner.Mode.OFF) 
            setLazyInitialization(true) 
        }
    }
}

总结 ​

SpringApplication 是 Spring Boot 的核心，它将复杂的应用启动过程简化为几行代码。通过理解其工作原理和各种配置选项，我们可以：

  • 🚀 快速启动：用最少的代码启动功能完整的应用
  • 🔧 灵活配置：根据不同环境需求定制启动行为
  • 📊 监控管理：通过事件机制和健康检查管理应用状态
  • ⚡ 性能优化：利用懒加载、虚拟线程等特性提升性能
  • 🛡️ 错误处理：智能的错误诊断和恢复机制

SpringApplication 体现了 Spring Boot "开箱即用"的设计理念，让开发者能够专注于业务逻辑而不是基础设施的搭建。掌握了 SpringApplication，你就掌握了 Spring Boot 应用的启动密码！ 🎯