• La méthode HTTP GET ;
• Le chemin, ici la racine / ;
• Plusieurs autre en-têtes de requête.

• Un code de réponse : ici le code est 200 OK.
• Plusieurs en-têtes de réponse, notamment Date, Server, Content-Type. Ici, le type de contenu est text/html, mais il pourrait s'agir de n'importe quel format comme du XML (application/xml) ou une image (image/jpeg), etc.
• Un corps ou représentation. Ici, il s'agit du contenu de la page web renvoyée qui n'est pas visible sur la figure proposée ci-dessus.

La première démarche consiste à utiliser une application Web au travers de laquelle nous allons annoter une simple classe Java POJO et renseigner le descripteur de déploiement web.xml qui va activer la servlet qui s'occupe d'implémenter la technologie REST.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
   
    <servlet>
        <servlet-name>javax.ws.rs.core.Application</servlet-name>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>javax.ws.rs.core.Application</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    
</web-app>

package rest;

import javax.ws.rs.*;

@Path("/bienvenue")
public class Bienvenue {    
   @GET   
   @Produces("text/plain")   
   public String getMessage() {      
      return "Bienvenue... (premier exemple REST)";   
   }
}

Pour accéder à la ressource, il suffit d'un client HTTP, simple navigateur par exemple, pouvant envoyer une requête GET vers l'URL http://localhost:8080/AWRest/bienvenue.

Il est également possible d'utiliser un client HTTP qui permet de tester les services web de type REST en nous montrant les différentes en-têtes. Vous pouvez installer par exemple le pluggin Poster du navigateur Firefox ou autre.

Le code précédent montre que le service REST n'implémente aucune interface et n'étend aucune classe : @Path est la seule annotation obligatoire pour transformer un POJO en service REST. JAX-RS utilisant la configuration par exception, un ensemble d'annotations permettent de modifier son comportement par défaut. Les exigences que doit satisfaire une classe pour devenir REST sont les suivantes :

• Elle doit être annoté par @javax.ws.rs.Path.
• Pour ajouter les fonctionnalités des EJB au service REST, la classe doit être annotée @javax.ejb.Stateless.
• Elle doit être publique et ne pas être finale ni abstraite.
• Les classes ressources racine celles ayant une annotation @Path doivent avoir un constructeur par défaut public ou aucun. Les classes ressources non racine n'exigent pas ce constructeur.
• La classe ne doit pas définir la méthode finalyze().

package entité;
import java.io.Serializable;
import java.util.*;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlRootElement;

@Entity
@XmlRootElement
@NamedQueries({   
   @NamedQuery(name="toutLePersonnel", query="SELECT p FROM Personne p ORDER BY p.nom, p.prénom"),   
   @NamedQuery(name="recherchePersonnel", query="SELECT p FROM Personne p WHERE p.nom = :nom AND p.prénom = :prénom")
})
public class Personne implements Serializable {
   @Id   
   @GeneratedValue(strategy = GenerationType.IDENTITY)   
   private long id;   private String nom;   
   private String prénom;   
   @Temporal(javax.persistence.TemporalType.DATE)
   private Date naissance;   
   private String téléphone;   

   public long getId() { return id;  }   

   public Date getNaissance() { return naissance;  }   
   public void setNaissance(Date naissance) {  this.naissance = naissance;  }   

   public String getNom() { return nom;  }   
   public void setNom(String nom) { this.nom = nom.toUpperCase(Locale.FRENCH); }

   public String getPrénom() { return prénom; }   
   public void setPrénom(String prénom) {  
       StringBuilder chaine = new StringBuilder(prénom.toLowerCase());
       chaine.setCharAt(0, Character.toUpperCase(chaine.charAt(0)));       
       this.prénom = chaine.toString();   
   }   

   public String getTéléphone() { return téléphone; }   
   public void setTéléphone(String téléphone) { this.téléphone = téléphone;  }   

   @Override   
   public String toString() { return nom +" "+ prénom;  } 
}

package session;
import entité.Personne;
import java.util.List;
import javax.ejb.*;
import javax.persistence.*;
import javax.ws.rs.*;
import javax.ws.rs.core.*;
import javax.xml.bind.JAXBElement;

@Path("/personnels")
@Stateless
@Produces({"application/xml", "application/json"})
@Consumes({"application/xml", "application/json"})
public class GestionPersonnel {
   @PersistenceContext   
   private EntityManager bd;   
   @Context   
   private UriInfo uri;
   
   @GET   
   public List<Personne> toutLePersonnel() {      
     Query requête = bd.createNamedQuery("toutLePersonnel");      
     return requête.getResultList();   
   }
   
   @POST   
   public void nouveauPersonnel(JAXBElement<Personne> personne) {      
     bd.persist(personne.getValue());    
   }
}

package rest;

import javax.ws.rs.*;

@Path("/")  // Changement du chemin de l'URI pour que cela corresponde à la racine de l'application Web
public class Bienvenue {
   
   @GET
   @Produces("text/plain")
   public String getMessage() {
      return "Bienvenue... (premier exemple REST)";
   }
}

package session;

import entité.Personne;
import java.util.List;
import javax.ejb.*;
import javax.persistence.*;
import javax.ws.rs.*;
import javax.ws.rs.core.*;
import javax.xml.bind.JAXBElement;

@Path("/personnels")
@Stateless
@Produces({"application/xml", "application/json"})
@Consumes({"application/xml", "application/json"})
public class GestionPersonnel {
   @PersistenceContext
   private EntityManager bd;
   @Context
   private UriInfo uri;
   
   @GET
   public List<Personne> toutLePersonnel() {
      Query requête = bd.createNamedQuery("toutLePersonnel");
      return requête.getResultList();
   }
   
   @GET
   @Path("{idPersonnel}")
   public Personne unPersonnel(@PathParam("idPersonnel") long idPersonnel) {
      return bd.find(Personne.class, idPersonnel);
   }        
   
   @GET
   @Path("requete")
   public Personne unPersonnel(@QueryParam("nom") String nom, @QueryParam("prenom") String prénom) {
      Query requête = bd.createNamedQuery("recherchePersonnel");
      requête.setParameter("nom", nom);
      requête.setParameter("prénom", prénom);
      return (Personne) requête.getSingleResult();
   }           
   
   @GET
   @Path("/premiers/")
   public List<Personne> dixPremiers() {
      Query requête = bd.createNamedQuery("toutLePersonnel");
      requête.setMaxResults(10);
      return requête.getResultList();
   }        
   
   @GET
   @Path("/suivants/{page}")
   public List<Personne> dixSuivants(@PathParam("page") int page) {
      Query requête = bd.createNamedQuery("toutLePersonnel");
      requête.setFirstResult(page);
      requête.setMaxResults(10*page);
      return requête.getResultList();
   }          
   
   @POST
   public void nouveauPersonnel(JAXBElement<Personne> personne) {
      bd.persist(personne.getValue());    
   }
 
   @DELETE
   @Path("{idPersonnel}")
   public void supprimePersonnel(@PathParam("idPersonnel") long idPersonnel) {
      bd.remove(unPersonnel(idPersonnel));
   }  

   @PUT
   @Path("{idPersonnel}")
   public void modifiePersonnel(@PathParam("idPersonnel") long idPersonnel) {
      bd.merge(unPersonnel(idPersonnel));
   }     
}

• Si @Path est appliquée à la fois sur la classe et une méthode, le chemin relatif de la ressource produite par cette méthode est la concaténation de la classe et de la méthode.
• Ainsi, pour obtenir un personnel par son identifiant, par exemple, le chemin sera /personnels/1234. Cette recherche sera effectuée au travers de la méthode unPersonnel().
• Si nous demandons la ressource racine /personnels, seule la méthode sans annotation @Path sera automatiquement sélectionnée : ici toutLePersonnel().
• Si nous demandons /personnels/premiers, c'est la méthode dixPremiers() qui sera invoquée.
• Si nous désirons avoir les dix personnels de la troisème page, c'est la méthode dixSuivants() qui sera invoquée en proposant l'URI /personnels/suivants/3.
• Si @Path("/personnels") n'annotait que la classe et aucune méthode, le chemin d'accès de toutes les méthodes serait le même et il faudrait alors utiliser le verbe HTTP (GET, PUT) et la négociation du contenu texte, XML, etc. pour les différencier.

Cette annotation permet d'extraire la valeur du paramètre d'une requête. Le code suivant permet d'extraire l'identifiant du personnel 1234 de l'URI : http://localhost:8080/RESTPersonnel/personnels/1234 :

@Path("/personnels")
public class GestionPersonnel {

   @GET
   @Path("{idPersonnel}")
   public Personne unPersonnel(@PathParam("idPersonnel") long idPersonnel) {
      return bd.find(Personne.class, idPersonnel);
   }        
...
}

Dans l'annotation @Path associée à une méthode, il est possible de proposer plusieurs variables qui deviendront les différents paramètres de la méthode. Il est ainsi possible de répérer un personnel à partir de son nom et de son prénom grâce à l'URI suivante : http://localhost:8080/RESTPersonnel/personnels/nom-REMY-prenom-Emmanuel.

@Path("/personnels")
public class GestionPersonnel {

   @GET
   @Path("nom-{nom}-prenom-{prenom}")
   public Personne unPersonnel(@PathParam("nom") String nom, @PathParam("prenom") String prénom) {
      Query requête = bd.createNamedQuery("recherchePersonnel");
      requête.setParameter("nom", nom);
      requête.setParameter("prénom", prénom);
      return (Personne) requête.getSingleResult();
   }         
...
}

Une particularité, c'est qu'il est possible de proposer une liste variable de paramètres dans votre URI. Chaque paramètre sera ensuite récupéré séparément.

@Path("/bienvenue/{civilité}")
public class Bienvenue {
   
   @GET
   @Path("{identité : .+}/age/{age}")
   @Produces("text/plain")
   public String récupérer(@PathParam("civilité") String choix, @PathParam("identité") List<PathSegment> params, @PathParam("age") int age) {
      StringBuilder chaîne = new StringBuilder(choix+' ');
      for (PathSegment segment : params) chaîne.append(segment.getPath()+' ');
      chaîne.append(age+" ans");
      return chaîne.toString();
   }
}

Cette annotation permet d'extraire la valeur d'un paramètre modèle d'une URI. Là aussi, le code suivant permet de retrouver un personnel à partir de son nom et de son prénom au moyen de l'URI suivante : http://localhost:8080/RESTPersonnel/personnels?nom=REMY&prenom=Emmanuel :

@Path("/personnels")
public class GestionPersonnel {

   @GET
   public Personne unPersonnel(@QueryParam("nom") String nom, @QueryParam("prenom") String prénom) {
      Query requête = bd.createNamedQuery("recherchePersonnel");
      requête.setParameter("nom", nom);
      requête.setParameter("prénom", prénom);
      return (Personne) requête.getSingleResult();
   }           
...
}

Cette annotation agit comme @QueryParam, sauf qu'elle extrait la valeur d'un paramètre matrice d'une URI le délimiteur est ; au lieu de ?. Le code suivant permet également, sous une autre forme, de retrouver un personnel à partir de son nom et de son prénom avec l'URI suivante : http://localhost:8080/RESTPersonnel/personnels;nom=REMY;prenom=Emmanuel :

@Path("/personnels")
public class GestionPersonnel {

   @GET
   public Personne unPersonnel(@MatrixParam("nom") String nom, @MatrixParam("prenom") String prénom) {
      Query requête = bd.createNamedQuery("recherchePersonnel");
      requête.setParameter("nom", nom);
      requête.setParameter("prénom", prénom);
      return (Personne) requête.getSingleResult();
   }           
...
}

Deux autres méthodes sont liées aux détails internes de HTTP, ce que nous ne voyons pas directement dans les URI : les cookies et les en-têtes. @CookieParam extrait la valeur d'un cookie, tandis que @HeaderParam permet d'obtenir la valeur d'un en-tête :

@Path("/")
@Produces("text/plain")
public class Bienvenue {
   
   @GET  
   public String bienvenue() {
      return "Bienvenue... (premier exemple REST)";
   }
   
   @GET
   @Path("paramètres")
   public String paramètres(@HeaderParam("Accept") String typeContenu, @HeaderParam("User-Agent") String agent) {
      return typeContenu+'\n'+agent;
   }
}

Cette annotation précise que la valeur d'un paramètre doit être extraite d'un formulaire situé dans le corps de la requête :

@Path("/personnels")
public class GestionPersonnel {

   @GET
   @Path("formulaire")
   @Consumes("application/x-www-form-urlencoded")
   public Personne recherche(@FormParam("nom") String nom, @FormParam("prenom") String prénom) {
      Query requête = bd.createNamedQuery("recherchePersonnel");
      requête.setParameter("nom", nom);
      requête.setParameter("prénom", prénom);
      return (Personne) requête.getSingleResult();
   }          
...
}

