Cómo SpringBoot usa la anotación @ExceptionHandler para el manejo de excepciones local
introducir
Al desarrollar aplicaciones web, el manejo de excepciones es una parte muy importante. SpringBoot proporciona múltiples formas de manejar excepciones, una de las cuales es usar la anotación @ExceptionHandler para el manejo de excepciones local. Usando la anotación @ExceptionHandler, podemos manejar excepciones en la capa del Controlador o en el nivel de método en lugar de manejarlas en toda la aplicación.
En este artículo, presentaremos la anotación @ExceptionHandler en SpringBoot y demostraremos cómo usarla para el manejo de excepciones local.
Anotación @ExceptionHandler
La anotación @ExceptionHandler es una anotación proporcionada por Spring Framework para manejar excepciones que ocurren en el controlador. Cuando se produce una excepción en un método de controlador, SpringBoot busca un método anotado con @ExceptionHandler y lo llama para manejar la excepción.
He aquí un ejemplo sencillo:
@RestController
public class UserController {
@GetMapping("/users/{id}")
public User getUser(@PathVariable int id) {
User user = userRepository.findById(id);
if (user == null) {
throw new UserNotFoundException("User not found");
}
return user;
}
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
}
}
En el código anterior, definimos una clase UserController e implementamos un método getUser. Si el usuario no existe, se lanza una excepción UserNotFoundException. Luego, usamos la anotación @ExceptionHandler para definir un método handleUserNotFoundException para manejar las excepciones UserNotFoundException. En este método, creamos un objeto ErrorResponse que contiene el código de estado y el mensaje de la respuesta de error, y luego lo encapsulamos en un objeto ResponseEntity y lo devolvemos.
Cómo utilizar la anotación @ExceptionHandler para el manejo de excepciones local
Para utilizar la anotación @ExceptionHandler para el manejo de excepciones local, siga estos pasos:
Paso 1: definir excepciones personalizadas
Defina excepciones personalizadas en el código, heredando de la clase Exception o RuntimeException. Por ejemplo:
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
}
En el código anterior, definimos una excepción personalizada llamada UserNotFoundException, que hereda de la clase RuntimeException.
Paso 2: lanzar una excepción
Lanza excepciones personalizadas en los métodos del controlador. Por ejemplo:
@GetMapping("/users/{id}")
public User getUser(@PathVariable int id) {
User user = userRepository.findById(id);
if (user == null) {
throw new UserNotFoundException("User not found");
}
return user;
}
En el código anterior, si el usuario no existe, se genera una excepción UserNotFoundException.
Paso 3: Manejar las excepciones
Utilice la anotación @ExceptionHandler para definir un método para manejar excepciones personalizadas. Por ejemplo:
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
}
En el código anterior, utilizamos la anotación @ExceptionHandler(UserNotFoundException.class) para definir un método handleUserNotFoundException para manejar las excepciones UserNotFoundException. En este método, creamos un objeto ErrorResponse que contiene el código de estado y el mensaje de la respuesta de error, y luego lo encapsulamos en un objeto ResponseEntity y lo devolvemos.
Ejemplo
Aquí tienes un ejemplo completo:
Controlador de usuario.java
@RestController
public class UserController {
@Autowired
private UserRepository userRepository;
@GetMapping("/users/{id}")
public User getUser(@PathVariable int id) {
User user = userRepository.findById(id);
if (user == null) {
throw new UserNotFoundException("User not found");
}
return user;
}
@PostMapping("/users")
public User createUser(@RequestBody User user) {
userRepository.save(user);
return user;
}
@PutMapping("/users/{id}")
public User updateUser(@PathVariable int id, @RequestBody User user) {
User existingUser = userRepository.findById(id);
if (existingUser == null) {
throw new UserNotFoundException("User not found");
}
existingUser.setName(user.getName());
existingUser.setAge(user.getAge());
userRepository.save(existingUser);
return existingUser;
}
@DeleteMapping("/users/{id}")
public void deleteUser(@PathVariable int id) {
UseruserRepository.deleteById(id);
}
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
}
}
UserNotFoundException.java
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
}
RespuestaError.java
public class ErrorResponse {
private int status;
private String message;
public ErrorResponse(int status, String message) {
this.status = status;
this.message = message;
}
public int getStatus() {
return status;
}
public String getMessage() {
return message;
}
}
En el código anterior, definimos una clase UserController e implementamos los métodos getUser, createUser, updateUser y deleteUser. Si el usuario no existe, se lanza una excepción UserNotFoundException. Luego, usamos la anotación @ExceptionHandler para definir un método handleUserNotFoundException para manejar las excepciones UserNotFoundException. En este método, creamos un objeto ErrorResponse que contiene el código de estado y el mensaje de la respuesta de error, y luego lo encapsulamos en un objeto ResponseEntity y lo devolvemos.
principio
Cuando un método de controlador genera una excepción, SpringBoot buscará un método anotado con @ExceptionHandler en la clase de controlador y lo llamará para manejar la excepción. Los métodos anotados @ExceptionHandler deben tener las siguientes características:
- El método debe ser público, no tener valor de retorno y tener un parámetro del tipo de excepción lanzada.
- El método debe estar anotado con la anotación @ExceptionHandler y el parámetro de esta anotación es el tipo de excepción lanzada.
Cuando un método de controlador genera una excepción, SpringBoot pasa la excepción al método anotado con @ExceptionHandler. Este método maneja la excepción y devuelve un objeto ResponseEntity que contiene el código de estado y el mensaje de la respuesta de error.
Resumir
En este artículo, presentamos la anotación @ExceptionHandler en SpringBoot y demostramos cómo usarla para el manejo de excepciones local. Usando la anotación @ExceptionHandler, podemos manejar excepciones en la capa del Controlador o en el nivel de método. Cuando un método de controlador genera una excepción, SpringBoot busca un método anotado con @ExceptionHandler y lo llama para manejar la excepción. Para utilizar la anotación @ExceptionHandler para el manejo de excepciones local, debe definir excepciones personalizadas, generar excepciones y manejar excepciones.