Tutoriel sur les services Web RESTful en Java

Bienvenue dans le tutoriel sur les services web REST en Java. REST est l’acronyme de REpresentational State Transfer. REST est un style architectural pour le développement d’applications accessibles via le réseau. Le style architectural REST a été mis en lumière par Roy Fielding dans sa thèse de doctorat en 2000.

Les services web RESTful

Les services web RESTful suivent une architecture client-serveur sans état où les services web sont des ressources identifiables par leurs URI. Les applications clientes REST peuvent utiliser les méthodes HTTP GET/POST pour invoquer 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 aucun standard. Nous pouvons utiliser XML, JSON, du texte ou tout autre type de données pour les demandes et les réponses.

API Java pour les services web RESTful

L’API Java pour les services web RESTful (JAX-RS) est l’API Java pour la création de services web REST. JAX-RS utilise des annotations pour simplifier le développement et le déploiement des services web. JAX-RS fait partie du JDK, donc vous n’avez rien à inclure pour utiliser ses annotations.

Annotations des Services Web Restful

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 de l’annotation Path.
• @GET, @PUT, @POST, @DELETE et @HEAD : utilisés pour spécifier le type de requête HTTP pour une méthode.
• @Produces, @Consumes : utilisés pour spécifier les types de requête et de réponse.
• @PathParam : utilisé pour lier le paramètre de méthode à la valeur de chemin en l’analysant.

Services Web Restful et SOAP

1. SOAP est un protocole tandis que REST est un style architectural.
2. Les applications serveur et client SOAP sont étroitement couplées et liées au contrat WSDL tandis qu’il n’y a pas de contrat dans les services web REST et le client.
3. La courbe d’apprentissage est facile pour REST par rapport aux services web SOAP.
4. Les types de requête et de réponse des services web REST peuvent être XML, JSON, texte, etc., tandis que SOAP fonctionne uniquement 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, nous devons simplement configurer son servlet dans le fichier web.xml et ajouter les dépendances requises. Notez que l’API JAX-RS fait partie de JDK, pas de Jersey, nous devons donc ajouter ses jars de dépendance dans notre application.
2. RESTEasy: RESTEasy est le projet JBoss qui fournit une implémentation JAX-RS.

Tutoriel sur les services web Java Restful

Voyons à quel point il est facile de créer un service web Restful en utilisant d’abord Jersey, puis RESTEasy. Nous exposerons les méthodes suivantes via HTTP et utiliserons l’extension Chrome Postman pour les tester.

Services web Restful avec Jersey

Créez un projet web dynamique, puis convertissez-le en Maven pour obtenir l’ossature de votre projet de services web. L’image ci-dessous montre la structure du projet final. Examinons les dépendances Jersey que nous avons dans le fichier pom.xml.

<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>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 tenus d’ajouter les dépendances jersey-client, mais si vous écrivez un programme Java pour invoquer un service web REST à l’aide de Jersey, c’est nécessaire. Examinons maintenant le descripteur de déploiement pour apprendre 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://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <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</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>/*</url-pattern>
  </servlet-mapping>
  <!-- Jersey Servlet configurations -->

</web-app>

C’est tout ce qui est nécessaire pour intégrer Jersey dans notre application web. Dans notre code Java, nous utiliserons des annotations JAX-RS. Remarquez la valeur du paramètre d’initialisation com.sun.jersey.config.property.packages pour spécifier le package qui sera analysé à la recherche de ressources et de méthodes de services web.

Exemple de classes de modèle REST

Tout d’abord, nous allons créer deux beans modèle – Personne pour les données de notre application et Réponse pour envoyer une réponse aux systèmes clients. Étant donné que nous enverrons une réponse XML, les beans doivent être annotés avec @XmlRootElement, c’est pourquoi nous avons 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 tutoriel 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, @Consumes et @Produces.

Test des services Web RESTful

C’est tout. Notre service Web est prêt, il suffit de l’exporter en tant que fichier WAR et de le placer dans le répertoire webapps de Tomcat ou de le déployer dans tout autre conteneur de votre choix. Ci-dessous, quelques 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 comme « application/xml » dans l’en-tête de la requête comme indiqué dans l’image ci-dessous.

• getDummy
• ajouter
• obtenir
• getAll
• supprimer

Voilà tout pour la création de services web en utilisant l’implémentation Jersey JAX-RS. Comme vous pouvez le voir, la plupart du code utilise des annotations JAX-RS et Jersey est intégré via le descripteur de déploiement et les dépendances.

Exemple de services web RESTful avec RESTEasy

Nous utiliserons toute la logique métier développée dans le projet Jersey, mais au lieu de faire des modifications dans le même projet, j’ai créé un nouveau projet. Créez un projet web dynamique et convertissez-le en projet Maven. Ensuite, copiez toutes les classes Java – Personne, Réponse, PersonneService et PersonneServiceImpl. Ci-dessous se trouve le projet final une fois toutes les modifications terminées. Ajoutez les dépendances RESTEasy ci-dessous 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>

Ci-dessous se trouve le fichier web.xml où 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://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <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 paramètre d’initialisation où nous fournissons la classe MyApp comme valeur, ici nous étendons la classe javax.ws.rs.core.Application 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 tout. Notre service web est prêt avec l’implémentation JAX-RS RESTEasy. Ci-dessous, vous trouverez quelques sorties du test de l’extension chrome Postman.

• getDummy
• ajouter
• obtenir

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