Nous pouvons ajouter @DefaultValue à toutes ces annotations pour définir une valeur par défaut pour le paramètre que nous attendons. Cette valeur sera utilisée si les métadonnées correspondantes sont absentes de la requête. Si le paramètre age ne se trouve pas dans la requête, par exemple, le code suivant utilisera la valeur 50 par défaut :

@Path("/personnels")
public class GestionPersonnel {

   @GET
   public Personne unPersonnel(@DefaultValue("50") @QueryParam("age") int âge) {
      ...
   }           
}

Dans le code qui suit, Bienvenue produit par défaut une représentation en texte brut, sauf pour la première méthode qui propose un résultat sous forme de page HTML.

package rest;

import javax.ws.rs.*;

@Path("/")
@Produces("text/plain")
public class Bienvenue {
   
   @GET  
   @Produces("text/html")
   public String bienvenue() {
      return "<html><h2 align='center'>Bienvenue... (premier exemple REST)</h2></html>";
   }
   
   @GET
   public String paramètres(@HeaderParam("Accept") String typeContenu, @HeaderParam("User-Agent") String agent) {
      return typeContenu+'\n'+agent;
   }
}

• Si une ressource peut produire plusieurs types de média Internet, la méthode choisie correspondra au type qui convient le mieux à l'en-tête Accept de la requête HTTP du client.
• Si, par exemple, cet en-tête est : Accept : text/plain et que l'URI est /, c'est la méthode bienvenue() qui sera invoquée.
• Le client aurait pu également utiliser l'en-tête suivant : Accept : text/plain; q=0.8, text/html. Cet en-tête annonce que le client peut accepter les types text/plain et text/html mais qu'il préfère le dernier choix avec un facteur de qualité de 0.8 je préfère huit fois plus le text/html que le text/plain. En incluant cet en-tête à la même requête /, c'est la méthode paramètres() qui est cette fois-ci invoquée :

  

Requête et réponse avec un flux d’entrée :

@POST
@Path("flux")
public void lireFlux(InputStream is) throws IOException {
   byte[] octets = lireOctets(is);
   String input = new String(octets);
   System.out.println(input);
}
   
private byte[] lireOctets(InputStream stream) throws IOException {
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   byte[] buffer = new byte[1000]; int octetsLus = 0;
   do {
       octetsLus = stream.read(buffer);
       if (octetsLus > 0) { baos.write(buffer, 0, octetsLus); }
    } 
    while (octetsLus > -1);
    return baos.toByteArray();
}
   
@Path("flux")
@GET
@Produces(MediaType.TEXT_XML)
public InputStream envoyerDocumentXML() throws FileNotFoundException {
    return new FileInputStream("exemple.xml");
}

Requête et réponse avec un fichier :

@Path("fichier")
@PUT
public void lireFichier(File file) throws IOException {
   byte[] octets = lireOctets(new FileInputStream(file));
   String input = new String(octets);
   System.out.println(input);
}

@Path("fichier")
@GET
@Produces(MediaType.TEXT_XML)
public File envoyerFichier() {
   File file = new File("exemple.xml");
   return file;
}

Requête et réponse avec un tableau d'octets :

@Path("/")
public class Bienvenue {
   
   @GET
   @Produces("text/plain")
   public byte[] get() {
      return "Bienvenue à tous".getBytes();
   }
   
   @POST
   @Consumes("text/plain")
   public void post(byte[] octets) {
      System.out.println(new String(octets));
   }
}

Requête et réponse avec une chaîne de caractères

@Path("chaine")
@PUT
public void contenuChaine(String current) throws IOException {
   System.out.println(current);
}

@Path("chaine")
@GET
@Produces(MediaType.TEXT_XML)
public String envoiChaine() {
   return "<?xml version=\"1.0\"?>" + "<details>Bienvenue à tous" +"</details>";
}

Gestion d'un personnel de l'entreprise

@GET
@Produces(MediaType.APPLICATION_XML)
public List<Personne> toutLePersonnel() {
   Query requête = bd.createNamedQuery("toutLePersonnel");
   return requête.getResultList();
}

@GET
@Produces(MediaType.APPLICATION_XML) 
// Le type MIME retourné par le service ce qui permet au client de connaître le format à traiter
@Path("{idPersonnel}")
public Personne unPersonnel(@PathParam("idPersonnel") long idPersonnel) {
   return bd.find(Personne.class, idPersonnel);
}      

@POST
@Consumes(MediaType.APPLICATION_XML)  // Utilisation d’un objet JAXBElement pour envelopper le type Personne
public void nouveauPersonnel(JAXBElement<Personne> personne) {
   bd.persist(personne.getValue());    
}

@DELETE
@Path("{idPersonnel}")
public void supprimePersonnel(@PathParam("idPersonnel") long idPersonnel) {
   bd.remove(unPersonnel(idPersonnel));
}  

@PUT
@Consumes(MediaType.APPLICATION_XML)
public void modifiePersonnel(Personne personne) {
   bd.merge(personne);
}

@Path("/personnels")
public class GestionPersonnel {
   
   @GET
   public List<Personne> toutLePersonnel() {
      ...
   }
   
   @POST
   @Consumes("application/xml")
   public Response nouveauPersonnel(InputStream is) {
      ...   
   }

   @PUT
   @Path("{idPersonnel}")
   @Consumes(MediaType.APPLICATION_XML)
   public Response modifiePersonnel(Personne personne, InputStream is) {
      ...
   }     
   
   @DELETE
   @Path("{idPersonnel}")
   public void supprimePersonnel(@PathParam("idPersonnel") long idPersonnel) {
      ...
   }  
}

• Lorsqu'une méthode ressource est invoquée, les paramètres annotés par l'une des méthodes d'extraction vues précédemment sont initialisés. La valeur d'un paramètre non annoté appelé paramètre entité est obtenue à partir du corps de la requête et convertie par un des fournisseurs d'entités vus précédemment.
• Les méthodes peuvent retourner void, Response ou un autre type Java. Response indique qu'il faudra fournir d'autres métadonnées. Lorsque nous créons un nouvel agent de l'entreprise, par exemple, il serait judicieux de renvoyer son URI personnelle.

• ResponseBuilder created(URI locale) : Modifie la valeur de Location dans l’en-tête, à utiliser pour une nouvelle ressource créée.
• ResponseBuilder notModified() : Statut à Not Modified.
• ResponseBuilder ok() : Statut à Ok.
• ResponseBuilder serverError() : Statut à Server Error.
• ResponseBuilder status(Response.Status) : défini un statut particulier défini dans Response.Status.

• Response build() : crée une instance.
• ResponseBuilder entity(Object value) : modifie le contenu du corps.
• ResponseBuilder header(String, Object) : modifie un paramètre de l’en-tête.

@Path("/bienvenue")
public class Bienvenue {

   @GET
   @Produces("text/plain")
   public Response getBooks() {
       return Response.status(Response.Status.OK)
                                 .header("message1", "Bonjour")
                                 .header("message2", "Salut")
                                 .entity("Bienvenue... (premier exemple REST)")
                                 .build();      // Finalisation en appelant la méthode build()
   }
}

@Path("/bienvenue")
public class Bienvenue {

   @GET
   public Response getBooks() {
       return Response.serverError().build();      // Finalisation en appelant la méthode build()
   }
}

Un objet de type UriInfo permet d’extraire les informations brutes d’une requête HTTP. Les principales méthodes sont les suivantes :

• String getPath() : Chemin relatif de la requête.
• MultivaluedMap<String, String> getPathParameters() : Valeurs des paramètres de la requête contenues dans Template Parameters.
• MultivaluedMap<String, String> getQueryParameters() : Valeurs des paramètres de la requête.
• URI getBaseUri() : Chemin de l’application.
• URI getAbsolutePath() : Chemin absolu base + chemins.
• URI getRequestUri() : Chemin absolu incluant les paramètres.

@Path("/bienvenue")
public class Bienvenue {

   @GET
   @Path("{param}")
   public void getInformationUriInfo(@Context UriInfo uriInfo, @PathParam("param") String param, @QueryParam("nom") String nom) {
      System.out.println("getPath() : " + uriInfo.getPath());
      System.out.println("getAbsolutePath() : " + uriInfo.getAbsolutePath());
      System.out.println("getBaseUri() : " + uriInfo.getBaseUri());
      System.out.println("getRequestUri() : " + uriInfo.getRequestUri());
      System.out.println("paramètre : "+ param);
      System.out.println("nom : "+ nom);
      System.out.println("getPathParameters() : "+uriInfo.getPathParameters());
      System.out.println("getQueryParameters() : "+uriInfo.getQueryParameters());
   }
}

• Infos: getPath() : bienvenue/test.
• Infos: getAbsolutePath() : http://localhost:8080/AWRest/bienvenue/test.
• Infos: getBaseUri() : http://localhost:8080/AWRest/.
• Infos: getRequestUri() : http://localhost:8080/AWRest/bienvenue/test?nom=REMY.
• Infos: paramètre : test.
• Infos: nom : REMY.
• Infos: getPathParameters() : {param=[test]}.
• Infos: getQueryParameters() : {nom=[REMY]}.

@Path("/bienvenue")
public class Bienvenue {
   
   @Context 
   UriInfo uriInfo;
   
   @GET
   @Path("{param}")
   public void getInformationUriInfo(@PathParam("param") String param, @QueryParam("nom") String nom) {
      System.out.println("getPath() : " + uriInfo.getPath());
      System.out.println("getAbsolutePath() : " + uriInfo.getAbsolutePath());
      System.out.println("getBaseUri() : " + uriInfo.getBaseUri());
      System.out.println("getRequestUri() : " + uriInfo.getRequestUri());
      System.out.println("paramètre : "+ param);
      System.out.println("nom : "+ nom);
      System.out.println("getPathParameters() : "+uriInfo.getPathParameters());
      System.out.println("getQueryParameters() : "+uriInfo.getQueryParameters());
   }
}

Comme nous l'avons vu précédemment, les informations transportées entre le client et le serveur sont formées non pas uniquement du corps d'une entité, mais également d'en-têtes Date, Content-type, etc.. Les en-têtes HTTP font partie de l'interface uniforme et les services web REST les utilisent. La classe javax.ws.rs.HttpHeaders peut être injectée dans un attribut ou dans un paramètre de méthode au moyen de l'annotation @Context afin de permettre d'accéder aux valeurs des en-têtes sans tenir compte de leur casse. Un objet de type HttpHeader permet d’extraire les informations contenues dans l’en-tête d’une requête. Les principales méthodes sont les suivantes :

• Map<String, Cookie> getCookies() : les cookies de la requête.
• Locale getLanguage() : la langue de la requête.
• MultivaluedMap<String, String> getRequestHeaders() : valeurs des paramètres de l’en-tête de la requête.
• MediaType getMediaType() : le type MIME de la requête.

@Path("/bienvenue")
public class Bienvenue {

   @GET
   @Produces("text/plain")
   public Response get(@Context HttpHeaders enTêtes) {
      StringBuilder chaîne = new StringBuilder(enTêtes.getAcceptableLanguages().toString());
      chaîne.append('\n');
      chaîne.append(enTêtes.getRequestHeader("accept-language"));
      return Response.ok().entity(chaîne.toString()).build();
   }
}

@Path("/bienvenue")
public class Bienvenue {

   @Context 
   HttpHeaders enTêtes;
   
   @GET
   @Produces("text/plain")
   public Response get() {
      StringBuilder chaîne = new StringBuilder(enTêtes.getAcceptableLanguages().toString());
      chaîne.append('\n');
      chaîne.append(enTêtes.getRequestHeader("accept-language"));
      return Response.ok().entity(chaîne.toString()).build();
   }
}

@Path("/bienvenue")
public class Bienvenue {

   @Context UriInfo info;
   
   @GET
   public Response get() {
      UriBuilder fabrique = info.getAbsolutePathBuilder();
      URI uri = fabrique.path("{nom}/{prenom}").queryParam("age", "{age}").build("REMY", "Emmanuel", 59);
      return Response.created(uri).build();
   }
}

@Path("/bienvenue")
public class Bienvenue {
   
   @GET
   @Path("age/{age}")
   @Produces("text/html")
   public String getAge(@PathParam("age") int age) {
      if (age<0) throw new WebApplicationException(Response.status(400).entity("Vous devez donner une valeur positive...").build());
      return "Age = "+age+ " ans";
   }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" ...
    <context-param>
        <param-name>primefaces.THEME</param-name>
        <param-value>sunny</param-value>
    </context-param>
    
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>ServletAdaptor</servlet-name>
        <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
    </servlet-mapping>
    
