1. 首页
  2. 作品
  3. Spring Boot 教程
  4. Spring Boot SpringApplication 介绍
SpringBoot

Spring Boot SpringApplication 介绍

通常启动Spring Boot应用时调用SpringApplication类的static run()进行启动。

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApplication.class, args);
    }
}

其内部最终会转换为new一个SpringApplication对象，然后调用该对象的run方法，然后整个核心启动逻辑就由SpringApplication对象的run方法完成。

public static ConfigurableApplicationContext run(Class<?>[] primarySources,
        String[] args) {
    return new SpringApplication(primarySources).run(args);
}

调用SpringApplication的静态run方法时，由于SpringApplication对象是在内部创建的，其会在启动Spring Boot时使用一些默认的配置。如果我们需要进行一些自定义配置，则可以自己手动的new一个SpringApplication对象，进行一些特殊配置后再调用SpringApplication对象的实例run方法。比如Spring Boot默认在启动的时候会输出Spring Boot的banner，其中包含了Spring Boot的版本信息，如果我们不希望输出该banner信息，则可以进行如下定制。

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);
    }
}

ApplicationEvent及其监听

SpringApplication在启动Spring Boot的过程中会发布以下ApplicationEvent，也可以参考SpringApplication的实例run方法的实现。

  • ApplicationStartingEvent ：会在进行其它操作之前发布
  • ApplicationEnvironmentPreparedEvent ： 接着是准备Environment，准备好了会发布该事件
  • ApplicationPreparedEvent ：接着会构造ApplicationContext，在构造好ApplicationContext之后，调用其refresh()方法之前会发布该事件
  • ApplicationStartedEvent ：在ApplicationContext进行refresh之后，调用ApplicationRunner和CommandLineRunner之前会发布该事件
  • ApplicationReadyEvent ：在Spring Boot应用启动完成之后，也就是在SpringApplication的run()调用马上结束之前会发布该事件
  • ApplicationFailedEvent ：在启动过程中出现异常时会发布该事件

从上述的事件发布过程可以看出，有些事件的发布是在ApplicationContext还没有准备好的情况下发布的，所以它们不能通过传统的定义ApplicationEvent实现类为bean容器中的一个bean的方式进行监听。SpringApplication接口为我们提供了专门的注册这些监听器的方法addListeners()。事件监听器需要实现org.springframework.context.ApplicationListener接口。以下定义了两个事件监听器，都只是简单的进行日志输出，然后在启动应用的时候通过addListeners()添加了监听器，程序启动后会看到这两个监听器输出的日志信息。

@Slf4j
public class ApplicationStartingEventListener implements ApplicationListener<ApplicationStartingEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartingEvent event) {
        log.info("收到Spring Boot应用准备启动的事件[{}]", event);
    }
}
@Slf4j
public class ApplicationReadyEventListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        log.info("收到Spring Boot应用启动完成的事件[{}]", event);
    }
}
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.addListeners(new ApplicationStartingEventListener(), new ApplicationReadyEventListener());
        app.run(args);
    }
}

特别需要注意的是在添加监听器的时候不要调用SpringApplication的setListeners()，而要调用其addListeners()。因为在构造SpringApplication对象的时候构造方法中已经通过Spring Boot的Spring factory机制获取并注册了一些ApplicationListener（可以通过调用SpringApplication的getListeners()获取到已经注册的ApplicationListener），使用setListeners()会覆盖掉已经注册过的ApplicationListener。Spring Boot的Spring factory机制是指可以创建一个META-INF/spring.factories文件，然后以接口类的全路径名称作为Key，以实现类的全路径名称作为Value，当有多个Value时以英文逗号分隔，当有多个Key时每个Key一行。它们会被SpringFactoriesLoader进行处理，可以通过它获取到定义的接口对应的实现类。Spring Boot中有很多扩展都是基于这个机制进行的。上面的定义的ApplicationListener实现类，如果需要使用Spring factory机制，则可以在spring.factories文件中添加如下内容：

org.springframework.context.ApplicationListener=com.elim.springboot.listener.ApplicationStartingEventListener,com.elim.springboot.listener.ApplicationReadyEventListener

当你觉得一行展示的内容太长了，期望折行展示时，可以在行末加上\，这语法跟定义properties文件是一样的。实际上其内部也是按照properties文件进行解析的。

org.springframework.context.ApplicationListener=com.elim.springboot.listener.ApplicationStartingEventListener,\
com.elim.springboot.listener.ApplicationReadyEventListener

通过spring.factories文件定义了ApplicationListener后，我们的启动应用代码就可以改写为如下这种最简单的方式了。

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

ApplicationContext的选择

