Willkommen beim Java Jersey Tutorial. Vor kurzem habe ich mit der Arbeit an einem Restful-Webdienstprojekt unter Verwendung des JAX-RS Jersey-Frameworks begonnen.
Was ist das Java Jersey Framework?
Das Java Jersey-Projekt verfolgt die JAX-RS-API, die zur Erstellung von Restful-Webdiensten in Java verwendet wird. 
1. Wer sollte dieses Tutorial verwenden?
Dieses Tutorial richtet sich an Java-Programmierer, die daran interessiert sind, Restful-Webdienste unter Verwendung der JAX-RS-API und JAXB zu entwickeln und bereitzustellen.
2. Voraussetzungen
Der Umfang dieses Tutorials besteht darin, die Jersey-API zum Erstellen von Restful-Webdiensten zu verwenden, den Webdienst mit einem Java-Clientprogramm aufzurufen und den Webdienst mit dem Tool zu testen. Grundlegende Kenntnisse in Java, Webdiensten, XML, Maven und einem Anwendungsserver (JBoss/Tomcat) sind erforderlich, um das Tutorial leicht zu verstehen.
3. Softwares und Tools
- JDK Version 1.8.0_131
- Apache Maven 3.5.3
- Mac OS X 10.13.4
- Tomcat 8.5.16
- Eclipse Java EE IDE Oxygen 4.7.3
Erstellung eines Jersey Eclipse Maven Projekts
Erstellen Sie ein „Dynamic Web Project“ in Eclipse und konvertieren Sie es dann in das Maven-Projekt. Dies wird uns ein auf Maven basierendes Webanwendungs-Grundprojekt bereitstellen. Ich habe GroupId als com.journaldev.jersey und artifactID als my-jersey-project angegeben, aber Sie können alles angeben, was Sie möchten. Sobald wir die Entwicklung unseres Projekts abgeschlossen haben, wird die Projektstruktur wie auf dem folgenden Bild aussehen. 
Java Jersey Restful Web Service Projekt Erklärung
1. pom.xml: Projektkonfigurationsdetails, beachten Sie die bereitgestellten Jersey-Abhängigkeiten, andere Details sind für jedes ähnliche Maven-Projekt üblich.
<project xmlns="https://maven.apache.org/POM/4.0.0"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.jersey</groupId>
<artifactId>my-jersey-project</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-server</artifactId>
<version>1.14</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-servlet</artifactId>
<version>1.14</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-client</artifactId>
<version>1.14</version>
</dependency>
</dependencies>
<build>
<finalName>My-Jersey-Project</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.0.0</version>
<configuration>
<warSourceDirectory>WebContent</warSourceDirectory>
</configuration>
</plugin>
</plugins>
</build>
</project>
2. EmpRequest.java: Java Bean für das Anforderungsobjekt. Das Wichtige hier ist die @XmlRootElement-Annotation, um die Klasse einem XML-Element zuzuordnen.
package com.journaldev.model;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "empRequest")
public class EmpRequest {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
3. EmpResponse.java: Java Bean für das Antwortobjekt.
package com.journaldev.model;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "empResponse")
public class EmpResponse {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
4. ErrorResponse.java: Java Bean, die im Falle einer Ausnahme als Antwort gesendet wird.
package com.journaldev.model;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "errorResponse")
public class ErrorResponse {
private String errorCode;
private int errorId;
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public int getErrorId() {
return errorId;
}
public void setErrorId(int errorId) {
this.errorId = errorId;
}
}
5. EmpNotFoundException.java: Eine normale Ausnahme-Klasse, die im Webdienst ausgelöst wird.
package com.journaldev.exception;
public class EmpNotFoundException extends Exception {
private static final long serialVersionUID = 4351720088030656859L;
private int errorId;
public int getErrorId() {
return errorId;
}
public EmpNotFoundException(String msg, int errorId) {
super(msg);
this.errorId = errorId;
}
public EmpNotFoundException(String msg, Throwable cause) {
super(msg, cause);
}
}
6. web.xml: Bereitstellungsbeschreibung für den Webdienst. Jede Anforderung mit der URI https://<HOST>:<PORT>/My-Jersey-Project/rest/* wird vom Jersey ServletContainer-Servlet verarbeitet. Der für „com.sun.jersey.config.property.packages“ übergebene init-param-Wert definiert das Paket, in dem Jersey nach den Klassen des Webdienstes sucht. Dieses Attribut muss auf Ihre Ressourcenklassen zeigen. Es sucht auch nach den Ressourcenklassen in den Unterpaketen.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xmlns="https://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>My Jersey Project</display-name>
<!-- Jersey Servlet configurations -->
<servlet>
<servlet-name>Jersey REST Service</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>com.journaldev</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey REST Service</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
<!-- Jersey Servlet configurations -->
</web-app>
7. EmpRouter.java: Ressourcenklasse, die verschiedene Arten von Anforderungen behandelt.
- @Path(„/emp“) – Alle Anfragen mit der URI
https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/werden von dieser Ressourcenklasse verarbeitet. - @Path(„/getEmp“) – Alle Anfragen mit URI
https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/getEmpwerden von dieser Methode verarbeitet. - @POST – Diese Annotation definiert, dass die verwendete HTTP-Methode POST sein soll. Einige andere mögliche Werte sind @GET, @PUT, @DELETE
- @Consumes(MediaType.APPLICATION_XML) – Die Methode akzeptiert XML-Elemente
- @Produces(MediaType.APPLICATION_XML) – Die Methode gibt XML-Elemente zurück
package com.journaldev.router;
import com.journaldev.exception.EmpNotFoundException;
import com.journaldev.model.*;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.xml.bind.JAXBElement;
@Path("/emp")
public class EmpRouter {
@POST
@Path("/getEmp")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)
public Response getEmp(JAXBElement<EmpRequest> empRequest)
throws EmpNotFoundException {
EmpResponse empResponse = new EmpResponse();
if (empRequest.getValue().getId() == 1) {
empResponse.setId(empRequest.getValue().getId());
empResponse.setName(empRequest.getValue().getName());
} else {
throw new EmpNotFoundException("Wrong ID", empRequest.getValue()
.getId());
}
return Response.ok(empResponse).build();
}
}
8. EmpNotFoundExceptionMapper.java: Exception Mapper-Klasse, die EmpNotFoundException auf ein Response-Objekt abbildet. Die Klasse sollte die Annotation @Provider haben. Diese Klasse sollte sich im Paket befinden, das für Ressourcenklassen in der web.xml bereitgestellt wurde. Die Implementierung der Methode toResponse() generiert das ErrorResponse-Objekt und setzt es als Entity im Response-Objekt mit dem Status INTERNAL_SERVER_ERROR.
package com.journaldev.exceptionmapper;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;
import com.journaldev.exception.EmpNotFoundException;
import com.journaldev.model.ErrorResponse;
@Provider
public class EmpNotFoundExceptionMapper implements
ExceptionMapper<EmpNotFoundException> {
public EmpNotFoundExceptionMapper() {
}
public Response toResponse(
EmpNotFoundException empNotFoundException) {
ErrorResponse errorResponse = new ErrorResponse();
errorResponse.setErrorId(empNotFoundException.getErrorId());
errorResponse.setErrorCode(empNotFoundException.getMessage());
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
errorResponse).type(
MediaType.APPLICATION_XML).build();
}
}
Unser Webdienst ist bereit, bauen Sie ihn einfach, um die WAR-Datei zu erstellen, und deployen Sie ihn auf dem Anwendungsserver.
Jersey Client Beispiel
Wir können den Jersey-Client verwenden, um unseren Webdienst aufzurufen und programmgesteuert eine Antwort zu erhalten. EmpClient.java: Dies ist ein Beispiel-Java-Programm, über das wir unseren Webdienst aufrufen. Wir verwenden die Jersey-Client-API, um den Dienst aufzurufen, und basierend auf dem Antwortstatus analysieren wir die Antwortentität in die EmpResponse- oder ErrorResponse-Klasse.
package com.journaldev.client;
import javax.ws.rs.core.MediaType;
import com.journaldev.model.EmpRequest;
import com.journaldev.model.EmpResponse;
import com.journaldev.model.ErrorResponse;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
public class EmpClient {
/**
* @param args
*/
public static void main(String[] args) {
String uri = "https://localhost:8080/My-Jersey-Project/rest/emp/getEmp";
EmpRequest request = new EmpRequest();
// setze id auf 1 für OK-Antwort
request.setId(2);
request.setName("PK");
try {
Client client = Client.create();
WebResource r = client.resource(uri);
ClientResponse response = r.type(MediaType.APPLICATION_XML).post(ClientResponse.class, request);
System.out.println(response.getStatus());
if (response.getStatus() == 200) {
EmpResponse empResponse = response.getEntity(EmpResponse.class);
System.out.println(empResponse.getId() + "::" + empResponse.getName());
} else {
ErrorResponse exc = response.getEntity(ErrorResponse.class);
System.out.println(exc.getErrorCode());
System.out.println(exc.getErrorId());
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
Erfolgsantwort 
Fehlerantwort 
Zusammenfassung
In diesem Beitrag haben wir gelernt, wie man einen REST-Webdienst mit der Jersey-API erstellt. Wir haben auch den Jersey-Client untersucht, um unsere REST-APIs über ein Java-Programm aufzurufen.
Sie können den vollständigen Projektcode aus unserem GitHub-Repository überprüfen.
Source:
https://www.digitalocean.com/community/tutorials/jersey-java-tutorial