Java >> Java Tutorial >  >> Tag >> Spring

Fehlerbehandlung und -protokollierung in der Spring Boot-REST-API – Teil III

In früheren Beiträgen habe ich darüber geschrieben, wie man eine Spring Boot-REST-API Teil I erstellt und wie man Swagger-Dokumentation für die REST-API Teil II hinzufügt. In diesem Beitrag werden wir Fehlerbehandlung und Protokollierung zu unserer REST-API hinzufügen. Fehlerbehandlung und Protokollierung sind zwei verschiedene Ideen, daher werde ich diesen Beitrag in zwei Abschnitte unterteilen.

1. Protokollierung

In den meisten Produktionsanwendungen ist die Protokollierung kritisch und wird für mehrere Zwecke verwendet. Nur wenige dieser Anwendungen sind das Debuggen von Produktionsproblemen oder das Auditieren der Anwendung. Im Laufe der Jahre haben sich verschiedene Protokollierungsbibliotheken für die Verwendung in Java-basierten Anwendungen entwickelt. slf4j ist das beliebteste Framework, da es eine einfache Abstraktionsschicht für jede Art von Protokollierungsframework bietet.

In unserem Tutorial für diese Anwendung verwenden wir log4j2, die neueste und fortschrittlichste Logging-Bibliothek, die es gibt. Es bietet viele nützliche Funktionen für Leistung, Unterstützung für mehrere APIs, erweiterte Filterung, automatisches Neuladen von Konfigurationen usw. Wir werden in diesem Artikel keine davon behandeln. Wenn Sie mehr über log4j2-Bibliotheken erfahren möchten, lesen Sie hier.

Log4j2-Bibliothek in Anwendung hinzufügen –

Um log4j2 zu verwenden, fügen wir die Maven-Abhängigkeit zur Pom-Datei unseres Projekts hinzu. Dies sollte wie folgt aussehen

 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-api</artifactId>
 </dependency>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-core</artifactId>
 </dependency>

Log4j2-Konfigurationsdatei hinzufügen

Um die Protokollierung zu aktivieren, müssen wir unserer Anwendung eine Konfigurationsdatei hinzufügen. Diese Konfigurationsdatei kann eine XML-, JSON- oder YAML-Datei sein. Wir werden eine XML-Datei log4j2.xml verwenden, die wie unten aussehen wird

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
 <Appenders>
 <Console name="Console" target="SYSTEM_OUT">
 <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
 </Console>
 <File name="BenefitsFile" fileName="benefits.log" append="true">
 <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
 </File>
 </Appenders>
 <Loggers>
 <Root level="debug">
 <AppenderRef ref="Console" />
 <AppenderRef ref="BenefitsFile"/>
 </Root>
 </Loggers>
</Configuration>

Also verwenden wir Console und BenefitsFile als zwei Protokollierer, die sich jeweils in eine Konsole und Datei einloggen. Wir setzen die Protokollebene auf DEBUG. Wenn Sie Nachrichten mit einem niedrigeren Level als DEBUG protokollieren, werden sie in der Konsole oder Datei protokolliert. Wir müssen eine Datei benefit.log im Klassenpfad hinzufügen, um diese Protokollierungsdatei zu erreichen. Das Protokollmuster besteht aus Datum, Uhrzeit, Protokollebene, Klasse, aus der das Protokoll stammt, und Protokollnachricht.

Fügen Sie den Anmeldeanwendungscode hinzu

Sobald wir die erforderlichen Protokollierungsbibliotheken und die Protokollierungskonfiguration angepasst haben, können wir die Protokollierung in unserem Code hinzufügen, um diese Protokollierung während der Laufzeitausführung zu erfassen. In einem der Manager CompanyManagerImpl werden wir einen Logger hinzufügen.

public static final Logger LOGGER = LogManager.getLogger(CompanyManagerImpl.class);

@Override
public List<Company> getAllCompanies()
{
  LOGGER.info(" Enter >> getAllCompanies() ");
  List<Company> cList = (List<Company>) companyRepository.findAll();
  LOGGER.info(" Exit << getAllCompanies() ");
  return cList;
}

Sobald wir unsere Spring-Boot-Anwendung ausgeführt haben, können wir die Protokolle in der Konsole oder Datei erfassen. Die Datei heißt benefit.log.

2. Fehlerbehandlung

Wir werden nicht im Detail über Ausnahmen schreiben, da sie in diesem Beitrag Ausnahmen behandelt wurden. Wir werden unsere eigene benutzerdefinierte Ausnahme erstellen, die ab WebApplicationException erweitert wird welche Jersey-Bibliothek bereitstellt.

Dies sieht wie folgt aus:

package com.betterjavacode.benefits.utilities;

import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;

public class InvalidRequestException extends WebApplicationException 
{

  /**
  *
  */
  private static final long serialVersionUID = 1L;
  private int errorcode = 00; // 00 indicates - no error

  public InvalidRequestException() 
  {

  }

  public InvalidRequestException(int errorcode, String message) 
  {
    super(Response.status(Response.Status.BAD_REQUEST).entity(message).build());
    this.errorcode = errorcode;
  }

  public InvalidRequestException(int errorcode, String message, Throwable cause) 
  {
     super(cause, Response.status(Response.Status.BAD_REQUEST).entity(message).build());
     this.errorcode = errorcode;
  }
}

Jetzt können wir diese benutzerdefinierte Ausnahme in unseren Managern verwenden, wenn wir eine Fehlermeldung ausgeben möchten, um anzuzeigen, ob mit der Clientanforderung etwas nicht stimmt. Auf ähnliche Weise können wir eine weitere Ausnahme erstellen, um anzuzeigen, ob auf der Serverseite etwas nicht stimmt. Der folgende Ausschnitt zeigt ab CompanyManagerImpl wo wir gezeigt haben, wie man diese Ausnahme auslöst.

@Override
public Company getCompany(int guid) 
{
  LOGGER.info(" Enter >> getCompany() ");
  Company company = companyRepository.findOne(guid);
  if (company == null) {
    LOGGER.info(" Exit << createCompany() ");
    throw new InvalidRequestException(400, "Company not found");
  }
  LOGGER.info(" Exit << getCompany() ");
  return company;
}

In diesem Beitrag haben wir gezeigt, wie Protokollierung und Fehler in einer REST-API behandelt werden. Der Code dafür ist im github-Repository verfügbar.


Java-Tag