it-swarm.com.de

Was ist der beste Weg, verschiedene Arten von ResponseEntity in Spring MVC oder Spring-Boot zurückzugeben?

Ich habe eine einfache Restanwendung mit Spring MVC 4 (oder Spring-Boot) geschrieben. Innerhalb des Controllers habe ich ResponseEntity zurückgegeben. Aber in einigen Fällen möchte ich Erfolg JSON geben, und wenn es einen Validierungsfehler gibt, möchte ich Fehler JSON geben. Derzeit sind Erfolg und Fehlerantworten völlig unterschiedlich. Daher habe ich zwei Klassen für Fehler und Erfolg erstellt. Innerhalb der Steuerung möchte ich ResponseEntity<Success> zurückgeben, wenn die interne Logik in Ordnung ist. Ansonsten möchte ich ResponseEntity<Error> zurückgeben. Gibt es eine Möglichkeit, dies zu tun?.

Success und Error sind die zwei Klassen, die ich für Erfolg und Fehlerreaktion verwende.

21

Sie können wie folgt implementieren, um Success und Error für dieselbe Anforderungszuordnungsmethode zurückzugeben

public ResponseEntity<?> method() {
    boolean b = // some logic
    if (b)
        return new ResponseEntity<Success>(HttpStatus.OK);
    else
        return new ResponseEntity<Error>(HttpStatus.CONFLICT); //appropriate error code
}
27
Saravana

Ich empfehle, Spring's @ControllerAdvice zu verwenden, um Validierungsfehler zu behandeln. Lesen Sie diese Anleitung für eine gute Einführung, beginnend mit dem Abschnitt "Spring Boot Error Handling". Für eine ausführliche Diskussion gibt es einen Artikel im Spring.io-Blog, der am April 2018 aktualisiert wurde.

Eine kurze Zusammenfassung, wie das funktioniert:

  • Ihre Controller-Methode sollte nur ResponseEntity<Success> zurückgeben. Es ist nicht verantwortlich für die Rückgabe von Fehler- oder Ausnahmeantworten.
  • Sie implementieren eine Klasse, die Ausnahmen für alle Controller behandelt. Diese Klasse wird mit @ControllerAdvice versehen.
  • Diese Controller-Hinweisklasse enthält Methoden, die mit @ExceptionHandler versehen sind.
  • Jede Ausnahmebehandlungsmethode wird so konfiguriert, dass sie einen oder mehrere Ausnahmetypen behandelt. Bei diesen Methoden geben Sie den Antworttyp für Fehler an
  • In Ihrem Beispiel würden Sie (in der Controller-Hinweisklasse) eine Ausnahmebehandlungsmethode für den Validierungsfehler angeben. Der Rückgabetyp wäre ResponseEntity<Error>

Bei diesem Ansatz müssen Sie nur die Controller-Ausnahmebehandlung für alle Endpunkte in Ihrer API an einer Stelle implementieren. Es macht es auch für Ihre API leicht, über alle Endpunkte hinweg eine einheitliche Ausnahmeantwortstruktur zu haben. Dies vereinfacht die Ausnahmebehandlung für Ihre Kunden.

23
Mark Norman

ich bin mir nicht sicher, aber ich denke, Sie können @ResponseEntity und @ResponseBody verwenden und zwei verschiedene senden, ist Erfolg und zweitens ist eine Fehlermeldung wie:

@RequestMapping(value ="/book2", produces =MediaType.APPLICATION_JSON_VALUE )
@ResponseBody
Book bookInfo2() {
    Book book = new Book();
    book.setBookName("Ramcharitmanas");
    book.setWriter("TulasiDas");
    return book;
}

@RequestMapping(value ="/book3", produces =MediaType.APPLICATION_JSON_VALUE )
public ResponseEntity<Book> bookInfo3() {
    Book book = new Book();
    book.setBookName("Ramayan");
    book.setWriter("Valmiki");
    return ResponseEntity.accepted().body(book);
}

Weitere Informationen finden Sie hier: http://www.concretepage.com/spring-4/spring-4-mvc-jsonp-example-with-rest-responsebody-responseentity

4
km8295

Es ist möglich, ResponseEntity ohne Generics wie folgt zurückzugeben:

public ResponseEntity method() {
    boolean isValid = // some logic
    if (isValid){
        return new ResponseEntity(new Success(), HttpStatus.OK);
    }
    else{
        return new ResponseEntity(new Error(), HttpStatus.BAD_REQUEST);
    }
}
3

Hier ist ein Weg, den ich machen würde:

