在使用Springboot过程中，或多或少我们会遇到在Springboot启动时要初始化类，或者加载文件之类的一些操作。关于初始化，主要分为两类，一类是在程序启动后的执行初始化操作，另一类是Bean实例化时执行初始化操作，本文将介绍这两类初始化操作常用的一些类和注解，相信总会有一种方法适合你的。

程序启动后的初始化

ApplicationRunner 接口

ApplicationRunner接口主要作用是在应用程序启动完成后执行一些自定义的逻辑。通过实现ApplicationRunner接口并重写其run方法，我们可以定义在应用程序启动后需要执行的任务逻辑。当Spring Boot应用程序启动完成后，ApplicationRunner接口的run方法会被自动调用，执行你在该方法中定义的任务。

ApplicationRunner接口特别适用于那些需要在应用程序启动后立即执行的任务，例如数据初始化、缓存预热等。此外，它也常被用作定时任务的触发点，在应用程序启动时即启动一些定时任务。

在run方法中，我们可以通过传入的ApplicationArguments对象获取到启动应用程序时传递的命令行参数，这为我们提供了更多的灵活性和控制力。

以下是一个简单的示例，演示了如何使用 ApplicationRunner 接口：

/**
 * @author 
 */
@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner 执行初始化操作...");

        // 获取命令行参数的值
        String name = args.getOptionValues("name").get(0); // 获取名为"name"的参数的值
        boolean hasCode = args.containsOption("code"); // 检查是否存在名为"code"的标志

        System.out.println("name: " + name);
        System.out.println("hasCode: " + hasCode);
        System.out.println("=============分割线=============");
    }
}

idea中设置启动参数：

控制台输出结果：

在这个示例中，我们使用getOptionValues()方法来获取命令行参数的值，该方法返回一个字符串列表。如果参数是标志而不是键值对，则可以使用containsOption()方法检查参数是否存在。从控制台中我们可以看到 ApplicationRunner 接口的初始化操作是在Tomcat启动之后即程序启动之后进行初始化的。

CommandLineRunner 接口

CommandLineRunner 接口是 Spring Boot 中的一个功能性接口，用于在 Spring Boot 应用程序启动后执行特定的任务或代码。我们可以使用它在 Spring Boot 应用程序启动后执行一些初始化操作，例如加载初始数据、执行特定的业务逻辑、启动后台任务等。

这个接口只定义了一个方法 run(String... args)，该方法在 Spring Boot 应用程序启动后会被自动调用，其中 args 参数是命令行参数。开发者需要实现这个接口，并在实现类中编写需要在应用程序启动后执行的代码逻辑。

Spring Boot 在启动时会自动检测所有实现了 CommandLineRunner 接口的 bean，并在应用程序启动后按照它们在 Spring 上下文中的注册顺序依次调用其 run 方法。

使用 CommandLineRunner 接口可以方便地进行应用程序启动后的初始化工作，而不需要显式地编写启动时的逻辑，从而使应用程序的启动过程更加灵活和可扩展。

以下是一个简单的示例，演示了如何使用 CommandLineRunner 接口：

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

/**
 * @author 
 */
@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner 执行初始化操作...");
        System.out.println("CommandLineRunner args = " + Arrays.toString(args));
    }
}

在这个示例中，我们创建了一个名为 MyCommandLineRunner 的类，它实现了 CommandLineRunner 接口，并重写了 run 方法，在方法中打印参数表示应用程序启动成功。从控制台中我们可以看到 CommandLineRunner 接口的初始化操作是在Tomcat启动之后即程序启动之后进行初始化的。

ApplicationRunner 和CommandLineRunner 的区别

了解完ApplicationRunner 和 CommandLineRunner 接口之后，不难发现，它们都是在程序启动后执行特定操作的，那它们之间有什么不同呢？

ApplicationRunner 和 CommandLineRunner 接口都继承了Runner接口， 它们之间的区别主要在于方法签名和传递参数的方式：

1. 方法签名：
2. CommandLineRunner 接口中的 run 方法签名为 void run(String... args)，其中参数 args 是一个字符串数组，用于接收命令行参数。
3. ApplicationRunner 接口中的 run 方法签名为 void run(ApplicationArguments args)，其中参数 args 是 ApplicationArguments 类型的对象，用于接收应用程序的启动参数。
4. 参数传递方式：
5. 在 CommandLineRunner 中，启动参数是作为字符串数组直接传递给 run 方法的参数。
6. 在 ApplicationRunner 中，启动参数是作为 ApplicationArguments 对象传递给 run 方法的参数，这个对象提供了更丰富的参数处理功能，例如获取非标准的命令行参数、获取命令行参数的选项和值等。

在大多数情况下，这两个接口可以互换使用，选择哪一个主要取决于对命令行参数处理的需求。如果你只需要简单地接收命令行参数，那么使用 CommandLineRunner 就足够了。但如果你需要更复杂的参数处理，例如获取命令行参数的选项和值，那么使用 ApplicationRunner 会更方便。

另外，需要注意的是，Spring Boot 在启动时会优先调用实现了 ApplicationRunner 接口的 bean 的 run 方法，如果没有找到 ApplicationRunner 类型的 bean，则会去调用实现了 CommandLineRunner 接口的 bean 的 run 方法。

Bean的实例化

InitializingBean 接口

InitializingBean 接口是Spring框架的一个接口，它允许Bean在其属性被设置后进行自定义初始化操作。这个接口定义了一个方法afterPropertiesSet()，在Bean的所有属性被设置后立即调用。 这使得 InitializingBean 可以作为自定义初始化回调的标记接口，用于执行那些需要在对象依赖注入完成之后进行的初始化操作。

