El manejo de excepciones es una parte fundamental de la creación de aplicaciones sólidas y fáciles de usar. En Spring Boot, podemos manejar excepciones de varias maneras para garantizar que nuestra aplicación permanezca estable y brinde comentarios significativos a los usuarios. Esta guía cubrirá diferentes estrategias para el manejo de excepciones, incluidas excepciones personalizadas, manejo de excepciones globales, errores de validación y mejores prácticas para la producción.

1. Conceptos básicos del manejo de excepciones

Excepciones son ​​eventos que interrumpen el flujo normal de un programa. Se pueden dividir en:

• Excepciones marcadas: Excepciones que se verifican en tiempo de compilación.
• Excepciones no marcadas (Excepciones en tiempo de ejecución): Excepciones que ocurren durante el tiempo de ejecución.
• Errores: Problemas graves que las aplicaciones no deberían manejar, como OutOfMemoryError.

2. Clases de excepción personalizadas

La creación de clases de excepción personalizadas ayuda a manejar condiciones de error específicas en su aplicación.

package com.example.SpringBootRefresher.exception;

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

3. Manejo de excepciones en controladores

@ExceptionHandler Anotación:
Puede definir métodos para manejar excepciones en sus clases 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. Manejo global de excepciones con @ControllerAdvice

Para manejar excepciones globalmente, puedes usar @ControllerAdvice y un controlador de excepciones 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. Crear una respuesta de error estándar

Defina una clase de respuesta de error estándar para estructurar sus mensajes de error.

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. Manejo de errores de validación

Spring Boot se integra bien con Bean Validation (JSR-380). Para manejar errores de validación 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. Uso de @ResponseStatus para excepciones simples

Para casos simples, puede anotar una clase de excepción con @ResponseStatus para especificar el código de estado 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. Mejores prácticas de producción

1. Respuestas de error consistentes: Asegúrese de que su aplicación devuelva respuestas de error consistentes y estructuradas. Utilice una clase de respuesta de error estándar.
2. Registro: Registra excepciones con fines de depuración y monitoreo. Asegúrese de que la información confidencial no quede expuesta en los registros.
3. Mensajes fáciles de usar: Proporciona mensajes de error fáciles de usar. Evite exponer detalles internos o seguimientos de pila a los usuarios.
4. Seguridad: Tenga cuidado con la información incluida en las respuestas de error para evitar exponer datos confidenciales.
5. Documentación: Documente su estrategia de manejo de excepciones para su equipo y futuros mantenedores.

Resumen

El manejo de excepciones en Spring Boot implica el uso de anotaciones como @ExceptionHandler, @ControllerAdvice y @ResponseStatus para administrar los errores de manera efectiva. Al crear excepciones personalizadas, manejar errores de validación y seguir las mejores prácticas, puede crear aplicaciones sólidas que manejen los errores de manera elegante y brinden comentarios significativos a los usuarios. El uso de las funciones de Java 17 garantiza que su aplicación aproveche las últimas mejoras en el ecosistema de Java.