spring1.0（一）Spring boot中容器启动前后回调的方法

最新推荐文章于 2024-08-18 09:11:50 发布

Arno-wei

最新推荐文章于 2024-08-18 09:11:50 发布

阅读量1k

点赞数

分类专栏： spring

本文链接：https://blog.csdn.net/insis_mo/article/details/87888647

版权

spring 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、ApplicationContextInitializer接口是spring容器在执行refreshed之前的一个回调，回调ApplicationContextInitializer接口实现类中的initialize方法。容器加载时会先刷新容器，refreshed方法为容器的刷新方法，当刚加载容器的时候就会执行该方法。而在加载容器之前就会回调initialize方法。
使用步骤：

写一个实现类，实现CommandLineRunner接口
把该类纳入到spring容器中进行管理

如下程序演示：

1、自定义一个类MyApplicationContextInitializer，实现ApplicationContextInitializer接口

package com.example.demo;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;

/*ConfigurableApplicationContext为接口中传入的参数类型，在initialize中可以通过传入的参数执行所需要的操作*/
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("bean的个数：" + applicationContext.getBeanDefinitionCount());
        /*下面还可以用applicationContext获取bean*/
    }

}

启动类为：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(App.class);

        /*把MyApplicationContextInitializer注入到容器中*/
        app.addInitializers(new MyApplicationContextInitializer());
        ConfigurableApplicationContext context = app.run(args);
        context.close();
    }
}

运行启动类，输出结果如下：

 .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)

bean的个数：6
2017-12-15 20:13:16.875  INFO 9528 --- [           main] com.example.demo.App                     : Starting App on DESKTOP-98FEQG9 with PID 9528 (E:\code\springboot\springboot-5\target\classes started by *** in E:\code\springboot\springboot-5)
2017-12-15 20:13:16.879  INFO 9528 --- [           main] com.example.demo.App                     : No active profile set, falling back to default profiles: default
……

从输出结果可以看出，MyApplicationContextInitializer 中的initialize方法在容器之前进行调用的。

2、创建MyApplicationContextInitializer 类时，就用@Component注解把该类注入到IOC容器中，在容器加载时就不需要显示加载了。

@Component
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("bean的个数：" + applicationContext.getBeanDefinitionCount());
        /*下面还可以用applicationContext获取bean*/
    }

}

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(App.class);
        ConfigurableApplicationContext context = app.run(args);
        context.close();
    }
}

运行结果同上面结果相同。

3、可以同时指定多个ApplicationContextInitializer实现类，用以在容器加载前进行回调实现类中的initialize方法。在上面示例的基础上继续实现下面的类

@Component
public class MyApplicationContextInitializer2 implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("name：" + applicationContext.getDisplayName());
        /*下面还可以用applicationContext获取bean*/
    }

}

启动类和上面示例相同，运行启动类，输出结果如下：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)

bean的个数：6
name：org.springframework.context.annotation.AnnotationConfigApplicationContext@5fdba6f9
……

从输出结果可以看出，程序在加载容器之前先回调了两个实现类的初始化方法。

二、当spring boot加载完容器后，但还没有执行程序自定义的方法时，也可以回调指定的方法。如果有实现CommandLineRunner或者ApplicationRunner接口，并把实现类纳入到容器中进行管理，当容器加载完后，会回调实现类中的run方法。步骤同上面示例的步骤相同。如下程序示例所示：

1、自定义类MyCommandLineRunner，实现CommandLineRunner接口，并实现接口中的方法。

package com.example.demo;
import java.util.Arrays;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Override
    /*args为获取到的容器中启动时的参数*/
    public void run(String... args) throws Exception {
        System.out.println("----回调类MyCommandLineRunner中的run方法----");
        System.out.println(Arrays.asList(args));
    }

}

启动类为：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(App.class);
        /*可以指定args参数，在这个地方为"aa"和"bb"*/
        ConfigurableApplicationContext context = app.run("aa", "bb");
        context.close();
    }
}

运行启动类，输出结果如下：

---MyApplicationRunner---
[aa, bb]

2、在1的实例下再自定义MyApplicationRunner类，实现ApplicationRunner接口，并实现接口中的run方法。

@Component
public class MyApplicationRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("---MyApplicationRunner---");
        System.out.println(Arrays.asList(args.getSourceArgs()));
    }

}

运行启动类，输出结果：

---MyApplicationRunner---
[aa, bb]
----回调类MyCommandLineRunner中的run方法----
[aa, bb]

3、ApplicationRunner接口与CommandLineRunner接口实现的功能相似，都是在容器加载完，执行后续程序之前发挥功能。类似于windows的开机自启功能。但ApplicationRunner功能比CommandLineRunner的功能更全面，因为CommandLineRunner中的run方法传入的参数类型为ApplicationArguments类型的，

public interface ApplicationRunner {

    /**
     * Callback used to run the bean.
     * @param args incoming application arguments
     * @throws Exception on error
     */
    void run(ApplicationArguments args) throws Exception;

}

而CommandLineRunner接口中的run方法传入的参数为string类型的，

public interface CommandLineRunner {

    /**
     * Callback used to run the bean.
     * @param args incoming main method arguments
     * @throws Exception on error
     */
    void run(String... args) throws Exception;

}

由于CommandLineRunner 中的run方法的参数类型为string类型的，只能获取到容器启动时传入的参数。而ApplicationRunner 接口中的run方法传入的参数类型为ApplicationArguments类型的，该类型是对容器启动参数的封装。如下所示：在run as -> run configurations -> arguments -> program arguments中设置启动参数为：--name=lzj

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(App.class);
        ConfigurableApplicationContext context = app.run(args);
        ApplicationArguments argsments = context.getBean(ApplicationArguments.class);
    /*getSourceArgs获取所有启动参数，返回一个字符串数组*/ System.out.println(argsments.getSourceArgs().length);
    System.out.println(Arrays.asList(argsments.getSourceArgs()));
    /*getOptionNames返回所有启动参数的键，然后把键放在set中进行返回*/ System.out.println(argsments.getOptionNames());
    /*getOptionValues根据启动参数中的键获取对应的值，返回字符串形式*/  System.out.println(argsments.getOptionValues("name"));
        context.close();
    }
}

运行启动类，输出结果：

1
[--name=lzj]
[name]
[lzj]

当然也可以在程序中指定启动参数，如：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(App.class);
        ConfigurableApplicationContext context = app.run("aa", "bb");
        ApplicationArguments argsments = context.getBean(ApplicationArguments.class);
        System.out.println(argsments.getSourceArgs().length);
        System.out.println(Arrays.asList(argsments.getSourceArgs()));
        context.close();
    }
}

运行启动类，输出：