SpringBoot启动时执行自定义内容的5种方法

- [1. 使用CommandLineRunner或ApplicationRunner接口（推荐）](#1. 使用CommandLineRunner或ApplicationRunner接口（推荐）)
- - [1.1 CommandLineRunner](#1.1 CommandLineRunner)
  - [1.2 ApplicationRunner](#1.2 ApplicationRunner)
  - [1.3 控制执行顺序](#1.3 控制执行顺序)
- [2. 使用@PostConstruct注解](#2. 使用@PostConstruct注解)
- [3. 实现ApplicationListener监听启动事件](#3. 实现ApplicationListener监听启动事件)
- - [3.1 监听ApplicationReadyEvent](#3.1 监听ApplicationReadyEvent)
- [4. 使用InitializingBean接口](#4. 使用InitializingBean接口)
- [5. 在main方法中直接执行](#5. 在main方法中直接执行)
- 总结

在Spring Boot应用开发中，我们经常需要在应用启动时执行一些初始化逻辑，比如加载配置、初始化数据、启动后台任务等。Spring Boot提供了多种方式来实现这一需求，本文将详细介绍5种常用的方法，并分析它们的适用场景和优缺点。

1. 使用CommandLineRunner或ApplicationRunner接口（推荐）

Spring Boot专门提供了CommandLineRunner和ApplicationRunner接口，用于在应用启动后执行自定义逻辑。它们的区别在于参数传递方式不同：

1.1 CommandLineRunner

CommandLineRunner接收一个字符串数组（String... args），适合处理简单的命令行参数。

java 复制代码

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommandLineRunner implements CommandLineRunner {
    
    @Override
    public void run(String... args) throws Exception {
        System.out.println("应用启动后执行 - CommandLineRunner");
        // 可以在这里访问Spring容器中的Bean
    }
}

1.2 ApplicationRunner

ApplicationRunner接收ApplicationArguments对象，提供了更结构化的参数访问方式（如getOptionNames()、getNonOptionArgs()等）。

java 复制代码

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationRunner implements ApplicationRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("应用启动后执行 - ApplicationRunner");
        // 可以访问命令行参数
        if (args.containsOption("debug")) {
            System.out.println("Debug模式已启用");
        }
    }
}

1.3 控制执行顺序

如果有多个Runner，可以使用@Order注解或实现Ordered接口来控制执行顺序：

java 复制代码

@Component
@Order(1)  // 数字越小，优先级越高
public class FirstRunner implements CommandLineRunner {
    @Override
    public void run(String... args) {
        System.out.println("第一个Runner执行");
    }
}

@Component
@Order(2)
public class SecondRunner implements CommandLineRunner {
    @Override
    public void run(String... args) {
        System.out.println("第二个Runner执行");
    }
}

适用场景：

需要在应用完全启动后执行初始化逻辑（如加载数据、启动后台任务）。
需要访问Spring容器中的Bean。

优点：

官方推荐，专为启动后执行设计。
支持执行顺序控制。

缺点：

无法在Bean初始化阶段执行。

2. 使用@PostConstruct注解

@PostConstruct是JSR-250标准注解，用于标记在Bean初始化完成后执行的方法。

java 复制代码

import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class MyPostConstructBean {
    
    @PostConstruct
    public void init() {
        System.out.println("Bean初始化后执行 - @PostConstruct");
        // 可以在这里执行初始化逻辑
    }
}

适用场景：

需要在单个Bean初始化完成后执行逻辑（如数据库连接测试、缓存预热）。

优点：

简单易用，适用于单个Bean的初始化。

缺点：

无法控制多个Bean的执行顺序。
执行时机较早（在Bean初始化后，但应用可能还未完全启动）。

3. 实现ApplicationListener监听启动事件

Spring Boot提供了多种事件，如ApplicationReadyEvent（应用完全启动后触发）、ApplicationStartedEvent（应用启动后但未处理请求时触发）等。

3.1 监听ApplicationReadyEvent

java 复制代码

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationReadyEvent> {
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("应用完全启动后执行 - ApplicationReadyEvent");
        // 可以在这里执行应用启动后的逻辑
    }
}

适用场景：

需要在应用完全启动后执行逻辑（如发送启动完成通知）。

优点：

精确控制执行时机（应用完全启动后）。

缺点：

代码稍显冗长，不如CommandLineRunner简洁。

4. 使用InitializingBean接口

InitializingBean是Spring提供的接口，其afterPropertiesSet()方法会在Bean属性设置完成后执行。

java 复制代码

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class MyInitializingBean implements InitializingBean {
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean属性设置后执行 - InitializingBean");
        // 可以在这里执行初始化逻辑
    }
}

适用场景：

需要在Bean属性设置完成后执行逻辑（如校验配置）。

优点：

适用于单个Bean的初始化。

缺点：

执行时机较早（在Bean初始化阶段）。
不如@PostConstruct简洁。

5. 在main方法中直接执行

如果逻辑非常简单，可以直接在main方法中执行：

java 复制代码

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        System.out.println("Spring Boot启动前执行");
        
        SpringApplication.run(MyApplication.class, args);
        
        System.out.println("Spring Boot启动过程完成后执行");
        // 注意：这里的代码会在Spring Boot启动后立即执行，但不一定是所有Bean都初始化完成
    }
}

适用场景：

极简单的初始化逻辑（如打印日志）。

优点：

无需额外代码。

缺点：

无法保证所有Bean都已初始化。
不推荐用于复杂逻辑。

总结

方法	适用场景	执行时机	优点	缺点
CommandLineRunner/ApplicationRunner	应用启动后执行初始化逻辑	应用完全启动后	官方推荐，支持顺序控制	无法在Bean初始化阶段执行
@PostConstruct	单个Bean初始化后执行逻辑	Bean初始化后	简单易用	无法控制多个Bean的执行顺序
ApplicationListener	应用完全启动后执行逻辑	应用完全启动后	精确控制执行时机	代码稍显冗长
InitializingBean	单个Bean属性设置后执行逻辑	Bean属性设置后	适用于单个Bean	执行时机较早
main方法直接执行	极简单的初始化逻辑	Spring Boot启动后	无需额外代码	无法保证所有Bean初始化

推荐选择：

需要应用完全启动后执行逻辑 → 使用CommandLineRunner或ApplicationRunner（推荐）。
需要在单个Bean初始化后执行逻辑 → 使用@PostConstruct。
需要精确控制执行时机 → 使用ApplicationListener监听ApplicationReadyEvent。

希望本文能帮助你选择最适合的方式，在Spring Boot启动时执行自定义逻辑！ 🚀