Uruchamianie kodu po uruchomieniu Spring Boot

Chcę uruchomić kod po tym, jak moja wiosenna aplikacja uruchomi monitorowanie katalogu pod kątem zmian.

Próbowałem uruchomić nowy wątek, ale @Autowiredusługi nie zostały ustawione w tym momencie.

Udało mi się znaleźć ApplicationPreparedEvent, który odpala przed ustawieniem @Autowiredadnotacji. Idealnie byłoby, gdyby zdarzenie zostało uruchomione, gdy aplikacja będzie gotowa do przetwarzania żądań HTTP.

Czy istnieje lepsze zdarzenie do użycia lub lepszy sposób uruchamiania kodu po uruchomieniu aplikacji w trybie rozruchu wiosennego ?

Próbować:

@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
    }
}

Jest to tak proste:

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

Testowane na wersji 1.5.1.RELEASE

Czy próbowałeś ApplicationReadyEvent?

@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;
  }
}

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

Oto, co dokumentacja wspomina o zdarzeniach uruchamiania:

...

Zdarzenia aplikacji są wysyłane w następującej kolejności, w miarę działania aplikacji:

ApplicationStartedEvent jest wysyłany na początku uruchomienia, ale przed jakimkolwiek przetwarzaniem, z wyjątkiem rejestracji detektorów i inicjatorów.

ApplicationEnvironmentPreparedEvent jest wysyłany, gdy znane jest środowisko do użycia w kontekście, ale przed utworzeniem kontekstu.

ApplicationPreparedEvent jest wysyłany tuż przed rozpoczęciem odświeżania, ale po załadowaniu definicji komponentu bean.

ApplicationReadyEvent jest wysyłany po odświeżeniu i wszelkich powiązanych wywołaniach zwrotnych, aby wskazać, że aplikacja jest gotowa do obsługi żądań.

ApplicationFailedEvent jest wysyłany, jeśli istnieje wyjątek podczas uruchamiania.

...

Dlaczego nie stworzyć fasoli, która uruchamia monitor podczas inicjalizacji, na przykład:

@Component
public class Monitor {
    @Autowired private SomeService service

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

initmetoda nie zostanie wywołana dopóki każdy autowiring odbywa się na fasoli.

„Spring Boot” polega na użyciu CommandLineRunner. Po prostu dodaj fasolę tego typu i możesz zacząć. W Spring 4.1 (Boot 1.2) jest też taki, SmartInitializingBeanktóry odbiera oddzwonienie po zainicjowaniu wszystkiego. I jest SmartLifecycle(od wiosny 3).

Możesz rozszerzyć klasę za pomocą ApplicationRunner, przesłonić run()metodę i dodać tam kod.

import org.springframework.boot.ApplicationRunner;

@Component
public class ServerInitializer implements ApplicationRunner {

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

        //code goes here

    }
}

ApplicationReadyEventjest naprawdę przydatny tylko wtedy, gdy zadanie, które chcesz wykonać, nie jest wymagane do poprawnego działania serwera. Dobrym przykładem jest uruchomienie zadania asynchronicznego w celu monitorowania czegoś pod kątem zmian.

Jeśli jednak serwer jest w stanie „niegotowym”, dopóki zadanie nie zostanie zakończone, lepiej go zaimplementować, SmartInitializingSingletonponieważ otrzymasz wywołanie zwrotne przed otwarciem portu REST i otwarciem serwera dla firmy.

Nie daj się skusić do @PostConstructwykonywania zadań, które powinny się zdarzyć tylko raz. Otrzymasz niegrzeczną niespodziankę, gdy zauważysz, że jest wywoływana wiele razy ...

W konfiguracji sprężynowej:

@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");
  }
}

Użyj SmartInitializingSingletonfasoli na wiosnę> 4.1

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

}

Alternatywnie CommandLineRunnermożna zaimplementować fasolę lub dodać do niej metodę fasoli @PostConstruct.

Podając przykład odpowiedzi Dave'a Syera, która działała jak urok:

@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));
    }
}

Wypróbuj ten, a uruchomi Twój kod, gdy kontekst aplikacji zostanie w pełni uruchomiony.

 @Component
public class OnStartServer implements ApplicationListener<ContextRefreshedEvent> {

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

Bardzo podoba mi się sugestia użycia EventListeneradnotacji przez @cahen ( https://stackoverflow.com/a/44923402/9122660 ), ponieważ jest bardzo czysta. Niestety nie udało mi się uruchomić tego w konfiguracji Spring + Kotlin. To, co działa dla Kotlin, to dodanie klasy jako parametru metody:

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

Najlepszym sposobem na wykonanie bloku kodu po uruchomieniu aplikacji Spring Boot jest skorzystanie z adnotacji PostConstruct lub do tego samego można użyć programu uruchamiającego z wiersza poleceń.

1. Korzystanie z adnotacji PostConstruct

@Configuration
public class InitialDataConfiguration {

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

}

2. Korzystanie z komponentu bean runner z wiersza poleceń

@Configuration
public class InitialDataConfiguration {

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

wystarczy zaimplementować CommandLineRunner dla aplikacji rozruchu wiosennego. Musisz zaimplementować metodę uruchamiania,

public classs SpringBootApplication implements CommandLineRunner{

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

        }
}

Najlepszy sposób korzystania z CommandLineRunner lub ApplicationRunner Jedyną różnicą jest metoda run () CommandLineRunner akceptuje tablicę ciągów, a ApplicationRunner akceptuje ApplicationArugument.