Ausnahmebehandlung im Spring Boot

Die Ausnahmebehandlung ist ein entscheidender Bestandteil beim Erstellen robuster und benutzerfreundlicher Anwendungen. In Spring Boot können wir Ausnahmen auf verschiedene Arten behandeln, um sicherzustellen, dass unsere Anwendung stabil bleibt und Benutzern aussagekräftiges Feedback gibt. In diesem Leitfaden werden verschiedene Strategien zur Ausnahmebehandlung behandelt, einschließlich benutzerdefinierter Ausnahmen, globaler Ausnahmebehandlung, Validierungsfehler und Best Practices für die Produktion.

1. Grundlagen der Ausnahmebehandlung

Ausnahmen sind Ereignisse, die den normalen Ablauf eines Programms stören. Sie können unterteilt werden in:

• Überprüfte Ausnahmen: Ausnahmen, die zur Kompilierungszeit überprüft werden.
• Ungeprüfte Ausnahmen (Laufzeitausnahmen): Ausnahmen, die während der Laufzeit auftreten.
• Fehler: Schwerwiegende Probleme, die Anwendungen nicht behandeln sollten, wie etwa OutOfMemoryError.

2. Benutzerdefinierte Ausnahmeklassen

Das Erstellen benutzerdefinierter Ausnahmeklassen hilft bei der Behandlung spezifischer Fehlerbedingungen in Ihrer Anwendung.

package com.example.SpringBootRefresher.exception;

public class DepartmentNotFoundException extends RuntimeException {
    public DepartmentNotFoundException(String message) {
        super(message);
    }
}

3. Ausnahmebehandlung in Controllern

@ExceptionHandler-Anmerkung:
Sie können Methoden zur Behandlung von Ausnahmen in Ihren Controller-Klassen definieren.

package com.example.SpringBootRefresher.controller;

import com.example.SpringBootRefresher.exception.DepartmentNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DepartmentController {

    @GetMapping("/department")
    public String getDepartment() {
        // Simulate an exception
        throw new DepartmentNotFoundException("Department not found!");
    }

    @ExceptionHandler(DepartmentNotFoundException.class)
    public ResponseEntity<String> handleDepartmentNotFoundException(DepartmentNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

4. Globale Ausnahmebehandlung mit @ControllerAdvice

Um Ausnahmen global zu behandeln, können Sie @ControllerAdvice und einen zentralen Ausnahmehandler verwenden.

package com.example.SpringBootRefresher.error;

import com.example.SpringBootRefresher.entity.ErrorMessage;
import com.example.SpringBootRefresher.exception.DepartmentNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
@ResponseStatus
public class CustomResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(DepartmentNotFoundException.class)
    public ResponseEntity<ErrorMessage> handleDepartmentNotFoundException(DepartmentNotFoundException exception, WebRequest request) {
        ErrorMessage message = new ErrorMessage(
                HttpStatus.NOT_FOUND.value(),
                exception.getMessage(),
                request.getDescription(false)
        );

        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(message);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorMessage> handleGlobalException(Exception exception, WebRequest request) {
        ErrorMessage message = new ErrorMessage(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                exception.getMessage(),
                request.getDescription(false)
        );

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(message);
    }
}

5. Erstellen einer Standardfehlerantwort

Definieren Sie eine Standard-Fehlerantwortklasse, um Ihre Fehlermeldungen zu strukturieren.

package com.example.SpringBootRefresher.entity;

public class ErrorMessage {
    private int statusCode;
    private String message;
    private String description;

    public ErrorMessage(int statusCode, String message, String description) {
        this.statusCode = statusCode;
        this.message = message;
        this.description = description;
    }

    // Getters and setters

    public int getStatusCode() {
        return statusCode;
    }

    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

6. Umgang mit Validierungsfehlern

Spring Boot lässt sich gut in Bean Validation (JSR-380) integrieren. Um Validierungsfehler global zu behandeln, verwenden Sie @ControllerAdvice.

package com.example.SpringBootRefresher.error;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.WebRequest;
import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
@ResponseStatus
public class ValidationExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });
        return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
    }
}

7. Verwenden von @ResponseStatus für einfache Ausnahmen

In einfachen Fällen können Sie eine Ausnahmeklasse mit @ResponseStatus annotieren, um den HTTP-Statuscode anzugeben.

package com.example.SpringBootRefresher.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(HttpStatus.NOT_FOUND)
public class DepartmentNotFoundException extends RuntimeException {
    public DepartmentNotFoundException(String message) {
        super(message);
    }
}

8. Best Practices für die Produktion

1. Konsistente Fehlerantworten: Stellen Sie sicher, dass Ihre Anwendung konsistente und strukturierte Fehlerantworten zurückgibt. Verwenden Sie eine Standard-Fehlerantwortklasse.
2. Protokollierung: Ausnahmen zu Debug- und Überwachungszwecken protokollieren. Stellen Sie sicher, dass vertrauliche Informationen nicht in Protokollen offengelegt werden.
3. Benutzerfreundliche Meldungen: Stellen Sie benutzerfreundliche Fehlermeldungen bereit. Vermeiden Sie es, interne Details oder Stack-Traces den Benutzern preiszugeben.
4. Sicherheit: Seien Sie vorsichtig mit den in Fehlerantworten enthaltenen Informationen, um die Offenlegung vertraulicher Daten zu vermeiden.
5. Dokumentation:Dokumentieren Sie Ihre Ausnahmebehandlungsstrategie für Ihr Team und zukünftige Betreuer.

Zusammenfassung

Die Ausnahmebehandlung in Spring Boot umfasst die Verwendung von Annotationen wie @ExceptionHandler, @ControllerAdvice und @ResponseStatus, um Fehler effektiv zu verwalten. Indem Sie benutzerdefinierte Ausnahmen erstellen, Validierungsfehler behandeln und Best Practices befolgen, können Sie robuste Anwendungen erstellen, die Fehler ordnungsgemäß behandeln und den Benutzern aussagekräftiges Feedback geben. Durch die Verwendung von Java 17-Funktionen wird sichergestellt, dass Ihre Anwendung die neuesten Verbesserungen im Java-Ökosystem nutzt.

Das obige ist der detaillierte Inhalt vonAusnahmebehandlung im Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!