Spring Boot - Manejo de excepciones

Manejar excepciones y errores en API y enviar la respuesta adecuada al cliente es bueno para las aplicaciones empresariales. En este capítulo, aprenderemos cómo manejar excepciones en Spring Boot.

Antes de continuar con el manejo de excepciones, comprendamos las siguientes anotaciones.

Asesoramiento del controlador

@ControllerAdvice es una anotación, para manejar las excepciones globalmente.

Controlador de excepciones

@ExceptionHandler es una anotación que se usa para manejar las excepciones específicas y enviar las respuestas personalizadas al cliente.

Puede usar el siguiente código para crear la clase @ControllerAdvice para manejar las excepciones globalmente:

package com.tutorialspoint.demo.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;

@ControllerAdvice
   public class ProductExceptionController {
}

Defina una clase que amplíe la clase RuntimeException.

package com.tutorialspoint.demo.exception;

public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

Puede definir el método @ExceptionHandler para manejar las excepciones como se muestra. Este método se debe utilizar para escribir el archivo de clase de avisos del controlador.

@ExceptionHandler(value = ProductNotfoundException.class)

public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}

Ahora, use el código que se proporciona a continuación para lanzar la excepción de la API.

@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() { 
   throw new ProductNotfoundException();
}

El código completo para manejar la excepción se proporciona a continuación. En este ejemplo, usamos la API PUT para actualizar el producto. Aquí, mientras actualiza el producto, si el producto no se encuentra, devuelva el mensaje de error de respuesta como "Producto no encontrado". Tenga en cuenta que elProductNotFoundException la clase de excepción debe extender el RuntimeException.

package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

La clase Controller Advice para manejar la excepción globalmente se proporciona a continuación. Podemos definir cualquier método de controlador de excepciones en este archivo de clase.

package com.tutorialspoint.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ProductExceptionController {
   @ExceptionHandler(value = ProductNotfoundException.class)
   public ResponseEntity<Object> exception(ProductNotfoundException exception) {
      return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);
   }
}

El archivo del controlador de API de servicio de producto se proporciona a continuación para actualizar el producto. Si no se encuentra el producto, lanza elProductNotFoundException clase.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      if(!productRepo.containsKey(id))throw new ProductNotfoundException();
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successfully", HttpStatus.OK);
   }
}

El código para el archivo de clase de la aplicación Spring Boot principal se proporciona a continuación:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

El código para POJO class para el producto se indica a continuación:

package com.tutorialspoint.demo.model;
public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

El código para Maven build – pom.xml se muestra a continuación -

<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

El código para Gradle Build – build.gradle se da a continuación -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los comandos de Maven o Gradle:

Para Maven, puede usar el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Puede ejecutar el archivo JAR utilizando el siguiente comando:

java –jar <JARFILE>

Esto iniciará la aplicación en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado como se muestra a continuación:

URL de actualización: http: // localhost: 8080 / products / 3