Executar método na inicialização no Spring

Existe algum recurso do Spring 3 para executar alguns métodos quando o aplicativo é iniciado pela primeira vez? Eu sei que posso @Scheduledexecutar o truque de definir um método com anotação e ele é executado logo após a inicialização, mas será executado periodicamente.

Se por "inicialização do aplicativo" você quer dizer "inicialização do contexto do aplicativo", sim, existem muitas maneiras de fazer isso , sendo a mais fácil (para os feijões singletons, de qualquer maneira) anotar seu método @PostConstruct. Dê uma olhada no link para ver as outras opções, mas em resumo elas são:

• Métodos anotados com @PostConstruct
• afterPropertiesSet()conforme definido pela InitializingBeaninterface de retorno de chamada
• Um método init () configurado personalizado

Tecnicamente, esses são ganchos no ciclo de vida do bean , em vez do ciclo de vida do contexto, mas em 99% dos casos, os dois são equivalentes.

Se você precisar se conectar especificamente ao contexto de inicialização / desligamento, poderá implementar a Lifecycleinterface , mas isso provavelmente é desnecessário.

Isso é feito facilmente com um ApplicationListener. Eu fiz isso funcionar ouvindo 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 
  }
}

Ouvintes de aplicativos são executados de forma síncrona no Spring. Se você deseja garantir que seu código seja executado apenas uma vez, mantenha algum estado em seu componente.

ATUALIZAR

A partir do Spring 4.2+, você também pode usar a @EventListeneranotação para observar o ContextRefreshedEvent(obrigado a @bphilipnyc por apontar isso):

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

No Spring 4.2+, agora você pode simplesmente fazer:

@Component
class StartupHousekeeper {

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

Se você estiver usando o boot de mola, esta é a melhor resposta.

Eu sinto que @PostConstructe outras interjeições de vários ciclos de vida são alternativas. Isso pode levar diretamente a problemas de tempo de execução ou causar defeitos menos que óbvios devido a eventos inesperados do ciclo de vida do bean / contexto. Por que não invocar diretamente seu bean usando Java simples? Você ainda invoca o bean da 'maneira da primavera' (por exemplo: através do proxy AoP da primavera). E o melhor de tudo, é Java simples, não pode ser mais simples que isso. Não há necessidade de ouvintes de contexto ou agendadores ímpares.

@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 usuários do Java 1.8 que recebem um aviso ao tentar referenciar a anotação @PostConstruct, acabei pegando a anotação @Scheduled, que você pode fazer se já tiver um trabalho @Scheduled com 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");
    }

}

O que fizemos foi estender org.springframework.web.context.ContextLoaderListenerpara imprimir algo quando o contexto começar.

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 a subclasse e, em web.xml:

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

Com o SpringBoot, podemos executar um método na inicialização via @EventListeneranotação

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

Atenção, isso só é aconselhável se o seu runOnceOnStartupmétodo depender de um contexto de primavera totalmente inicializado. Por exemplo: você deseja chamar um dao com demarcação de transação

Você também pode usar um método agendado com FixedDelay definido muito alto

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

Isso tem a vantagem de que todo o aplicativo está conectado (Transações, Dao, ...)

visto em Planejando tarefas para serem executadas uma vez, usando o namespace da tarefa Spring

Publicou outra solução que implementa o WebApplicationInitializer e é chamada muito antes de qualquer spring bean ser instanciado, caso alguém tenha esse caso de uso

Inicializar localidade e fuso horário padrão com a configuração do Spring

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

        }
    }
}

Se você deseja configurar um bean antes que seu aplicativo esteja sendo executado completamente, você pode usar @Autowired:

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

Você pode usar @EventListenerem seu componente, que será chamado após o servidor ser iniciado e todos os beans inicializados.

@EventListener
public void onApplicationEvent(ContextClosedEvent event) {

}

Para um arquivo StartupHousekeeper.javalocalizado no pacotecom.app.startup ,

Faça isso em StartupHousekeeper.java:

@Component
public class StartupHousekeeper {

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

E faça isso em myDispatcher-servlet.java:

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

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

</beans>