TP2 - Un registre comme service - Contrôle optimiste de la concurrence

Le client communique avec l'intercepteur. Lorsqu'il réalise une écriture, sa requête peut échouer : il reçoit alors une réponse KO au lieu de OK.

• canaux fournis :
  • lecture pour la réception des get
  • ecriture pour la réception des set
• canaux requis :
  • getI et setI (fournis par l'intercepteur)
• état : Affichage(x)

// Etat initial 
- getI(lecture)

// Incrémentation
- lecture(x) -> setI(ecriture, x + 1)
// Echec avec reprise
- ecriture(KO, x) -> setI(ecriture, x + 1)
// Succès 
- ecriture(OK, x) -> Affichage(x)

Le client gère la reprise de la transaction.

L'intercepteur intercepte les requêtes du client qu'il transmet au serveur. Il gère le cache et annote les messages avec la version du cache.

• canaux fournis :
  • lectureI pour la réception des get
  • ecritureI pour la réception des set
  • getI et setI (interception)
• canaux requis :
  • get et set (serveur)
  • lecture et ecriture (client)
• état : Cache(x, n)

// Etat initial 
- Cache(NON_DEFINI, NON_DEFINI)

// Interception d'une requête en lecture
- getI(k) & Cache(x, n) -> get(lectureI, n) & Cache(x, n)
// Réponse demandant la lecture en cache
- lectureI(CACHE, n) & Cache(x, n) -> lecture(x) & Cache(x, n)
// Réponse transmettant le résultat et mise en cache
- lectureI(y, m) & Cache(x, n) -> lecture(y) & Cache(y, m)

// Interception d'une requête en écriture 
- setI(k, y) & Cache(x, n) -> set(ecritureI, y, n) & Cache(x, n)
// Ecriture réussie avec mise à jour du cache 
- ecritureI(OK, y, m) & Cache(x, n) -> ecriture(OK, y) & Cache(y, m)
// Ecriture annulée avec mise à jour du cache
- ecritureI(KO, y, m) & Cache(x, n) -> ecriture(KO, y) & Cache(y, m)

Annoter les méthodes de l'interface ServiceRegistre de manière à vérifier les propriétés suivantes.

1. Chaque méthode est qualifiée par le type idoine de méthode HTTP.
2. Les chemins relatifs d'accès à la ressource correspondant aux deux méthodes sont vides : il est inutile de le préciser.
3. Les données sont produites ou consommées au format application/xml. (Pour indiquer qu'un résultat est sérialisé suivant un certain format javax.ws.rs.core.MediaType.F, on utilise l'annotation @Produces(MediaType.F) ou @Consumes(MediaType.F) après importation de MediaType.)

Annoter la classe d'implémentation Registre de manière à ce que la ressource soit accessible par le chemin relatif optimiste. Pour indiquer un chemin C, on utilise l'annotation @Path("C"). Annoter cette ressource de manière à en faire un singleton (en utilisant l'annotation javax.inject.Singleton).

(Toutes ces annotations appartiennent au paquet javax.ws.rs.)

Annoter la classe Ressource de manière à vérifier les propriétés suivantes.

1. Une instance de la classe Ressource peut être traduite en un document XML racine.
2. L'attribut i se traduit par un élément XML de nom x. (On annotera le getter correspondant.)

Cf. les annotations XmlRootElement et XmlElement.

Dans le fichier web.xml, référencer sous la balise servlet la définition du service dans la classe infrastructure.Service.

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

Etudier le code de cette classe. Noter qu'en plus de la fonctionnalité de log, une autre fonctionnalité est ajoutée :

• la capacité à traiter JSON en utilisant l'outil Jackson.

Comment le registre est-il enregistré dans la configuration ? Est-ce nécessairement un singleton ?

La configuration utilisée dan la classe Service est propre à Jersey : consulter la documentation de Jersey (notamment la section 4.7) et de ResourceConfig pour de plus amples informations.

Déployer le service sur le serveur Tomcat. Tester avec Poster.

Il est aussi possible de déployer le service par une application lançant un serveur HTTP, comme Grizzly. Lancer l'application serveur.Lancement après avoir modifié l'adresse utilisée pour le déploiement, en veillant à ce que le port utilisé (8087) ne soit pas celui du serveur Tomcat.

Etudier son code.

Créer un nouveau projet Java.

• Le transformer en projet Maven.

• Ajouter les dépendances suivantes dans le fichier pom.xml. Les deux premières donnent les bibliothèques côté client, tandis que les suivantes permettent à Jersey d'utiliser les formats XML et JSON pour échanger des données.

  <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>
  <dependency>
     <groupId>org.glassfish.jersey.media</groupId>
     <artifactId>jersey-media-jaxb</artifactId>
     <version>2.23.2</version>
  </dependency>
  <dependency>
     <groupId>org.glassfish.jersey.media</groupId>
     <artifactId>jersey-media-json-jackson</artifactId>
     <version>2.23.2</version>
  </dependency>
  

Y importer à la racine l'archive codeFourni_ClientRegistre.zip.

Trois paquets sont importés :

• modele : le modèle objet sans l'implémentation du service
• infrastructure.jaxrs : filtres et intercepteurs utilisés pour le contrôle de la concurrence et le cache
• client : deux classes principales permettant de consommer le service

Annoter l'interface ServiceRegistre comme sur le serveur. Préciser également le chemin relatif optimiste.

Annoter la classe Ressource comme sur le serveur.

Etudier la fonction principale de la classe client.TestRegistre. Configurer correctement le proxy.

Tester votre application cliente.

Que constatez-vous lorsque vous lancez plusieurs clients simultanément ?

Avec JAX-RS, il est possible de réaliser ces échanges de messages en utilisant des filtres.

Etudier les filtres du paquet infrastructure.jaxrs, côté serveur.

• Que font les filtres CompterRequetes et CompterReponses ?
• Que fait le filtre InteragirAtomiquement ?
• Que fait le filtre Cacher ?
• Que fait le filtre RealiserEcritureOptimiste ?
• Que fait le filtre AjouterVersionAuxReponses ?

A quoi sert la classe Versionneur ? Quels filtres partagent le même versionneur ?

Dans quel ordre les filtres s'exécutent-ils ?

Commenter tous ces filtres, avec un niveau de détail analogue à celui de la classe infrastructure.jaxrs.Cacher du projet client.

Complément : voir le cours.

Annoter l'interface ServiceRegistre de manière à appliquer les six filtres pour chaque appel de méthode. On utilisera les annotations définies dans le paquet infrastructure.jaxrs.annotations. Cf. la section 6.5.2 de la spécification de JAX-RS 2.0 pour des précisions complémentaires.

Mettre à jour la classe infrastructure.Service de manière

• à injecter un versionneur et
• à enregistrer les filtres.

Indication :

// Initialisation du décorateur avec version
Versionneur rV = new Versionneur(r);
// Enregistrement du lieur pour l'injection de dépendances relativement aux filtres
this.register(new AbstractBinder() {
  @Override
  protected void configure() {
    bind(rV)
      .to(Versionneur.class); 
  }
});
// Enregistrement des filtres (alternative possible via providers)
this.register(CompterRequetes.class);
this.register(CompterReponses.class);
this.register(new InteragirAtomiquement());
this.register(Cacher.class);
this.register(RealiserEcritureOptimiste.class);
this.register(AjouterVersionAuxReponses.class);

Noter que pour chaque classe enregistrée, Jersey instancie un filtre par interface implémentée ContainerRequestFilter ou ContainerResponseFilter : si l'on souhaite une seule instanciation, il est nécessaire d'enregistrer cette instance, comme cela a été fait pour la classe InteragirAtomiquement.