ApplicationRunner-Schnittstelle und CommandLineRunner-Schnittstelle in [SpringBoot]

1. ApplicationRunner-Schnittstelle

Verwendung:

• Typ: Schnittstelle

• Methode: Es ist nur eine Ausführungsmethode definiert

• Verwendungsszenarien: Wenn Sie beim Start des SpringBoot-Projekts einen bestimmten Code direkt nach dem Start ausführen möchten, können Sie die ApplicationRunner-Schnittstelle verwenden, die Methode run(ApplicationArguments args) in der Schnittstelle implementieren und Ihre eigene Codelogik schreiben die Methode. Das heißt: Nach dem Start des Spring-Containers wird die Ausführungsmethode dieser Schnittstellenimplementierungsklasse sofort ausgeführt.

• Parameter der Ausführungsmethode: ApplicationArguments kann die vom aktuellen Projekt ausgeführten Befehlsparameter abrufen. (Wenn Sie beispielsweise dieses Projekt in ein JAR eingeben und ausführen, können die Parameter über ApplicationArguments abgerufen werden.)

@Component  //此类一定要交给spring管理
public class ConsumerRunner implements ApplicationRunner{
    
    
     @Override
     public void run(ApplicationArgumers args) throws Exception{
    
    
        //代码
        System.out.println("需要在springBoot项目启动时执行的代码---");
     }
}

Wenn mehrere Codesegmente ausgeführt werden müssen, kann die Annotation @Order verwendet werden, um die Ausführungsreihenfolge festzulegen.

Im selben Projekt können Sie mehrere ApplicationRunner-Implementierungsklassen definieren. Ihre Ausführungsreihenfolge wird durch Annotieren der @Order-Annotation oder Implementieren der Ordered-Schnittstelle erreicht.
@Order-Annotation: Wenn mehrere Implementierungsklassen vorhanden sind und diese in einer bestimmten Reihenfolge ausgeführt werden sollen, können Sie der Implementierungsklasse die @Order-Annotation hinzufügen. @Order(Wert=Ganzzahlwert). SpringBoot führt die Werte in @Order von klein nach groß aus.

@order: Verwenden Sie Anmerkungen, um die Ladereihenfolge von Beans zu steuern. Das @Order-Tag definiert die Ladereihenfolge von Komponenten. Je kleiner der Wert, desto höher die Priorität, und es kann eine negative Zahl sein. Je kleiner der Wert, desto früher wird geladen.
@Order(-1) hat Vorrang vor @Order(0)
@Order(1) hat Vorrang vor @Order(2)

@Component  //此类一定要交给spring管理
@Order(value=1) //首先执行
public class ConsumerRunnerA implements ApplicationRunner{
    
    
    @Override
    public void run(ApplicationArgumers args) throws Exception{
    
    
        //代码
        System.out.println("需要在springBoot项目启动时执行的代码1---");
    }
}

@Component  //此类一定要交给spring管理
@Order(value=2) //其次执行
public class ConsumerRunnerB implements ApplicationRunner{
    
    
    @Override
    public void run(ApplicationArgumers args) throws Exception{
    
    
        //代码
        System.out.println("需要在springBoot项目启动时执行的代码2---");
    }
}

@Component-Annotation: Injizieren Sie die Klasse in den Spring-Container.

Referenzlink: https://blog.csdn.net/hc1285653662/article/details/122445495

2. CommandLineRunner-Schnittstelle

Verwendung:

Schreiben Sie im letzten Rückrufschritt eine Klasse, nachdem der Container erfolgreich gestartet wurde (ähnlich dem Selbststart beim Booten)
, implementieren Sie die CommandLineRunner-Schnittstelle und fügen Sie diese Klasse in den Spring-Container ein.

Die Ausführungsreihenfolge kann über die Annotation @Order (je kleiner die durch das Attribut angegebene Zahl, desto höher die Priorität) oder die Ordered-Schnittstelle gesteuert werden.

