Exécuter la méthode au démarrage au printemps

Existe-t-il une fonctionnalité Spring 3 pour exécuter certaines méthodes lorsque l'application démarre pour la première fois? Je sais que je peux faire l'astuce de définir une méthode avec @Scheduledannotation et qu'elle s'exécute juste après le démarrage, mais ensuite elle s'exécutera périodiquement.

Si par "démarrage de l'application" vous entendez "démarrage du contexte de l'application", alors oui, il existe de nombreuses façons de le faire , la plus simple (pour les beans singletons, en tout cas) étant d'annoter votre méthode avec @PostConstruct. Jetez un œil au lien pour voir les autres options, mais en résumé, ce sont:

• Méthodes annotées avec @PostConstruct
• afterPropertiesSet()comme défini par l' InitializingBeaninterface de rappel
• Une méthode init () personnalisée

Techniquement, ce sont des crochets dans le cycle de vie du bean , plutôt que dans le cycle de vie du contexte, mais dans 99% des cas, les deux sont équivalents.

Si vous avez besoin de vous connecter spécifiquement au démarrage / arrêt du contexte, vous pouvez implémenter l' Lifecycleinterface à la place, mais ce n'est probablement pas nécessaire.

Cela se fait facilement avec un fichier ApplicationListener. J'ai fait travailler ça en écoutant Spring ContextRefreshedEvent:

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class StartupHousekeeper implements ApplicationListener<ContextRefreshedEvent> {

  @Override
  public void onApplicationEvent(final ContextRefreshedEvent event) {
    // do whatever you need here 
  }
}

Les écouteurs d'applications s'exécutent de manière synchrone dans Spring. Si vous voulez vous assurer que votre code n'est exécuté qu'une seule fois, gardez simplement un état dans votre composant.

METTRE À JOUR

À partir de Spring 4.2+, vous pouvez également utiliser l' @EventListenerannotation pour observer le ContextRefreshedEvent(merci à @bphilipnyc pour l'avoir signalé):

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class StartupHousekeeper {

  @EventListener(ContextRefreshedEvent.class)
  public void contextRefreshedEvent() {
    // do whatever you need here 
  }
}

Dans Spring 4.2+, vous pouvez maintenant simplement faire:

@Component
class StartupHousekeeper {

    @EventListener(ContextRefreshedEvent.class)
    public void contextRefreshedEvent() {
        //do whatever
    }
}

Si vous utilisez des bottes à ressort, c'est la meilleure réponse.

Je pense que cela @PostConstructet d'autres interjections du cycle de vie sont des voies rondes. Celles-ci peuvent conduire directement à des problèmes d'exécution ou provoquer des défauts moins qu'évidents dus à des événements de cycle de vie bean / contexte inattendus. Pourquoi ne pas simplement appeler directement votre bean en utilisant Java brut? Vous invoquez toujours le bean de la «manière du ressort» (par exemple: via le proxy Spring AoP). Et le meilleur de tous, c'est du java simple, ne peut pas être plus simple que cela. Pas besoin d'écouteurs de contexte ou de programmateurs étranges.

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext app = SpringApplication.run(DemoApplication.class, args);

        MyBean myBean = (MyBean)app.getBean("myBean");

        myBean.invokeMyEntryPoint();
    }
}

Pour les utilisateurs de Java 1.8 qui reçoivent un avertissement lorsqu'ils essaient de référencer l'annotation @PostConstruct, j'ai fini par utiliser l'annotation @Scheduled, ce que vous pouvez faire si vous avez déjà un travail @Scheduled avec fixedRate ou fixedDelay.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@EnableScheduling
@Component
public class ScheduledTasks {

private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTasks.class);

private static boolean needToRunStartupMethod = true;

    @Scheduled(fixedRate = 3600000)
    public void keepAlive() {
        //log "alive" every hour for sanity checks
        LOGGER.debug("alive");
        if (needToRunStartupMethod) {
            runOnceOnlyOnStartup();
            needToRunStartupMethod = false;
        }
    }

    public void runOnceOnlyOnStartup() {
        LOGGER.debug("running startup job");
    }

}

Ce que nous avons fait a été d'étendre org.springframework.web.context.ContextLoaderListenerpour imprimer quelque chose lorsque le contexte démarre.

public class ContextLoaderListener extends org.springframework.web.context.ContextLoaderListener
{
    private static final Logger logger = LoggerFactory.getLogger( ContextLoaderListener.class );

    public ContextLoaderListener()
    {
        logger.info( "Starting application..." );
    }
}

Configurez ensuite la sous-classe dans web.xml:

<listener>
    <listener-class>
        com.mycomp.myapp.web.context.ContextLoaderListener
    </listener-class>
</listener>

Avec SpringBoot, nous pouvons exécuter une méthode au démarrage via une @EventListenerannotation

@Component
public class LoadDataOnStartUp
{   
    @EventListener(ApplicationReadyEvent.class)
    public void loadData()
    {
        // do something
    }
}

Attention, cela n'est conseillé que si votre runOnceOnStartupméthode dépend d'un contexte de ressort entièrement initialisé. Par exemple: vous souhaitez appeler un DAO avec une démarcation de transaction

Vous pouvez également utiliser une méthode planifiée avec un paramètre fixedDelay très élevé

@Scheduled(fixedDelay = Long.MAX_VALUE)
public void runOnceOnStartup() {
    dosomething();
}

Cela présente l'avantage que toute l'application est câblée (Transactions, Dao, ...)

vu dans Planification des tâches à exécuter une fois, à l'aide de l'espace de noms de tâches Spring

Publication d'une autre solution qui implémente WebApplicationInitializer et qui est appelée bien avant qu'un bean spring ne soit instancié, au cas où quelqu'un aurait ce cas d'utilisation

Initialiser les paramètres régionaux et le fuseau horaire par défaut avec la configuration Spring

AppStartListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if(event instanceof ApplicationReadyEvent){
            System.out.print("ciao");

        }
    }
}

Si vous souhaitez configurer un bean avant que votre application ne s'exécute complètement, vous pouvez utiliser @Autowired:

@Autowired
private void configureBean(MyBean: bean) {
    bean.setConfiguration(myConfiguration);
}

Vous pouvez utiliser @EventListenersur votre composant, qui sera appelé après le démarrage du serveur et l'initialisation de tous les beans.

@EventListener
public void onApplicationEvent(ContextClosedEvent event) {

}

Pour un fichier StartupHousekeeper.javasitué dans le package com.app.startup,

Faites ceci dans StartupHousekeeper.java:

@Component
public class StartupHousekeeper {

  @EventListener(ContextRefreshedEvent.class)
  public void keepHouse() {
    System.out.println("This prints at startup.");
  }
}

Et faites-le en myDispatcher-servlet.java:

<?xml version="1.0" encoding="UTF-8"?>
<beans>

    <mvc:annotation-driven />
    <context:component-scan base-package="com.app.startup" />

</beans>