Spring Initializr

▶️ Spring Initializr

Primeiramente, caso você não esteja familiarizado, pode estar se perguntando o que é o Spring Initializr. Sendo objetivo, o Spring Initializr é uma ferramenta online que facilita a criação de projetos Spring Boot. Ele permite aos desenvolvedores gerar rapidamente a estrutura inicial de um novo projeto Spring Boot, selecionando as dependências e configurações básicas desejadas.

Como criar um projeto Spring Boot

Para iniciarmos um projeto Spring Boot com o Spring Initializr é bem simples. Vamos aos primeiros passos. Acesse a URL: https://start.spring.io ou clique aqui. Nos deparamos então com nosso primeiro e pequeno desafio:

• Project: Temos as opções de gerenciadores de dependência. Em nosso caso vamos escolher Maven
• Language: A linguagem na qual deseja criar o projeto com Spring.
• Spring Boot: Aqui podemos escolher a versão do Spring Boot.
• Project Metadata:
  • Group: É o mesmo que um pacote Java. Geralmente, o padrão é colocar o nome do domínio ao contrário, como por exemplo: br.com.projetodemonstrativo.
  • Artifact: O nome do projeto.
  • Name: O mesmo que Artifact.
  • Description: A descrição do projeto.
  • Package Name: O pacote inicial onde será criado o projeto.
  • Packaging: A forma de empacotar seu projeto. O padrão é Jar, mas pode usar War se preferir.
  • Java Version: Versão do Java ou da linguagem que escolheu. Pode escolher a versão que preferir.
• Dependências: Aqui podemos adicionar as dependências que desejarmos ao projeto clicando em ADD DEPENDENCIES. Podemos buscar por qualquer uma que desejar. Pode-se iniciar um projeto sem nenhuma dependência, sendo possível adicioná-las posteriormente. Recomendo adicionar dependências conforme o projeto avança. Pode haver problemas ao inicializar um projeto onde não tenha feito uma configuração adequada para recebê-las.

ApplicationRunner

A interface ApplicationRunner do Spring é usada para executar algum código logo após o contexto da aplicação ser inicializado, mas antes que a aplicação comece a aceitar requisições ou interações. Ela é uma alternativa ao CommandLineRunner, e permite que você escreva lógica de inicialização de forma mais limpa.

A principal função da interface ApplicationRunner é fornecer acesso aos argumentos de linha de comando da aplicação quando ela é iniciada, permitindo que você possa processá-los dentro do método run().

Aqui está como ela funciona:

Método da Interface:

• run(ApplicationArguments args): Este é o método principal da interface, e ele será executado depois que a aplicação for completamente carregada. O ApplicationArguments contém os argumentos passados na linha de comando quando a aplicação foi iniciada.

Exemplo:

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class MeuApplicationRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // Lógica a ser executada após a inicialização do Spring Boot
        System.out.println("Aplicação iniciada com os seguintes argumentos:");
        
        args.getNonOptionArgs().forEach(arg -> System.out.println(arg));
        args.getOptionNames().forEach(option -> System.out.println(option + ": " + args.getOptionValues(option)));
    }
}

▶️ E agora, o que fazer?

Características:

1. Execução pós-contexto: O código dentro do método run() é executado após o contexto do Spring ser inicializado. Isso permite que você configure ou inicialize componentes logo após a aplicação ser carregada.
2. Acesso aos argumentos de linha de comando: Diferente do CommandLineRunner, que recebe um array de String[], o ApplicationArguments oferece um acesso mais flexível, permitindo pegar argumentos não opcionais e opcionais de forma mais estruturada.

Quando usar?

• Você pode usar o ApplicationRunner quando precisar de lógica de inicialização (por exemplo, carregamento de dados de configuração, realização de verificações, etc.) após o Spring Boot terminar de configurar o contexto da aplicação.

A interface é muito útil quando você precisa executar algum processo adicional que dependa da inicialização completa da aplicação.