UP | HOME

Installation et test des outils

Table of Contents

Prérequis

Java 8

Eclipse (Oxygen) - version JEE

  • Toutes plates-formes: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/oxygen1a
  • 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).

Tomcat 8.5.23

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

Configuration

  • Lancer Eclipse (double-clic sur eclipse (Unix) ou eclipse.exe (Windows) devrait suffire).
  • Quitter l'écran d'accueil (le cas échéant).

Serveur

  • 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.5 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.5 Server at localhost et cliquer sur la flèche verte.

Maven

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. Une configuration est nécessaire pour permettre la recherche de modules externes.

  • Demander la mise-à-jour de l'index au lancement : Window > Prefrences > Maven, sélectionner Download repository index updates on start.
  • Ouvrir la vue Window > Show view > Other > Maven > Maven Repositories.
  • Dans la console d'administration, choisir l'onglet Maven Repositories, puis Global Repositories > central. Sélectionner dans le menu contextuel Full Index Enabled puis lancer la construction de l'index avec Rebuild Index (ce qui peut demander du temps).

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

Test

Création d'un projet web dynamique

  • Créer un nouveau projet : File > New > Dynamic Web Project.
  • Entrer un nom pour le projet, par exemple testJersey.
  • Choisir Apache Tomcat v8.5 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.

Utilisation de Jersey

  • 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) :
  • Ajouter un framework d'injection de dépendances. Entrer jersey-hk2 puis sélectionner jersey-hk2 de org.glassfish.jersey.inject.

    <dependencies>
      <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <artifactId>jersey-container-servlet</artifactId>
        <version>2.26</version>
      </dependency>
      <dependency>
        <groupId>org.glassfish.jersey.inject</groupId>
        <artifactId>jersey-hk2</artifactId>
        <version>2.26</version>
      </dependency>
    </dependencies>
    
  • 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 après 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éation d'une première application côté serveur

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

Test de l'application

  • 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 :
  • Sous Firefox, ajouter le module HttpRequester. Pour les autres navigateurs, il existe des modules analogues, permettant d'interagir avec des services web.
  • Réaliser avec HttpRequester une requête GET aux adresses précédentes, puis PUT et POST.
  • Observer les messages de la console associée au serveur.

Réalisation d'une application cliente

  • 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.26</version>
    </dependency>
    <dependency>
      <groupId>org.glassfish.jersey.ext</groupId>
      <artifactId>jersey-proxy-client</artifactId>
      <version>2.26</version>
    </dependency>
    <dependency>
      <groupId>org.glassfish.jersey.inject</groupId>
      <artifactId>jersey-hk2</artifactId>
      <version>2.26</version>
    </dependency>
    
  • Recopier l'interface essai.Salut dans le projet client.
  • Créer l'application cliente principale.

    import javax.ws.rs.client.Client;
    import javax.ws.rs.client.ClientBuilder;
    import javax.ws.rs.client.WebTarget;
    
    import org.glassfish.jersey.client.ClientConfig;
    import org.glassfish.jersey.client.proxy.WebResourceFactory;
    
    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).

Liens utiles

Maven

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

JAX-RS (2.0)

Author: Hervé Grall
Version history: v1: 2016-10-20; v2: 2017-01-30 [update]; v3: 2017-10-30 [update].
Comments or questions: Send a mail.
The webpage content is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.