Spring Boot - Ausnahmebehandlung

Der Umgang mit Ausnahmen und Fehlern in APIs und das Senden der richtigen Antwort an den Client ist gut für Unternehmensanwendungen. In diesem Kapitel erfahren Sie, wie Sie mit Ausnahmen in Spring Boot umgehen.

Bevor Sie mit der Ausnahmebehandlung fortfahren, sollten Sie sich mit den folgenden Anmerkungen vertraut machen.

Controller-Beratung

Das @ControllerAdvice ist eine Anmerkung, um die Ausnahmen global zu behandeln.

Ausnahmehandler

Der @ExceptionHandler ist eine Anmerkung, mit der die spezifischen Ausnahmen behandelt und die benutzerdefinierten Antworten an den Client gesendet werden.

Mit dem folgenden Code können Sie die @ ControllerAdvice-Klasse erstellen, um die Ausnahmen global zu behandeln.

package com.tutorialspoint.demo.exception;

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

@ControllerAdvice
   public class ProductExceptionController {
}

Definieren Sie eine Klasse, die die RuntimeException-Klasse erweitert.

package com.tutorialspoint.demo.exception;

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

Sie können die @ ExcceptionHandler-Methode definieren, um die Ausnahmen wie gezeigt zu behandeln. Diese Methode sollte zum Schreiben der Controller Advice-Klassendatei verwendet werden.

@ExceptionHandler(value = ProductNotfoundException.class)

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

Verwenden Sie nun den unten angegebenen Code, um die Ausnahme von der API auszulösen.

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

Der vollständige Code zur Behandlung der Ausnahme ist unten angegeben. In diesem Beispiel haben wir die PUT-API verwendet, um das Produkt zu aktualisieren. Wenn das Produkt während der Aktualisierung nicht gefunden wird, wird die Antwortfehlermeldung als "Produkt nicht gefunden" zurückgegeben. Notiere dass derProductNotFoundException Ausnahmeklasse sollte die erweitern RuntimeException.

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

Die Controller Advice-Klasse zur globalen Behandlung der Ausnahme ist unten angegeben. In dieser Klassendatei können beliebige Exception-Handler-Methoden definiert werden.

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

Die Product Service API-Controller-Datei wird unten angegeben, um das Produkt zu aktualisieren. Wenn das Produkt nicht gefunden wird, wirft es dasProductNotFoundException Klasse.

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

Der Code für die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

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

Der Code für POJO class für Produkt ist unten angegeben -

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

Der Code für Maven build – pom.xml wird unten gezeigt -

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

Der Code für Gradle Build – build.gradle ist unten angegeben -

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

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den Befehlen Maven oder Gradle ausführen.

Für Maven können Sie den folgenden Befehl verwenden: