Spring Boot - Gestione delle eccezioni

La gestione delle eccezioni e degli errori nelle API e l'invio della risposta corretta al client è utile per le applicazioni aziendali. In questo capitolo impareremo come gestire le eccezioni in Spring Boot.

Prima di procedere con la gestione delle eccezioni, acquisiamo una comprensione delle seguenti annotazioni.

Consiglio del controllore

@ControllerAdvice è un'annotazione, per gestire le eccezioni a livello globale.

Gestore delle eccezioni

@ExceptionHandler è un'annotazione utilizzata per gestire le eccezioni specifiche e inviare le risposte personalizzate al client.

È possibile utilizzare il codice seguente per creare la classe @ControllerAdvice per gestire le eccezioni a livello globale:

package com.tutorialspoint.demo.exception;

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

@ControllerAdvice
   public class ProductExceptionController {
}

Definisci una classe che estende la classe RuntimeException.

package com.tutorialspoint.demo.exception;

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

È possibile definire il metodo @ExceptionHandler per gestire le eccezioni come mostrato. Questo metodo dovrebbe essere utilizzato per scrivere il file di classe Controller Advice.

@ExceptionHandler(value = ProductNotfoundException.class)

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

Ora, usa il codice fornito di seguito per lanciare l'eccezione dall'API.

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

Di seguito viene fornito il codice completo per gestire l'eccezione. In questo esempio, abbiamo utilizzato l'API PUT per aggiornare il prodotto. Qui, durante l'aggiornamento del prodotto, se il prodotto non viene trovato, restituire il messaggio di errore di risposta come "Prodotto non trovato". Nota che ilProductNotFoundException la classe di eccezione dovrebbe estendere la RuntimeException.

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

Di seguito viene fornita la classe Controller Advice per gestire l'eccezione a livello globale. Possiamo definire qualsiasi metodo di gestione delle eccezioni in questo file di classe.

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);
   }
}

Di seguito viene fornito il file del controller API del servizio prodotto per aggiornare il prodotto. Se il prodotto non viene trovato, lancia il fileProductNotFoundException classe.

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);
   }
}

Di seguito è riportato il codice per il file di classe dell'applicazione Spring Boot principale:

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);
   }
}

Il codice per POJO class per il prodotto è dato di seguito -

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;
   }
}

Il codice per Maven build – pom.xml è mostrato di seguito -

<?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>

Il codice per Gradle Build – build.gradle è dato di seguito -

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')
}

È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle -

Per Maven, puoi usare il seguente comando:

mvn clean install

Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.

Per Gradle, puoi utilizzare il seguente comando:

gradle clean build

Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.

È possibile eseguire il file JAR utilizzando il seguente comando:

java –jar <JARFILE>

Questo avvierà l'applicazione sulla porta Tomcat 8080 come mostrato di seguito -

Ora premi l'URL seguente nell'applicazione POSTMAN e puoi vedere l'output come mostrato di seguito -

URL di aggiornamento: http: // localhost: 8080 / products / 3