Tutoriel sur Jersey Java

Tutoriels
Java

Bienvenue dans le Tutoriel Java Jersey. Récemment, j’ai commencé à travailler sur un projet de service web Restful en utilisant le framework JAX-RS Jersey.

Qu’est-ce que le framework Java Jersey?

Le projet Java Jersey suit l’API JAX-RS, qui est utilisée pour créer des services web Restful en Java.

1. Qui devrait utiliser ce tutoriel?

Ce tutoriel s’adresse aux programmeurs Java intéressés par le développement et le déploiement de services web Restful en utilisant l’API JAX-RS et JAXB.

2. Prérequis

La portée de ce tutoriel est d’utiliser l’API Jersey pour créer des services web Restful, d’invoquer le service web à l’aide d’un programme client Java et de tester le service web à l’aide de l’outil. Une compréhension de base de Java, des services web, XML, Maven et de tout serveur d’applications (JBoss/Tomcat) est nécessaire pour comprendre le tutoriel plus facilement.

3. Logiciels et Outils

  • Version 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

Création de Projet Jersey Eclipse Maven

Créez un « Projet Web Dynamique » dans Eclipse puis convertissez-le en projet maven. Cela nous fournira un projet d’application web basique basé sur maven. J’ai donné GroupId comme com.journaldev.jersey et artifactID comme my-jersey-project mais vous pouvez spécifier ce que vous voulez. Une fois que nous aurons terminé le développement de notre projet, la structure du projet ressemblera à l’image ci-dessous.

Explication du Projet de Service Web Restful Java Jersey

1. pom.xml: Détails de configuration du projet, notez les dépendances jersey fournies, les autres détails sont communs à tout projet Maven similaire.

<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: Bean Java pour l’objet de demande. La chose importante à noter ici est l’annotation @XmlRootElement pour mapper la classe à un élément 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: Bean Java pour l’objet de réponse.

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: Bean Java qui sera envoyé en réponse en cas d’exception.

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: Une classe d’exception normale jetée dans le service 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: Descripteur de déploiement pour le service web. Ainsi, toute demande avec l’URI https://<HOST>:<PORT>/My-Jersey-Project/rest/* sera traitée par le servlet Jersey ServletContainer. La valeur init-param passée pour « com.sun.jersey.config.property.packages » définit le package que jersey recherchera pour les classes de service web. Cette propriété doit pointer vers vos classes de ressources. Il recherche également les classes de ressources dans les sous-packages.

<?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: Classe de ressource traitant différents types de demandes.

  • @Path(« /emp ») – Toutes les demandes avec l’URI https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/ seront traitées par cette classe de ressource.
  • @Path(« /getEmp ») – Toutes les demandes avec l’URI https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/getEmp seront traitées par cette méthode.
  • @POST – Cette annotation définit que la méthode HTTP utilisée doit être POST. Quelques autres valeurs possibles sont @GET, @PUT, @DELETE
  • @Consumes(MediaType.APPLICATION_XML) – La méthode accepte l’élément XML
  • @Produces(MediaType.APPLICATION_XML) – La méthode retourne l’élément 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: Classe de mapping d’exception qui mappe EmpNotFoundException vers un objet Response. La classe doit avoir l’annotation @Provider. Cette classe doit être dans le package fourni pour les classes de ressource dans web.xml. L’implémentation de la méthode toResponse() génère l’objet ErrorResponse et le définit en tant qu’entité dans l’objet Response avec le statut 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();

	}

}

Notre service web est prêt, il suffit de le construire pour créer le fichier WAR et de le déployer sur le serveur d’application.

Exemple de client Jersey

Nous pouvons utiliser le client Jersey pour appeler notre service web et obtenir une réponse de manière programmatique. EmpClient.java : Il s’agit d’un programme Java d’exemple à travers lequel nous invoquons notre service web. Nous utilisons l’API Jersey Client pour invoquer le service et en fonction du statut de la réponse, nous analysons l’entité de réponse en classe EmpResponse ou 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();
		// définir l'identifiant comme 1 pour une réponse 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());
		}
	}

}

Réponse réussie Réponse d’erreur

Résumé

Dans ce post, nous avons appris comment créer un service web REST en utilisant l’API Jersey. Nous avons également examiné le client Jersey pour invoquer nos APIs REST à travers un programme Java.

Vous pouvez consulter le code complet du projet sur notre Dépôt GitHub.

Source:
https://www.digitalocean.com/community/tutorials/jersey-java-tutorial