Nesta postagem do blog, exploraremos um recurso interessante no Spring Boot - FailureAnalyzer. Esse recurso pode nos ajudar a localizar rapidamente o problema e corrigi-lo quando o aplicativo falha ao iniciar. Analisaremos um exemplo simples para ver como usar o FailureAnalyzer.
O que é o Failure Analyzer?
O FailureAnalyzer do Spring Boot é uma interface usada para fornecer informações detalhadas sobre erros quando um aplicativo Spring Boot falha ao iniciar. Isso é ótimo para os desenvolvedores, pois nos ajuda a identificar rapidamente os problemas e encontrar soluções.
FailureAnalyzer é amplamente utilizado no Spring Boot, como: DataSourceBeanCreationFailureAnalyzer, PortInUseFailureAnalyzer, etc. Esses FailureAnalyzers podem nos ajudar a diagnosticar vários tipos de falhas de inicialização.
Como usar o FailureAnalyzer?
Para implementar um FailureAnalyzer personalizado, precisamos concluir as seguintes etapas:
- Crie uma classe e implemente a interface FailureAnalyzer.
- Substitua o método analyze() para analisar exceções e retornar um objeto FailureAnalysis.
- Registre a classe FailureAnalyzer customizada no arquivo spring.factories.
Abaixo, usamos um exemplo simples para entender como usar o FailureAnalyzer.
Exemplo
Suponha que nosso aplicativo exija uma propriedade chamada required.property, se essa propriedade não existir, o aplicativo não será iniciado. Criaremos um FailureAnalyzer personalizado para este cenário.
Etapa 1: criar a classe FailureAnalyzer
Primeiro, criamos uma classe chamada RequiredPropertyFailureAnalyzer e implementamos a interface FailureAnalyzer:
import org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
import org.springframework.boot.diagnostics.FailureAnalysis;
public class RequiredPropertyFailureAnalyzer extends AbstractFailureAnalyzer<RequiredPropertyException> {
@Override
protected FailureAnalysis analyze(Throwable rootFailure, RequiredPropertyException cause) {
return new FailureAnalysis(getDescription(cause), getAction(cause), cause);
}
private String getDescription(RequiredPropertyException ex) {
return String.format("The required property '%s' is missing.", ex.getPropertyName());
}
private String getAction(RequiredPropertyException ex) {
return String.format("Please provide the property '%s' in your application configuration.", ex.getPropertyName());
}
}
Etapa 2: criar uma exceção personalizada
Em seguida, precisamos criar uma classe de exceção personalizada RequiredPropertyException:
public class RequiredPropertyException extends RuntimeException {
private final String propertyName;
public RequiredPropertyException(String propertyName) {
super(String.format("Required property '%s' not found", propertyName));
this.propertyName = propertyName;
}
public String getPropertyName() {
return propertyName;
}
}
Passo 3: Registre o FailureAnalyzer
Para que o Spring Boot encontre nosso FailureAnalyzer personalizado, precisamos registrá-lo no arquivo spring.factories. Crie um arquivo chamado spring.factories no diretório src/main/resources/META-INF e adicione o seguinte conteúdo:
org.springframework.boot.diagnostics.FailureAnalyzer=\
com.example.demo.RequiredPropertyFailureAnalyzer
Etapa 4: usar exceções personalizadas e FailureAnalyzer
Agora que nosso FailureAnalyzer personalizado está pronto, precisamos usá-lo em nosso aplicativo. Suponha que tenhamos um aplicativo Spring Boot chamado DemoApplication:
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Component
public class RequiredPropertyChecker {
@Value("${required.property:null}")
private String requiredProperty;
@PostConstruct
public void checkRequiredProperty() {
if (requiredProperty == null || requiredProperty.equals("null")) {
throw new RequiredPropertyException("required.property");
}
}
}
}
Neste exemplo, verificamos a existência da propriedade required.property no método principal de DemoApplication. Se não existir, lançaremos um RequiredPropertyException.
Agora, se tentarmos iniciar o aplicativo e nenhum required.property for fornecido, veremos a seguinte mensagem de erro:
***************************
APPLICATION FAILED TO START
***************************
Description:
The required property 'required.property' is missing.
Action:
Please provide the property 'required.property' in your application configuration.
Por meio do exemplo acima, podemos ver como um FailureAnalyzer personalizado pode nos ajudar a localizar problemas rapidamente e fornecer soluções.
Resumir
Neste artigo, aprendemos sobre o FailureAnalyzer no Spring Boot e seu uso. Ao criar um FailureAnalyzer personalizado, podemos diagnosticar mais facilmente problemas com falhas de inicialização de aplicativos e fornecer aos desenvolvedores informações detalhadas sobre como resolver os problemas. Isso melhorará muito nossa eficiência na solução de problemas durante o desenvolvimento e a manutenção.
Exemplo de código-fonte do Github
https://github.com/Heiffeng/spring-boot-learning/tree/failure-analyzer