Eseguire il metodo all'avvio in primavera

Esiste qualche funzione di Spring 3 per eseguire alcuni metodi quando l'applicazione viene avviata per la prima volta? So che posso fare il trucco di impostare un metodo con @Scheduledannotazione e viene eseguito subito dopo l'avvio, ma poi verrà eseguito periodicamente.

Se per "avvio dell'applicazione" intendi "avvio del contesto dell'applicazione", allora sì, ci sono molti modi per farlo , il più semplice (per i bean singleton, comunque) è annotare il tuo metodo @PostConstruct. Dai un'occhiata al link per vedere le altre opzioni, ma in sintesi sono:

• Metodi annotati con @PostConstruct
• afterPropertiesSet()come definito dall'interfaccia di InitializingBeancallback
• Un metodo init () personalizzato configurato

Tecnicamente, questi sono agganci nel ciclo di vita del bean , piuttosto che nel ciclo di vita del contesto, ma nel 99% dei casi i due sono equivalenti.

Se devi collegarti specificamente al contesto di avvio / arresto, puoi invece implementare l' Lifecycleinterfaccia , ma probabilmente non è necessario.

Questo è fatto facilmente con un ApplicationListener. Ho ottenuto questo per lavorare ascoltando 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 
  }
}

I listener di applicazioni vengono eseguiti in modo sincrono in primavera. Se vuoi assicurarti che il tuo codice venga eseguito una sola volta, mantieni uno stato nel tuo componente.

AGGIORNARE

A partire da Spring 4.2+ puoi anche usare l' @EventListenerannotazione per osservare ContextRefreshedEvent(grazie a @bphilipnyc per averlo sottolineato):

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

In Spring 4.2+ ora puoi semplicemente fare:

@Component
class StartupHousekeeper {

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

Se si utilizza l'avvio a molla, questa è la risposta migliore.

Sento che @PostConstructe altre varie interiezioni del ciclo di vita sono modi circolari. Questi possono portare direttamente a problemi di runtime o causare difetti non ovvi a causa di eventi imprevisti del ciclo di vita del bean / contesto. Perché non semplicemente invocare direttamente il tuo bean usando Java semplice? Invoca ancora il bean in "modo primaverile" (ad es. Attraverso il proxy AoP di primavera). E soprattutto, è semplicemente Java, non può essere più semplice di così. Non sono necessari ascoltatori di contesto o programmatori dispari.

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

Per gli utenti di Java 1.8 che stanno ricevendo un avviso quando provano a fare riferimento all'annotazione @PostConstruct, ho finito invece con il piggyback dell'annotazione @Scheduled che puoi fare se hai già un lavoro @Scheduled con fixedRate o 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");
    }

}

Ciò che abbiamo fatto è stato estendere org.springframework.web.context.ContextLoaderListenerper stampare qualcosa quando inizia il contesto.

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

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

Configurare la sottoclasse quindi in web.xml:

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

Con SpringBoot, possiamo eseguire un metodo all'avvio tramite @EventListenerannotazione

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

Attenzione, questo è consigliato solo se il runOnceOnStartupmetodo dipende da un contesto di primavera completamente inizializzato. Ad esempio: decidi di chiamare un dao con demarcazione delle transazioni

È inoltre possibile utilizzare un metodo pianificato con fixedDelay impostato su un valore molto alto

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

Questo ha il vantaggio che l'intera applicazione è cablata (Transazioni, Dao, ...)

visto in Pianificazione delle attività da eseguire una volta, utilizzando lo spazio dei nomi delle attività di Spring

Inserita un'altra soluzione che implementa WebApplicationInitializer e viene chiamata molto prima che un'istanza di un bean di primavera, nel caso in cui qualcuno abbia quel caso d'uso

Inizializza impostazioni internazionali e fuso orario predefiniti con la configurazione Spring

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

        }
    }
}

Se si desidera configurare un bean prima che l'applicazione venga eseguita completamente, è possibile utilizzare @Autowired:

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

È possibile utilizzare @EventListeneril componente, che verrà richiamato dopo l'avvio del server e l'inizializzazione di tutti i bean.

@EventListener
public void onApplicationEvent(ContextClosedEvent event) {

}

Per un file che si StartupHousekeeper.javatrova nel pacchetto com.app.startup,

Fallo in StartupHousekeeper.java:

@Component
public class StartupHousekeeper {

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

E farlo in myDispatcher-servlet.java:

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

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

</beans>