通过实现InitializingBean接口，可以确保在Spring容器完成Bean的实例化和属性设置后执行特定的初始化逻辑。这在需要在Bean初始化阶段执行一些特定操作时非常有用，例如数据验证、资源初始化或与其他Bean的交互等。

以下是一个简单的示例，演示了如何实现InitializingBean接口：

/**
 * @author sunlong
 * @author  
 */
public class MyInitializingBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean 执行初始化操作...");
    }
}

注入MyInitializingBean 实例：

@Configuration
public class ServiceConfig {
    @Bean
    public MyInitializingBean MyInitializingBean() {
        System.out.println("MyInitializingBean 注入。。。");
        return new MyInitializingBean();
    }
}

控制台打印结果：

MyInitializingBean 注入。。。
InitializingBean 执行初始化操作...

在这个例子中，当Spring容器实例化MyInitializingBean 时，会自动调用afterPropertiesSet()方法来执行初始化逻辑。

@PostConstruct注解

@PostConstruct注解是Java EE 5规范中引入的一个注解，主要在JSR 250标准中定义。它被设计用于在对象实例化后、依赖注入完成之时自动调用某个方法，以执行初始化操作。这个注解通常用于Java EE和Spring等框架中，标记那些需要在依赖注入后执行的方法。

其主要用途包括在依赖注入完成后，执行一些需要依赖注入对象的初始化逻辑。例如，你可以在@PostConstruct注解的方法中进行一些属性的赋值、资源的初始化、连接的建立等操作。

在Spring框架中，当Spring创建了一个类的实例并完成依赖注入后，如果该类中存在被@PostConstruct注解的方法，Spring会自动调用这个方法。需要注意的是，@PostConstruct注解只能用于非静态方法，并且只会被容器调用一次。如果一个类中存在多个被@PostConstruct注解的方法，它们的执行顺序并不确定，但你可以通过@Order注解来指定执行顺序。

在Spring项目中，一个bean的初始化过程中，方法执行的先后顺序为：Constructor > @Autowired > @PostConstruct。即首先执行构造方法，然后进行依赖注入，最后执行初始化操作。

关于@PostConstruct注解的方法，它可以有返回值，尽管通常我们将其返回类型设置为void。而且，这个方法的访问修饰符可以是public、protected或private，因为它的功能是通过反射来实现的。此外，这个方法不能是static的，但可以是final的。

与InitializingBean接口相比，@PostConstruct注解提供了更清晰、更灵活的方式来定义初始化方法，而且不需要实现任何特定的接口。

以下是一个简单的示例，演示了如何实现**@PostConstruct**注解：

@Component
public class PostConstructComponent {

    @PostConstruct
    public void init() {
        // 执行初始化操作
        System.out.println("PostConstruct执行初始化操作...");
    }
}

在这个示例中，当Spring容器实例化PostConstructComponent 并完成依赖注入后，会调用init()方法来执行初始化逻辑。

@Bean

@Bean注解主要用于将对象（通常是bean）存入Spring的IoC）容器中。与@Controller、@Service、@Repository、@Component等类注解不同，@Bean注解是方法级别的，它通过将当前方法的返回值对象放入容器中来实现对象的管理。通过这种方式我们可以自定义bean的创建逻辑。

在Spring配置类中，你可以使用@Bean注解来定义一个或多个bean。默认情况下，bean的名称与带有@Bean注解的方法名相同，但你也可以使用name属性来指定一个自定义的名称。

@Bean注解有一个initMethod属性，用于指定bean的初始化方法。

例如：

创建MyService 类：

@Component
public class PostConstructComponent {

    @PostConstruct
    public void init() {
        // 执行初始化操作
        System.out.println("PostConstruct执行初始化操作...");
    }
}

注入MyService ：

@Configuration
public class ServiceConfig {

    @Bean(initMethod = "initMethod")
    public MyService myService() {
        System.out.println("MyService 注入。。。");
        return new MyService();
    }
}

在这个例子中，MyService的实例会被创建，并且作为名为myService的bean注册到Spring容器中，在MyService被实例化时，会自动调用MyService的initMethod方法。

InitializingBean 接口、@PostConstruct注解、@Bean注解区别

InitializingBean接口、@PostConstruct注解和@Bean注解在Spring框架中都有各自的作用，尽管它们都可以用于执行Bean的初始化逻辑，但它们还是有所区别的：

• InitializingBean和@PostConstruct主要用于执行Bean的初始化逻辑，但它们来源于不同的框架或规范。InitializingBean是Spring特有的，而@PostConstruct是Java EE规范的一部分，由Java EE容器调用。
• @Bean主要用于声明和定义Bean，虽然可以在其方法内部执行初始化逻辑，但其主要目的是定义和注册Bean。
• InitializingBean和@PostConstruct都可以在Bean的属性被注入之后执行初始化逻辑，但@PostConstruct的方法在InitializingBean的afterPropertiesSet()方法之前执行。

在Spring中，通常推荐使用@PostConstruct注解来执行初始化逻辑，因为它更符合Java EE规范，并且与Spring的依赖注入机制结合得更好。

总结

本文介绍了程序启动后和Bean实例化后可以进行的初始化操作，有生就有死，能够初始化就能够销毁，下篇文章将介绍如何在程序关闭时和Bean销毁时进行一系列操作，感兴趣可以关注一下，敬请期待。

作者：索码理
链接：https://juejin.cn/post/7358336719166177332