spring启动时只执行一次的方法实现

jakeswang

已于 2025-04-03 13:28:24 修改

阅读量8.4k

点赞数 3

分类专栏： javaweb 文章标签： spring java

于 2019-06-19 10:04:01 首次发布

本文链接：https://blog.csdn.net/jakeswang/article/details/92805046

版权

javaweb 专栏收录该内容

49 篇文章

订阅专栏

在Spring应用中，有时需在启动时执行一次初始化逻辑，如初始化静态数据等。可通过使用@PostConstruct注解、实现InitializingBean接口、监听Spring上下文事件、实现CommandLineRunner或ApplicationRunner接口等方法实现，可按需选择合适方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在Spring应用中，有时需要在应用启动时执行某些初始化逻辑，并且这些逻辑只需执行一次。比如，初始化一些静态数据、加载配置文件或进行某些开销较大的操作。你可以通过多种方法实现这一需求：

使用 `@PostConstruct`

@PostConstruct 是Java EE中的一个注解，Spring也支持该注解。它标记的方法会在bean的依赖注入完成后自动调用。

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

@Component
public class MyInitializer {

    @PostConstruct
    public void init() {
        // 在这里放置你的初始化逻辑
        System.out.println("Application has started and this method is called once.");
    }
}

使用 `InitializingBean` 接口

另一个方法是实现 InitializingBean 接口，其 afterPropertiesSet 方法将在所有属性设置后被调用。

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

@Component
public class MyInitializer implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        // 在这里放置你的初始化逻辑
        System.out.println("Application has started and this method is called once.");
    }
}

使用 `@EventListener` 监听 `ContextRefreshedEvent`

你也可以监听Spring上下文的事件，比如 ContextRefreshedEvent，当上下文初始化或刷新时，该事件会触发。

import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class MyInitializer {

    @EventListener
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 在这里放置你的初始化逻辑
        System.out.println("Application has started and this method is called once.");
    }
}

使用 `ApplicationRunner` 或 `CommandLineRunner`

如果你使用的是Spring Boot，可以实现 ApplicationRunner 或 CommandLineRunner 接口，这两个接口用于在Spring Boot应用启动完成后执行代码。

使用 `ApplicationRunner`

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

@Component
public class MyInitializer implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 在这里放置你的初始化逻辑
        System.out.println("Application has started and this method is called once.");
    }
}

使用 `CommandLineRunner`

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

@Component
public class MyInitializer implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        // 在这里放置你的初始化逻辑
        System.out.println("Application has started and this method is called once.");
    }
}

总结

以上几种方法都是在Spring应用启动时执行一次初始化逻辑的有效方式，根据你的需求和喜好选择适合的方式即可：

@PostConstruct：简单直接，但只能在Spring管理的bean中使用。
InitializingBean：适合需要更明确生命周期控制的场景。
@EventListener：可以灵活地响应Spring上下文的各种事件。
ApplicationRunner/CommandLineRunner：特别适用于Spring Boot项目，方便处理启动后的逻辑。

通过这些方法，你可以确保某些特定的初始化逻辑只在应用启动时执行一次。

详细：

在 Spring 应用中，有几种常见的方式可以实现应用启动时只执行一次的初始化逻辑。以下是几种常用的实现方法：

1. 使用 @PostConstruct 注解

java

import javax.annotation.PostConstruct;

@Component
public class StartupInitializer {

    @PostConstruct
    public void init() {
        // 这个方法会在bean初始化完成后执行一次
        System.out.println("应用启动时执行一次的逻辑");
    }
}

特点：

简单直接
适用于单例Bean
方法会在依赖注入完成后执行

2. 实现 ApplicationListener 接口

java

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class StartupApplicationListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 确保只执行一次（因为可能有父子容器）
        if (event.getApplicationContext().getParent() == null) {
            System.out.println("应用上下文刷新完成后执行一次");
        }
    }
}

3. 使用 @EventListener 注解

java

import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class StartupEventListener {

    @EventListener
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 检查是否是根上下文，避免重复执行
        if (event.getApplicationContext().getParent() == null) {
            System.out.println("使用@EventListener执行启动逻辑");
        }
    }
}

4. 实现 CommandLineRunner 或 ApplicationRunner 接口

java

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

@Component
public class StartupRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("应用启动后执行一次，可以访问命令行参数");
    }
}

或使用 ApplicationRunner：

java

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

@Component
public class AppStartupRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("应用启动后执行一次，可以更方便地访问参数");
    }
}

5. 使用 @Bean 的 initMethod 属性

java

@Configuration
public class AppConfig {

    @Bean(initMethod = "init")
    public MyService myService() {
        return new MyService();
    }
}

public class MyService {
    public void init() {
        System.out.println("Bean初始化时执行一次");
    }
}

6. 使用 SmartLifecycle 接口（控制执行顺序）

java

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

@Component
public class SmartLifecycleInitializer implements SmartLifecycle {

    private volatile boolean running = false;

    @Override
    public void start() {
        if (!running) {
            System.out.println("SmartLifecycle启动时执行");
            running = true;
        }
    }

    @Override
    public void stop() {
        if (running) {
            System.out.println("SmartLifecycle停止时执行");
            running = false;
        }
    }

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

    @Override
    public int getPhase() {
        return 0; // 控制执行顺序，数字越小优先级越高
    }
}

7. 使用 Spring Boot 的 ApplicationReadyEvent

java

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

@Component
public class ApplicationReadyListener {

    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady() {
        System.out.println("应用完全准备好后执行一次");
    }
}