O tratamento de exceções é uma parte crítica da construção de aplicativos robustos e fáceis de usar. No Spring Boot, podemos lidar com exceções de várias maneiras para garantir que nosso aplicativo permaneça estável e forneça feedback significativo aos usuários. Este guia abordará diferentes estratégias para tratamento de exceções, incluindo exceções personalizadas, tratamento de exceções globais, erros de validação e práticas recomendadas para produção.

1. Noções básicas de tratamento de exceções

Exceções são eventos que interrompem o fluxo normal de um programa. Eles podem ser divididos em:

• Exceções verificadas: Exceções que são verificadas em tempo de compilação.
• Exceções não verificadas (Exceções de tempo de execução): Exceções que ocorrem durante o tempo de execução.
• Erros: Problemas sérios que os aplicativos não devem resolver, como OutOfMemoryError.

2. Classes de exceção personalizadas

A criação de classes de exceção personalizadas ajuda a lidar com condições de erro específicas em seu aplicativo.

package com.example.SpringBootRefresher.exception;

public class DepartmentNotFoundException extends RuntimeException {
    public DepartmentNotFoundException(String message) {
        super(message);
    }
}

3. Tratamento de exceções em controladores

@Anotação do ExceptionHandler:
Você pode definir métodos para lidar com exceções em suas classes de controlador.

package com.example.SpringBootRefresher.controller;

import com.example.SpringBootRefresher.exception.DepartmentNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DepartmentController {

    @GetMapping("/department")
    public String getDepartment() {
        // Simulate an exception
        throw new DepartmentNotFoundException("Department not found!");
    }

    @ExceptionHandler(DepartmentNotFoundException.class)
    public ResponseEntity handleDepartmentNotFoundException(DepartmentNotFoundException ex) {
        return new ResponseEntity(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

4. Tratamento de exceções globais com @ControllerAdvice

Para lidar com exceções globalmente, você pode usar @ControllerAdvice e um manipulador de exceções centralizado.

package com.example.SpringBootRefresher.error;

import com.example.SpringBootRefresher.entity.ErrorMessage;
import com.example.SpringBootRefresher.exception.DepartmentNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
@ResponseStatus
public class CustomResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(DepartmentNotFoundException.class)
    public ResponseEntity handleDepartmentNotFoundException(DepartmentNotFoundException exception, WebRequest request) {
        ErrorMessage message = new ErrorMessage(
                HttpStatus.NOT_FOUND.value(),
                exception.getMessage(),
                request.getDescription(false)
        );

        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(message);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity handleGlobalException(Exception exception, WebRequest request) {
        ErrorMessage message = new ErrorMessage(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                exception.getMessage(),
                request.getDescription(false)
        );

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(message);
    }
}

5. Criando uma resposta de erro padrão

Defina uma classe de resposta de erro padrão para estruturar suas mensagens de erro.

package com.example.SpringBootRefresher.entity;

public class ErrorMessage {
    private int statusCode;
    private String message;
    private String description;

    public ErrorMessage(int statusCode, String message, String description) {
        this.statusCode = statusCode;
        this.message = message;
        this.description = description;
    }

    // Getters and setters

    public int getStatusCode() {
        return statusCode;
    }

    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

6. Tratamento de erros de validação

Spring Boot integra-se bem com Bean Validation (JSR-380). Para lidar com erros de validação globalmente, use @ControllerAdvice.

package com.example.SpringBootRefresher.error;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.WebRequest;
import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
@ResponseStatus
public class ValidationExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity

7. Usando @ResponseStatus para exceções simples

Para casos simples, você pode anotar uma classe de exceção com @ResponseStatus para especificar o código de status HTTP.

package com.example.SpringBootRefresher.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(HttpStatus.NOT_FOUND)
public class DepartmentNotFoundException extends RuntimeException {
    public DepartmentNotFoundException(String message) {
        super(message);
    }
}

8. Melhores Práticas para Produção

1. Respostas de erro consistentes: Garanta que seu aplicativo retorne respostas de erro consistentes e estruturadas. Use uma classe de resposta de erro padrão.
2. Logging: Registra exceções para fins de depuração e monitoramento. Certifique-se de que informações confidenciais não sejam expostas nos registros.
3. Mensagens fáceis de usar: Fornece mensagens de erro fáceis de usar. Evite expor detalhes internos ou rastreamentos de pilha aos usuários.
4. Segurança: Tenha cuidado com as informações incluídas nas respostas de erro para evitar a exposição de dados confidenciais.
5. Documentação: Documente sua estratégia de tratamento de exceções para sua equipe e futuros mantenedores.

Resumo

O tratamento de exceções no Spring Boot envolve o uso de anotações como @ExceptionHandler, @ControllerAdvice e @ResponseStatus para gerenciar erros de forma eficaz. Ao criar exceções personalizadas, lidar com erros de validação e seguir as práticas recomendadas, você pode criar aplicativos robustos que lidam com erros de maneira elegante e fornecem feedback significativo aos usuários. O uso dos recursos do Java 17 garante que seu aplicativo aproveite as melhorias mais recentes no ecossistema Java.