Código em execução após o início do Spring Boot

Quero executar o código depois que meu aplicativo de inicialização por primavera começar a monitorar um diretório em busca de alterações.

Eu tentei executar um novo thread, mas os @Autowiredserviços não foram definidos nesse ponto.

Eu consegui encontrar o ApplicationPreparedEventque é acionado antes que as @Autowiredanotações sejam definidas. Idealmente, eu gostaria que o evento fosse acionado assim que o aplicativo estiver pronto para processar solicitações http.

Existe um evento melhor para usar ou uma maneira melhor de executar código depois que o aplicativo estiver ativo na inicialização por mola ?

Experimentar:

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application extends SpringBootServletInitializer {

    @SuppressWarnings("resource")
    public static void main(final String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);

        context.getBean(Table.class).fillWithTestdata(); // <-- here
    }
}

É tão simples quanto isto:

@EventListener(ApplicationReadyEvent.class)
public void doSomethingAfterStartup() {
    System.out.println("hello world, I have just started up");
}

Testado na versão 1.5.1.RELEASE

Você já tentou o ApplicationReadyEvent?

@Component
public class ApplicationStartup 
implements ApplicationListener<ApplicationReadyEvent> {

  /**
   * This event is executed as late as conceivably possible to indicate that 
   * the application is ready to service requests.
   */
  @Override
  public void onApplicationEvent(final ApplicationReadyEvent event) {

    // here your code ...

    return;
  }
}

Código de: http://blog.netgloo.com/2014/11/13/run-code-at-spring-boot-startup/

Isto é o que a documentação menciona sobre os eventos de inicialização:

...

Os eventos do aplicativo são enviados na seguinte ordem, conforme seu aplicativo é executado:

Um ApplicationStartedEvent é enviado no início de uma execução, mas antes de qualquer processamento, exceto o registro de ouvintes e inicializadores.

Um ApplicationEnvironmentPreparedEvent é enviado quando o ambiente a ser usado no contexto é conhecido, mas antes que o contexto seja criado.

Um ApplicationPreparedEvent é enviado imediatamente antes do início da atualização, mas após o carregamento das definições do bean.

Um ApplicationReadyEvent é enviado após a atualização e todos os retornos de chamada relacionados foram processados ​​para indicar que o aplicativo está pronto para atender às solicitações.

Um ApplicationFailedEvent é enviado se houver uma exceção na inicialização.

...

Por que não criar um bean que inicia o monitor na inicialização, algo como:

@Component
public class Monitor {
    @Autowired private SomeService service

    @PostConstruct
    public void init(){
        // start your monitoring in here
    }
}

o initmétodo não será chamado até que qualquer ligação automática seja feita para o bean.

A maneira "Spring Boot" é usar a CommandLineRunner. Basta adicionar grãos desse tipo e você estará pronto. No Spring 4.1 (Boot 1.2), há também um SmartInitializingBeanque recebe um retorno de chamada depois que tudo foi inicializado. E existe SmartLifecycle(da Primavera 3).

Você pode estender uma classe usando ApplicationRunner, substituir o run()método e adicionar o código lá.

import org.springframework.boot.ApplicationRunner;

@Component
public class ServerInitializer implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments applicationArguments) throws Exception {

        //code goes here

    }
}

ApplicationReadyEventé realmente útil apenas se a tarefa que você deseja executar não for um requisito para a operação correta do servidor. Iniciar uma tarefa assíncrona para monitorar algo em busca de alterações é um bom exemplo.

Se, no entanto, seu servidor estiver em um estado 'não pronto' até que a tarefa seja concluída, é melhor implementá- SmartInitializingSingletonlo, pois você receberá o retorno de chamada antes que sua porta REST seja aberta e seu servidor esteja aberto para negócios.

Não fique tentado a usar @PostConstructtarefas que só devem acontecer uma vez. Você receberá uma surpresa rude quando perceber que ele é chamado várias vezes ...

Com configuração de mola:

@Configuration
public class ProjectConfiguration {
    private static final Logger log = 
   LoggerFactory.getLogger(ProjectConfiguration.class);

   @EventListener(ApplicationReadyEvent.class)
   public void doSomethingAfterStartup() {
    log.info("hello world, I have just started up");
  }
}

Use um SmartInitializingSingletonfeijão na primavera> 4.1

@Bean
public SmartInitializingSingleton importProcessor() {
    return () -> {
        doStuff();
    };

}

Como alternativa, um CommandLineRunnerbean pode ser implementado ou anotando um método de bean @PostConstruct.

Fornecendo um exemplo para a resposta de Dave Syer, que funcionou como um encanto:

@Component
public class CommandLineAppStartupRunner implements CommandLineRunner {
    private static final Logger logger = LoggerFactory.getLogger(CommandLineAppStartupRunner.class);

    @Override
    public void run(String...args) throws Exception {
        logger.info("Application started with command-line arguments: {} . \n To kill this application, press Ctrl + C.", Arrays.toString(args));
    }
}

Experimente este e ele executará seu código quando o contexto do aplicativo for totalmente iniciado.

 @Component
public class OnStartServer implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent arg0) {
                // EXECUTE YOUR CODE HERE 
    }
}

Eu realmente gosto da sugestão de uso da EventListeneranotação por @cahen ( https://stackoverflow.com/a/44923402/9122660 ), pois ela é muito limpa. Infelizmente, não consegui fazer isso funcionar em uma configuração do Spring + Kotlin. O que funciona para o Kotlin é adicionar a classe como um parâmetro do método:

@EventListener 
fun doSomethingAfterStartup(event: ApplicationReadyEvent) {
    System.out.println("hello world, I have just started up");
}

A melhor maneira de executar o bloco de código após o início do aplicativo Spring Boot é usar a anotação PostConstruct ou também usar o corredor de linha de comando para o mesmo.

1. Usando a anotação PostConstruct

@Configuration
public class InitialDataConfiguration {

    @PostConstruct
    public void postConstruct() {
        System.out.println("Started after Spring boot application !");
    }

}

2. Usando Bean Runner da Linha de Comandos

@Configuration
public class InitialDataConfiguration {

    @Bean
    CommandLineRunner runner() {
        return args -> {
            System.out.println("CommandLineRunner running in the UnsplashApplication class...");
        };
    }
}

basta implementar CommandLineRunner para o aplicativo de inicialização por primavera. Você precisa implementar o método run,

public classs SpringBootApplication implements CommandLineRunner{

    @Override
        public void run(String... arg0) throws Exception {
        // write your logic here 

        }
}

Melhor maneira de usar CommandLineRunner ou ApplicationRunner A única diferença entre o método run () CommandLineRunner aceita matriz de cadeias e ApplicationRunner aceita ApplicationArugument.