Installation et test des outils pour Java

• 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 (Linux, Windows x64 (64 bits), MacOS X, etc.).
  • Noter le répertoire d'installation (le chemin devant être sans espaces).

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

• Vérifier que la perspective utilisée est Java EE (Window > Prespective > 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).
• 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 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 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.

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

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

  <dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-servlet</artifactId>
    <version>2.28</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.28</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 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é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>
  

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

• 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.28</version>
  </dependency>
  <dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-proxy-client</artifactId>
    <version>2.28</version>
  </dependency>
  <dependency>
    <groupId>org.glassfish.jersey.inject</groupId>
    <artifactId>jersey-hk2</artifactId>
    <version>2.28</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).

• Wikipedia
• Documentation v4.7 Oxygen

• Wikipedia
• Documentation v8.5

• 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