Esegui metodo all'avvio in primavera

Question

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

Grazie.

Answer 1

Se per "l'avvio dell'applicazione" si intende "l'avvio contesto di applicazione", allora sì, ci sono many ways to do this, il modo più semplice (per i fagioli single, comunque) è quello di annotare il metodo con @PostConstruct. Date un'occhiata al link per vedere le altre opzioni, ma in sintesi sono:

• metodi annotati con @PostConstruct
• afterPropertiesSet() come definito dall'interfaccia InitializingBean richiamata
• Un init configurato personalizzato() metodo

Tecnicamente, questi sono ganci nella fagiolo ciclo di vita, piuttosto che il ciclo di vita del contesto, ma nel 99% dei casi, i due sono equivalenti.

Se è necessario collegare in modo specifico all'avvio/arresto del contesto, è possibile invece implement the Lifecycle interface, ma probabilmente non è necessario.

Answer 2

Questo è facilmente possibile con un ApplicationListener. Ho avuto questo lavoro l'ascolto di Primavera di 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 
    } 
} 

ascoltatori applicativi eseguiti in modo sincrono in primavera. Se vuoi assicurarti che il codice venga eseguito una volta sola, mantieni uno stato nel componente.

UPDATE

partire con la primavera 4.2+ è anche possibile utilizzare il @EventListener annotazioni di osservare le ContextRefreshedEvent (grazie al @bphilipnyc per la precisazione):

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

Answer 3

Quello che abbiamo fatto è stato che si estende org.springframework.web.context.ContextLoaderListener per stampare qualcosa all'avvio del 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 poi in web.xml:

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

Answer 4

Pubblicato un'altra soluzione che implementa WebApplicationInitializer e si chiama molto prima di ogni chicco di primavera viene creata un'istanza, nel caso in cui qualcuno ha quel caso d'uso

Initialize default Locale and Timezone with Spring configuration

Answer 5

Per gli utenti di Java 1.8 che ricevono un avviso quando si tenta di fare riferimento a @PostC onstruct annotation, ho finito invece con il piggybacking 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"); 
    } 

} 

Answer 6

Se si utilizza lo spring-boot, questa è la migliore risposta.

Ritengo che @PostConstruct e altre varie interruzioni del ciclo di vita siano modi di arrotondamento. Questi possono portare direttamente a problemi di runtime o causare meno di difetti evidenti a causa di eventi di ciclo di vita di bean/contesto imprevisti. Perché non invocare direttamente il tuo bean usando semplicemente Java? Continui a invocare il bean come "spring way" (es: attraverso il proxy AoP di primavera). E soprattutto, è semplice java, non può essere più semplice di così. Non c'è bisogno di 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(); 
    } 
} 

Answer 7

Se si desidera configurare un fagiolo prima che l'applicazione è in esecuzione completamente, è possibile utilizzare @Autowired:

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

Answer 8

Attenzione, questo è consigliato solo se il metodo di runOnceOnStartup dipende da un completamente contesto primaverile inizializzato. Per esempio: si wan per chiamare un dao con la demarcazione delle transazioni

È inoltre possibile utilizzare un metodo programmato con FIXEDRimossa l'attesa impostato molto alto

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

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

visti in Scheduling tasks to run once, using the Spring task namespace

Answer 9

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

     } 
    } 
} 

Answer 10

In primavera 4.2+ ora puoi semplicemente fare:

@Component 
class StartupHousekeeper { 

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