    <servlet-mapping>
        <servlet-name>ServletAdaptor</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>faces/index.xhtml</welcome-file>
    </welcome-file-list>
</web-app>

package entité;

import java.io.Serializable;
import java.util.*;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
@Entity
@NamedQuery(name="toutLePersonnel", query="SELECT p FROM Personne p ORDER BY p.nom, p.prénom")
public class Personne implements Serializable {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private long id;
   private String nom;
   private String prénom;
   @Temporal(javax.persistence.TemporalType.DATE)
   private Date naissance;
   private String téléphone;

   public Personne() {}

   public Personne(String nom, String prénom, Date naissance, String téléphone) {
      setNom(nom);
      setPrénom(prénom);
      this.naissance = naissance;
      this.téléphone = téléphone;
   }   

   public long getId() { return id;  }

   public Date getNaissance() { return naissance;  }
   public void setNaissance(Date naissance) {  this.naissance = naissance;   }

   public String getNom() { return nom;  }
   public void setNom(String nom) {  this.nom = nom.toUpperCase(Locale.FRANCE);   }

   public String getTéléphone() { return téléphone;  }
   public void setTéléphone(String téléphone) { this.téléphone = téléphone; }

   public String getPrénom() { return prénom;   }

   public void setPrénom(String prénom) { 
      StringBuilder chaîne = new StringBuilder(prénom.toLowerCase(Locale.FRANCE));
      chaîne.setCharAt(0, Character.toUpperCase(chaîne.charAt(0)));
      this.prénom = chaîne.toString();   
   }

   @Override
   public String toString() { return nom + " " + prénom;  }   
}

package service;

import entité.Personne;
import java.util.*;
import javax.ejb.*;
import javax.persistence.*;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;

@Path("/")
@Stateless
public class GestionPersonnel {
   @PersistenceContext
   private EntityManager bd;

   @GET
   @Produces("application/json")
   @Path("tous")
   public List<Personne> listePersonnels() {
      Query requête = bd.createNamedQuery("toutLePersonnel");
      return requête.getResultList();
   }
   
   @GET
   @Produces("application/json")
   @Path("json/{id}")
   public Personne rechercheJSON(@PathParam("id") long id) {
      return bd.find(Personne.class, id);
   }
   
   @GET
   @Path("{id}")
   public Response rechercheDétaillée(@PathParam("id") long id) {
      Personne personne = bd.find(Personne.class, id);
      return Response.ok().header("nom", personne.getNom())
                                        .header("prenom", personne.getPrénom())
                                        .header("date", personne.getNaissance().getTime())
                                        .header("telephone", personne.getTéléphone()).build();
   }   
   
   @POST
   public Response nouveau(@HeaderParam("nom") String nom, 
                           @HeaderParam("prenom") String prénom, 
                           @HeaderParam("date") long date, 
                           @HeaderParam("telephone") String téléphone) {
      Personne personne = new Personne(nom, prénom, new Date(date), téléphone);
      bd.persist(personne);
      return Response.ok().header("id", personne.getId()).build();
   }   
   
   @POST
   @Path("{nom}/{prénom}/{téléphone}")
   public Response nouveau(@PathParam("nom") String nom, 
                           @PathParam("prénom") String prénom, 
                           @QueryParam("annee") int année, 
                           @QueryParam("mois") int mois,
                           @QueryParam("jour") int jour,
                           @PathParam("téléphone") String téléphone) {
      Personne personne = new Personne(nom, prénom, new GregorianCalendar(année, mois-1, jour).getTime(), téléphone);
      bd.persist(personne);
      return Response.ok().header("id", personne.getId()).build();
   }   

   @POST
   @Path("json")
   @Consumes("application/json")
   public void nouveau(Personne personne) {
      bd.persist(personne);
   }

   @PUT
   @Path("enTête/{id}")
   public void modifier(@PathParam("id") long id, 
                        @HeaderParam("date") long date, 
                        @HeaderParam("telephone") String téléphone) {     
      Personne personne = bd.find(Personne.class, id);
      personne.setNaissance(new Date(date));
      personne.setTéléphone(téléphone);
      bd.merge(personne);
   }  
   
   @PUT
   @Path("{id}/{téléphone}")
   public void modifier(@PathParam("id") long id, 
                        @QueryParam("annee") int année, 
                        @QueryParam("mois") int mois,
                        @QueryParam("jour") int jour,
                        @PathParam("téléphone") String téléphone) {
      Personne personne = bd.find(Personne.class, id);
      personne.setNaissance(new GregorianCalendar(année, mois-1, jour).getTime());
      personne.setTéléphone(téléphone);
      bd.merge(personne);
   }     

   @PUT
   @Path("{id}/telephone({téléphone})")
   public void modifier(@PathParam("id") long id, @PathParam("téléphone") String téléphone) {
      Personne personne = bd.find(Personne.class, id);
      personne.setTéléphone(téléphone);
      bd.merge(personne);
   }     

   @PUT
   @Path("{id}/jour={jour}-mois={mois}-annee={annee}")
   public void modifier(@PathParam("id") long id, 
                        @PathParam("annee") int année, 
                        @PathParam("mois") int mois,
                        @PathParam("jour") int jour) {
      Personne personne = bd.find(Personne.class, id);
      personne.setNaissance(new GregorianCalendar(année, mois-1, jour).getTime());
      bd.merge(personne);
   }        

   @PUT
   @Path("json")
   @Consumes("application/json")
   public void modifier(Personne personne) {
     bd.merge(personne);
   }
   
   @DELETE
   @Path("{id}")
   public void supprimer(@PathParam("id") long id) {
      Personne personne = bd.find(Personne.class, id);
      bd.remove(personne);
   }   

   @DELETE
   @Path("json")
   @Consumes("application/json")
   public void supprimer(Personne personne) {
     Personne recherche = bd.find(Personne.class, personne.getId());
     bd.remove(recherche);
   }   
}

package bean;

import entité.Personne;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.*;
import javax.faces.context.FacesContext;
import service.GestionPersonnel;

@ManagedBean
@ViewScoped
public class Personnel {
   private Personne personne;
   @EJB
   private GestionPersonnel gestion;
   private List<Personne> tous;
   private int indice;
   
   @PostConstruct
   private void init() {
      tous = gestion.listePersonnels();
      if (tous.isEmpty()) personne = new Personne();
      else {
         indice = tous.size()-1;
         personne = tous.get(indice);
      }
   }

   public Personne getPersonne() { return personne;  }
   public void setPersonne(Personne personne) {   this.personne = personne;  }

   public List<Personne> getTous() { return tous;   }
   
   public boolean isNouveau() { return personne.getId() == 0; }
   
   public void nouveau()     { 
      personne = new Personne(); 
      message("Nouvel agent", "Saisissez l'ensemble des coordonnées");
   }

   public void enregistrer()   { 
      if (isNouveau()) gestion.nouveau(personne); 
      else gestion.modifier(personne); 
      init(); 
      message("Enregistrement", personne+" est bien enregistrée");      
   }

   public void supprimer()   { 
      message("Suppression", personne+" ne fait plus partie du personnel");
      gestion.supprimer(personne); 
      init(); 
   }
   
   public void précédent() {
      if (indice>0) indice--;
      personne = tous.get(indice);
   }
   
   public void suivant() {
      if (indice<tous.size()-1) indice++;
      personne = tous.get(indice);
   }
   
   private void message(String titre, String détail) {
      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(titre, détail));
   }
}

Ce code correspond au bean managé Personnel qui utilise les compétences du bean session GestionPersonnel vu précédemment. Il sert de modèle dans la structure JSF et il est en étroite relation avec la vue représentée par la page web index.xhtml.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:p="http://primefaces.org/ui"
      xmlns:f="http://java.sun.com/jsf/core">
   <h:head>
      <title>Gestion du personnel</title>
   </h:head>
   
   <h:body>
      <h:form>
         <p:growl autoUpdate="true" showDetail="true" />
         <p:panel header="Gestion du personnel">
            <p:accordionPanel activeIndex="-1">
               <p:tab title="Liste du personnel">
                  <p:outputPanel autoUpdate="true">
                     <p:dataTable var="personne" value="#{personnel.tous}" paginator="true" rows="7">
                        <p:column>
                           <f:facet name="header"><h:outputText value="Nom" /></f:facet>
                           <h:outputText value="#{personne.nom}" />
                        </p:column>
                        <p:column>
                           <f:facet name="header"><h:outputText value="Prénom" /></f:facet>
                           <h:outputText value="#{personne.prénom}" />
                        </p:column>
                        <p:column>
                           <f:facet name="header"><h:outputText value="Date de naissance" /></f:facet>
                           <p:calendar locale="fr" value="#{personne.naissance}" pattern="EEEE dd MMMM yyyy" disabled="true"/>
                        </p:column>
                        <p:column>
                           <f:facet name="header"><h:outputText value="Téléphones" /></f:facet>                          
                           <h:outputText var="téléphone" value="#{personne.téléphone}" />
                        </p:column>
                     </p:dataTable> 
                  </p:outputPanel>
               </p:tab>
               <p:tab title="Edition de chaque agent">
                  <p:outputPanel autoUpdate="true">
                     <p:panelGrid columns="2">
                        <h:outputText value="Nom :" />
                        <p:inputText value="#{personnel.personne.nom}" disabled="#{not personnel.nouveau}" />
                        <h:outputText value="Prénom :" />
                        <p:inputText value="#{personnel.personne.prénom}" disabled="#{not personnel.nouveau}"  />
                        <h:outputText value="Date de naissance :" />
                        <p:calendar locale="fr" value="#{personnel.personne.naissance}" beforeShowDay="true" pattern="dd MMMM yyyy" />
                        <h:outputText value="Téléphone :" />
                        <p:inputMask value="#{personnel.personne.téléphone}" mask="99-99-99-99-99" />                          
                        <f:facet name="footer">
                           <p:commandButton value="Nouveau" action="#{personnel.nouveau()}" icon="ui-icon-document"/>
                           <p:commandButton value="Enregistrer" action="#{personnel.enregistrer()}" icon="ui-icon-disk"/>
                           <p:commandButton value="Supprimer" action="#{personnel.supprimer()}" disabled="#{personnel.nouveau}" icon="ui-icon-trash" />
                           <p:commandButton value="Précedent" action="#{personnel.précédent()}" />
                           <p:commandButton value="Suivant" action="#{personnel.suivant()}" />
                        </f:facet>
                     </p:panelGrid>
                  </p:outputPanel>
               </p:tab>
            </p:accordionPanel>
         </p:panel>
      </h:form>
   </h:body>
</html>

@Path("/")
@Stateless
public class GestionPersonnel {
   @PersistenceContext
   private EntityManager bd;

   @GET
   @Produces("application/json")
   @Path("tous")
   public List<Personne> listePersonnels() {
      Query requête = bd.createNamedQuery("toutLePersonnel");
      return requête.getResultList();
   }
   
   @GET
   @Produces("application/json")
   @Path("json/{id}")
   public Personne rechercheJSON(@PathParam("id") long id) {
      return bd.find(Personne.class, id);
   }
   
   @GET
   @Path("{id}")
   public Response rechercheDétaillée(@PathParam("id") long id) {
      Personne personne = bd.find(Personne.class, id);
      return Response.ok().header("nom", personne.getNom())
                                        .header("prenom", personne.getPrénom())
                                        .header("date", personne.getNaissance().getTime())
                                        .header("telephone", personne.getTéléphone()).build();
   }   
...
}

• Ce service propose trois méthodes avec l'annotation @GET. Le première permet de restituer l'ensemble du personnel au format JSON. Voici ce que nous obtenons respectivement au travers d'un navigateur et du pluggin Poster. Dans ce dernier cas, les accents sont pris en compte. Remarquez bien au passage l'URI à soumettre pour que ce service soit opérationnel.

  

• La deuxième méthode permet de retourner un personnel également au format JSON à partir de son identifiant :

  

• Enfin, la dernière méthode retourne également un seul personnel, mais les informations retournées se situent dans l'en-tête de la réponse :

  

@Path("/")
@Stateless
public class GestionPersonnel {
   @PersistenceContext
   private EntityManager bd;

   @POST
   public Response nouveau(@HeaderParam("nom") String nom, 
                           @HeaderParam("prenom") String prénom, 
                           @HeaderParam("date") long date, 
                           @HeaderParam("telephone") String téléphone) {
      Personne personne = new Personne(nom, prénom, new Date(date), téléphone);
      bd.persist(personne);
      return Response.ok().header("id", personne.getId()).build();
   }   
   
   @POST
   @Path("{nom}/{prénom}/{téléphone}")
   public Response nouveau(@PathParam("nom") String nom, 
                           @PathParam("prénom") String prénom, 
                           @QueryParam("annee") int année, 
                           @QueryParam("mois") int mois,
                           @QueryParam("jour") int jour,
                           @PathParam("téléphone") String téléphone) {
      Personne personne = new Personne(nom, prénom, new GregorianCalendar(année, mois-1, jour).getTime(), téléphone);
      bd.persist(personne);
      return Response.ok().header("id", personne.getId()).build();
   }   

   @POST
   @Path("json")
   @Consumes("application/json")
   public void nouveau(Personne personne) {
      bd.persist(personne);
   }
  ...
}

• Ce service propose deux méthodes avec l'annotation @POST. Le première permet de créer un nouveau personnel à partir de l'en-tête de la requête :

  

• La deuxième méthode permet également de créer un nouveau personnel directement au travers de l'URI. L'avantage d'utiliser des paramètres de type @QueryParam, c'est que lorsque nous élaborons notre URI, l'ordre des paramètres n'a pas d'importance du moment que nous les évoquons tous.

  

• Enfin, la troisième méthode, qui sert également pour le bean géré, permet au travers du service web REST de générer un nouveau personnel directement à partir d'un document JSON. Comme l'entité possède l'annotation @XmlRootElement, le mapping entre le document JSON et la classe Personne se fait automatiquement.

  

@Path("/")
@Stateless
public class GestionPersonnel {
   @PersistenceContext
   private EntityManager bd;
   
   @PUT
   @Path("enTête/{id}")
   public void modifier(@PathParam("id") long id, 
                        @HeaderParam("date") long date, 
                        @HeaderParam("telephone") String téléphone) {     
      Personne personne = bd.find(Personne.class, id);
      personne.setNaissance(new Date(date));
      personne.setTéléphone(téléphone);
      bd.merge(personne);
   }  
   
   @PUT
   @Path("{id}/{téléphone}")
   public void modifier(@PathParam("id") long id, 
                        @QueryParam("annee") int année, 
                        @QueryParam("mois") int mois,
                        @QueryParam("jour") int jour,
                        @PathParam("téléphone") String téléphone) {
      Personne personne = bd.find(Personne.class, id);
      personne.setNaissance(new GregorianCalendar(année, mois-1, jour).getTime());
      personne.setTéléphone(téléphone);
      bd.merge(personne);
   }     

   @PUT
   @Path("{id}/telephone({téléphone})")
   public void modifier(@PathParam("id") long id, @PathParam("téléphone") String téléphone) {
      Personne personne = bd.find(Personne.class, id);
      personne.setTéléphone(téléphone);
      bd.merge(personne);
   }     

   @PUT
   @Path("{id}/jour={jour}-mois={mois}-annee={annee}")
   public void modifier(@PathParam("id") long id, 
                        @PathParam("annee") int année, 
                        @PathParam("mois") int mois,
                        @PathParam("jour") int jour) {
      Personne personne = bd.find(Personne.class, id);
      personne.setNaissance(new GregorianCalendar(année, mois-1, jour).getTime());
      bd.merge(personne);
   }    

   @PUT
   @Path("json")
   @Consumes("application/json")
   public void modifier(Personne personne) {
     bd.merge(personne);
   }
...    
}

• Ce service propose cette fois-ci quatre méthodes avec l'annotation @PUT. Le première permet de modifier le numéro de téléphone ainsi que la date de naissance en plaçant les nouvelles valeurs dans l'en-tête de la requête, en spécifiant l'identifiant du personnel à modifier directement dans l'URI.

  

• La deuxième méthode modifie également le numéro de téléphone et la date de naissance du personnel identifié, mais cette fois-ci tout doit être spécifié directement dans l'URI et au travers de paramètres de requête :

  

• La troisième méthode ne modifie que le numéro de téléphone du personnel identifié :

  

• La quatrième méthode ne modifie quant à elle que la date de naissance :

  

• La dernière version permet de modifier la totalité du personnel à l'aide d'un document JSON.

@Path("/")
@Stateless
public class GestionPersonnel {
   @PersistenceContext
   private EntityManager bd;

...
   @DELETE
   @Path("{id}")
   public void supprimer(@PathParam("id") long id) {
      Personne personne = bd.find(Personne.class, id);
      bd.remove(personne);
   }   

   @DELETE
   @Path("json")
   @Consumes("application/json")
   public void supprimer(Personne personne) {
     Personne recherche = bd.find(Personne.class, personne.getId());
     bd.remove(recherche);
   }   
}

• Il n'existe ici deux méthodes de suppression, reconnaissables par l'annotation @DELETE. Dans le premier cas, il suffit de préciser l'identifiant du personnel à supprimer :

  

• Dans le deuxième cas, nous envoyons la totalité des informations du personnel au travers d'un document JSON.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.rest"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Client REST Personnel" >
         <activity android:name="ListePersonnel" android:label="Liste du Personnel">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>       
        <activity android:name="ChoixServeur" android:label="Choix du serveur" android:theme="@android:style/Theme.Dialog" />        
        <activity android:name="Personnel" android:label="Edition du Personnel" android:theme="@android:style/Theme.Dialog"/>
    </application>
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

<?xml version="1.0" encoding="UTF-8"?>
<shape 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle" >
   <gradient 
      android:startColor="#FF0000"
      android:endColor="#FFFF00"
      android:type="radial"
      android:gradientRadius="300" />
</shape>

<?xml version="1.0" encoding="UTF-8"?>
   <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:padding="2dp">
      <Button
         android:id="@+id/ok"
         android:layout_alignParentRight="true"
         android:layout_width="wrap_content" 
         android:layout_height="wrap_content" 
         android:text="OK" 
         android:onClick="ok"/>              
      <EditText
         android:layout_toLeftOf="@id/ok"
         android:id="@+id/adresse"
         android:layout_width="fill_parent" 
         android:layout_height="wrap_content" 
         android:hint="Adresse IP" />                   
</RelativeLayout>

package fr.btsiris.rest;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.*;
import android.widget.EditText;

public class ChoixServeur extends Activity {
   private EditText adresse;

   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);  
      setContentView(R.layout.adresse);
      adresse = (EditText) findViewById(R.id.adresse);
   }
   
   public void ok(View vue) {
      Intent intent = new Intent();
      intent.putExtra("adresse", adresse.getText().toString());
      setResult(RESULT_OK, intent);
      finish();      
   }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@drawable/fond"
    android:padding="3dp">  
   <Button
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Nouvelle personne"
      android:onClick="edition" />
   <ListView  
      android:id="@android:id/list"
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent" />
</LinearLayout>

package fr.btsiris.rest;

import java.io.Serializable;

public class Personne implements Serializable {
   private long id;
   private String nom;
   private String prenom;
   private long naissance;
   private String telephone;

   public long getId() { return id;  }
   public void setId(long id) {  this.id = id;  } 

   public long getNaissance() { return naissance;  }
   public void setNaissance(long naissance) {  this.naissance = naissance;   }

   public String getNom() { return nom;  }
   public void setNom(String nom) {  this.nom = nom; }

   public String getTelephone() { return telephone;  }
   public void setTelephone(String telephone) { this.telephone = telephone; }

   public String getPrenom() { return prenom;   }
   public void setPrenom(String prenom) { this.prenom = prenom; }

   @Override
   public String toString() { return nom + " " + prenom;  }   
} 

package fr.btsiris.rest;

import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.*;
import java.io.IOException;
import java.util.*;
import org.apache.http.HttpResponse;
import org.apache.http.client.*;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.*;

public class ListePersonnel extends ListActivity {
    private ArrayList<Personne> personnes = new ArrayList<Personne>();
    private String adresse;
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.liste);
       startActivityForResult(new Intent(this, ChoixServeur.class), 1);
    }
    
    protected void onActivityResult(int requestCode, int resultCode, Intent intention) {
       if (resultCode == RESULT_OK) {
          adresse = intention.getStringExtra("adresse");
          try {
             miseAJour();
          } 
          catch (Exception ex) {  Toast.makeText(this, "Réponse incorrecte", Toast.LENGTH_SHORT).show();  }
       }
    }

   @Override
   protected void onResume() {
      super.onResume();
      if (adresse!=null) try {
         miseAJour();
      } 
      catch (Exception ex) { }
   }

   @Override
   protected void onStop() {
      super.onStop();
      finish();
   }
   
    public void miseAJour() throws IOException, JSONException {
      HttpClient client = new DefaultHttpClient();
      HttpGet requete = new HttpGet("http://"+adresse+":8080/Personnel/rest/tous/");
      HttpResponse reponse = client.execute(requete);
      if (reponse.getStatusLine().getStatusCode() == 200) {
         Scanner lecture = new Scanner(reponse.getEntity().getContent());
         StringBuilder contenu = new StringBuilder();
         while (lecture.hasNextLine()) contenu.append(lecture.nextLine()+'\n');             
         JSONArray tableauJSON = new JSONArray(contenu.toString());
         StringBuilder message = new StringBuilder();
         personnes.clear();
         for (int i=0; i<tableauJSON.length(); i++) {
            JSONObject json = tableauJSON.getJSONObject(i);
            Personne personne = new Personne();
            personne.setId(json.getLong("id"));
            personne.setNom(json.getString("nom"));
            personne.setPrenom(json.getString("prénom"));
            personne.setNaissance(json.getLong("naissance"));
            personne.setTelephone(json.getString("téléphone"));
            personnes.add(personne);
         }
         setListAdapter(new ArrayAdapter<Personne>(this, android.R.layout.simple_list_item_1, personnes));
      }
      else Toast.makeText(this, "Problème de communication", Toast.LENGTH_SHORT).show();       
    }
    
    public void edition(View vue) {
       Intent intention = new Intent(this, Personnel.class);
       intention.putExtra("id", 0);
       intention.putExtra("adresse", adresse);
       startActivity(intention);
    }

    @Override
    protected void onListItemClick(ListView liste, View vue, int position, long id) {
       Personne personne = personnes.get(position);
       Intent intention = new Intent(this, Personnel.class);
       intention.putExtra("id", personne.getId());
       intention.putExtra("adresse", adresse);
       intention.putExtra("nom", personne.getNom());
       intention.putExtra("prenom", personne.getPrenom());
       intention.putExtra("naissance", personne.getNaissance());
       intention.putExtra("telephone", personne.getTelephone());
       startActivity(intention);      
    }      
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@drawable/fond"
    android:padding="3px">
    <EditText  
      android:id="@+id/nom"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="Nom" />   
    <EditText  
      android:id="@+id/prenom"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="Prénom" />   
    <EditText 
      android:id="@+id/naissance"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="Date naissance"
      android:onClick="changeDate"/>   
    <EditText  
      android:id="@+id/telephone"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="n° téléphone"/>         
      <LinearLayout 
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:gravity="center">
         <Button
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:text="Nouveau"
            android:onClick="nouveau"/>    
         <Button
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:text="Enregistrer" 
            android:onClick="enregistrer"/>            
         <Button
            android:id="@+id/supprimer"
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:text="Supprimer" 
            android:onClick="supprimer"/>              
      </LinearLayout>
</LinearLayout>

package fr.btsiris.rest;

import android.app.*;
import android.content.Intent;
import android.os.Bundle;
import android.text.format.DateFormat;
import android.view.*;
import android.widget.*;
import java.io.IOException;
import java.util.*;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.*;
import org.apache.http.impl.client.DefaultHttpClient;

public class Personnel extends Activity {  
   private EditText nom, prenom, naissance, telephone;
   private Button supprimer;
   private long id;
   private String adresse;
   private Calendar calendrier = Calendar.getInstance();
   
   @Override
   public void onCreate(Bundle savedInstanceState)  {
      super.onCreate(savedInstanceState);
      requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
      setContentView(R.layout.personnel);
      nom = (EditText) findViewById(R.id.nom);
      prenom = (EditText) findViewById(R.id.prenom);
      telephone = (EditText) findViewById(R.id.telephone);
      naissance = (EditText) findViewById(R.id.naissance);
      supprimer = (Button) findViewById(R.id.supprimer);
   }

   @Override
   protected void onStart() {
      super.onStart();
      Intent intention = getIntent();
      Bundle donnees = intention.getExtras();
      id = donnees.getLong("id");
      adresse = donnees.getString("adresse");
      if (id==0) toutEffacer();
      else {
         nom.setEnabled(false);
         prenom.setEnabled(false);      
         supprimer.setEnabled(true);
         nom.setText(donnees.getString("nom"));
         prenom.setText(donnees.getString("prenom"));
         long date = donnees.getLong("naissance");
         calendrier.setTimeInMillis(date);
         naissance.setText(DateFormat.format("EEEE dd MMMM yyyy", date)); 
         telephone.setText(donnees.getString("telephone"));               
      }      
   }
   
   private void toutEffacer() {
      id = 0;
      nom.setEnabled(true);
      prenom.setEnabled(true);
      supprimer.setEnabled(false);  
      nom.setText("");
      prenom.setText("");
      naissance.setText("");
      telephone.setText("");        
      calendrier = Calendar.getInstance();
   }
   
