// Didacticiel //

Tutoriel sur les services Web reposants en Java

Publié le 3 août 2022

JavaEE Java
 Bien que nous pensions que ce contenu profite à notre communauté, nous ne l'avons pas
encore examiné en profondeur. Si vous avez des suggestions d'améliorations, n'hésitez pas
à nous en faire part en cliquant sur le bouton "Signaler un problème" en bas du didacticiel.

Bienvenue dans le didacticiel des services Web reposants en Java. REST est l'acronyme
de REpresentational State Transfer . REST est un style architectural pour le
développement d'applications accessibles sur le réseau. Le style architectural REST a
été mis en lumière par Roy Fielding dans sa thèse de doctorat en 2000.
Services Web reposants

Les services Web reposants sont une architecture client-serveur sans état dans
laquelle les services Web sont des ressources et peuvent être identifiés par leurs URI.
Les applications clientes REST peuvent utiliser les méthodes HTTP GET/POST pour
appeler les services Web Restful. REST ne spécifie aucun protocole spécifique à utiliser,
mais dans presque tous les cas, il est utilisé sur HTTP/HTTPS. Comparés aux services
Web SOAP, ils sont légers et ne suivent aucune norme. Nous pouvons utiliser XML,
JSON, texte ou tout autre type de données pour la demande et la réponse.
API de services Web RESTful Java

L'API Java pour les services Web RESTful (JAX-RS) est l'API Java permettant de créer
des services Web REST. JAX-RS utilise des annotations pour simplifier le développement
et le déploiement de services Web. JAX-RS fait partie du JDK, vous n'avez donc pas
besoin d'inclure quoi que ce soit pour utiliser ses annotations.
Annotations de services Web reposants

Certaines des annotations JAX-RS importantes sont :

@Path : utilisé pour spécifier le chemin relatif de la classe et des méthodes. Nous
pouvons obtenir l'URI d'un service Web en analysant la valeur d'annotation Path.
@GET , @PUT , @POST , @DELETE et @HEAD : utilisé pour spécifier le type de requête
HTTP pour une méthode.
@Produces , @Consumes : utilisé pour spécifier les types de requête et de réponse.
@PathParam : utilisé pour lier le paramètre de méthode à la valeur du chemin en
l'analysant.
Services Web reposants et SOAP

1. SOAP est un protocole alors que REST est un style architectural.

2. Les applications serveur et client SOAP sont étroitement couplées et liées au
contrat WSDL alors qu'il n'y a pas de contrat dans les services Web et le client
 REST.
3. La courbe d'apprentissage est facile pour REST par rapport aux services Web
SOAP.
4. Les types de demande et de réponse des services Web REST peuvent être XML,
JSON, texte, etc., tandis que SOAP ne fonctionne qu'avec XML.
5. JAX-RS est l'API Java pour les services Web REST, tandis que JAX-WS est l'API Java
pour les services Web SOAP.
Implémentations d'API REST

Il existe deux implémentations majeures de l'API JAX-RS.

1. Jersey : Jersey est l'implémentation de référence fournie par Sun. Pour utiliser
Jersey comme implémentation JAX-RS, il nous suffit de configurer son servlet dans
web.xml et d'ajouter les dépendances requises. Notez que l'API JAX-RS fait partie
de JDK et non de Jersey, nous devons donc ajouter ses jars de dépendance dans
notre application.
2. RESTEasy : RESTEasy est le projet JBoss qui fournit l'implémentation JAX-RS.
Tutoriel sur les services Web reposants Java

Voyons à quel point il est facile de créer un service Web Restful en utilisant Jersey puis
RESTEasy. Nous allons exposer les méthodes suivantes sur HTTP et utiliser l'extension
Chrome Postman pour les tester.
URI Méthode HTTP Description

/personne/{id}/getDummy OBTENIR Renvoie un objet personne factice

/personne/ajouter POSTE Ajoute une personne

/personne/{id}/supprimer OBTENIR Supprimer la personne avec 'id' dans l'URI

