springboot principio de combate (11) - springboot análisis extendido CommandLineRunner

directorio

En este artículo se entiende sobre todo en una interfaz de devolución de llamada antes de la ejecución refrescó contenedor de primavera: ApplicationContextInitializer,
la última etapa de devolución de llamada (similar a arrancar desde el inicio) después de un lanzamiento exitoso en las interfaces de contenedores: CommandLineRunner y ApplicationRunner.
Cerebro figura siguiente:

一, ApplicationContextInitializer

La interfaz es la interfaz es una devolución de llamada antes de ejecutar recipiente resorte refrescado.

① Use estos pasos:

• 1: Escribir una clase: la interfaz para implementar AApplicationContextInitializer
• 2: Registro ApplicationContextInitializer

② registrado tres métodos:

• 1.app.addInitializers
• 2: Especificar través de la configuración artículos context.initializer.classes
• mecanismo 3. lata spring.factories (oyente detector registrado también se puede utilizar de esta manera)

modo de demostración 1.app.addInitializers

Escribir una clase de implementación

public class MyAppliationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("bean count: " + applicationContext.getBeanDefinitionCount());
    }
}

Y llamadas de inscripción en el registro:

@SpringBootApplication
public class Demo8Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Demo8Application.class);
        app.addInitializers(new MyAppliationContextInitializer());
        ConfigurableApplicationContext context = app.run(args);
        context.close();
    }
}

Prueba
:
La prueba ha sido inyectado!

Tour 2: especificado por los elementos de configuración context.initializer.classes

public class MyAppliationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("bean count: " + applicationContext.getBeanDefinitionCount());
    }

}

public class MyAppliationContextInitializer2 implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println(applicationContext.getDisplayName());
   }
}

application.properties, escribió dos clases de implementación:

context.initializer.classes=com.springboot.demo8.MyAppliationContextInitializer,com.springboot.demo8.MyAppliationContextInitializer2

@SpringBootApplication
public class Demo8Application {

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

Los resultados operativos ok:

mecanismo 3.spring.factories (oyente detector registrado también se puede utilizar de esta manera)

Crear un nuevo proyecto intializer:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.springboot</groupId>
    <artifactId>intializer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>intializer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>

public class EchoAppliationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("=========EchoAppliationContextInitializer==========");
    }

}

intializer \ src \ principales \ Resources \ META-INF \ spring.factories:

org.springframework.context.ApplicationContextInitializer=com.springboot.intializer.EchoAppliationContextInitializer

El proyecto introdujo el proyecto original:

 <dependency>
   <groupId>com.springboot</groupId>
     <artifactId>intializer</artifactId>
     <version>0.0.1-SNAPSHOT</version>
 </dependency>

prueba:

@SpringBootApplication
public class Demo8Application {

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

Resultados de la ejecución:

Los resultados mostraron que ya se inyecta! !

二, CommandLineRunner

La interfaz de devolución de llamada es un comienzo el paso final después del éxito del contenedor (similar a arrancar desde el inicio), puede imprimir algo así como cuando se inicia la aplicación.

① Use estos pasos:

• 1. Escriba una clase que implementa la interfaz CommandLineRunner
• 2 clase en la primavera de gestión de contenedores
  注意：可以通过@Order注解或者Ordered接口来控制执行顺序。order值小的优先
  lo demuestran

@Order(1)
@Component
public class ServerSuccessReport implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("=====应用已经成功的启动============" + Arrays.asList(args));
    }

}

@Order(2)
@Component
public class ServerStartedReport implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("=====应用启动后的时间是:============"+ LocalDateTime.now().toString());
    }

}

Dos o más clases implementan la interfaz CommandLineRunner, y con @Compoent, y mediante el control del orden de prioridad, el pequeño valor de la prioridad de ejecución, el resorte de inyección:

caso de prueba:

@SpringBootApplication
public class Demo8Application {

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

El resultado:

三, ApplicationRunner

CommandLineRunner, diferencia ApplicationRunner
excepto que los diferentes parámetros del método de
parámetros más primitivas parámetros CommandLineRunner, no hace el procesamiento de la tarea
parámetro ApplicationRunner es ApplicationArguments, el parámetro original se hace además encapsulado

Por ejemplo:

adquisición CommandLineRunner mirada parámetros de código:

@Component
public class ServerSuccessReport implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("=====应用已经成功的启动============" + Arrays.asList(args));
    }
}

adquisición de teatro ApplicationRunner parámetros de código:

import java.util.Arrays;
@Component
public class StartedApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("应用已经启动，参数为:" + Arrays.asList(args.getSourceArgs()));
    }
}

El resultado:

tanto obtener los parámetros del programa, donde no podemos decir la diferencia, para continuar la transformación:

• En primer lugar establece los parámetros de inicio:
  
  ApplicationRunner se obtiene es una ApplicationArguments objetos, miramos a través del objeto de parámetro de impresión:

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Demo8Application.class);
        ConfigurableApplicationContext context = app.run(args);
        ApplicationArguments arg = context.getBean(ApplicationArguments.class);
        System.out.println(arg.getSourceArgs().length);
        System.out.println(arg.getOptionNames());
        System.out.println(arg.getOptionValues("myname"));
        context.close();
    }

El resultado:

se puede ver que se puede utilizar getOptionNames proporcionados por ApplicationArguments, getOptionValues método muy conveniente de obtener los valores de los parámetros, y CommandLineRunner sólo pueden llegar a --myname=adminesta cadena, se obtiene la clave o el valor requiere el uso de dividir cortar un montón de problemas, sino también ApplicationArguments hay muchas formas prácticas:

esto es CommandLineRunner, diferencia ApplicationRunner: tipo de parámetro del método no es el mismo.

En este artículo se habló sobre todo springboot contenedor de dos interfaces comunes: Antes de realizar el depósito de primavera refrescado de una interfaz de devolución de llamada: ApplicationContextInitializer,
el paso final en la devolución de llamada después de que el buque inició con éxito (similar a arrancar desde el inicio) Interfaz: CommandLineRunner y ApplicationRunner, y esto 2 diferencia interfaces.

---

Personal de micro-canales número público:
Buscar: la floración de cada día
de vez en cuando empuje artículos pertinentes, y esperamos crecer juntos! !

---

completo