Esecuzione del codice dopo l'avvio di Spring Boot

Voglio eseguire il codice dopo che la mia app di avvio a molla inizia a monitorare una directory per le modifiche.

Ho provato a eseguire un nuovo thread ma i @Autowiredservizi non sono stati impostati a quel punto.

Sono stato in grado di trovare ApplicationPreparedEvent, che si attiva prima che @Autowiredvengano impostate le annotazioni. Idealmente, vorrei che l'evento si attivasse quando l'applicazione è pronta per elaborare le richieste http.

Esiste un evento migliore da utilizzare o un modo migliore di eseguire il codice dopo che l'applicazione è attiva in Spring-Boot ?

Provare:

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

È semplice come questo:

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

Testato sulla versione 1.5.1.RELEASE

Hai provato 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;
  }
}

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

Questo è ciò che la documentazione menziona sugli eventi di avvio:

...

Gli eventi dell'applicazione vengono inviati nel seguente ordine, durante l'esecuzione dell'applicazione:

Un ApplicationStartedEvent viene inviato all'inizio di una corsa, ma prima di qualsiasi elaborazione eccetto la registrazione di listener e inizializzatori.

Un ApplicationEnvironmentPreparedEvent viene inviato quando l'ambiente da utilizzare nel contesto è noto, ma prima della creazione del contesto.

Un ApplicationPreparedEvent viene inviato subito prima dell'avvio dell'aggiornamento, ma dopo che le definizioni dei bean sono state caricate.

Un ApplicationReadyEvent viene inviato dopo l'aggiornamento e tutti i callback correlati sono stati elaborati per indicare che l'applicazione è pronta per soddisfare le richieste.

Viene inviato un ApplicationFailedEvent se si verifica un'eccezione all'avvio.

...

Perché non creare semplicemente un bean che avvia il monitor all'inizializzazione, qualcosa del tipo:

@Component
public class Monitor {
    @Autowired private SomeService service

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

il initmetodo non verrà chiamato fino a quando non viene eseguito alcun autowiring per il bean.

Il modo "Spring Boot" è di usare a CommandLineRunner. Aggiungi solo fagioli di quel tipo e sei a posto. In Spring 4.1 (Boot 1.2) c'è anche un oggetto SmartInitializingBeanche riceve un callback dopo che tutto è stato inizializzato. E c'è SmartLifecycle(dalla primavera 3).

È possibile estendere una classe utilizzando ApplicationRunner, sovrascrivere il run()metodo e aggiungere il codice lì.

import org.springframework.boot.ApplicationRunner;

@Component
public class ServerInitializer implements ApplicationRunner {

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

        //code goes here

    }
}

ApplicationReadyEventè davvero utile solo se l'attività che si desidera eseguire non è un requisito per il corretto funzionamento del server. L'avvio di un'attività asincrona per monitorare qualcosa per le modifiche è un buon esempio.

Se, tuttavia, il tuo server è in uno stato 'non pronto' fino al completamento dell'attività, è meglio implementarlo SmartInitializingSingletonperché otterrai la richiamata prima che la tua porta REST sia stata aperta e che il tuo server sia aperto per le imprese.

Non essere tentato di utilizzare @PostConstructper attività che dovrebbero avvenire una sola volta. Riceverai una brutta sorpresa quando noti che viene chiamato più volte ...

Con configurazione a molla:

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

Usa un SmartInitializingSingletonfagiolo in primavera> 4.1

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

}

In alternativa è CommandLineRunnerpossibile implementare un bean o annotare un metodo bean con @PostConstruct.

Fornendo un esempio per la risposta di Dave Syer, che ha funzionato come un incantesimo:

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

Prova questo ed eseguirà il tuo codice quando il contesto dell'applicazione sarà completamente avviato.

 @Component
public class OnStartServer implements ApplicationListener<ContextRefreshedEvent> {

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

Mi piace molto il suggerimento per l'utilizzo EventListenerdell'annotazione di @cahen ( https://stackoverflow.com/a/44923402/9122660 ) poiché è molto pulito. Purtroppo non sono riuscito a farlo funzionare in una configurazione Spring + Kotlin. Ciò che funziona per Kotlin è l'aggiunta della classe come parametro del metodo:

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

Il modo migliore per eseguire il blocco di codice dopo l'avvio dell'applicazione Spring Boot consiste nell'utilizzare l'annotazione PostConstruct, oppure è possibile utilizzare il runner della riga di comando per lo stesso.

1. Usando l'annotazione PostConstruct

@Configuration
public class InitialDataConfiguration {

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

}

2. Utilizzo del bean runner della riga di comando

@Configuration
public class InitialDataConfiguration {

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

basta implementare CommandLineRunner per l'applicazione di avvio a molla. È necessario implementare il metodo di esecuzione,

public classs SpringBootApplication implements CommandLineRunner{

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

        }
}

Il modo migliore di utilizzare CommandLineRunner o ApplicationRunner L'unica differenza tra il metodo run () CommandLineRunner accetta la matrice di stringhe e ApplicationRunner accetta ApplicationArugument.