Développement JSF


Une interface WEB pour éditer des tables

le datatable de JSF

Montre comment créer une interface web avc JSF pour visualiser et éditer un tableau de données.

Java fournie de nombreuses API pour développer des applications. Pour le Web nous avons l’approche JSP  /Servlet mais nous avons également une approche orienté composant avec JSF   et nous allons voir que ce n’est pas si compliqué de définir une interface WEB pour visualiser et éditer le contenu d’une table. Dans cet article nous nous contenterons d’utiliser une table mémoire. Dans un article suivant, nous la remplacerons par une table de base de données.


 Présentation

Nous allons utiliser NetBeans avec GlassFish pour réaliser notre exemple. Nous créerons un nouveau projet de type Web Application dans lequel nous ajouterons nos différents fichiers exemple.

Remarque : Vous pourrez suivre les explications dans l’article Présentation de CDI pour voir comment créer une application WEB utilisant CDI  .

 Création d’une page chargée d’afficher le contenu d’une table

Dans notre projet, nous allons d’abord créer une classe Personnel correspondant aux objets à afficher ainsi qu’une classe de service qui sera chargée de créer et gérer une liste de ces objets.

Définition de la classe "Personnel"

Nous ferons au plus simple pour ne pas avoir à coder trop de code. Cette classe ne sera composée que d’un identifiant, d’un nom et d’un prénom.

