Exécution de code après le démarrage de Spring Boot

Je souhaite exécuter du code après le démarrage de mon application Spring-Boot pour surveiller les modifications d'un répertoire.

J'ai essayé d'exécuter un nouveau thread mais les @Autowiredservices n'ont pas été définis à ce stade.

J'ai pu trouver ApplicationPreparedEventce qui se déclenche avant que les @Autowiredannotations ne soient définies. Idéalement, j'aimerais que l'événement se déclenche une fois que l'application est prête à traiter les demandes http.

Y a-t-il un meilleur événement à utiliser ou une meilleure façon d'exécuter du code après que l'application est en ligne au printemps ?

Essayer:

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

C'est aussi simple que cela:

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

Testé sur la version 1.5.1.RELEASE

Avez-vous essayé 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;
  }
}

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

Voici ce que la documentation mentionne sur les événements de démarrage:

...

Les événements d'application sont envoyés dans l'ordre suivant lors de l'exécution de votre application:

Un ApplicationStartedEvent est envoyé au début d'une exécution, mais avant tout traitement, à l'exception de l'enregistrement des écouteurs et des initialiseurs.

Un ApplicationEnvironmentPreparedEvent est envoyé lorsque l'environnement à utiliser dans le contexte est connu, mais avant la création du contexte.

Un ApplicationPreparedEvent est envoyé juste avant le démarrage de l'actualisation, mais après le chargement des définitions de bean.

Un ApplicationReadyEvent est envoyé après l'actualisation et tous les rappels associés ont été traités pour indiquer que l'application est prête à répondre aux demandes.

Un ApplicationFailedEvent est envoyé s'il existe une exception au démarrage.

...

Pourquoi ne pas simplement créer un bean qui démarre votre moniteur lors de l'initialisation, quelque chose comme:

@Component
public class Monitor {
    @Autowired private SomeService service

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

la initméthode ne sera pas appelée tant que le câblage automatique n'aura pas été effectué pour le bean.

La méthode "Spring Boot" consiste à utiliser a CommandLineRunner. Ajoutez simplement des haricots de ce type et vous êtes prêt à partir. Dans Spring 4.1 (Boot 1.2), il y a aussi un SmartInitializingBeanqui reçoit un rappel après que tout a été initialisé. Et il y en a SmartLifecycle(à partir du printemps 3).

Vous pouvez étendre une classe à l'aide de ApplicationRunner, remplacer la run()méthode et y ajouter le code.

import org.springframework.boot.ApplicationRunner;

@Component
public class ServerInitializer implements ApplicationRunner {

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

        //code goes here

    }
}

ApplicationReadyEventn'est vraiment utile que si la tâche que vous souhaitez effectuer n'est pas requise pour un fonctionnement correct du serveur. Le démarrage d'une tâche asynchrone pour surveiller quelque chose pour les changements est un bon exemple.

Si, cependant, votre serveur est dans un état `` non prêt '' jusqu'à ce que la tâche soit terminée, il est préférable de l'implémenter SmartInitializingSingletoncar vous recevrez le rappel avant l' ouverture de votre port REST et votre serveur est ouvert pour les entreprises.

Ne soyez pas tenté d'utiliser @PostConstructpour des tâches qui ne devraient se produire qu'une seule fois. Vous aurez une grossière surprise lorsque vous remarquerez qu'il est appelé plusieurs fois ...

Avec configuration à ressort:

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

Utilisez un SmartInitializingSingletonharicot au printemps> 4,1

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

}

Comme alternative, un CommandLineRunnerbean peut être implémenté ou annoter une méthode de bean avec @PostConstruct.

Voici un exemple de réponse de Dave Syer, qui a fonctionné comme un charme:

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

Essayez celui-ci et il exécutera votre code lorsque le contexte d'application aura complètement démarré.

 @Component
public class OnStartServer implements ApplicationListener<ContextRefreshedEvent> {

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

J'aime vraiment la suggestion d'utilisation de l' EventListenerannotation par @cahen ( https://stackoverflow.com/a/44923402/9122660 ) car elle est très propre. Malheureusement, je n'ai pas pu faire fonctionner cela dans une configuration Spring + Kotlin. Ce qui fonctionne pour Kotlin, c'est l'ajout de la classe comme paramètre de méthode:

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

La meilleure façon d'exécuter un bloc de code après le démarrage de l'application Spring Boot est d'utiliser l'annotation PostConstruct, ou vous pouvez également utiliser un exécuteur de ligne de commande pour la même chose.

1. Utilisation de l'annotation PostConstruct

@Configuration
public class InitialDataConfiguration {

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

}

2. Utilisation du bean runner de ligne de commande

@Configuration
public class InitialDataConfiguration {

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

implémentez simplement CommandLineRunner pour l’application Spring Boot. Vous devez implémenter la méthode d'exécution,

public classs SpringBootApplication implements CommandLineRunner{

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

        }
}

Meilleure façon d'utiliser CommandLineRunner ou ApplicationRunner La seule différence entre la méthode run () est que CommandLineRunner accepte un tableau de chaînes et ApplicationRunner accepte ApplicationArugument.