Ausführen von Code nach dem Start von Spring Boot

Ich möchte Code ausführen, nachdem meine Spring-Boot- App ein Verzeichnis auf Änderungen überwacht.

Ich habe versucht, einen neuen Thread auszuführen, aber die @AutowiredDienste wurden zu diesem Zeitpunkt noch nicht festgelegt.

Ich konnte herausfinden ApplicationPreparedEvent, welche Brände @Autowiredausgelöst werden, bevor die Anmerkungen gesetzt werden. Idealerweise möchte ich, dass das Ereignis ausgelöst wird, sobald die Anwendung bereit ist, http-Anforderungen zu verarbeiten.

Gibt es ein besseres Ereignis oder eine bessere Möglichkeit, Code auszuführen, nachdem die Anwendung im Spring-Boot live ist ?

Versuchen:

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application extends SpringBootServletInitializer {

    @SuppressWarnings("resource")
    public static void main(final String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);

        context.getBean(Table.class).fillWithTestdata(); // <-- here
    }
}

So einfach ist das:

@EventListener(ApplicationReadyEvent.class)
public void doSomethingAfterStartup() {
    System.out.println("hello world, I have just started up");
}

Auf Version getestet 1.5.1.RELEASE

Haben Sie ApplicationReadyEvent ausprobiert?

@Component
public class ApplicationStartup 
implements ApplicationListener<ApplicationReadyEvent> {

  /**
   * This event is executed as late as conceivably possible to indicate that 
   * the application is ready to service requests.
   */
  @Override
  public void onApplicationEvent(final ApplicationReadyEvent event) {

    // here your code ...

    return;
  }
}

Code von: http://blog.netgloo.com/2014/11/13/run-code-at-spring-boot-startup/

In der Dokumentation wird Folgendes zu den Startereignissen erwähnt:

...

Anwendungsereignisse werden in der folgenden Reihenfolge gesendet, während Ihre Anwendung ausgeführt wird:

Ein ApplicationStartedEvent wird zu Beginn eines Laufs gesendet, jedoch vor jeder Verarbeitung mit Ausnahme der Registrierung von Listenern und Initialisierern.

Ein ApplicationEnvironmentPreparedEvent wird gesendet, wenn die im Kontext zu verwendende Umgebung bekannt ist, jedoch bevor der Kontext erstellt wird.

Ein ApplicationPreparedEvent wird unmittelbar vor dem Start der Aktualisierung gesendet, jedoch nachdem die Bean-Definitionen geladen wurden.

Nach der Aktualisierung wird ein ApplicationReadyEvent gesendet, und alle zugehörigen Rückrufe wurden verarbeitet, um anzuzeigen, dass die Anwendung für Serviceanforderungen bereit ist.

Ein ApplicationFailedEvent wird gesendet, wenn beim Start eine Ausnahme auftritt.

...

Warum erstellen Sie nicht einfach eine Bean, die Ihren Monitor bei der Initialisierung startet?

@Component
public class Monitor {
    @Autowired private SomeService service

    @PostConstruct
    public void init(){
        // start your monitoring in here
    }
}

Die initMethode wird erst aufgerufen, wenn für die Bean eine automatische Verdrahtung durchgeführt wurde.

Der "Spring Boot" Weg ist die Verwendung von a CommandLineRunner. Fügen Sie einfach Bohnen dieser Art hinzu und schon kann es losgehen. In Spring 4.1 (Boot 1.2) gibt es auch einen, SmartInitializingBeander einen Rückruf erhält, nachdem alles initialisiert wurde. Und das gibt es SmartLifecycle(ab Frühling 3).

Sie können eine Klasse mit erweitern ApplicationRunner, die run()Methode überschreiben und dort den Code hinzufügen.

import org.springframework.boot.ApplicationRunner;

@Component
public class ServerInitializer implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments applicationArguments) throws Exception {

        //code goes here

    }
}

