Spring boot 梳理 - SpringApplication

简单启动方式

public static void main(String[] args) {

    SpringApplication.run(MySpringConfiguration.class, args);

}

调试方式启动

java -jar myproject-0.0.1-SNAPSHOT.jar --debug

高级启动方式

@SpringBootApplication

public class App

{

    public static void main( String[] args )

    {

        SpringApplication app=new SpringApplication(App.class);

        app.setBannerMode(Banner.Mode.OFF);

        app.run(args);

    }

}

Web Environment
1. A SpringApplication attempts to create the right type of ApplicationContext on your behalf. The algorithm used to determine a WebApplicationType is fairly simple:
  - If Spring MVC is present, an AnnotationConfigServletWebServerApplicationContext is used
  - If Spring MVC is not present and Spring WebFlux is present, an AnnotationConfigReactiveWebServerApplicationContext is used
  - Otherwise, AnnotationConfigApplicationContext is used
  This means that if you are using Spring MVC and the new WebClient from Spring WebFlux in the same application, Spring MVC will be used by default. You can override that easily by calling setWebApplicationType(WebApplicationType).
  
  It is also possible to take complete control of the ApplicationContext type that is used by calling setApplicationContextClass(…).

Accessing Application Arguments

If you need to access the application arguments that were passed to SpringApplication.run(…), you can inject a org.springframework.boot.ApplicationArguments bean. The ApplicationArguments interface provides access to both the raw String[] arguments as well as parsed option and non-option arguments, as shown in the following example:

import org.springframework.boot.*;

import org.springframework.beans.factory.annotation.*;

import org.springframework.stereotype.*;

@Component

public class MyBean {

    @Autowired

    public MyBean(ApplicationArguments args) {

        boolean debug = args.containsOption("debug");

        List<String> files = args.getNonOptionArgs();

        // if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]

    }

}

Using the ApplicationRunner or CommandLineRunner
1. If you need to run some specific code once the SpringApplication has started, you can implement the ApplicationRunner or CommandLineRunner interfaces. Both interfaces work in the same way and offer a single run method, which is called just before SpringApplication.run(…) completes.
  
  The CommandLineRunner interfaces provides access to application arguments as a simple string array, whereas the ApplicationRunner uses the ApplicationArguments interface discussed earlier. The following example shows a CommandLineRunner with a run method:
2. If several CommandLineRunner or ApplicationRunner beans are defined that must be called in a specific order, you can additionally implement the org.springframework.core.Ordered interface or use the org.springframework.core.annotation.Order annotation.
3. ```
import org.springframework.boot.*;

import org.springframework.stereotype.*;

@Component

public class MyBean implements CommandLineRunner {

    public void run(String... args) {

        // Do something...

    }

}
```
Admin Features
1. It is possible to enable admin-related features for the application by specifying the spring.application.admin.enabled property. This exposes the SpringApplicationAdminMXBean on the platform MBeanServer. You could use this feature to administer your Spring Boot application remotely. This feature could also be useful for any service wrapper implementation.
2. If you want to know on which HTTP port the application is running, get the property with a key of local.server.port.
3. Take care when enabling this feature, as the MBean exposes a method to shutdown the application.
Application Exit
1. Each SpringApplication registers a shutdown hook with the JVM to ensure that the ApplicationContext closes gracefully on exit. All the standard Spring lifecycle callbacks (such as the DisposableBean interface or the @PreDestroy annotation) can be used.
  
  In addition, beans may implement the org.springframework.boot.ExitCodeGenerator interface if they wish to return a specific exit code when SpringApplication.exit() is called. This exit code can then be passed to System.exit() to return it as a status code, as shown in the following example:
2. Also, the ExitCodeGenerator interface may be implemented by exceptions. When such an exception is encountered, Spring Boot returns the exit code provided by the implemented getExitCode() method.
3. ```
@SpringBootApplication

public class ExitCodeApplication {

    @Bean

    public ExitCodeGenerator exitCodeGenerator() {

        return () -> ;

    }

    public static void main(String[] args) {

        System.exit(SpringApplication

                .exit(SpringApplication.run(ExitCodeApplication.class, args)));

    }

}
```

巴特西

Spring boot 梳理 - SpringApplication

Web Environment

Accessing Application Arguments

Using the ApplicationRunner or CommandLineRunner

Admin Features

Application Exit

最新文章

热门文章