   private DatePickerDialog.OnDateSetListener evt = new DatePickerDialog.OnDateSetListener() {
      public void onDateSet(DatePicker dialog, int annee, int mois, int jour) {
         calendrier.set(annee, mois, jour);
         naissance.setText(DateFormat.format("EEEE dd MMMM yyyy", calendrier));
      }
   };
   
   public void changeDate(View vue) {
       new DatePickerDialog(this, evt, 
               calendrier.get(Calendar.YEAR), 
               calendrier.get(Calendar.MONTH),
               calendrier.get(Calendar.DAY_OF_MONTH)).show();      
   }
   
   public void nouveau(View vue) {
      toutEffacer();
   }
   
   public void enregistrer(View vue) throws IOException {
      if (id==0) nouveauPersonnel();
      else modifierPersonne();
   }
   
   public void supprimer(View vue) throws IOException {
      HttpClient client = new DefaultHttpClient();
      HttpDelete requete = new HttpDelete("http://"+adresse+":8080/Personnel/rest/"+id);
      client.execute(requete);
      Toast.makeText(this, "Personnel "+id+" supprimé", Toast.LENGTH_SHORT).show();   
      finish();
   }

   private void nouveauPersonnel() throws IOException {
      HttpClient client = new DefaultHttpClient();
      HttpPost requete = new HttpPost("http://"+adresse+":8080/Personnel/rest/");  
      requete.addHeader("nom", nom.getText().toString());
      requete.addHeader("prenom", prenom.getText().toString());
      requete.addHeader("date", ""+calendrier.getTimeInMillis());
      requete.addHeader("telephone", telephone.getText().toString());
      client.execute(requete);      
      Toast.makeText(this, "Nouveau personnel enregistré", Toast.LENGTH_SHORT).show();    
      finish();
   }

   private void modifierPersonne() throws IOException {
      HttpClient client = new DefaultHttpClient();
      HttpPut requete = new HttpPut("http://"+adresse+":8080/Personnel/rest/enTête/"+id);
      requete.setHeader("date", ""+calendrier.getTimeInMillis());
      requete.setHeader("telephone", telephone.getText().toString());
      client.execute(requete);      
      Toast.makeText(this, "Personnel modifié", Toast.LENGTH_SHORT).show();         
   }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <context-param>
        <param-name>primefaces.THEME</param-name>
        <param-value>sunny</param-value>
    </context-param>
    
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>ServletAdaptor</servlet-name>
        <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>ServletAdaptor</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>

    <welcome-file-list>
        <welcome-file>faces/index.xhtml</welcome-file>
    </welcome-file-list>
</web-app>

package service;

import java.io.*;
import javax.annotation.PostConstruct;
import javax.faces.bean.*;
import javax.ws.rs.*;

@Path("/")
@ManagedBean
public class Archivage {
   private final String répertoire = "ArchivagePhotos/";
   
   @PostConstruct
   private void init() {
      File rep = new File(répertoire);
      if (!rep.exists()) rep.mkdir();
   }
   
   @GET
   @Path("liste")
   @Produces("application/json")
   public String[] getPhotos() { return new File(répertoire).list();  }
   
   @GET
   @Path("{nomFichier}")
   @Produces("image/jpeg")
   public InputStream restituer(@PathParam("nomFichier") String nom) throws FileNotFoundException {
      return new FileInputStream(répertoire+nom);
   }  
   
   @POST
   @Path("{nomFichier}")
   @Consumes("image/jpeg")
   public void stocker(@PathParam("nomFichier") String nom, InputStream flux) throws IOException {     
      byte[] octets = lireOctets(flux);
      FileOutputStream fichier = new FileOutputStream(répertoire+nom);
      fichier.write(octets);
      fichier.close();
   }
   
   @DELETE
   @Path("{nomFichier}")
   public void supprimer(@PathParam("nomFichier") String nom) {
      new File(répertoire+nom).delete();
   }   
  
   private byte[] lireOctets(InputStream stream) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      byte[] buffer = new byte[1024]; int octetsLus = 0;
      do {
         octetsLus = stream.read(buffer);
         if (octetsLus > 0) { baos.write(buffer, 0, octetsLus); }
      } 
      while (octetsLus > -1);
      return baos.toByteArray();
   }   
}

• La grande particularité ici, c'est que notre service web REST est également un bean managé qui va être également utile pour la vue de la structure JSF.
• Par contre, il ne s'agit pas d'un bean session puisque la persistance, au travers d'entité, n'est pas gérée.
• Un répertoire de stockage est prévu directement dans le serveur d'application utilisé. Cela se produit la première fois que le service entre en action au moyen de la méthode de rappel init(), grâce à l'annotation @PostConstruct.
• Nous retrouvons ensuite tous les méthodes classiques du protocole HTTP au moyen des annotation spécifiques @GET, @POST et @DELETE. Seule la méthode @PUT n'est pas utilisée ici puisqu'elle ne correspond à aucune fonctionnalité adaptée à ce genre de problème.
• Une autre grande particularité, que nous découvrirons tout à l'heure, c'est que la méthode restituer() va également être utilisée par la vue afin de proposer le flux de chaque image à la galerie présentée.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:p="http://primefaces.org/ui"
      xmlns:f="http://java.sun.com/jsf/core">
   
   <h:head>
      <title>Archivage de photos</title>
   </h:head>
   
   <h:body>
      <h:form>
         <p:panel header="Archivage de photos">
            <p:galleria value="#{archivage.photos}" var="photo">  
               <p:graphicImage value="rest/#{photo}" />   
            </p:galleria>  
          </p:panel>        
      </h:form>
   </h:body>
</html>

@Path("/")
@Produces("image/jpeg")
@Consumes("image/jpeg")
@ManagedBean
public class Archivage {
   private final String répertoire = "ArchivagePhotos/";
...   

   @POST
   @Path("{nomFichier}")
   public void stocker(@PathParam("nomFichier") String nom, InputStream flux) throws IOException {     
      byte[] octets = lireOctets(flux);
      FileOutputStream fichier = new FileOutputStream(répertoire+nom);
      fichier.write(octets);
      fichier.close();
   }

   private byte[] lireOctets(InputStream stream) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      byte[] buffer = new byte[1024]; int octetsLus = 0;
      do {
         octetsLus = stream.read(buffer);
         if (octetsLus > 0) { baos.write(buffer, 0, octetsLus); }
      } 
      while (octetsLus > -1);
      return baos.toByteArray();
   }   
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.photos"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Stockage photos" >
        <activity android:name="ArchivagePhotos" android:label="Stocker vos photos" android:screenOrientation="portrait">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="ChoixServeur" android:label="Choix du serveur" android:theme="@android:style/Theme.Dialog" /> 
    </application>
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

<?xml version="1.0" encoding="UTF-8"?>
   <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:padding="2dp">
      <Button
         android:id="@+id/ok"
         android:layout_alignParentRight="true"
         android:layout_width="wrap_content" 
         android:layout_height="wrap_content" 
         android:text="OK" 
         android:onClick="ok"/>              
      <EditText
         android:layout_toLeftOf="@id/ok"
         android:id="@+id/adresse"
         android:layout_width="fill_parent" 
         android:layout_height="wrap_content" 
         android:hint="Adresse IP" />                   
</RelativeLayout>

package fr.btsiris.rest;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.*;
import android.widget.EditText;

public class ChoixServeur extends Activity {
   private EditText adresse;

   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);  
      setContentView(R.layout.adresse);
      adresse = (EditText) findViewById(R.id.adresse);
   }
   
   public void ok(View vue) {
      Intent intent = new Intent();
      intent.putExtra("adresse", adresse.getText().toString());
      setResult(RESULT_OK, intent);
      finish();      
   }
}

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:background="#008800"
   android:padding="3dp">
    <EditText
       android:id="@+id/description"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:hint="Description de la photo"
       android:layout_alignParentBottom="true"/> 
    <LinearLayout 
       android:id="@+id/boutons"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content"
       android:layout_above="@id/description">   
       <Button 
            android:layout_width="0dp" 
            android:layout_height="wrap_content" 
            android:layout_weight="1"
            android:text="Photographier" 
            android:onClick="photographier" /> 
       <Button 
            android:layout_width="0dp" 
            android:layout_weight="1"
            android:layout_height="wrap_content" 
            android:text="Envoyer" 
            android:onClick="envoyer" />             
    </LinearLayout>
    <ImageView
       android:id="@+id/image"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent"
       android:padding="10dp"
       android:layout_above="@id/boutons" />
</RelativeLayout>

package fr.btsiris.photos;

import android.app.Activity;
import android.content.Intent;
import android.graphics.*;
import android.net.Uri;
import android.os.*;
import android.provider.MediaStore;
import android.view.View;
import android.widget.*;
import java.io.*;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.FileEntity;
import org.apache.http.impl.client.DefaultHttpClient;

public class ArchivagePhotos extends Activity {
   private EditText description;
   private ImageView image;
   private Uri fichierUri;
   private String adresse;
   private final int RECHERCHE_ADRESSE = 1;
   private final int PHOTOGRAPHIER = 2;
   
   @Override
   public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        description = (EditText) findViewById(R.id.description);
        image = (ImageView) findViewById(R.id.image);
        startActivityForResult(new Intent(this, ChoixServeur.class), RECHERCHE_ADRESSE);
   }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent intention) {
      switch (requestCode) {
         case RECHERCHE_ADRESSE :
            adresse = intention.getStringExtra("adresse");
            break;         
         case PHOTOGRAPHIER :
            File fichier = new File(Environment.getExternalStorageDirectory(), "photo.jpg");
            Bitmap photo = BitmapFactory.decodeFile(fichier.getPath());
            image.setImageBitmap(photo);
            break;
      }
   }

   public void photographier(View vue) {
      Intent intention = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
      File fichier = new File(Environment.getExternalStorageDirectory(), "photo.jpg");
      fichierUri = Uri.fromFile(fichier);
      intention.putExtra(MediaStore.EXTRA_OUTPUT, fichierUri);
      startActivityForResult(intention, PHOTOGRAPHIER);
   }   
   
   public void envoyer(View vue) throws IOException {
      HttpClient client = new DefaultHttpClient();
      HttpPost requete = new HttpPost("http://"+adresse+":8080/Photos/rest/"+description.getText().toString()+".jpg");  
      requete.setEntity(new FileEntity(new File(Environment.getExternalStorageDirectory(), "photo.jpg"), "image/jpeg"));
      client.execute(requete);      
   }
}

#-------------------------------------------------
#
# Project created by QtCreator 2014-01-12T10:30:24
#
#-------------------------------------------------
QT       += core gui network
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
CONFIG   += c++11
TARGET    = ConversionREST
TEMPLATE  = app
SOURCES  += main.cpp principal.cpp  rest.cpp
HEADERS  += principal.h   rest.h
FORMS    += principal.ui

#ifndef REST_H
#define REST_H

#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QnetworkReply>

class Rest : public QObject
{
    Q_OBJECT
    QNetworkAccessManager reseau;
public:
    Rest();
    void requete(const QString &adresse, const QString &demande);
signals:
    void alerte(const QString&);
    void reception(const QString&);
private slots:
    void reponse(QNetworkReply *resultat);
};

#endif // REST_H

• reseau : un objet de la classe QNetworkAccessManager qui permet d'établir la communication avec le service Web.
• requete() : une méthode qui permet de formaliser la requête souhaitée.
• reponse() : une méthode qui récupère la réponse à la requête.
• reception() : signal envoyé avec le contenu de la réponse.
• alerte() : signal envoyé au cas où un problème de communication apparaît.

#include "rest.h"

Rest::Rest()  { connect(&reseau, SIGNAL(finished(QNetworkReply *)), this, SLOT(reponse(QNetworkReply *))); }

void Rest::requete(const QString &adresse, const QString &demande)
{
    QString url = "HTTP://";
    url+=adresse;
    url+=":8080/Conversion/";
    url+=demande;
    reseau.get(QNetworkRequest(QUrl(url)));
}

void Rest::reponse(QNetworkReply *resultat)
{
    if (resultat->error() == QNetworkReply::NoError)
    {
        QByteArray donnees = resultat->readAll();
        reception(donnees.data());
    }
    else alerte("Problème de communication !");
    delete resultat;
}

• Le constructeur met en œuvre la gestion événementielle qui permet de lancer automatiquement la méthode reponse() dès que le résultat a été obtenu à l'issue de chaque requête.
• requete() : la méthode formalise correctement la bonne URL afin de se connecter au bon service Web d'une part et de faire la demande souhaitée par l'application cliente. Nous passons par la classe QUrl pour que la chaîne de caractère soit bien formater. Nous passons ensuite par la classe QNetworkRequest pour envoyer notre requête avec l'URL formatée et nous utilisons l'objet reseau de type QNetworkAccessManager pour finaliser le type de requête HTTP souhaitée, ici la méthode GET.
• reponse() : la méthode est appelée automatiquement après chaque envoi d'une requête. Elle prend en paramètre un objet de type QNetworkReply qui représente le résultat reçu. Il convient de vérifier systématiquement si l'opération s'est bien déroulée en appelant la méthode error(). Si effectivement la communication a pue être établie, nous pouvons récupérer la totalité de la donnée envoyée par le web service à l'aide de la méthode readAll(). ATTENTION ! Une fois que vous avez bien récupéré votre valeur, vous devez également systématiquement la supprimer du buffer de réception à l'aide de l'opération delete.

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include "ui_principal.h"
#include "rest.h"

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT
Public:
    explicit Principal(QWidget *parent = 0);