/personne/getAll OBTENIR Obtenir toutes les personnes

/personne/{id}/obtenir OBTENIR Obtenir la personne avec 'id' dans l'URI

Jersey Services Web reposants

Créez un projet Web dynamique, puis convertissez-le en Maven pour obtenir le squelette
de votre projet de services Web. L'image ci-dessous montre la structure du projet du
projet final.

Regardons les dépendances de Jersey que nous avons dans le fichier pom.xml.
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.o
<modelVersion>4.0.0</modelVersion>
<groupId>JAXRS-Example</groupId>
<artifactId>JAXRS-Example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>

<dependencies>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-server</artifactId>
<version>1.19</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-servlet</artifactId>
<version>1.19</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-client</artifactId>
<version>1.19</version>
 </dependency>
</dependencies>

<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.6</version>
<configuration>
<warSourceDirectory>WebContent</warSourceDirectory>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.3</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

Nous ne sommes pas obligés d'ajouter des dépendances jersey-client, mais si vous
écrivez un programme Java pour invoquer un service Web REST à l'aide de Jersey, cela
est obligatoire. Examinons maintenant le descripteur de déploiement pour savoir
comment configurer Jersey pour créer notre application Web.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://
<display-name>JAXRS-Example</display-name>

<!-- Jersey Servlet configurations -->