ApplicationReadyEventist wirklich nur dann nützlich, wenn die Aufgabe, die Sie ausführen möchten, keine Voraussetzung für einen korrekten Serverbetrieb ist. Ein gutes Beispiel ist das Starten einer asynchronen Aufgabe, um etwas auf Änderungen zu überwachen.

Wenn sich Ihr Server jedoch bis zum Abschluss der Aufgabe in einem Status "Nicht bereit" befindet, ist es besser, ihn zu implementieren, SmartInitializingSingletonda Sie den Rückruf erhalten, bevor Ihr REST-Port geöffnet wurde und Ihr Server für den Geschäftsbetrieb geöffnet ist.

Seien Sie nicht versucht, @PostConstructAufgaben zu verwenden, die nur einmal ausgeführt werden sollten. Sie werden eine grobe Überraschung bekommen, wenn Sie bemerken, dass es mehrmals aufgerufen wird ...

Mit Federkonfiguration:

@Configuration
public class ProjectConfiguration {
    private static final Logger log = 
   LoggerFactory.getLogger(ProjectConfiguration.class);

   @EventListener(ApplicationReadyEvent.class)
   public void doSomethingAfterStartup() {
    log.info("hello world, I have just started up");
  }
}

Verwenden Sie SmartInitializingSingletonim Frühjahr eine Bohne> 4.1

@Bean
public SmartInitializingSingleton importProcessor() {
    return () -> {
        doStuff();
    };

}

Alternativ kann eine CommandLineRunnerBean implementiert oder eine Bean-Methode mit kommentiert werden @PostConstruct.

Ein Beispiel für die Antwort von Dave Syer, die wie ein Zauber wirkte:

@Component
public class CommandLineAppStartupRunner implements CommandLineRunner {
    private static final Logger logger = LoggerFactory.getLogger(CommandLineAppStartupRunner.class);

    @Override
    public void run(String...args) throws Exception {
        logger.info("Application started with command-line arguments: {} . \n To kill this application, press Ctrl + C.", Arrays.toString(args));
    }
}

Versuchen Sie dies und es wird Ihr Code ausgeführt, wenn der Anwendungskontext vollständig gestartet wurde.

 @Component
public class OnStartServer implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent arg0) {
                // EXECUTE YOUR CODE HERE 
    }
}

Ich mag den Vorschlag für die Verwendung der EventListenerAnmerkung von @cahen ( https://stackoverflow.com/a/44923402/9122660 ) sehr, da sie sehr sauber ist. Leider konnte ich dies in einem Spring + Kotlin-Setup nicht zum Laufen bringen. Für Kotlin funktioniert das Hinzufügen der Klasse als Methodenparameter:

@EventListener 
fun doSomethingAfterStartup(event: ApplicationReadyEvent) {
    System.out.println("hello world, I have just started up");
}

Der beste Weg, um einen Codeblock nach dem Start der Spring Boot-Anwendung auszuführen, ist die Verwendung der PostConstruct-Annotation. Oder Sie können auch den Befehlszeilen-Runner für dieselbe verwenden.

1. Verwenden der PostConstruct-Annotation

@Configuration
public class InitialDataConfiguration {

    @PostConstruct
    public void postConstruct() {
        System.out.println("Started after Spring boot application !");
    }

}

2. Verwenden der Befehlszeilen-Runner-Bean

@Configuration
public class InitialDataConfiguration {

    @Bean
    CommandLineRunner runner() {
        return args -> {
            System.out.println("CommandLineRunner running in the UnsplashApplication class...");
        };
    }
}

Implementieren Sie einfach CommandLineRunner für die Spring-Boot-Anwendung. Sie müssen die Ausführungsmethode implementieren.

public classs SpringBootApplication implements CommandLineRunner{

    @Override
        public void run(String... arg0) throws Exception {
        // write your logic here 

        }
}

Beste Verwendung von CommandLineRunner oder ApplicationRunner Der einzige Unterschied zwischen der run () -Methode CommandLineRunner akzeptiert ein Array von Zeichenfolgen und ApplicationRunner akzeptiert ApplicationArugument.