Welkom bij de Java Jersey Tutorial. Onlangs ben ik begonnen met werken aan een project voor een Restful webservice met behulp van het JAX-RS Jersey-framework.
Wat is het Java Jersey Framework?
Het Java Jersey-project volgt de JAX-RS API, die wordt gebruikt om Restful webservices in Java te creëren. 
1. Voor wie is deze tutorial bedoeld?
Deze tutorial is bedoeld voor Java-programmeurs die geïnteresseerd zijn in het ontwikkelen en implementeren van Restful webservices met behulp van de JAX-RS API en JAXB.
2. Vereisten
Het doel van deze tutorial is om de Jersey API te gebruiken voor het maken van Restful webservices, het aanroepen van de webservice met behulp van een Java-clientprogramma en het testen van de webservice met de tool. Elementaire kennis van Java, webservices, XML, Maven, en een willekeurige applicatieserver (JBoss/Tomcat) is vereist om de tutorial gemakkelijk te begrijpen.
3. Software en Tools
- JDK-versie 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
Jersey Eclipse Maven Project Maken
Maak een “Dynamic Web Project” in Eclipse en converteer het vervolgens naar het Maven-project. Dit zal ons een op Maven gebaseerd basisproject voor een webtoepassing bieden. Ik heb GroupId ingesteld als com.journaldev.jersey en artifactID als my-jersey-project, maar je kunt naar wens iets anders specificeren. Zodra we de ontwikkeling van ons project voltooien, zal de projectstructuur eruitzien zoals weergegeven in de onderstaande afbeelding. 
Uitleg van het Java Jersey Restful Web Service Project
1. pom.xml: Projectconfiguratiegegevens. Let op de jersey-afhankelijkheden die zijn opgegeven; andere details zijn algemeen voor elk vergelijkbaar Maven-project.
<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 voor het verzoekobject. Het belangrijkste om hier op te merken, is de annotatie @XmlRootElement om de klasse aan een XML-element te koppelen.
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 voor het responsobject.
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 als respons wordt verzonden in geval van een uitzondering.
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: Een normale uitzonderingsklasse die wordt gegooid in de webservice.
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: Inzetdescriptor voor de webservice. Dus elke aanvraag met URI https://<HOST>:<PORT>/My-Jersey-Project/rest/* wordt verwerkt door de Jersey ServletContainer-servlet. De init-param-waarde doorgegeven voor “com.sun.jersey.config.property.packages” definieert het pakket waar Jersey naar de webserviceklassen zal zoeken. Deze eigenschap moet verwijzen naar uw resourceklassen. Het zoekt ook naar de resourceklassen in de subpakketten.
<?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: Resourceklasse die verschillende soorten verzoeken afhandelt.
- @Path(“/emp”) – Alle verzoeken met URI
https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/worden verwerkt door deze resourceklasse. - @Path(“/getEmp”) – Alle verzoeken met URI
https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/getEmpworden verwerkt door deze methode. - @POST – Deze annotatie definieert dat de gebruikte HTTP-methode POST moet zijn. Enkele andere mogelijke waarden zijn @GET, @PUT, @DELETE
- @Consumes(MediaType.APPLICATION_XML) – De methode accepteert een XML-element
- @Produces(MediaType.APPLICATION_XML) – De methode retourneert een XML-element
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: Uitzonderingsmapperklasse die EmpNotFoundException koppelt aan een Response-object. De klasse moet de annotatie @Provider hebben. Deze klasse moet zich bevinden in het pakket dat is opgegeven voor resourceklassen in web.xml. Implementatie van de methode toResponse() genereert het ErrorResponse-object en stelt het in als Entity in het Response-object met statuscode 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();
}
}
Onze webservice is klaar, bouw deze gewoon om het WAR-bestand te maken en implementeer het op de applicatieserver.
Voorbeeld van Jersey Client
We kunnen de Jersey Client gebruiken om ons webservice aan te roepen en programmatisch een antwoord te krijgen. EmpClient.java: Dit is een voorbeeld van een Java-programma waarmee we ons webservice aanroepen. We gebruiken de Jersey Client API om de service aan te roepen en op basis van de reactiestatus analyseren we het antwoordentity naar de EmpResponse- of 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();
// stel id in als 1 voor OK-reactie
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());
}
}
}
Succesreactie 
Foutreactie 
Samenvatting
In deze post hebben we geleerd hoe we een REST-webservice kunnen maken met behulp van de Jersey API. We hebben ook gekeken naar de Jersey Client om onze REST-API’s aan te roepen via een Java-programma.
Je kunt de volledige projectcode bekijken op onze GitHub Repository.
Source:
https://www.digitalocean.com/community/tutorials/jersey-java-tutorial