Installation et test des outils

• Installer Java Standard Edition 8 (Java Development Kit).
  • Toutes plates-formes : http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
  • Choisir la version correspondant à votre système d'exploitation (Linjux ou Windows soit x64 (64 bits) soit x86 (32 bits), MacOS X, etc.).
  • Noter le répertoire d'installation (le chemin devant être sans espaces).

• Toutes plates-formes: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/neon1a
• Installer la même version (en termes de 32 ou 64 bits) que celle choisie pour Java.
• Utiliser Eclipse avec Java 8 (lancement, compilateur, environnement d'exécution) :
  • configurer votre système pour qu'il lance java du JRE 8 (via la variable d'environnement PATH),
  • configurer Eclipse pour travailler avec Java 8 (Window > Preferences > Java > Compiler et JRE).

• Toutes plates-formes: https://tomcat.apache.org/download-80.cgi (binary distribution > core > zip).
  • Télécharger le ZIP (y compris pour Windows: ne pas utiliser l'installeur).
  • Les utilisateurs de Mac ou Linux peuvent utiliser l'archive tar.
• Extraire dans un dossier utilisateur. Eviter les espaces dans le nom du chemin.

• Vérifier que la perspective utilisée est Java EE (Window > Prespective > Open perspective > Other [Java EE]).
• Dans la fenêtre inférieure doànnant une vue administrative, ouvrir l'onglet Servers et créer un nouveau serveur.
• Sélectionner Tomcat v8.0 Server et configurer ce serveur (répertoire d'installation, JRE 8).
• Terminer.

À ce stade, lancer le serveur à blanc pour vérifier que tout fonctionne:

• dans la vue, onglet Servers, sélectionner Tomcat v8.0 Server at localhost et cliquer sur la flèche verte.

Maven permet de gérer et d'automatiser la production des projets Java SE et EE. Il est directement intégré à la version JEE d'Eclipse, ce qui fait qu'aucune configuration n'est nécessaire.

Pour chaque projet, l'outil est configuré à l'aide d'un fichier pom.xml.

• Créer un nouveau projet : File > New > Dynamic Web Project.
• Entrer un nom pour le projet, par exemple testJersey.
• Choisir Apache Tomcat v8.0 pour target runtime, puis passer à la suite Next > Next.
• Cocher la case Generate web.xml, ce qui permet d'obtenir le squelette d'un fichier de description du déploiement sur le serveur.
• Terminer.

• Transformer le projet en un projet géré par Maven :
  • clic droit sur le projet > Configure > Convert to Maven Project > Finish.
• Choisir l'onglet Dependencies du pom.xml ouvert.
• Ajouter une dépendance en entrant jersey puis en sélectionnant jersey-container-servlet de org.glassfish.jersey.containers.

• Vérifier dans l'onglet pom.xml du fichier pom.xml la présence de la dépendance suivante (qui aurait pu être ajoutée directement) :

  <dependency>
     <groupId>org.glassfish.jersey.containers</groupId>
     <artifactId>jersey-container-servlet</artifactId>
     <version>2.23.2</version>
  </dependency>
  

• Valider puis sauver le fichier.
• Après une modification du pom.xml, il peut être nécessaire de valider la modification :
  • clic droit sur le projet > Maven > Update project > OK.

Après cet ajout, il devient possible d'accéder à l'implémentation de la norme JAX-RS (version 2) fournie par Jersey. On peut aussi utiliser une servlet fournie par Jersey pour traiter les messages échangés via le protocole http.

• Dans le fichier WebContent/WEB-INF/web.xml, ajouter sous l'élément welcome-file-list l'élément suivant. Le nom peut être modifié, comme le motif /∗ utilisé pour filtrer les requêtes par leur adresse.

  <servlet>
     <servlet-name>Jersey</servlet-name>
     <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
  </servlet>
  <servlet-mapping>
     <servlet-name>Jersey</servlet-name>
     <url-pattern>/*</url-pattern>
  </servlet-mapping>
  

Pour tout projet de services Web, on utilisera pour le serveur cette configuration minimale des fichiers pom.xml et web.xml.

• Créer un paquet essai dans la section Java resources ( clic droit > new > Package).

• Créer l'interface Salut dans le paquet essai. Elle utilise des annotations de JAX-RS (paquet javax.ws.rs).

  package essai;
  
  import javax.ws.rs.GET;
  import javax.ws.rs.Path;
  import javax.ws.rs.Produces;
  import javax.ws.rs.QueryParam;
  import javax.ws.rs.core.MediaType;
  
  public interface Salut {
  
    @Path("salut")
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    String dire(@QueryParam("de") String x);
  }
  

• Créer deux classes d'implémentation de l'interface, SalutFr et SalutEn.

  package essai;
  
  import javax.inject.Singleton;
  import javax.ws.rs.Path;
  
  @Path("en")
  @Singleton // (chargement unique au premier usage)
  public class SalutEn implements Salut {
    public SalutEn(){
      System.out.println("Chargement de " + this.getClass());
    }
    @Override
    public String dire(String x) {
      return "Hello from " + x;
    }
  }
  
  @Path("fr")
  @Singleton // (chargement au premier usage)
  public class SalutFr implements Salut {
    public SalutFr(){
      System.out.println("Chargement de " + this.getClass());
    }
    @Override
    public String dire(String x) {
      return "Salut de " + x;
    }
  }
  

• Créer le service regroupant les ressources dans une classe Service héritant d'une classe propre à Jersey, ResourceConfig, elle-même héritant d'une classe de JAX-RS, javax.ws.rs.core.Application. Dans le constructeur, on enregistre les ressources Rest à utiliser et on configure le serveur, par exemple en indiquant l'utilisation d'un log.

  package essai;
  
  import org.glassfish.jersey.logging.LoggingFeature;
  import org.glassfish.jersey.server.ResourceConfig;
  
  public class Service extends ResourceConfig {
    public Service(){
      System.out.println("Chargement de " + this.getClass());
      this.register(LoggingFeature.class); 
      this.property(LoggingFeature.LOGGING_FEATURE_LOGGER_LEVEL_SERVER, "INFO");
      this.register(SalutFr.class);
      this.register(SalutEn.class);
    }
  }
  

• Enregistrer l'usage du service dans le fichier web.xml, dans l'élément servlet.

  <init-param>
     <param-name>javax.ws.rs.Application</param-name>
     <param-value>essai.Service</param-value>
  </init-param>
  <load-on-startup>1 </load-on-startup>
  

• Ajouter le service sur le serveur, précédemment arrêté :
  • clic droit sur le serveur > Add and remove > testJersey.
• Lancer le serveur.
• Vérifier dans la console que le serveur a bien démarré, en chargeant le service.
• Dans votre navigateur, taper les adresses suivantes :
  • http://localhost:8080/testJersey/fr/salut?de=coco,
  • http://localhost:8080/testJersey/en/salut?de=coco.
• Sous Firefox, ajouter le module Poster. Pour les autres navigateurs, il existe des modules analogues, permettant d'interagir avec des services web.
• Réaliser avec Poster une requête GET aux adresses précédentes, puis PUT et POST.
• Observer les messages de la console associée au serveur.

• Créer un nouveau projet Java : File > New > Project > Java project.
• Le nommer puis terminer.
• Comme précédemment, le transformer en un projet géré par Maven :
  • clic droit sur le projet > Configure > Convert to Maven Project > Finish.

• Ajouter les dépendances suivantes au pom.xml.

  <dependency>
     <groupId>org.glassfish.jersey.core</groupId>
     <artifactId>jersey-client</artifactId>
     <version>2.23.2</version>
  </dependency>
  <dependency>
     <groupId>org.glassfish.jersey.ext</groupId>
     <artifactId>jersey-proxy-client</artifactId>
     <version>2.23.2</version>
  </dependency>
  

• Recopier l'interface essai.Salut dans le projet client.

• Créer l'application cliente principale.

  public class AppliCliente {
    public static Client clientJAXRS() {
      ClientConfig config = new ClientConfig();
      return ClientBuilder.newClient(config);
    }
    public static void main(String[] args) {
      WebTarget cible = clientJAXRS().target("http://localhost:8080/testJersey/fr");
      Salut salutation = WebResourceFactory.newResource(Salut.class, cible);
  
      System.out.println("*************");
      System.out.println(salutation.dire("coco"));
  
      cible = clientJAXRS().target("http://localhost:8080/testJersey/en");
      salutation = WebResourceFactory.newResource(Salut.class, cible);
  
      System.out.println("*************");
      System.out.println(salutation.dire("coco"));
    }
  }
  

• Lancer l'application (clic droit > Run as > Java application).

• Wikipedia
• Documentation v4.6 Neon

• Wikipedia
• Documentation v8

• Wikipedia
• Documentation
• Recherche dans le dépôt central
  • Entrer un critère de recherche proche du nom (de l'ArtifactId). Exemple : jersey container.
  • Sélectionner la version d'une réponse dans la colonne Latest version.
  • Les informations concernant la dépendance apparaissent alors dans un cadre.

• Wikipedia
• Documentation (latest)
• API

• Wikipedia
• API
• Norme