java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > SpringBoot启动时运行特定代码

SpringBoot启动时运行特定代码的多种方式小结

作者：一叶飘零_sweeeet

SpringBoot提供了多种方式在应用程序启动时运行特定的代码,包括CommandLineRunner、ApplicationRunner、@PostConstruct、InitializingBean、事件机制和自定义注解等,下面就来具体介绍一下

一、使用 CommandLineRunner 和 ApplicationRunner 接口

（一）CommandLineRunner 和 ApplicationRunner 介绍

（二）使用 CommandLineRunner

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

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Override
    public void run(String... args) {
        System.out.println("Application started with command line arguments: " + java.util.Arrays.toString(args));
    }
}

（三）使用 ApplicationRunner

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) {
        System.out.println("Application started with application arguments: " + args.getNonOptionArgs());
    }
}

二、使用 @PostConstruct 注解

（一）@PostConstruct 注解介绍

（二）使用示例

import javax.annotation.PostConstruct;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    @PostConstruct
    public void init() {
        System.out.println("MyBean initialized.");
    }
}

三、使用 InitializingBean 接口

（一）InitializingBean 接口介绍

（二）使用示例

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("MyInitializingBean initialized.");
    }
}

四、使用 Spring Boot 的事件机制

（一）Spring Boot 事件机制介绍

（二）使用示例

import org.springframework.context.ApplicationListener;
import org.springframework.boot.context.event.ApplicationStartedEvent;

import org.springframework.stereotype.Component;

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("Application started.");
    }
}

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Component;

@Component
public class MyEventPublisher implements ApplicationEventPublisherAware {

    private ApplicationEventPublisher applicationEventPublisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void publishEvent() {
        MyCustomEvent event = new MyCustomEvent(this);
        applicationEventPublisher.publishEvent(event);
    }
}

五、使用自定义注解和 AOP

（一）自定义注解介绍

（二）使用示例

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RunAtStartup {
    int order() default 0;
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class StartupAspect {

    @Around("@annotation(com.example.RunAtStartup)")
    public Object runAtStartup(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Running method annotated with @RunAtStartup.");
        return joinPoint.proceed();
    }
}

import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @RunAtStartup(order = 1)
    public void startupMethod1() {
        System.out.println("Startup method 1 executed.");
    }

    @RunAtStartup(order = 2)
    public void startupMethod2() {
        System.out.println("Startup method 2 executed.");
    }
}

六、实际案例分析

（一）案例背景

假设有一个企业级应用程序，需要在启动时进行一些初始化操作，例如加载配置文件、连接数据库、初始化缓存等。

（二）技术选型

（三）具体实现

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) {
        if (args.containsOption("config")) {
            String configFile = args.getOptionValues("config").get(0);
            // 加载指定的配置文件
        }
    }
}

import javax.annotation.PostConstruct;

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

@Component
public class DatabaseConnectionBean implements InitializingBean {

    @PostConstruct
    public void init() {
        System.out.println("Preparing to connect to database.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 建立数据库连接
        System.out.println("Connected to database.");
    }
}

import org.springframework.context.ApplicationListener;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationReadyEvent> {

    private final JavaMailSender javaMailSender;

    public MyApplicationListener(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo("admin@example.com");
        message.setSubject("Application started");
        message.setText("The application has started successfully.");
        javaMailSender.send(message);
    }
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface InitializeCache {
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class CacheInitializationAspect {

    @Around("@annotation(com.example.InitializeCache)")
    public Object initializeCache(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Initializing cache.");
        return joinPoint.proceed();
    }
}

import org.springframework.stereotype.Component;

@Component
public class CacheManager {

    @InitializeCache
    public void initCache() {
        // 初始化缓存
        System.out.println("Cache initialized.");
    }
}

（四）效果评估

七、性能考虑和最佳实践

（一）性能影响

（二）最佳实践

八、常见问题及解决方案

（一）多个启动时执行的代码之间的依赖关系问题

（二）启动时代码执行失败的处理

九、总结与展望

Spring Boot 提供了多种方式来在应用程序启动时运行特定的代码。通过使用 CommandLineRunner、ApplicationRunner、@PostConstruct、InitializingBean、事件机制和自定义注解等方式，可以在应用程序启动时进行各种初始化操作，提高应用程序的可靠性和稳定性。在实际应用中，应该根据具体的需求选择合适的方式，并注意性能和可维护性的考虑。

到此这篇关于SpringBoot启动时运行特定代码的多种方式小结的文章就介绍到这了,更多相关SpringBoot启动时运行特定代码内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文