private:
    Rest rest;
    enum {AUCUN, EURO, FRANC} commande = AUCUN;
private slots:
    void euroFranc();
    void francEuro();
    void resultat(QString monnaie);
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QMessageBox>

Principal::Principal(QWidget *parent) : QMainWindow(parent)
{
    setupUi(this);
    connect(&rest, SIGNAL(alerte(QString)), barreEtat, SLOT(showMessage(QString)));
    connect(&rest, SIGNAL(reception(QString)), this, SLOT(resultat(QString)));
}

void Principal::euroFranc()
{
    commande = FRANC;
    rest.requete(adresseIP->text(), QString("franc?euro=%1").arg(euro->value()));    
}

void Principal::francEuro()
{
    commande = EURO;
    rest.requete(adresseIP->text(), QString("euro?franc=%1").arg(franc->value()));
}

void Principal::resultat(QString monnaie)
{
    switch (commande) {
       case FRANC : franc->setValue(monnaie.toDouble()); break;
       case EURO  : euro->setValue(monnaie.toDouble()); break;
       case AUCUN : barreEtat->showMessage("Choisissez votre monnaie"); break;
    }
    commande = AUCUN;
}

package service;

import java.io.*;
import java.util.*;
import javax.ws.rs.*;

@Path("/")
public class Archivage {
   private final String répertoire = "/home/manu/Applications/Archivage/";
   
   @GET
   @Produces("text/plain")
   public String listePhotos() { 
      String[] liste = new File(répertoire).list();  
      StringBuilder noms = new StringBuilder();
      for (String nom : liste) noms.append(nom.split(".jpg")[0]+'\n');
      return noms.toString();
   }
   
   @GET
   @Path("{nomFichier}")
   @Produces("image/jpeg")
   public InputStream restituer(@PathParam("nomFichier") String nom) throws FileNotFoundException {
      return new FileInputStream(répertoire+nom+".jpg");
   }  
   
   @POST
   @Path("{nomFichier}")
   @Consumes("image/jpeg")
   public void stocker(@PathParam("nomFichier") String nom, InputStream flux) throws IOException {     
      byte[] octets = lireOctets(flux);
      FileOutputStream fichier = new FileOutputStream(répertoire+nom+".jpg");
      fichier.write(octets);
      fichier.close();
   }
   
   @PUT
   @Path("change")
   public void  changerNom(@QueryParam("ancien") String ancien, @QueryParam("nouveau") String nouveau) {
      new File(répertoire+ancien+".jpg").renameTo(new File(répertoire+nouveau+".jpg"));
   }
   
   @DELETE
   @Path("{nomFichier}")
   public void supprimer(@PathParam("nomFichier") String nom) {
      new File(répertoire+nom+".jpg").delete();
   }   
  
   private byte[] lireOctets(InputStream stream) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      byte[] buffer = new byte[1024]; int octetsLus = 0;
      do {
         octetsLus = stream.read(buffer);
         if (octetsLus > 0) { baos.write(buffer, 0, octetsLus); }
      } 
      while (octetsLus > -1);
      return baos.toByteArray();
   }   
}

#-------------------------------------------------
#
# Project created by QtCreator 2014-01-15T21:34:58
#
#-------------------------------------------------
QT       += core gui network

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG   += c++11
TARGET   = ClientPhotoREST
TEMPLATE = app
SOURCES  += main.cpp  client.cpp   image.cpp
HEADERS  += client.h  image.h
FORMS    += client.ui

#ifndef IMAGE_H
#define IMAGE_H

#include <QWidget>

class Image : public QWidget
{
    Q_OBJECT
public:
    explicit Image(QWidget *parent = 0) : QWidget(parent) {}
    void chargerPhoto(const QByteArray &octets);
    QByteArray getOctets() { return octets; }
signals:
    void envoyerMessage(const QString &message);
    void envoyerNom(const QString &nom);
public slots:
    void chargerPhoto();    
    void sauverPhoto();
protected:
    void paintEvent(QPaintEvent *) override;
private:
    QImage photo;
    QByteArray octets;
};

#include "image.h"

#include <QFileDialog>
#include <QPainter>
#include <QRect>
#include <Qfile>

void Image::chargerPhoto()
{
    QString nom = QFileDialog::getOpenFileName(this, "Choisissez votre photo", "", "Images (*.jpeg *.jpg)");
    if (!nom.isEmpty())
    {     
        envoyerMessage(QString("Local : %1").arg(nom));
        QFile fichier(nom);
        fichier.open(QIODevice::ReadOnly);
        octets = fichier.readAll();
        photo.loadFromData(octets);
        update();
        QFileInfo infoFichier(nom);
        envoyerNom(infoFichier.baseName());
    }
}

void Image::chargerPhoto(const QByteArray &octets)
{
    photo.loadFromData(this->octets = octets);
    update();
}

void Image::sauverPhoto()
{
    if (!photo.isNull())
    {
        QString nom = QFileDialog::getSaveFileName(this, "Sauvegardez la photo");
        if (!nom.isEmpty())
        {
            QFile fichier(nom);
            fichier.open(QIODevice::WriteOnly);
            fichier.write(octets);
            envoyerMessage("La photo est sauvegardée sur le disque local");
        }
    }
}

void Image::paintEvent(QPaintEvent *)
{
    if (!photo.isNull())
    {
        QPainter dessin(this);
        double ratio = (double) photo.width() / photo.height();
        int largeur = width();
        int hauteur = width() / ratio;
        QRect cadrage(0, 0, largeur, hauteur);
//        QImage image = photo.scaledToWidth(width());
        dessin.drawImage(cadrage, photo, photo.rect());
    }
    else envoyerMessage("Choisissez votre photo");
}

#ifndef CLIENT_H
#define CLIENT_H

#include <QMainWindow>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QUrlQuery>
#include "ui_client.h"

class Client : public QMainWindow, public Ui::Client
{
    Q_OBJECT
public:
    explicit Client(QWidget *parent = 0);
private:
    QNetworkAccessManager reseau;
    QString adresse;
    enum {Aucune, ListePhotos, Restituer, Stocker, ChangerNom, Supprimer} requete = Aucune;
private slots:
    void reponse(QNetworkReply *resultat);
    void changerAdresse(const QString &adresse);
    void listePhotos();
    void changerPhoto(const QString &nom);
    void stocker();
    void changerNom();
    void supprimer();
signals:
    void info(const QString &info);
private:   
    void restituer();    
};

#endif // CLIENT_H

#include "client.h"

Client::Client(QWidget *parent) : QMainWindow(parent)
{
    setupUi(this);
    connect(&reseau, SIGNAL(finished(QNetworkReply*)), this, SLOT(reponse(QNetworkReply*)));
    adresse = "http://";
    adresse += adresseIP->text();
    adresse += ":8080/Archivage/";
}

void Client::reponse(QNetworkReply *resultat)
{
    if (resultat->error() == QNetworkReply::NoError)
    {
        switch (requete) {
        case ListePhotos :
            photos->clear();
            while(resultat->canReadLine()) {
                QString photo = resultat->readLine();
                photo.remove("\n");
                photos->addItem(photo);
            }
            nomPhotoServeur->setText(photos->currentText());
            break;
        case Restituer :
            photoServeur->chargerPhoto(resultat->readAll());
            break;
        case Stocker :
            info("Photo envoyée sur le serveur");
            listePhotos();
            break;
        case ChangerNom :
            info("Le nom de la photo est changée sur le serveur");
            listePhotos();
            break;
        case Supprimer :
            info("La photo a été supprimée sur le serveur");
            listePhotos();
            break;
        case Aucune :
            info("Aucune requête demandée");
            break;
        }
    }
    else info("Problème avec le service d'archivage !");
    delete resultat;
}

void Client::listePhotos()
{
    requete = ListePhotos;
    reseau.get(QNetworkRequest(QUrl(adresse)));
}

void Client::changerPhoto(const QString &nom)
{
    nomPhotoServeur->setText(nom);
    onglets->setCurrentIndex(1);
    restituer();
}

void Client::restituer()
{
    requete = Restituer;
    QString nomImage = QString("%1%2").arg(adresse).arg(nomPhotoServeur->text());
    info(nomImage);
    reseau.get(QNetworkRequest(QUrl(nomImage)));
}

void Client::stocker()
{
    QString nom = nomPhotoClient->text();
    if (!nom.isEmpty())
    {
        requete = Stocker;
        QString url = adresse;
        url+=nom;
        QNetworkRequest envoi;
        envoi.setUrl(QUrl(url));
        envoi.setRawHeader("Content-Type", "image/jpeg");
        reseau.post(envoi, photoLocal->getOctets());
    }
}

void Client::changerNom()
{
    QString nom = nomPhotoServeur->text();
    if (!nom.isEmpty())
    {
        requete = ChangerNom;
        QString url = QString("%1change?ancien=%2&nouveau=%3").arg(adresse).arg(photos->currentText()).arg(nom);
        QByteArray vide;
        reseau.put(QNetworkRequest(QUrl(url)), vide);
    }
}

void Client::supprimer()
{
    QString nom = nomPhotoServeur->text();
    if (!nom.isEmpty())
    {
        requete = Supprimer;
        QString url = adresse;
        url+=nom;
        reseau.deleteResource(QNetworkRequest(QUrl(url)));
    }
}

void Client::changerAdresse(const QString &adresse)
{
    this->adresse = "http://";
    this->adresse += adresse;
    this->adresse += ":8080/Archivage/";
    info(this->adresse);
}

• Vous remarquez que cette fois-ci nous avons proposé l'ensemble des requête HTTP en utilisant les méthodes get(), post(), put() et deleteResource() de la classe QNetworkAccessManager.
• Par ailleurs, lorsque nous devons spécifier le type mime lors de l'envoi d'un contenu supplémentaire, comme c'est le cas avec les méthodes post() et put(), nous devons donc au préalable utiliser la méthode setRawHeader() de la classe QNetworkRequest.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <context-param>
        <param-name>primefaces.THEME</param-name>
        <param-value>afterdark</param-value>
    </context-param>
     
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet>
        <servlet-name>ServletAdaptor</servlet-name>
        <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
       
    <filter>
       <filter-name>PrimeFaces FileUpload Filter</filter-name>
       <filter-class>org.primefaces.webapp.filter.FileUploadFilter</filter-class>
    </filter>
    
    <filter-mapping>
       <filter-name>PrimeFaces FileUpload Filter</filter-name>
       <servlet-name>Faces Servlet</servlet-name>
    </filter-mapping>

    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
    </servlet-mapping>
    
    <servlet-mapping>
        <servlet-name>ServletAdaptor</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>

    <welcome-file-list>
        <welcome-file>faces/index.xhtml</welcome-file>
    </welcome-file-list>