默认情况下，当ClassPath下存在SpringMVC相关的Class时将使用org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext，当不存在SpringMVC相关的Class，而是存在SpringWebFlux相关的Class时将使用org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext，当两者都不存在时可以使用默认的org.springframework.context.annotation.AnnotationConfigApplicationContext。可以通过其setWebApplicationType(WebApplicationType webApplicationType)手动指定WebApplicationType，从而影响使用的ApplicationContext的选择，也可以直接通过setApplicationContextClass(Class applicationContextClass)指定需要使用的ApplicationContext对应的Class。

访问命令行参数

调用SpringApplication的run()时传递的参数通常来自于命令行的参数，SpringApplication内部在调用run()时会把它们封装为一个ApplicationArguments对象，并且会把它定义为bean容器中的一个bean。如果在应用中需要访问命令行传递的参数，则可以通过注入ApplicationArguments对象，进行获取到对应的参数。命令行指定参数时有两种参数，一种是可选型参数、一种是非可选型参数，可选型参数以--开头，需要赋值时可以加上=，比如指定命令行参数为--debug --foo=bar abc，则可选型参数为debug和foo，而非可选型参数为abc。如下代码就是基于该命令行参数的一个简单示例。

@Controller
public class SampleController {
    @Autowired
    private ApplicationArguments arguments;
  
    /**
     * 传递的命令行参数是--debug --foo=bar abc
     * @param writer
     * @throws Exception
     */
    @GetMapping("sample/args")
    public void arguments(PrintWriter writer) throws Exception {
        writer.println("包含debug参数：" + arguments.containsOption("debug"));//true
        writer.println("参数foo的值是：" + arguments.getOptionValues("foo"));//[bar]
        writer.println("其它非选项性参数：" + arguments.getNonOptionArgs());//[abc]
        writer.println("原始参数是：" + Arrays.toString(arguments.getSourceArgs()));//--debug, --foo=bar, abc
    }
}

这种参数有别于在运行程序时通过-Dkey=value指定的虚拟机参数，通过-Dkey=value指定的虚拟机参数可以通过System.getProperty("key")获取到。命令行参数是对应程序运行主命令之后添加的参数，比如上面添加的那些参数的完整指令是java -jar app.jar --debug --foo=bar abc。

ApplicationRunner和CommandLineRunner

前面在介绍事件监听器的时候已经介绍了，在Spring Boot应用启动成功后会在bean容器中寻找ApplicationRunner和CommandLineRunner类型的bean，调用它们的run()。所以如果想在Spring Boot应用启动成功或做一些事情，则可以实现自己的ApplicationRunner或CommandLineRunner。它们的区别在于ApplicationRunner的run()的入参是ApplicationArguments对象，而CommandLineRunner的run()的入参是原始的参数数组。

@Component
@Slf4j
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("Spring Boot应用启动成功，携带的命令行参数是：{}", Arrays.toString(args.getSourceArgs()));
    }
}
@Component
@Slf4j
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        log.info("Spring Boot应用已经启动成功了，携带的命令行参数是：{}", Arrays.toString(args));
    }
}

其实前面介绍事件监听器的时候也提到了，通过实现ApplicationListener，监听ApplicationStartedEvent或ApplicationReadyEvent也可以在Spring Boot应用启动成功后做一些事情。它们的区别主要就在于ApplicationRunner和CommandLineRunner实现类是bean容器中的一个bean，可以注入其它bean，而且它们可以很方便的访问到命令行参数。

SpringApplicationBuilder

在构建SpringApplication对象时也可以通过SpringApplicationBuilder进行构建，通过它可以流式的进行配置，还可以指定子ApplicationContext。

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // SpringApplication.run(SpringBootApplication.class, args);
        SpringApplication app = new SpringApplicationBuilder(Application.class)
            .child(ChildConfig.class)
            .bannerMode(Banner.Mode.OFF)
            .build();
        app.run(args);
    }
}

关于SpringApplication的更多可定制的信息可以参考对应的API文档。

启用JMX管理

在application.properties文件中添加spring.application.admin.enabled=true可以启用JMX管理，这会发布一个SpringApplicationAdminMXBean类型的MBean。通过它的getProperty()可以获取当前应用对应的启动JVM的一些系统属性或者是定义在application.properties中的一些属性的值，因为其底层对应的是当前Environment对象。通过其shutdown()可以进行远程的关闭操作。

参考文档

https://docs.spring.io/spring-boot/docs/2.0.3.RELEASE/reference/html/boot-features-spring-application.html

作品《Spring Boot 教程 - Spring Boot SpringApplication 介绍》由 一点 发布于 匠果，转载请注明出处及链接地址： http://www.jiangguo.net/c/q62/8w5.html