<servlet>
<servlet-name>Jersey REST Service</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servl
<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>/*</url-pattern>
</servlet-mapping>
<!-- Jersey Servlet configurations -->
 </web-app>

C'est tout ce qu'il faut pour brancher Jersey dans notre application Web, dans notre
code Java, nous utiliserons les annotations JAX-RS. Notez la valeur du paramètre init
com.sun.jersey.config.property.packages pour fournir le package qui sera analysé à la
recherche de ressources et de méthodes de service Web.
Exemple de classes de modèles REST

Tout d'abord, nous allons créer deux beans modèles - Person pour nos données
d'application et Response pour envoyer une réponse aux systèmes clients. Puisque nous
enverrons une réponse XML, les beans doivent être annotés avec @XmlRootElement ,
nous avons donc cette classe.
package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement (name="person")
public class Person {
private String name;
private int age;
private int id;

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public int getAge() {

return age;
}

public void setAge(int age) {

this.age = age;
}

public int getId() {

return id;
}

public void setId(int id) {

this.id = id;
}

@Override
 public String toString(){
return id+"::"+name+"::"+age;
}

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Response {

private boolean status;

private String message;

public boolean isStatus() {

return status;
}

public void setStatus(boolean status) {

this.status = status;
}

public String getMessage() {

return message;
}

public void setMessage(String message) {

this.message = message;
}
}

Services de didacticiel sur les services Web REST

Basé sur notre structure d'URI, voici l'interface de service et son code d'implémentation.
package com.journaldev.jaxrs.service;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

public interface PersonService {

public Response addPerson(Person p);

public Response deletePerson(int id);

public Person getPerson(int id);

 public Person[] getAllPersons();

package com.journaldev.jaxrs.service;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

@Path("/person")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)
public class PersonServiceImpl implements PersonService {

private static Map<Integer,Person> persons = new HashMap<Integer,Person

@Override
@POST
@Path("/add")
public Response addPerson(Person p) {
Response response = new Response();
if(persons.get(p.getId()) != null){
response.setStatus(false);
response.setMessage("Person Already Exists");
return response;
}
persons.put(p.getId(), p);
response.setStatus(true);
response.setMessage("Person created successfully");
return response;
}

@Override
@GET
@Path("/{id}/delete")
public Response deletePerson(@PathParam("id") int id) {
Response response = new Response();
if(persons.get(id) == null){
response.setStatus(false);
 response.setMessage("Person Doesn't Exists");
return response;
}
persons.remove(id);
response.setStatus(true);
response.setMessage("Person deleted successfully");
return response;
}

@Override
@GET
@Path("/{id}/get")
public Person getPerson(@PathParam("id") int id) {
return persons.get(id);
}

@GET
@Path("/{id}/getDummy")
public Person getDummyPerson(@PathParam("id") int id) {
Person p = new Person();
p.setAge(99);
p.setName("Dummy");
p.setId(id);
return p;
}

@Override
@GET
@Path("/getAll")
public Person[] getAllPersons() {
Set<Integer> ids = persons.keySet();
Person[] p = new Person[ids.size()];
int i=0;
for(Integer id : ids){
p[i] = persons.get(id);
i++;
}
return p;
}

La plupart du code est explicite, prenez le temps de vous familiariser avec les
annotations JAX- RS @Path , @PathParam , @POST , @GET et @Consumes . @Produces
Test de services Web reposants

C'est ça. Notre service Web est prêt, exportez-le simplement en tant que fichier WAR et
placez-le dans le répertoire des applications Web Tomcat ou déployez-le dans tout autre
conteneur de votre choix. Vous trouverez ci-dessous quelques-uns des tests effectués à
l'aide de l'extension Chrome Postman pour ce service Web. Notez que nous devons
fournir les valeurs Accept et Content-Type en tant que "application/xml" dans l'en-tête
de la demande, comme indiqué dans l'image ci-dessous.

getDummy

ajouter

obtenir
 Avoir tout

supprimer

C'est tout pour créer des services Web à l'aide de l'implémentation Jersey JAX-RS.
Comme vous pouvez le constater, la majeure partie du code utilise des annotations JAX-
RS et Jersey est connecté via le descripteur de déploiement et les dépendances.
Exemple de services Web RESTEasy RESTful
Nous utiliserons toute la logique métier développée dans le projet Jersey, mais plutôt
que d'apporter des modifications au même projet, j'ai créé un nouveau projet. Créez un
projet Web dynamique et convertissez-le en projet Maven. Copiez ensuite toutes les
classes Java - Person, Response, PersonService et PersonServiceImpl. Vous trouverez
ci-dessous le projet final une fois que nous aurons terminé avec tous les changements.

Ajoutez ci-dessous les dépendances RESTEasy dans le fichier pom.xml.

<dependency>
<groupId>org.jboss.resteasy</groupId>
<artifactId>resteasy-jaxrs</artifactId>
<version>3.0.13.Final</version>
</dependency>
<dependency>
<groupId>org.jboss.resteasy</groupId>
<artifactId>resteasy-jaxb-provider</artifactId>
<version>3.0.13.Final</version>
</dependency>

Vous trouverez ci-dessous le fichier web.xml dans lequel nous configurons le servlet
Resteasy.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://
<display-name>JAXRS-Example-RestEasy</display-name>
 <listener>
<listener-class>
org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
</listener-class>
</listener>

<servlet>
<servlet-name>resteasy-servlet</servlet-name>
<servlet-class>
org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
</servlet-class>
<init-param>
<param-name>javax.ws.rs.Application</param-name>
<param-value>com.journaldev.jaxrs.resteasy.app.MyApp</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>resteasy-servlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>

</web-app>

Remarquez le init-param où nous fournissons la MyApp classe comme valeur, ici nous
étendons javax.ws.rs.core.Application la classe comme indiqué ci-dessous.
package com.journaldev.jaxrs.resteasy.app;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import com.journaldev.jaxrs.service.PersonServiceImpl;

public class MyApp extends Application {

private Set<Object> singletons = new HashSet<Object>();

public MyApp() {
singletons.add(new PersonServiceImpl());
}

@Override
public Set<Object> getSingletons() {
return singletons;
}

}
Test des services Web RESTEasy

C'est ça. Notre service Web est prêt avec l'implémentation RESTEasy JAX-RS. Vous
trouverez ci-dessous quelques-uns des résultats du test d'extension Chrome Postman.
getDummy

ajouter

obtenir

C'est tout pour le didacticiel sur les services Web reposants , j'espère que vous avez
appris les annotations JAX-RS et compris les avantages d'avoir une API standard qui
nous a aidés à réutiliser le code et à passer de Jersey à RESTEasy si facilement.