</web-app>

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:p="http://primefaces.org/ui"
      xmlns:f="http://java.sun.com/jsf/core">
   
   <h:head>
      <title>Archivage de photos</title>
   </h:head>
   
   <script src="http://maps.google.com/maps/api/js?sensor=true" type="text/javascript" />
   
   <h:body style="background-color: darkseagreen">
      <h:form>  
         <p:growl autoUpdate="true" showDetail="true" />
         <p:panel header="Archivage de photos">  
            <p:outputPanel autoUpdate="true">
               <p:selectOneMenu value="#{archivage.titre}">
                  <f:selectItems value="#{archivage.listeDesLots}" />
                  <p:ajax listener="#{archivage.changeLot()}"/>
               </p:selectOneMenu>      
            </p:outputPanel>
            <p:tabView>
               <p:tab title="Gallerie des photos">
                  <p:outputPanel autoUpdate="true">
                     <p:galleria value="#{archivage.lot.photos}" var="photo" effect="slide" filmstripPosition="right" showOverlays="true" frameWidth="90" frameHeight="60" >  
                        <p:graphicImage value="rest/#{photo.id}" width="600" height="400" styleClass="ui-corner-all" />
                        <p:galleriaOverlay title="#{photo}">  
                           <h:outputText value="#{photo.jour}" rendered="#{photo.exif}">
                              <f:convertDateTime dateStyle="full" />
                           </h:outputText> 
                           <br />
                           <h:outputText value="(Lat. = #{photo.latitude}, Lon.= #{photo.longitude})" rendered="#{photo.exif}" /> 
                           <h:outputText value="Aucunes données EXIF" rendered="#{not photo.exif}" />
                        </p:galleriaOverlay>                             
                     </p:galleria>                 
                  </p:outputPanel>                  
               </p:tab>
               <p:tab title="Google Map">
                  <p:outputPanel autoUpdate="#{archivage.miseAJour}">
                     <p:gmap zoom="15" type="HYBRID" center="#{archivage.centre}" style="width:600px;height:400px" model="#{archivage.cartographie}">
                        <p:ajax event="overlaySelect" listener="#{archivage.choixMarqueur}" />  
                        <p:gmapInfoWindow>  
                           <p:graphicImage value="rest/#{archivage.marqueur.data}" width="200" /><br />
                           <h:outputText value="#{archivage.marqueur.title}" />                                  
                        </p:gmapInfoWindow>  
                     </p:gmap> 
                  </p:outputPanel>
               </p:tab>        
               <p:tab title="Edition des photos">
                  <p:outputPanel autoUpdate="true">
                     Titre : <p:inputText value="#{archivage.lot.titre}" />
                     <p:commandButton icon="ui-icon-disk" value="Changer le titre" action="#{archivage.changeTitre()}" />
                     <p:commandButton icon="ui-icon-trash" value="Supprimer totalement ce lot" action="#{archivage.supprimeLot()}" />
                     <p:dataTable value="#{archivage.lot.photos}" var="photo" paginator="true" rows="4">
                        <p:column>
                           <f:facet name="header">Photo</f:facet>
                           <a target="_blank" href="rest/#{photo.id}">
                              <p:graphicImage value="rest/#{photo.id}" width="200" styleClass="ui-corner-all"  id="image"/>
                           </a>
                           <p:tooltip for="image" value="Cliquez pour avoir un Zoom sur cette photo" showEffect="slide" />
                        </p:column>
                        <p:column>
                           <f:facet name="header">Traitements annexes</f:facet>
                           <p:inputText value="#{photo.description}" />
                           <p:commandButton icon="ui-icon-disk" value="Changer la description" action="#{archivage.changeDescription(photo)}" />
                           <p:commandButton icon="ui-icon-trash" value="Supprimer la photo" action="#{archivage.supprimePhoto(photo)}" />
                        </p:column>                               
                     </p:dataTable>
                  </p:outputPanel>
               </p:tab>  
               <p:tab title="Ajouter une nouvelle photo">
                  Description obligatoire de la photo : 
                  <p:inputText value="#{archivage.description}">
                     <p:ajax event="keyup"  />
                  </p:inputText>
                  <p:fileUpload fileUploadListener="#{archivage.stockerPhoto}" mode="advanced" label="Choisissez votre photo" uploadLabel="Archiver" cancelLabel="Annuler" />
               </p:tab>
            </p:tabView> 
            <f:facet name="footer">
                Titre : <p:inputText value="#{archivage.nouveauTitre}" />
                <p:commandButton icon="ui-icon-document" value="Création d'un nouveau lot de photos" action="#{archivage.nouveauLot()}" />                                 
            </f:facet>
          </p:panel>             
      </h:form>
   </h:body>
</html>

package service;

import entité.*;
import java.io.*;
import java.util.*;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.*;
import javax.faces.context.FacesContext;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.map.OverlaySelectEvent;
import org.primefaces.model.*;
import org.primefaces.model.map.*;

@ManagedBean
@SessionScoped
public class Archivage {
   @EJB
   private ServiceREST service;
   private LotDePhotos lot;
   private List<LotDePhotos> listeDesLots;
   private String titre;
   private String nouveauTitre;
   private MapModel cartographie = new DefaultMapModel();
   private String centre;
   private Marker marqueur;
   private boolean miseAJour;
   private String description;
   
   @PostConstruct
   private void init() {
      File rep = new File(service.getRépertoire());
      if (!rep.exists()) rep.mkdir();
      listeDesLots = service.getListeDesLots();
      if (!listeDesLots.isEmpty()) lot = listeDesLots.get(0);
      marqueurs();
   }

   public boolean isMiseAJour() { return miseAJour;  }
   
   public String getTitre() { return titre;   }
   public void setTitre(String titre) {  this.titre = titre; }

   public String getNouveauTitre() { return nouveauTitre;  }
   public void setNouveauTitre(String nouveauTitre) { this.nouveauTitre = nouveauTitre;  }

   public String getDescription() { return description;  }
   public void setDescription(String description) { this.description = description;  }

   public List<LotDePhotos> getListeDesLots() { return listeDesLots;  }
   public LotDePhotos getLot() { return lot;  }
   public Photo getPhoto(String id) {  return service.recherchePhoto(id);  }
   public String getCentre() { return centre; }
   public MapModel getCartographie() { return cartographie;  }   

   public void changeLot() {  
      lot = service.rechercheLot(titre);
      marqueurs();
      miseAJour = true;
   }
   
   public void nouveauLot() { 
      service.créationLotDePhotos(nouveauTitre); 
      listeDesLots = service.getListeDesLots();
   }
    
   public void changeTitre() { 
      service.modifierTitreLotDePhoto(lot);  
      listeDesLots = service.getListeDesLots();
   }   

   public void supprimeLot() {
      service.supprimeLot(lot.getId());
      init();
   }
   
   public void changeDescription(Photo photo) { service.modifierDescriptionPhoto(photo);  }   
   public void supprimePhoto(Photo photo) {  service.supprimePhoto(lot, photo);  }
   
   public void stockerPhoto(FileUploadEvent evt) { 
      try {
         UploadedFile fichier = evt.getFile();
         service.stocker(lot.getId(), description, fichier.getContents());
         message(description, "Votre photo vient d'être stockée dans le service");
         lot = service.rechercheLot(titre);
      } 
      catch (Exception ex) { message("ATTENTION", "Impossible de stocker votre photo dans le service"); }
   }
 
   public void choixMarqueur(OverlaySelectEvent event) { 
      marqueur = (Marker) event.getOverlay(); 
      miseAJour = false;
   }

   public Marker getMarqueur() { return marqueur; }
   
   private void marqueurs() {
      for (Photo photo : lot.getPhotos()) {
         if (photo.isExif()) {
            LatLng coordonnées = new LatLng(photo.getLatitude(), photo.getLongitude());
            marqueur = new Marker(coordonnées, photo.getDescription(), photo.getId());
            cartographie.addOverlay(marqueur); 
            centre = photo.getLatitude()+", "+photo.getLongitude();
         }       
      }  
   }
   
   private void message(String titre, String détail) {
      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(titre, détail));
   }
}

package service;

import com.drew.imaging.ImageMetadataReader;
import com.drew.metadata.*;
import com.drew.metadata.exif.GpsDirectory;
import entité.*;
import java.io.*;
import java.util.*;
import javax.ejb.*;
import javax.persistence.*;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;

@Path("/")
@Stateless
@LocalBean
public class ServiceREST {
   private final String répertoire = "ArchivagePhotos/";
   @PersistenceContext
   private EntityManager bd;
   
   @POST
   @Path("{titre}")
   public Response créationLotDePhotos(@PathParam("titre") String titre) {
      LotDePhotos lot = new LotDePhotos(titre);
      bd.persist(lot);
      Query requête = bd.createNamedQuery("recherche");
      requête.setParameter("titre", titre);
      lot = (LotDePhotos) requête.getSingleResult();
      return Response.ok().header("id", lot.getId()).build();     
   }

   @POST
   @Path("{id}/description={description}")
   @Consumes("image/jpeg")
   public void stocker(@PathParam("id") long id, @PathParam("description") String description, InputStream flux) throws Exception {     
      byte[] octets = lireOctets(flux);
      stocker(id, description, octets);
   }     

   @PUT
   @Path("{id}/titre={titre}")
   public void changeTitre(@PathParam("id") long id, @PathParam("titre") String titre) {
      LotDePhotos lot = bd.find(LotDePhotos.class, id);
      lot.setTitre(titre);
      bd.merge(lot);
   } 
     
   @GET
   @Path("{nomFichier}")
   @Produces("image/jpeg")
   public InputStream restituer(@PathParam("nomFichier") String nom) throws FileNotFoundException {
      return new FileInputStream(répertoire+nom);
   }   
   
   @GET
   @Produces("application/json")
   public List<LotDePhotos> getListeDesLots() {
      return bd.createNamedQuery("toutLesLots").getResultList();
   }
   
   @DELETE
   @Path("{id}")
   public void supprimeLot(@PathParam("id") long id) {
      LotDePhotos lot = bd.find(LotDePhotos.class, id);
      for (Photo photo : lot.getPhotos()) new File(répertoire+photo.getId()).delete();
      bd.remove(lot);
   }
   
   public LotDePhotos rechercheLot(String titre) {
      Query requête = bd.createNamedQuery("recherche");
      requête.setParameter("titre", titre);
      return (LotDePhotos) requête.getSingleResult();      
   }
   
   public Photo recherchePhoto(String id) { return (Photo) bd.find(Photo.class, id); }
   
   public void modifierTitreLotDePhoto(LotDePhotos lot) { bd.merge(lot); }
   public void modifierDescriptionPhoto(Photo photo) { bd.merge(photo); }
   
   public void supprimePhoto(LotDePhotos lot, Photo photo) {
      lot.getPhotos().remove(photo);
      bd.merge(lot);
      bd.remove(recherchePhoto(photo.getId()));
      new File(répertoire+photo.getId()).delete();
   }
   
   public String getRépertoire() {  return répertoire;  }

   public void stocker(long id, String description, byte[] octets) throws Exception {     
      Photo photo = new Photo(description);
      FileOutputStream fichier = new FileOutputStream(répertoire+photo.getId());
      fichier.write(octets);
      fichier.close();
      exif(répertoire, photo);
      LotDePhotos lot = bd.find(LotDePhotos.class, id);
      lot.ajoutPhoto(photo);
      bd.merge(lot);
   }        

   private byte[] lireOctets(InputStream stream) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      byte[] buffer = new byte[1024]; int octetsLus = 0;
      do {
         octetsLus = stream.read(buffer);
         if (octetsLus > 0) { baos.write(buffer, 0, octetsLus); }
      } 
      while (octetsLus > -1);
      return baos.toByteArray();
   }  
   
   private void exif(String répertoire, Photo photo) throws Exception {
      Metadata metadata = ImageMetadataReader.readMetadata(new File(répertoire+photo.getId()));
      Directory exif = metadata.getDirectory(GpsDirectory.class);
      boolean EXIF;
      try {
         exif.getDescription(GpsDirectory.TAG_GPS_LATITUDE);
         EXIF = true;
      }
      catch (Exception ex) { EXIF = false; }
      photo.setExif(EXIF);
      if (photo.isExif()) {
         photo.setLatitude(toDouble(exif.getDescription(GpsDirectory.TAG_GPS_LATITUDE)));
         photo.setLongitude(toDouble(exif.getDescription(GpsDirectory.TAG_GPS_LONGITUDE)));
         photo.setJour(date(exif.getDescription(GpsDirectory.TAG_GPS_DATE_STAMP)));
      }
   }
   
   private double toDouble(String localisation) {
      String[] degrés = localisation.split("°");
      double valeur = Integer.parseInt(degrés[0]);
      String[] minutes = degrés[1].split("'");
      valeur += Integer.parseInt(minutes[0]) / (double)60;
      String[] secondes = minutes[1].split("\"");
      valeur += Double.parseDouble(secondes[0]) / 3600;
      return valeur;
   }
   
   private Date date(String date) {
      String[] séparation = date.split(":");
      int année = Integer.parseInt(séparation[0]);
      int mois = Integer.parseInt(séparation[1]);
      int jour =  Integer.parseInt(séparation[2]);
      Calendar calendrier = new GregorianCalendar(année, mois-1, jour);
      return calendrier.getTime();
   }   
}

package entité;

import java.io.Serializable;
import java.util.*;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
@Entity
@NamedQueries({
   @NamedQuery(name="recherche", query="SELECT lot FROM LotDePhotos lot WHERE lot.titre = :titre"),
   @NamedQuery(name="toutLesLots", query="SELECT lot FROM LotDePhotos lot")
})
public class LotDePhotos implements Serializable {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private long id;
   private String titre;
   @JoinColumn
   @OneToMany(fetch= FetchType.EAGER, cascade= CascadeType.ALL)
   private List<Photo> photos = new ArrayList<Photo>();

   public LotDePhotos() { }
   public LotDePhotos(String titre) {  this.titre = titre;  }

   public long getId() {  return id;   }

   public String getTitre() { return titre;  }
   public void setTitre(String titre) {  this.titre = titre;  }

   public List<Photo> getPhotos() { return photos;  }
   public void ajoutPhoto(Photo photo) { photos.add(photo); }

   @Override
   public String toString() { return titre; } 
}