public ResponseEntity < ? extends BaseResponse > message(@PathVariable String player) { //REST Endpoint.

 try {
  Integer.parseInt(player);
  return new ResponseEntity < ErrorResponse > (new ErrorResponse("111", "player is not found"), HttpStatus.BAD_REQUEST);
 } catch (Exception e) {


 }
 Message msg = new Message(player, "Hello " + player);
 return new ResponseEntity < Message > (msg, HttpStatus.OK);

}

@RequestMapping(value = "/getAll/{player}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity < List < ? extends BaseResponse >> messageAll(@PathVariable String player) { //REST Endpoint.

 try {
  Integer.parseInt(player);
  List < ErrorResponse > errs = new ArrayList < ErrorResponse > ();
  errs.add(new ErrorResponse("111", "player is not found"));
  return new ResponseEntity < List < ? extends BaseResponse >> (errs, HttpStatus.BAD_REQUEST);
 } catch (Exception e) {


 }
 Message msg = new Message(player, "Hello " + player);
 List < Message > msgList = new ArrayList < Message > ();
 msgList.add(msg);
 return new ResponseEntity < List < ? extends BaseResponse >> (msgList, HttpStatus.OK);

}
2
sharath

Sie können auch wie folgt implementieren, um Success und Error für dieselbe Anforderungsmapping-Methode zurückzugeben. Verwenden Sie Object class (übergeordnete Klasse jeder Klasse in Java): 

public ResponseEntity< Object> method() {                                                                                                                                                                                                                                                                                                                                                                                  
    boolean b = //  logic  here   
      if (b)  
        return new ResponseEntity< Object>(HttpStatus.OK);      
    else      
        return new ResponseEntity< Object>(HttpStatus.CONFLICT); //appropriate error code   
}
1
NeeruSingh

Ich habe eine solche Klasse benutzt. Der statusCode wird gesetzt, wenn bei der in message eingestellten Fehlermeldung ein Fehler auftritt. Die Daten werden je nach Bedarf in der Karte oder in einer Liste gespeichert.

/**
* 
*/
package com.test.presentation.response;

import Java.util.Collection;
import Java.util.Map;

/**
 * A simple POJO to send JSON response to ajax requests. This POJO enables  us to
 * send messages and error codes with the actual objects in the application.
 * 
 * 
 */
@SuppressWarnings("rawtypes")
public class GenericResponse {

/**
 * An array that contains the actual objects
 */
private Collection rows;

/**
 * An Map that contains the actual objects
 */
private Map mapData;

/**
 * A String containing error code. Set to 1 if there is an error
 */
private int statusCode = 0;

/**
 * A String containing error message.
 */
private String message;

/**
 * An array that contains the actual objects
 * 
 * @return the rows
 */
public Collection getRows() {
    return rows;
}

/**
 * An array that contains the actual objects
 * 
 * @param rows
 *            the rows to set
 */
public void setRows(Collection rows) {
    this.rows = rows;
}

/**
 * An Map that contains the actual objects
 * 
 * @return the mapData
 */
public Map getMapData() {
    return mapData;
}

/**
 * An Map that contains the actual objects
 * 
 * @param mapData
 *            the mapData to set
 */
public void setMapData(Map mapData) {
    this.mapData = mapData;
}

/**
 * A String containing error code.
 * 
 * @return the errorCode
 */
public int getStatusCode() {
    return statusCode;
}

/**
 * A String containing error code.
 * 
 * @param errorCode
 *            the errorCode to set
 */
public void setStatusCode(int errorCode) {
    this.statusCode = errorCode;
}

/**
 * A String containing error message.
 * 
 * @return the errorMessage
 */
public String getMessage() {
    return message;
}

/**
 * A String containing error message.
 * 
 * @param errorMessage
 *            the errorMessage to set
 */
public void setMessage(String errorMessage) {
    this.message = errorMessage;
}

}

Hoffe das hilft.

0
shazinltc

Sie können eine Karte mit Ihrem Objekt oder einer Zeichenfolge wie folgt verwenden:

@RequestMapping(value = "/path", 
        method = RequestMethod.GET, 
        produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public ResponseEntity<Map<String,String>> getData(){

    Map<String,String> response = new HashMap<String, String>();

    boolean isValid = // some logic
    if (isValid){
        response.put("ok", "success saving data");
        return ResponseEntity.accepted().body(response);
    }
    else{
        response.put("error", "an error expected on processing file");
        return ResponseEntity.badRequest().body(response);
    }

}
0
Ridha10