Beispiel: Passen Sie zwei Klassen an, implementieren Sie die CommandLineRunner-Schnittstelle, implementieren Sie die Ausführungsmethode und fügen Sie der Ausführungsmethode Verarbeitungslogik hinzu.

@Order(5)
@Component
public class AppStartReport implements CommandLineRunner {
    
    

    @Override
    public void run(String... args) throws Exception {
    
    
        System.out.println("AppStartReport : 项目成功启动------------------");
    }
}

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

    @Override
    public void run(String... args) throws Exception {
    
    
        System.out.println("AppStartReport2 : 项目成功启动------------------");
    }
}

Starteffekt: AppStartReport2 wird vor AppStartReport ausgeführt:

3. Der Unterschied zwischen der ApplicationRunner-Schnittstelle und der CommandLineRunner-Schnittstelle

der Unterschied:

1. Die Methodenparameter von CommandLineRunner sind Originalparameter ohne jegliche Verarbeitung;
2. Die Parameter von ApplicationRunner sind ApplicationArguments-Objekte, die eine weitere Kapselung der ursprünglichen Parameter darstellen. ApplicationArguments verarbeitet die Parameter weiter (hauptsächlich für die Hauptmethode). Es kann die Parameter von –name=value analysieren und wir können den Wert basierend auf dem Namen erhalten.

@Component
public class AppStartReport3 implements ApplicationRunner {
    
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
    
    
        System.out.println("AppStartReport3 : 项目成功启动，参数为: " + Arrays.asList(args.getSourceArgs()));
    }
}

@SpringBootApplication
public class App {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication application = new SpringApplication(App.class);
        ConfigurableApplicationContext context = application.run("aaa", "bbb");
        context.close();
    }
}

Nachdem Sie die Parameter selbst angegeben haben, ist der Ausführungseffekt wie folgt:

Sie können den Anfangswert auch im Optionsfeld „Programmargumente“ in der Form „–key=value“ festlegen, beispielsweise „–argname=ccc“, wie in der folgenden Abbildung dargestellt:

@SpringBootApplication
public class App {
    
    

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

Die vom Launcher übergebenen Parameter sind die Parameterargumente der Hauptmethode und haben folgende Auswirkungen:

Analyse des ApplicationArguments-Quellcodes

public interface ApplicationArguments {
    
    

   String[] getSourceArgs();

   Set<String> getOptionNames();

   boolean containsOption(String name);

   List<String> getOptionValues(String name);

   List<String> getNonOptionArgs();

}

Es gibt zwei Arten von Ressourcenparametern: Einer wird beim Aufruf der Ausführungsmethode („aaa“, „bbb“) übergeben und der andere ist der konfigurierte Systemparameter, der der args-Parameter der Hauptmethode („ccc“) ist. .

• Erstens kann die Methode getSourceArgs alle Parameter abrufen, bei denen es sich um von Ihnen selbst übergebene Parameter oder um konfigurierte Systemparameter handeln kann.

• Die getNonOptionArgs-Methode kann die von uns übergebenen Parameter („aaa“, „bbb“) abrufen. ;

• Mit den verbleibenden drei Methoden können Systemparameter ermittelt werden. Die tatsächliche Verwendung ist wie folgt:
  EX:

@SpringBootApplication
public class App {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication application = new SpringApplication(App.class);
        ConfigurableApplicationContext context = application.run(args);
        ApplicationArguments arguments = context.getBean(ApplicationArguments.class);
        System.out.println("参数个数：" + arguments.getSourceArgs().length);
        System.out.println("Non OptionArgs：" + arguments.getNonOptionArgs());
        System.out.println("Option Names：" + arguments.getOptionNames());
        System.out.println("获取key为argname的value值：" + arguments.getOptionValues("argname"));
        System.out.println("是否包含key为argname的参数：" + arguments.containsOption("argname"));
        context.close();
    }
}

Ausgabeeffekt:

Referenzlink: https://blog.csdn.net/qq_35006663/article/details/102264172