package entité;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
@Entity
public class Photo implements Serializable {
   @Id
   private String id;
   private String description;
   private boolean exif;
   private double longitude;
   private double latitude;
   @Temporal(javax.persistence.TemporalType.DATE)
   private Date jour;

   public Photo() {  id = System.currentTimeMillis()+".jpg"; }

   public Photo(String description) {
      id = System.currentTimeMillis()+".jpg"; 
      this.description = description;
   }

   public String getId() { return id;  }

   public String getDescription() { return description;  }
   public void setDescription(String description) {  this.description = description;   }

   public Date getJour() {  return jour;  }
   public void setJour(Date jour) {  this.jour = jour;  }

   public double getLatitude() {  return latitude;  }
   public void setLatitude(double latitude) {  this.latitude = latitude;  }
   
   public boolean isExif() { return exif;  }
   public void setExif(boolean localisation) {  this.exif = localisation;  }

   public double getLongitude() { return longitude;  }
   public void setLongitude(double longitude) {  this.longitude = longitude;  }

   @Override
   public String toString() { return description;  }
}

Ce type de sécurité est utilisée avec l'interface d'administration de GlassFish accessible à l'adresse URL suivante http://localhost:4848/. Je profite de l'occasion pour générer un nouveau realm qui sera utilisé uniquement par ce service Web. Les captures d'écran ci-dessous vous montre l'ensemble des enchaînements.

package service;

import java.io.*;
import javax.annotation.PostConstruct;
import javax.ws.rs.*;

@Path("/")
public class Archivage {
   private final String répertoire = "ArchivagePhotos/";
   
   @PostConstruct
   private void init() {
      File rep = new File(répertoire);
      if (!rep.exists()) rep.mkdir();
   }
   
   @GET  
   @Path("consultation/liste")
   @Produces("application/json")
   public String[] getPhotos() { return new File(répertoire).list();  }
   
   @GET
   @Path("consultation/{nomFichier}")
   @Produces("image/jpeg")
   public InputStream restituer(@PathParam("nomFichier") String nom) throws FileNotFoundException {
      return new FileInputStream(répertoire+nom);
   }  
   
   @POST
   @Path("gestion/{nomFichier}")
   @Consumes("image/jpeg")
   public void stocker(@PathParam("nomFichier") String nom, InputStream flux) throws IOException {     
      byte[] octets = lireOctets(flux);
      FileOutputStream fichier = new FileOutputStream(répertoire+nom);
      fichier.write(octets);
      fichier.close();
   }
   
   @PUT
   @Path("gestion/ancien={ancien}/nouveau={nouveau}")
   public void changerNomPhoto(@PathParam("ancien") String ancien, @PathParam("nouveau") String nouveau) {
      File rep = new File(répertoire);
      File ancienFichier = new File(rep+"/"+ancien);
      File nouveauFichier = new File(rep+"/"+nouveau);
      ancienFichier.renameTo(nouveauFichier);
      System.out.println(ancienFichier.getPath());
      System.out.println(nouveauFichier.getPath());
   }
   
   @DELETE
   @Path("gestion/{nomFichier}")
   public void supprimer(@PathParam("nomFichier") String nom) {
      new File(répertoire+nom).delete();
   }   
  
   private byte[] lireOctets(InputStream stream) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      byte[] buffer = new byte[1024]; int octetsLus = 0;
      do {
         octetsLus = stream.read(buffer);
         if (octetsLus > 0) { baos.write(buffer, 0, octetsLus); }
      } 
      while (octetsLus > -1);
      return baos.toByteArray();
   }   
}

<?xml version="1.0" encoding="UTF-8"?>
<sun-web-app error-url="">
   <context-root>/Photos</context-root>
   
   <security-role-mapping>
      <role-name>gestion</role-name>
      <group-name>creation</group-name>
      <group-name>modification</group-name>
   </security-role-mapping>
   
   <security-role-mapping>
      <role-name>recuperer</role-name>
      <group-name>consultation</group-name>
   </security-role-mapping>   
   
   <security-role-mapping>
      <role-name>supprimer</role-name>
      <principal-name>manu</principal-name>
   </security-role-mapping>   
</sun-web-app>

• Quand nous avons créé photos-realm, nous avons défini un certain nombre d'utilisateurs associés à un ensemble de groupes, respectivement, pour notre exemple, les utilisateurs manu, jeanne et martin avec les groupes consultation, creation, modification et suppression.
• Cette notion de groupe est souvent associée à la notion de rôle. Toutefois, il est possible de faire la distinction pour une application donnée. C'est d'ailleurs souvent le concept qui est retenu dans le système de sécurité des serveurs d'applications implémentant Java EE.
• C'est dans cette démarche que le descripteur de déploiement spécifique au serveur glassfish-web.xml est conçu. Il définit les rôles attendus à cette application Web et les associent à des utilisateurs ou des groupes d'utilisateurs.
• Ainsi, dans notre exemple, nous devons prendre en compte trois rôles spécifiques, gestion, recuperer et supprimer.
• Puisque nous avons trois cas particulier, nous devons donc proposer trois balises <security-role-mapping> qui vont réaliser le mapping entre les rôles de l'application définis par les balises <role-name> et les utilisateurs ou les groupes au travers respectivement des balises <principal-name> et <group-name>.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <servlet>
        <servlet-name>ServletAdaptor</servlet-name>
        <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>ServletAdaptor</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    
    <security-constraint>
       <web-resource-collection>
          <web-resource-name>Gestion des photos</web-resource-name>
          <url-pattern>/gestion/*</url-pattern>
          <http-method>POST</http-method>
          <http-method>PUT</http-method>
       </web-resource-collection>
       <auth-constraint>
          <role-name>gestion</role-name>
       </auth-constraint>
    </security-constraint> 

    <security-constraint>
       <web-resource-collection>
          <web-resource-name>Suppression de photos</web-resource-name>
          <url-pattern>/gestion/*</url-pattern>
          <http-method>DELETE</http-method>
       </web-resource-collection>
       <auth-constraint>
          <role-name>supprimer</role-name>
       </auth-constraint>
    </security-constraint> 

    <security-constraint>
       <web-resource-collection>
          <web-resource-name>Récupération de photo</web-resource-name>
          <url-pattern>/consultation/*</url-pattern>
          <http-method>GET</http-method>
       </web-resource-collection>
       <auth-constraint>
          <role-name>recuperer</role-name>
       </auth-constraint>
    </security-constraint> 
    
    <security-role>
       <role-name>gestion</role-name>
       <role-name>recuperer</role-name>
       <role-name>supprimer</role-name>
    </security-role>    

    <login-config>
       <auth-method>BASIC</auth-method>
       <realm-name>photos-realm</realm-name>
    </login-config>
</web-app>

• Ainsi, à l'aide de la balise <login-config>, nous pouvons spécifier le realm à prendre en compte avec la balise <realm-name> et de préciser le type d'authentification attendu à l'aide de la balise <auth-method>, ici le mode basique.
• Nous définissons ensuite tous les rôles à prendre en compte au travers de la balise <security-role> à l'intérieur de laquelle va se trouver l'ensemble des balises <role-name>.
• La grosse partie se situe dans la définissions des contraintes de sécurité associées à chaque rôle spécifié, au travers de la balise <security-constraint>. A l'intérieur de cette balise se trouvent un certain nombre d'autres balises qui vont nous permettre de régler précisément les filtres d'utilisation pour chacun de ces rôles.
• <web-resource-collection> : cette balise permet de décrire les contarintes d'accès aux ressources spécifiées.
• <web-resource-name> : cette balise permet de donner un nom au système d'authentification.
• <url-pattern> : cette balise permet de définir, à partir d'une expression régulière, les ressources à protéger. Il doit y avoir zéro ou plusieurs balises <url-pattern> dans une balise <web-ressource-collection>. L'abscence de la balise <url-pattern> indique que la contrainte de sécurité doit s'appliquer à toutes les ressources.
• <http-method> : il est possible de proposer un filtre sur le choix des méthodes HTTP. Là aussi, cette balise est optionnelle et nous pouvons en avoir plusieurs.
• <auth-constraint> : cette balise contient zéro ou plusieurs balises <role-name> afin de préciser le ou les rôles ayant accès aux ressources.
• <role-name> : cette balise permet de définir le nom du rôle ayant accès aux ressources sécurisées.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.photos"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Stockage photos" >
        <activity android:name="ArchivagePhotos" android:label="Stocker vos photos" android:screenOrientation="portrait">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="ChoixServeur" android:label="Choix du serveur" android:theme="@android:style/Theme.Dialog" /> 
    </application>
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   android:padding="3dp">
   <RelativeLayout
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:padding="3dp">
      <Button
         android:id="@+id/ok"
         android:layout_alignParentRight="true"
         android:layout_width="wrap_content" 
         android:layout_height="wrap_content" 
         android:text="OK" 
         android:onClick="ok"/>              
      <EditText
         android:layout_toLeftOf="@id/ok"
         android:id="@+id/adresse"
         android:layout_width="fill_parent" 
         android:layout_height="wrap_content" 
         android:hint="Adresse IP" />                   
   </RelativeLayout>
   <EditText
      android:id="@+id/utilisateur"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="Utilisateur" />       
   <EditText
      android:id="@+id/motdepasse"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:password="true"
      android:hint="Mot de passe" />             
</LinearLayout>

package fr.btsiris.rest;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.*;
import android.widget.EditText;

public class ChoixServeur extends Activity {
   private EditText adresse;

   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);  
      setContentView(R.layout.adresse);
      adresse = (EditText) findViewById(R.id.adresse);
   }
   
   public void ok(View vue) {
      Intent intent = new Intent();
      intent.putExtra("adresse", adresse.getText().toString());
      setResult(RESULT_OK, intent);
      finish();      
   }
}

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:background="#008800"
   android:padding="3dp">
    <EditText
       android:id="@+id/description"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:hint="Description de la photo"
       android:layout_alignParentBottom="true"/> 
    <LinearLayout 
       android:id="@+id/boutons"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content"
       android:layout_above="@id/description">   
       <Button 
            android:layout_width="0dp" 
            android:layout_height="wrap_content" 
            android:layout_weight="1"
            android:text="Photographier" 
            android:onClick="photographier" /> 
       <Button 
            android:layout_width="0dp" 
            android:layout_weight="1"
            android:layout_height="wrap_content" 
            android:text="Envoyer" 
            android:onClick="envoyer" />             
    </LinearLayout>
    <ImageView
       android:id="@+id/image"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent"
       android:padding="10dp"
       android:layout_above="@id/boutons" />
</RelativeLayout>

package fr.btsiris.photos;

import android.app.Activity;
import android.content.Intent;
import android.graphics.*;
import android.net.Uri;
import android.os.*;
import android.provider.MediaStore;
import android.view.View;
import android.widget.*;
import java.io.*;
import org.apache.http.auth.*;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.FileEntity;
import org.apache.http.impl.client.DefaultHttpClient;

public class ArchivagePhotos extends Activity {
   private EditText description;
   private ImageView image;
   private Uri fichierUri;
   private String adresse, utilisateur, motdepasse;
   private final int RECHERCHE_ADRESSE = 1;
   private final int PHOTOGRAPHIER = 2;
   
   @Override
   public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        description = (EditText) findViewById(R.id.description);
        image = (ImageView) findViewById(R.id.image);
        startActivityForResult(new Intent(this, ChoixServeur.class), RECHERCHE_ADRESSE);
   }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent intention) {
      switch (requestCode) {
         case RECHERCHE_ADRESSE :
            adresse = intention.getStringExtra("adresse");
            utilisateur = intention.getStringExtra("utilisateur");
            motdepasse = intention.getStringExtra("motdepasse");
            break;         
         case PHOTOGRAPHIER :
            File fichier = new File(Environment.getExternalStorageDirectory(), "photo.jpg");
            Bitmap photo = BitmapFactory.decodeFile(fichier.getPath());
            image.setImageBitmap(photo);
            break;
      }
   }

   public void photographier(View vue) {
      Intent intention = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
      File fichier = new File(Environment.getExternalStorageDirectory(), "photo.jpg");
      fichierUri = Uri.fromFile(fichier);
      intention.putExtra(MediaStore.EXTRA_OUTPUT, fichierUri);
      startActivityForResult(intention, PHOTOGRAPHIER);
   }   
   
   public void envoyer(View vue) throws IOException {
      DefaultHttpClient client = new DefaultHttpClient();
      client.getCredentialsProvider().setCredentials(
              new AuthScope(adresse, 8080),
              new UsernamePasswordCredentials(utilisateur, motdepasse));
      HttpPost requete = new HttpPost("http://"+adresse+":8080/Photos/gestion/"+description.getText().toString()+".jpg");  
      requete.setEntity(new FileEntity(new File(Environment.getExternalStorageDirectory(), "photo.jpg"), "image/jpeg"));
      client.execute(requete);      
   }
}