Setel Badan Respons di JAX-RS

1. Ikhtisar

Untuk menyederhanakan pengembangan layanan web REST dan klien mereka di Java, telah dirancang implementasi standar dan portabel dari JAX-RS API yang disebut Jersey.

Jersey adalah kerangka kerja sumber terbuka untuk mengembangkan layanan web REST yang memberikan dukungan untuk API JAX-RS dan berfungsi sebagai implementasi referensi JAX-RS .

Dalam tutorial ini, kita akan melihat bagaimana kita bisa mengatur isi Jersey respon dengan tipe media yang berbeda.

2. Ketergantungan Maven

Pertama, kita membutuhkan dependensi berikut yang disertakan dalam file pom.xml :

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

Versi terbaru JAX-RS dapat ditemukan di jaxrs-ri, dan server Jersey dapat ditemukan di jersey-server

3. Respon di Jersey

Secara alami, ada berbagai cara untuk membangun tanggapan menggunakan Jersey , dan kita akan melihat bagaimana kita dapat membangunnya di bawah ini.

Semua contoh di sini adalah permintaan HTTP GET, dan kami akan menggunakan perintah curl untuk menguji sumber daya.

3.1. Ok Text Respon

Titik akhir yang ditampilkan di sini adalah contoh sederhana bagaimana teks biasa dapat dikembalikan sebagai respons Jersey:

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

Kita dapat melakukan HTTP GET menggunakan curl untuk memverifikasi respons:

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

Titik akhir ini akan mengirimkan kembali tanggapan sebagai berikut:

This is a text response

Jika jenis media tidak ditentukan, Jersey akan default ke teks / biasa.

3.2. Respon Kesalahan

Kesalahan juga dapat dikirim kembali sebagai tanggapan Jersey:

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

Untuk memverifikasi respon, kita dapat melakukan permintaan HTTP GET menggunakan curl :

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

Pesan kesalahan akan dikirim kembali sebagai tanggapan:

There was an internal server error

3.3. Respon Teks Biasa

Kami juga dapat mengembalikan tanggapan teks biasa sederhana :

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

Sekali lagi, kita dapat melakukan HTTP GET menggunakan curl untuk memverifikasi respons:

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

Tanggapannya adalah sebagai berikut:

This is a plain text response

Hasil yang sama juga bisa dicapai melalui anotasi Produces daripada menggunakan metode type () dalam Respon :

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

Kami dapat melakukan verifikasi respons menggunakan curl :

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

Berikut tanggapannya:

This is a plain text response via annotation

3.4. Respon JSON Menggunakan POJO

A simple Plain Old Java Object (POJO) can also be used build a Jersey response.

We have a very simple Person POJO shown below, which we'll use to build a response:

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

The Person POJO can now be used to return JSON as the Response body:

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

The working of this GET endpoint can be verified – via the following curl command:

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

The Person POJO will be transformed into a JSON and sent back as a response:

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

3.5. JSON Response Using Simple String

We can use preformatted strings to create a response, and it can be done simply.

The following endpoint is an example of how a JSON represented as a String can be sent back as a JSON in the Jersey response:

@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.