Définissons une classe Personnel comme suit :

  1. public class Personnel
  2. {
  3.   public Personnel()
  4.   {
  5.   }
  6.  
  7.   public Personnel( int id, String nom, String prenom )
  8.   {
  9.     this.id = id;
  10.     this.nom = nom;
  11.     this.prenom = prenom;
  12.   }
  13.   //get/set, hashCode, equals
  14.   ...
  15.   private Integer id;
  16.   private String nom;
  17.   private String prenom;

Télécharger

Définition de la classe "PersonnelsService"

Nous allons maintenant définir une classe de service dont le but sera de créer en mémoire la liste de personnels que nous devrons afficher dans la page Web.

Voici d’abord le code complet de cette classe.

  1. package exercice2;
  2.  
  3. import java.io.Serializable;
  4. import java.util.ArrayList;
  5. import java.util.HashMap;
  6. import java.util.List;
  7. import java.util.Map;
  8. import javax.annotation.PostConstruct;
  9. import javax.enterprise.context.ApplicationScoped;
  10. import javax.inject.Named;
  11.  
  12. @Named( value = "listePersonnels" )
  13. @ApplicationScoped
  14. public class PersonnelsService implements Serializable
  15. {
  16.   public PersonnelsService()
  17.   {
  18.     personnels = new HashMap<>();
  19.     System.out.println( "TEST: Création PersonnelsService" );
  20.   }
  21.  
  22.   @PostConstruct
  23.   public void init()
  24.   {
  25.     System.out.println( "TEST: PostConstruct PersonnelsService" );
  26.     for ( int i = 0; i < 20; i++ )
  27.     {
  28.       personnels.put( i + 1, new Personnel( i + 1, "LeNom-" + ( i + 1 ), "LePrénom-" + ( i + 1 ) ) );
  29.     }
  30.   }
  31.  
  32.   public Personnel findById( int id )
  33.   {
  34.     return personnels.get( id );
  35.   }
  36.  
  37.   public List< Personnel > findAll()
  38.   {
  39.     List< Personnel > result = new ArrayList<>();
  40.    
  41.     personnels.values().forEach( p -> { result.add( p ); } );
  42.    
  43.     return result;
  44.   }
  45.  
  46.   public void create( Personnel personnel ) throws Exception
  47.   {
  48.     Personnel p = personnels.get( personnel.getId() );
  49.     if ( p == null )
  50.     {
  51.       int max = personnels.keySet().stream().max( Integer::compare ).get();
  52.       personnel.setId( max + 1 );
  53.       System.out.println( "Création personnel n° " + personnel.getId() );
  54.       personnels.put( personnel.getId(), personnel );
  55.     }
  56.     else
  57.     {
  58.       throw new Exception( "Ajout impossible: Tentative de doublon sur la clé." );
  59.     }
  60.   }
  61.  
  62.   public void update( Personnel personnel ) throws Exception
  63.   {
  64.     Personnel p = personnels.get( personnel.getId() );
  65.     if ( p!= null )
  66.     {
  67.       personnels.put( personnel.getId(), personnel );
  68.       System.out.println( "Mise à jour du personnel n° " + personnel.getId() );
  69.     }
  70.     else
  71.     {
  72.       throw new Exception( "Mise à jour impossible: clé non trouvée." );
  73.     }
  74.   }
  75.  
  76.   public void remove( int id ) throws Exception
  77.   {
  78.     Personnel p = personnels.get( id );
  79.     if ( p != null )
  80.     {
  81.       personnels.remove( id );
  82.     }
  83.     else
  84.     {
  85.       throw new Exception("Suppression impossibe: clé non trouvée" );
  86.     }
  87.   }
  88.  
  89.   private final Map< Integer, Personnel > personnels;
  90. }

Télécharger

Voici maintenenant, quelques explications sur cette classe :

  1. @Named( value = "listePersonnels" )
  2. @ApplicationScoped
  3. public class PersonnelsService implements Serializable

Télécharger

Le code précédent défini la classe comme étant un Managed Bean dont la durée de vie est l’application.

  1. private final Map< Integer, Personnel > personnels;

Cette classe possède un attribut de type Map composé d’objets de types Personnel. On utilisera l’identifiant du personnel comme clé de la Map.

  1.   @PostConstruct
  2.   public void init()
  3.   {
  4.     System.out.println( "TEST: PostConstruct PersonnelsService" );
  5.     for ( int i = 0; i < 20; i++ )
  6.     {
  7.       personnels.put( i + 1, new Personnel( i + 1, "LeNom-" + ( i + 1 ), "LePrénom-" + ( i + 1 ) ) );
  8.     }
  9.   }

Télécharger

La méthode init() est appelée dès que l’instance a terminée d’être créée (annotation @PostConstruct). Sont but est de remplir la liste de 20 objets.

Les autres méthodes correspondent aux fonctions de création, mises à jour, suppression et recherche ( fonctions CRUD) d’un personnel dans la liste. J’en ai profité pour utiliser des Streams et lambda, une des nouveautés de Java 8. Par exemple, pour la méthode chargée de renvoyer le contenu de la Map sous forme de List :

  1.  public List< Personnel > findAll()
  2.   {
  3.     List< Personnel > result = new ArrayList<>();
  4.     personnels.values().forEach( p -> { result.add( p ); } );
  5.     return result;
  6.   }

Télécharger

La méthode forEach() exécute pour chaque élément de la Collection, l’expression qui récupère l’élément et l’ajoute dans le ArrayList.

Pour la méthode create, l’initialisation d’un nouvel identifiant s’effectue à partir de la plus grande valeur de clé trouvée. Cette valeur est trouvé par la ligne suivante :

  1. int max = personnels.keySet().stream().max( Integer::compare ).get();

Il aurait été difficile de faire aussi court sans la nouvelle syntaxe de Java 8.

Définition du Managed Bean "PersonnelView"

Nous allons maintenant définir un Managed Bean qui gérera la vue JSF  .

Voici le code de cette classes :

  1. package exercice2;
  2.  
  3. import javax.inject.Named;
  4. import javax.enterprise.context.SessionScoped;
  5. import java.io.Serializable;
  6. import java.util.List;
  7. import javax.inject.Inject;
  8.  
  9. @Named( value = "voirListePersonnelsView" )
  10. @SessionScoped
  11. public class VoirListePersonnelsView implements Serializable
  12. {
  13.   public VoirListePersonnelsView() {}
  14.  
  15.   public List< Personnel > getItems()
  16.   {
  17.     return service.findAll();
  18.   }
  19.          
  20.   @Inject
  21.   private PersonnelsService service;
  22. }

Télécharger

Cette classe est annotée avec une durée de vie Session, elle doit donc être Serializable. Elle utilise PersonnelsService avec l’annotation @Inject. Comme dans un premier temps, nous désirons que visualiser la liste, nous ne définissons qu’une seule méthode, dont le but est de récupérer la liste des personnels.

Définition de la page JSF   d’affichage du tableau

Il ne nous reste plus qu’à définir le fichier JSF. Pour cela, vous choisissez de définir une JSF Page à partir du menu contextuel dans le dossier Web pages. Vous le nommez VoirListePersonnels.xhtml. NetBeans vous créé le squelette de fichier suivant :

  1. ?xml version='1.0' encoding='UTF-8' ?>
  2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3. <html xmlns="http://www.w3.org/1999/xhtml"
  4.      xmlns:h="http://xmlns.jcp.org/jsf/html">
  5.     <h:head>
  6.         <title>Facelet Title</title>
  7.     </h:head>
  8.     <h:body>
  9.         Hello from Facelets
  10.     </h:body>
  11. </html>

Télécharger

Supprimez le texte "Hello from Facelet" et tout en laissant le curseur à cet endroit, appuyez sur les touches Alt + Insert pour afficher le menu suivant :

Sélectionnez l’option JSF Data Table. NetBeans devrait avoir généré le code suivant :

  1. <f:view>
  2.             <h:form>
  3.                 <h:dataTable value="#{}" var="item">
  4.                 </h:dataTable>
  5.             </h:form>
  6.         </f:view>

Télécharger

Il va falloir maintenant compléter l’attribut value="#{}" pour spécifier la liste à visualiser comme suit :

<h:dataTable value="#{voirListePersonnelsView.items}" var="item">

Le paramètre value fait référence à la méthode du bean chargée de renvoyer la liste des éléments à afficher et le paramètre var définie une variable locale item qui correspondra à chaque élément de la liste à afficher. Vous allez maintenant définir les colonnes à afficher.

  1. <h:dataTable value="#{voirListePersonnelsView.items}" var="item">
  2.             <h:column>
  3.               <f:facet name="header">
  4.                 <h:outputText value="n°" />
  5.               </f:facet>
  6.               <h:outputText value="#{item.id}" />
  7.             </h:column>
  8.             <h:column>
  9.               <f:facet name="header">
  10.                 <h:outputText value="Nom" />
  11.               </f:facet>
  12.               <h:outputText value="#{item.nom}" />
  13.             </h:column>
  14.             <h:column>
  15.               <f:facet name="header">
  16.                 <h:outputText value="Prénom" />
  17.               </f:facet>
  18.               <h:outputText value="#{item.prenom}" />
  19.             </h:column>
  20.           </h:dataTable>

Télécharger

Nous venons de définir une colonne par champ à afficher en faisant référence à la variable item définie précédemment.

Si nous exécutons le programme et affichons la page que nous venons de définir, nous obtenons bien l’affichage du contenu de notre table.

Bien sur, cet affichage n’est pas très jolis mais cela peut être corrigé en définissant une feuille de style dans un fichier .css. Un exemple de style sera fourni dans la suite de l’aticle.

Remarque : La présentation générale ne doit en principe, pas être définie directement dans le fichier .xhtml, surtout, si l’on souhaite que tout les tableaux de notre application aient la même présentation : couleurs, police de caractères, etc.


La configuration utilisée dans cet article est un poste Ubuntu 12.4, JDK 8 et Netbeans 8.1 (bundle complet) avec GlassFish 4.1.1.

Article n° 68

Crée par: chris

Créé le: 17 mars 2016

Modifié le: 17 mars 2016

Nombre de visites: 1324

Popularité: 7 %

Popularité absolue: 1

Mots clés de cet article


SPIP

2003-2023 LePpf
Plan du site | | Contact | RSS 2.0 | Sur YouTube

Visiteurs connectés : 0

Nombre moyen de visites quotidiennes sur le site: 195