Bienvenido al Tutorial de Java Jersey. Recientemente, comencé a trabajar en un proyecto de servicio web Restful utilizando el marco JAX-RS Jersey.
¿Qué es el Framework Java Jersey?
El proyecto Java Jersey sigue la API JAX-RS, que se utiliza para crear servicios web Restful en Java. 
1. ¿Quién debería usar este tutorial?
Este tutorial está destinado a programadores Java interesados en desarrollar e implementar servicios web Restful utilizando la API JAX-RS y JAXB.
2. Prerrequisitos
El alcance de este tutorial es utilizar la API Jersey para crear servicios web Restful e invocar el servicio web utilizando un programa cliente Java y probar el servicio web con la herramienta. Se requiere una comprensión básica de Java, servicios web, XML, Maven y cualquier servidor de aplicaciones (JBoss/Tomcat) para entender el tutorial con facilidad.
3. Software y Herramientas
- Versión JDK 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
Creación de Proyecto Maven Jersey en Eclipse
Crear un “Proyecto Web Dinámico” en Eclipse y luego convertirlo en un proyecto Maven. Esto nos proporcionará un proyecto básico de aplicación web basado en Maven. He dado GroupId como com.journaldev.jersey y artifactID como mi-proyecto-jersey, pero puedes especificar lo que desees. Una vez que completemos el desarrollo de nuestro proyecto, la estructura del proyecto se verá como en la siguiente imagen. 
Explicación del Proyecto de Servicio Web Java Jersey Restful
1. pom.xml: Detalles de configuración del proyecto, ten en cuenta las dependencias de Jersey proporcionadas, otros detalles son comunes para cualquier proyecto Maven similar.
<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 para el objeto de solicitud. Lo importante a tener en cuenta aquí es la anotación @XmlRootElement para mapear la clase a un elemento XML.
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 para el objeto de respuesta.
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 que se enviará como respuesta en caso de una excepción.
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: Una clase de excepción normal lanzada en el servicio web.
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: Descriptor de implementación para el servicio web. Entonces, cualquier solicitud con URI https://<HOST>:<PORT>/My-Jersey-Project/rest/* será procesada por el servlet ServletContainer de Jersey. El valor init-param pasado para “com.sun.jersey.config.property.packages” define el paquete que Jersey buscará para las clases de servicio web. Esta propiedad debe apuntar a tus clases de recursos. También busca las clases de recursos en los subpaquetes.
<?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: Clase de recurso que maneja diferentes tipos de solicitud.
- @Path(“/emp”) – Todas las solicitudes con URI
https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/serán procesadas por esta clase de recurso. - @Ruta(“/getEmp”) – Todos los pedidos con URI
https://<HOST>:<PORT>/Mi-Proyecto-Jersey/rest/emp/getEmpserán procesados por este método. - @POST – Esta anotación define que el método HTTP utilizado debe ser POST. Algunos otros valores posibles son @GET, @PUT, @DELETE
- @Consumes(MediaType.APPLICATION_XML) – El método acepta elemento XML
- @Produces(MediaType.APPLICATION_XML) – El método devuelve elemento XML
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: Clase del mapeador de excepciones que asigna EmpNotFoundException a un objeto de respuesta. La clase debe tener la anotación @Provider. Esta clase debe estar en el paquete proporcionado para las clases de recursos en web.xml. La implementación del método toResponse() genera el objeto ErrorResponse y lo establece como Entidad en el objeto Response con estado como 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();
}
}
Nuestro servicio web está listo, simplemente constrúyalo para crear el archivo WAR y despliéguelo en el servidor de aplicaciones.
Ejemplo del Cliente de Jersey
Podemos usar el Cliente de Jersey para llamar a nuestro servicio web y obtener una respuesta de forma programática. EmpClient.java: Este es un programa de ejemplo en Java a través del cual estamos invocando nuestro servicio web. Estamos utilizando la API del Cliente de Jersey para invocar el servicio y, en función del estado de la respuesta, estamos analizando la entidad de respuesta en las clases EmpResponse o ErrorResponse.
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();
// establecer id como 1 para la respuesta OK
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());
}
}
}
Respuesta Exitosa 
Respuesta de Error 
Resumen
En esta publicación, aprendimos cómo crear un servicio web REST utilizando la API de Jersey. También exploramos el Cliente de Jersey para invocar nuestros APIs REST a través de un programa en Java.
Puedes revisar el código completo del proyecto en nuestro Repositorio de GitHub.
Source:
https://www.digitalocean.com/community/tutorials/jersey-java-tutorial