La fiabilidad es un activo de las grandes plataformas financieras y analíticas.Cuando rediseñamos una plataforma empresarial, aprendimos que lo principal que hizo a los clientes insatisfechos no era el rendimiento o la interfaz de usuario; fueron fallos que no fueron corregidos que destruyeron los procesos. En Spring Boot o patrones similares en otros marcos, asegúrese de que los sistemas se comporten como se esperaba cuando están bajo estrés. @ControllerAdvice Why This Matters Cuando construyes REST APIs en Sin embargo, usted se enfrentará rápidamente a este problema: Spring Boot “ ” How do I handle errors neatly without writing repetitive try-catch blocks everywhere? Imagínese tener Cada uno puede fallar con una Una entrada inválida o un recurso perdido. En lugar de devolver rastros de pilas desordenadas, desea . 50+ endpoints Cero puntos de excepción consistent, meaningful, and client-friendly error responses Eso es donde entra - centralizan todo el manejo de errores en un solo lugar. Vamos a ver Paso a paso, con un ejemplo del mundo real. @ControllerAdvice how Use Case — User Management REST API Crearemos una Esto apoya: simple User API 
 
 
 
 
 
 Fetching users 
 
 Creating users 
 
 
 Simulating failures for testing Our goal → build a   that returns clean JSON responses. unified global error-handling layer Step 1: Project Setup Dependencies (Maven): <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
 This brings in web + validation support. Then create your main app: @SpringBootApplication
public class ExceptionHandlerDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(ExceptionHandlerDemoApplication.class, args);
    }
}
 Step 2: Define the Entity — User.java @Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    @NotBlank(message = "Name cannot be blank")
    private String name;
    @Min(value = 18, message = "Age must be at least 18")
    private int age;
}
 • Por qué: **Añadimos validaciones simples para que Spring pueda desencadenar automáticamente la Excepción de Argumento de Método No Valido cuando la entrada es inválida. Step 3: Custom Exception for Missing Data public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}
public class InvalidRequestException extends RuntimeException {
    public InvalidRequestException(String message) {
        super(message);
    }
}
 • Por qué: ** Representar una situación de “usuario no encontrado” de forma limpia en lugar de excepciones genéricas. Step 4: Build the Controller @RestController
@RequestMapping("/api/users")
public class UserController {
    // Simple GET that throws ResourceNotFoundException for id > 100
    @GetMapping("/{id}")
    public String getUser(@PathVariable("id") @Min(1) Integer id) {
        if (id > 100) {
            throw new ResourceNotFoundException("User with id " + id + " not found");
        }
        return "User-" + id;
    }
    // Create user example to demonstrate validation
    public static record CreateUserRequest(
            @NotBlank(message = "name is required") String name,
            @Min(value = 18, message = "age must be >= 18") int age) {}
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public String createUser(@RequestBody @Valid CreateUserRequest body) {
        if ("bad".equalsIgnoreCase(body.name())) {
            throw new InvalidRequestException("Name 'bad' is not allowed");
        }
        return "created:" + body.name();
    }
    // Endpoint to force a server error for demo
    @GetMapping("/boom")
    public void boom() {
        throw new IllegalStateException("simulated server error");
    }
}
 • Por qué: ** Creamos escenarios realistas - no encontrados, errores de validación y errores de tiempo de ejecución - que nuestro operador global gestionará. Step 5: Create a Standard Error Model @Data
@AllArgsConstructor
@NoArgsConstructor
public class ErrorResponse {
    private OffsetDateTime timestamp;
    private int status;
    private String error;
    private String message;
    private String path;
    private List<FieldError> fieldErrors;}
 • Por qué: **Todas las APIs deben devolver errores en la misma estructura, lo que mejora el seguimiento y el borrado en la producción. Step 6: Implement @ControllerAdvice (Global Handler) @ControllerAdvice
