Ejecutar método al inicio en primavera

¿Existe alguna característica de Spring 3 para ejecutar algunos métodos cuando la aplicación se inicia por primera vez? Sé que puedo hacer el truco de configurar un método con @Scheduledanotaciones y se ejecuta justo después del inicio, pero luego se ejecutará periódicamente.

Si por "inicio de la aplicación" te refieres a "inicio del contexto de la aplicación", entonces sí, hay muchas maneras de hacerlo , la más fácil (para los beans singletons, de todos modos) es anotar tu método @PostConstruct. Eche un vistazo al enlace para ver las otras opciones, pero en resumen son:

• Métodos anotados con @PostConstruct
• afterPropertiesSet()según lo definido por la InitializingBeaninterfaz de devolución de llamada
• Un método init () configurado personalizado

Técnicamente, estos son ganchos en el ciclo de vida del bean , en lugar del ciclo de vida del contexto, pero en el 99% de los casos, los dos son equivalentes.

Si necesita conectarse específicamente al inicio / apagado del contexto, puede implementar la Lifecycleinterfaz en su lugar, pero probablemente eso sea innecesario.

Esto se hace fácilmente con un ApplicationListener. Llegué a esto escuchando Spring's 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 
  }
}

Los escuchas de aplicaciones se ejecutan sincrónicamente en Spring. Si desea asegurarse de que su código se ejecute solo una vez, solo mantenga algún estado en su componente.

ACTUALIZAR

Comenzando con Spring 4.2+ también puede usar la @EventListeneranotación para observar el ContextRefreshedEvent(gracias a @bphilipnyc por señalar esto):

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

En Spring 4.2+ ahora puedes simplemente hacer:

@Component
class StartupHousekeeper {

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

Si está utilizando spring-boot, esta es la mejor respuesta.

Siento que @PostConstructy otras diversas interjecciones del ciclo de vida son formas redondas. Estos pueden conducir directamente a problemas de tiempo de ejecución o causar defectos menos que obvios debido a eventos inesperados del ciclo de vida del bean / contexto. ¿Por qué no invocar directamente su bean utilizando Java simple? Todavía invocas el bean 'spring way' (por ejemplo, a través del proxy AoP de spring). Y lo mejor de todo, es simplemente Java, no puede ser más simple que eso. No hay necesidad de oyentes contextuales o programadores extraños.

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

Para los usuarios de Java 1.8 que reciben una advertencia cuando intentan hacer referencia a la anotación @PostConstruct, terminé aprovechando la anotación @Scheduled que puede hacer si ya tiene un trabajo @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");
    }

}

Lo que hemos hecho fue extender org.springframework.web.context.ContextLoaderListenerpara imprimir algo cuando comienza el contexto.

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

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

Configure la subclase luego en web.xml:

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

Con SpringBoot, podemos ejecutar un método en el inicio mediante @EventListeneranotaciones

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

Atención, esto solo se recomienda si su runOnceOnStartupmétodo depende de un contexto de primavera totalmente inicializado. Por ejemplo: desea llamar a un dao con demarcación de transacción

También puede usar un método programado con fixedDelay establecido muy alto

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

Esto tiene la ventaja de que toda la aplicación está conectada (Transacciones, Dao, ...)

visto en Programación de tareas para ejecutar una vez, usando el espacio de nombres de tareas Spring

Publicó otra solución que implementa WebApplicationInitializer y se llama mucho antes de que se instale cualquier bean spring, en caso de que alguien tenga ese caso de uso

Inicialice la configuración regional y la zona horaria predeterminadas con la configuración de Spring

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

        }
    }
}

Si desea configurar un bean antes de que su aplicación se ejecute por completo, puede usar @Autowired:

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

Puede usar @EventListeneren su componente, que se invocará después de que se inicie el servidor y se inicialicen todos los beans.

@EventListener
public void onApplicationEvent(ContextClosedEvent event) {

}

Para un archivo StartupHousekeeper.javaubicado en el paquetecom.app.startup ,

Haz esto en StartupHousekeeper.java:

@Component
public class StartupHousekeeper {

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

Y haz esto en myDispatcher-servlet.java:

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

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

</beans>