Legen Sie in JAX-RS einen Antworttext fest

1. Übersicht

Um die Entwicklung von REST-Webdiensten und deren Clients in Java zu vereinfachen, wurde eine standardmäßige und portable Implementierung der JAX-RS- API namens Jersey entwickelt.

Jersey ist ein Open-Source-Framework für die Entwicklung von REST-Webdiensten, das JAX-RS- APIs unterstützt und als JAX-RS- Referenzimplementierung dient .

In diesem Tutorial sehen wir uns an, wie wir einen Jersey- Antworttext mit verschiedenen Medientypen einrichten können.

2. Maven-Abhängigkeiten

Zunächst benötigen wir die folgenden Abhängigkeiten, die in der Datei pom.xml enthalten sind:

 org.glassfish.jersey.bundles jaxrs-ri 2.26   org.glassfish.jersey.core jersey-server 2.26 

Die neueste Version von JAX-RS finden Sie unter jaxrs-ri und den Jersey- Server unter jerseyrs -server

3. Antwort in Jersey

Natürlich gibt es verschiedene Möglichkeiten, eine Antwort mit Jersey zu erstellen , und wir werden im Folgenden untersuchen, wie wir sie erstellen können.

Alle Beispiele hier sind HTTP-GET-Anforderungen, und wir werden den Befehl curl verwenden , um die Ressourcen zu testen.

3.1. Ok Textantwort

Der hier gezeigte Endpunkt ist ein einfaches Beispiel dafür, wie einfacher Text als Jersey-Antwort zurückgegeben werden kann:

@GET @Path("/ok") public Response getOkResponse() { String message = "This is a text response"; return Response .status(Response.Status.OK) .entity(message) .build(); }

Wir können ein HTTP-GET mit Curl durchführen , um die Antwort zu überprüfen:

curl -XGET //localhost:8080/jersey/response/ok

Dieser Endpunkt sendet eine Antwort wie folgt zurück:

This is a text response

Wenn der Medientyp nicht angegeben ist, verwendet Jersey standardmäßig Text / Nur.

3.2. Fehlerantwort

Fehler können auch als Jersey-Antwort zurückgesendet werden:

@GET @Path("/not_ok") public Response getNOkTextResponse() { String message = "There was an internal server error"; return Response .status(Response.Status.INTERNAL_SERVER_ERROR) .entity(message) .build(); }

Um die Antwort zu überprüfen, können wir eine HTTP-GET-Anforderung mit curl ausführen :

curl -XGET //localhost:8080/jersey/response/not_ok

Die Fehlermeldung wird in der Antwort zurückgesendet:

There was an internal server error

3.3. Nur-Text-Antwort

Wir können auch einfache Klartextantworten zurückgeben :

@GET @Path("/text_plain") public Response getTextResponseTypeDefined() { String message = "This is a plain text response"; return Response .status(Response.Status.OK) .entity(message) .type(MediaType.TEXT_PLAIN) .build(); }

Wieder können wir ein HTTP-GET mit Curl durchführen , um die Antwort zu überprüfen:

curl -XGET //localhost:8080/jersey/response/text_plain

Die Antwort lautet wie folgt:

This is a plain text response

Das gleiche Ergebnis könnte auch über die Annotation " Produces" erzielt werden, anstatt die Methode type () in der Antwort zu verwenden :

@GET @Path("/text_plain_annotation") @Produces({ MediaType.TEXT_PLAIN }) public Response getTextResponseTypeAnnotated() { String message = "This is a plain text response via annotation"; return Response .status(Response.Status.OK) .entity(message) .build(); }

Wir können die Antwort mit curl überprüfen :

curl -XGET //localhost:8080/jersey/response/text_plain_annotation

Hier ist die Antwort:

This is a plain text response via annotation

3.4. JSON-Antwort mit POJO

Ein einfaches einfaches altes Java-Objekt (POJO) kann auch zum Erstellen einer Jersey-Antwort verwendet werden .

Wir haben unten ein sehr einfaches Personen- POJO, mit dem wir eine Antwort erstellen:

public class Person { String name; String address; // standard constructor // standard getters and setters }

Das Personen- POJO kann jetzt verwendet werden, um JSON als Antworttext zurückzugeben :

@GET @Path("/pojo") public Response getPojoResponse() { Person person = new Person("Abhinayak", "Nepal"); return Response .status(Response.Status.OK) .entity(person) .build(); }

Die Funktion dieses GET-Endpunkts kann über den folgenden Curl- Befehl überprüft werden :

curl -XGET //localhost:8080/jersey/response/pojo

Die Person POJO wird in einen JSON umgewandelt und als Antwort zurückgesendet:

{"address":"Nepal","name":"Abhinayak"}

3.5. JSON-Antwort mit einfacher Zeichenfolge

Wir können vorformatierte Zeichenfolgen verwenden, um eine Antwort zu erstellen , und dies kann einfach erfolgen.

Der folgende Endpunkt ist ein Beispiel dafür, wie ein als String dargestellter JSON in der Jersey-Antwort als JSON zurückgesendet werden kann:

@GET @Path("/json") public Response getJsonResponse() { String message = "{\"hello\": \"This is a JSON response\"}"; return Response .status(Response.Status.OK) .entity(message) .type(MediaType.APPLICATION_JSON) .build(); }

This can be verified by doing an HTTP GET using curl to verify the response:

curl -XGET //localhost:8080/jersey/response/json

Calling this resource will return a JSON:

{"hello":"This is a JSON response"}

The same pattern applies for other common media types like XML or HTML. We just need to notify Jersey that it's an XML or HTML using MediaType.TEXT_XML or MediaType.TEXT_HTML and Jersey will handle the rest.

4. Conclusion

In this quick article, we constructed Jersey (JAX-RS) responses for a variety of media types.

All of the code snippets, mentioned in the article, can be found in over on GitHub.