public class GlobalExceptionHandler {
    private final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    // Handle custom validation exceptions
    @ExceptionHandler(InvalidRequestException.class)
    public ResponseEntity<ErrorResponse> handleInvalidRequest(InvalidRequestException ex, HttpServletRequest req) {
        log.debug("InvalidRequestException: {}", ex.getMessage());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(), ex.getMessage(), req.getRequestURI());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(body);
    }
    // Resource not found -> 404
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex, HttpServletRequest req) {
        log.debug("ResourceNotFoundException: {}", ex.getMessage());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.NOT_FOUND.value(),
                HttpStatus.NOT_FOUND.getReasonPhrase(), ex.getMessage(), req.getRequestURI());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(body);
    }
    // Validation errors from @Valid on request bodies
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException ex, HttpServletRequest req) {
        log.debug("Validation failed: {}", ex.getMessage());
        List<ErrorResponse.FieldError> fieldErrors = ex.getBindingResult().getFieldErrors().stream()
                .map(fe -> new ErrorResponse.FieldError(fe.getField(), fe.getRejectedValue(), fe.getDefaultMessage()))
                .collect(Collectors.toList());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(), "Validation failed", req.getRequestURI());
        body.setFieldErrors(fieldErrors);
        return ResponseEntity.badRequest().body(body);
    }
    // Type mismatch for method args (?id=abc)
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public ResponseEntity<ErrorResponse> handleTypeMismatch(MethodArgumentTypeMismatchException ex, HttpServletRequest req) {
        log.debug("Type mismatch: {}", ex.getMessage());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(), ex.getMessage(), req.getRequestURI());
        return ResponseEntity.badRequest().body(body);
    }
    // No handler found (404 for unmatched endpoints)
    @ExceptionHandler(NoHandlerFoundException.class)
    public ResponseEntity<ErrorResponse> handleNoHandler(NoHandlerFoundException ex, HttpServletRequest req) {
        log.debug("NoHandlerFound: {} {}", ex.getHttpMethod(), ex.getRequestURL());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.NOT_FOUND.value(),
                HttpStatus.NOT_FOUND.getReasonPhrase(), "Endpoint not found", req.getRequestURL().toString());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(body);
    }
    // Generic fallback
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAll(Exception ex, HttpServletRequest req) {
        log.error("Unhandled exception: ", ex);
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.INTERNAL_SERVER_ERROR.value(),
                HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), "An internal error occurred", req.getRequestURI());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
    }
}
 Why: 
 
 
 
 @ControllerAdvice → hace que sea global en todos los controladores. @ExceptionHandler → Catcha tipos de excepciones específicas. El ayudante buildResponse() mantiene el código DRY y limpio. Step 7: Test Scenarios   GET /api/users/1 Código de respuesta: 200 -Succesos * El * El GET /api/users/999 Código de respuesta: 404 Resource Not Found * El * El Validation Error POST / API / Usuarios {"name":"", "age": 15} Response: * El * El Unexpected Error GET /api/usuarios / boom * El * El Why This Approach Works in Real Projects 
 
 
 
 
 
 
 
 
 
 Problem 
 Solution 
 
 
 
 Too many try-catch blocks 
 Centralized handling with @ControllerAdvice 
 
 
 
 Inconsistent responses 
 Unified ErrorResponse structure 
 
 
 
 Hard to debug 
 Standardized messages with timestamps and paths 
 
 
 
 Client confusion 
 Clear, meaningful messages for each failure type Muchos bloques de try-catch Gestión centralizada con @ControllerAdvice Respuestas inconsistentes Estructura Unificada de ErrorResponse Dificultad para debutar Mensajes estandarizados con timestamps y caminos La confusión del cliente Mensajes claros y significativos para cada tipo de error Real-World Usage Scenarios 
 
 
 
 
 APIs bancarios: Asegúrese de que los errores de validación (como el número de cuenta inválido) no caigan en el servicio. Comercio electrónico: maneja de forma graciosa los errores de producto no encontrados o de pago. Microservicios de datos: Devuelve mensajes estructurados cuando los datos de entrada no se validan. API Gateway: Respuestas coherentes en múltiples microservicios. Final Thoughts Al combinar @ControllerAdvice, @ExceptionHandler y un modelo de respuesta de error simple, obtendrá: 
 
 
 
 Código limpio Experiencia de API consistente Debugging más fácil en la producción Es uno de los patrones de diseño más simples y poderosos en el desarrollo de Spring Boot.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Este audio es producido en el idioma original de la historia!

Diseño de sistemas de API fiables: manejo excepcional con el controlador de Spring Boot

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps