UP | HOME

Installation et test des outils pour Java

Table of Contents

Prérequis

Java 8 ou Java 11 (avant-dernière et dernière versions LTS ("long time support"))

  • Installer Java Standard Edition 8 ou 11 (Java Development Kit).

Eclipse - version JEE - R 2019-09

  • Toutes plates-formes: https://www.eclipse.org/downloads/packages/
  • Utiliser l'installateur, ou télécharger directement la version "Eclipse IDE for Enterprise Java Developers".
  • Utiliser Eclipse avec Java 8 ou 11 (lancement, compilateur, environnement d'exécution) :
    • configurer votre système pour qu'il lance java du JRE 8 ou 11 (via la variable d'environnement PATH, ou via un utilitaire gérant des liens symboliques comme update-alternatives),
    • configurer Eclipse pour travailler avec Java 8 ou 11 (Window > Preferences > Java > Compiler et JRE).

Tomcat 8.5.46

  • Toutes plates-formes: https://tomcat.apache.org/download-80.cgi (binary distribution > core > zip).
    • Télécharger le ZIP de la "binary distribution, core" (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 > Perspective > Open perspective > Other [Java EE]).
  • Dans la fenêtre inférieure donnant une vue administrative, ouvrir l'onglet Servers et créer un nouveau serveur.
  • Sélectionner Apache/Tomcat v8.5 Server et configurer ce serveur (répertoire d'installation, JRE 8 ou 11).
  • 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 > Preferences > Maven, sélectionner Download repository index updates on startup.
  • 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 Enable Full Index 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 JAX-B avec Java 11

Certains modules ont été retirés du JDK de Java 11. C'est le cas de la bibliothèque implémentant la norme JAX-B, qui permet de traduire des objets en documents XML et réciproquement. Avec Java 11, il est nécessaire d'importer cette bibliothèque.

  • 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 javax.xml puis en sélectionnant jaxb-api et jaxb-impl.
  • Vérifier dans l'onglet pom.xml du fichier pom.xml la présence des dépendances suivantes (qui auraient pu être ajoutées directement), à l'intérieur de la balise dependencies:

    <dependency>
      <groupId>javax.xml</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.1</version>
    </dependency>
    <dependency>
      <groupId>javax.xml</groupId>
      <artifactId>jaxb-impl</artifactId>
      <version>2.1</version>
    </dependency>
    

Utilisation de Jersey

Il faut aussi importer l'implémentation de la norme JAX-RS (version 2), permettant de développer des services Web Restful.

  • 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, à l'intérieur de la balise dependencies:

    <dependency>
      <groupId>org.glassfish.jersey.containers</groupId>
      <artifactId>jersey-container-servlet</artifactId>
      <version>2.29.1</version>
    </dependency>
    
  • Ajouter un framework d'injection de dépendances. Entrer jersey-hk2 puis sélectionner jersey-hk2 de org.glassfish.jersey.inject.

    <dependency>
      <groupId>org.glassfish.jersey.inject</groupId>
      <artifactId>jersey-hk2</artifactId>
      <version>2.29.1</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 ces ajouts, 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 unique 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, à l'intérieur de 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 RESTer ("A REST client for almost any web service"). Pour les autres navigateurs, il existe des modules analogues, permettant d'interagir avec des services web.
  • Réaliser avec RESTer 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 : jersey-client, jersey-proxy-client et jersey-hk2.

    <dependency>
      <groupId>org.glassfish.jersey.core</groupId>
      <artifactId>jersey-client</artifactId>
      <version>2.29.1</version>
    </dependency>
    <dependency>
      <groupId>org.glassfish.jersey.ext</groupId>
      <artifactId>jersey-proxy-client</artifactId>
      <version>2.29.1</version>
    </dependency>
    <dependency>
      <groupId>org.glassfish.jersey.inject</groupId>
      <artifactId>jersey-hk2</artifactId>
      <version>2.29.1</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 le module pertinent parmi les réponses et choisir la dernière version.
    • Les informations concernant la dépendance à intégrer dans le pom 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]; v4: 2019-04-02 [update]; v5: 2019-10-14 [update].
Comments or questions: Send a mail.
The webpage content is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.