在 Spring Boot 中，服务启动后执行代码的常见方法

在 Spring Boot 中，服务启动后执行代码的常见方法有以下几种：

---

1. 使用 CommandLineRunner 接口

CommandLineRunner 是 Spring Boot 提供的一个接口，可以在应用启动后执行一些代码。

实现步骤：

1. 创建一个类并实现 CommandLineRunner 接口。
2. 重写 run 方法，在方法中编写需要执行的代码。
3. 将该类注册为 Spring Bean。

示例代码：

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

@Component
public class MyStartupRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("应用启动后执行代码 - CommandLineRunner");
        // 在这里编写需要执行的代码
    }
}

特点：

• run 方法会在应用启动后执行。
• 可以通过 args 参数获取命令行参数。

---

2. 使用 ApplicationRunner 接口

ApplicationRunner 是 CommandLineRunner 的增强版，支持更复杂的参数处理。

实现步骤：

1. 创建一个类并实现 ApplicationRunner 接口。
2. 重写 run 方法，在方法中编写需要执行的代码。
3. 将该类注册为 Spring Bean。

示例代码：

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

@Component
public class MyStartupRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("应用启动后执行代码 - ApplicationRunner");
        // 在这里编写需要执行的代码
    }
}

特点：

• run 方法会在应用启动后执行。
• 可以通过 ApplicationArguments 获取更丰富的命令行参数。

---

3. 使用 @PostConstruct 注解

@PostConstruct 是 JSR-250 提供的注解，用于在 Bean 初始化完成后执行代码。

实现步骤：

1. 在需要执行代码的方法上添加 @PostConstruct 注解。
2. 确保该方法所在的类是一个 Spring Bean。

示例代码：

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

@Component
public class MyStartupRunner {

    @PostConstruct
    public void init() {
        System.out.println("应用启动后执行代码 - @PostConstruct");
        // 在这里编写需要执行的代码
    }
}

特点：

• 方法会在 Bean 初始化完成后执行。
• 适用于需要在 Bean 初始化时执行的逻辑。

---

4. 使用 @EventListener 监听 ApplicationReadyEvent

Spring Boot 提供了多种应用事件，可以通过监听这些事件来执行代码。ApplicationReadyEvent 表示应用已启动完成。

实现步骤：

1. 创建一个方法并添加 @EventListener 注解。
2. 将 ApplicationReadyEvent 作为方法参数。

示例代码：

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

@Component
public class MyStartupRunner {

    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady() {
        System.out.println("应用启动后执行代码 - @EventListener");
        // 在这里编写需要执行的代码
    }
}

特点：

• 方法会在应用完全启动后执行。
• 适合需要在所有 Bean 初始化完成后执行的逻辑。

---

5. 使用 SmartLifecycle 接口

SmartLifecycle 是 Spring 提供的一个接口，可以控制 Bean 的生命周期，并在应用启动或停止时执行代码。

实现步骤：

1. 创建一个类并实现 SmartLifecycle 接口。
2. 重写 start 方法，在方法中编写需要执行的代码。
3. 将该类注册为 Spring Bean。

示例代码：

import org.springframework.context.SmartLifecycle;
import org.springframework.stereotype.Component;

@Component
public class MyStartupRunner implements SmartLifecycle {

    private boolean running = false;

    @Override
    public void start() {
        System.out.println("应用启动后执行代码 - SmartLifecycle");
        // 在这里编写需要执行的代码
        running = true;
    }

    @Override
    public void stop() {
        System.out.println("应用停止时执行代码");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

特点：

• 可以精确控制 Bean 的启动和停止行为。
• 适合需要实现复杂生命周期管理的场景。

---

6. 使用 InitializingBean 接口

InitializingBean 是 Spring 提供的一个接口，可以在 Bean 初始化完成后执行代码。

实现步骤：

1. 创建一个类并实现 InitializingBean 接口。
2. 重写 afterPropertiesSet 方法，在方法中编写需要执行的代码。
3. 将该类注册为 Spring Bean。

示例代码：

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

@Component
public class MyStartupRunner implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("应用启动后执行代码 - InitializingBean");
        // 在这里编写需要执行的代码
    }
}

特点：

• 方法会在 Bean 初始化完成后执行。
• 适用于需要在 Bean 初始化时执行的逻辑。

---

7. 使用 @Bean 注解的 initMethod 属性

在定义 Bean 时，可以通过 @Bean 注解的 initMethod 属性指定初始化方法。

实现步骤：

1. 在配置类中定义 Bean，并指定 initMethod。
2. 在目标类中定义初始化方法。

示例代码：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {

    @Bean(initMethod = "init")
    public MyStartupRunner myStartupRunner() {
        return new MyStartupRunner();
    }
}

public class MyStartupRunner {

    public void init() {
        System.out.println("应用启动后执行代码 - initMethod");
        // 在这里编写需要执行的代码
    }
}

特点：

• 方法会在 Bean 初始化完成后执行。
• 适合在配置类中定义 Bean 时使用。

---

8. 使用 SpringApplication.run() 的返回值

在 main 方法中，可以通过 SpringApplication.run() 的返回值获取 ApplicationContext，然后执行代码。

示例代码：

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

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
        // 在这里编写需要执行的代码
        System.out.println("应用启动后执行代码 - SpringApplication.run()");
    }
}

特点：

• 方法会在应用启动后立即执行。
• 适合在 main 方法中执行简单的启动逻辑。

---

总结

方法	特点
CommandLineRunner	简单易用，适合执行启动任务。
ApplicationRunner	支持更复杂的参数处理。
@PostConstruct	适用于 Bean 初始化时执行的逻辑。
@EventListener	监听应用事件，适合在应用完全启动后执行代码。
SmartLifecycle	精确控制 Bean 的生命周期，适合复杂场景。
InitializingBean	适用于 Bean 初始化时执行的逻辑。
@Bean 的 initMethod 属性	适合在配置类中定义 Bean 时使用。
SpringApplication.run()	适合在 main 方法中执行简单的启动逻辑。

根据具体需求选择合适的方法。如果需要简单的启动任务，推荐使用 CommandLineRunner 或 ApplicationRunner；如果需要更复杂的生命周期管理，可以使用 SmartLifecycle 或 @EventListener。