TP 4 - JSF/EJB/JPA (gestionnaire de comptes bancaires)

Retour TPs

  1. Introduction
  2. Création d'une base de donnée "Banque"
  3. Écriture d'une entité CompteBancaire
  4. Écriture d'un EJB session façade, GestionnaireDeCompteBancaire, et d'un EJB singleton Init
  5. Écriture des pages JSF et des backing beans associés
    1. Configuration
    2. Template
    3. Page qui liste tous les comptes
    4. Page index.xhtml et test de l'application
    5. Mise en forme de la dataTable
    6. Autres pages et fonctionnalités : transferts entre comptes, ajout d'un nouveau compte, ajouter ou retirer de l'argent sur un compte, supprimer un compte, modifier le nom d'un possesseur de compte
  6. Pour ceux qui veulent aller encore plus loin : demande de confirmation pour suppression, transferts entre comptes avec Ajax, lazy loading, utilisation d'une exception, portée "flot", menus PrimeFaces

Introduction

Dans ce TP vous allez écrire une application de gestion de comptes bancaires.

Contrairement au TP 1 vous ne partirez pas de tables pré-existantes. Vous écrirez une entité CompteBancaire et la table correspondante sera générée automatiquement à partir de l'entité. Vous écrirez un EJB session bean GestionnaireDeCompteBancaire pour gérer les comptes bancaires. Le TP comporte également l'écriture de pages JSF et de backing beans pour accèder à ces comptes, déposer ou retirer de l'argent, transférer de l'argent d'un compte bancaire à un autre, chercher des comptes...

Ce TP est long. Il vous faudra le terminer seul(e) si vous n'avez pas pu le faire pendant les séances du cours, car le TP suivant est la suite de ce TP.

Ressources

Support sur JPA distribué pour ce cours.

Rappel : si vous avez des erreurs curieuses, faites un "Clean and Build" du projet avant de lancer son exécution.

Création d'une base de donnée "banque"

Vous travaillerez sur une nouvelle base de données !

Créez une nouvelle base de données "banque" en utilisant Workbench de MySQL comme pour la création de la base de données "customer".

Lancez le workbench de MySQL (menu Windows >MySQL > MySQL Workbench).

Dans le workbench, menu File > New Query Tab.

Dans l'onglet créé, tapez
create database customer;

Lancez la commande en cliquant sur l'icône "Execute the selected portion of the script, or everything is there is no selection". La zone Output du bas devrez vous confirmer que tout s'est bien passé.

Vous pouvez sortir de Workbench.

Vous devriez maintenant voir cette nouvelle base depuis NetBeans, avec la même entrée que pour la base customer (dans la fenêtre Services), en ouvrant la sous-entrée "Other database" (éventuellement après un refresh de l'entrée par clic droit et Refresh).

Les tables de cette base vont êtres créées à partir des classes entités que vous allez écrire.

Écriture d'une entité CompteBancaire

Créez un nouveau projet comme dans les TPs précédents. Donnez-lui un nom, par exemple "TPBanque". Donnez bien Payara comme serveur.

Rappel : pour accélérer les prochains démarrages du serveur d'application, vous ferez un Undeploy des précédents TPs dans l'entrée Applications du serveur (onglet Services) lorsque le serveur sera démarré.

Au lieu de créer une entité à partir d'une table de la base de données, vous ferez une simple création d'entité : clic droit sur le projet ejb TPBanque-ejb, choix New > "Entity Class..." (si "Entity Class" n'apparait pas, "Other..." > Persistence > "Entity Class").
Donnez-lui le nom CompteBancaire, et spécifiez un paquetage, entities par exemple.
Dans les copies d'écran ci-dessous ne tenez pas compte des noms de projet, nom de base de données ou d'unité de persistance qui pourraient être différents dans votre propre projet.

Nouvelle entité

Dans le code source de l'entité, vérifiez qu'une propriété est le numéro d'identification (la clé primaire, déclaré par l'annotation @Id), et qu'elle sera générée automatiquement par le SGBD (annotation @GeneratedValue(strategy=GenerationType.AUTO).

Vous pouvez enlever la méthode setId de l'entité. Il ne faut pas modifier la clé d'une entité. JPA accédera aux champs de l'entité par ses champs et pas par ses propriétés (si vous ne voyez pas pourquoi, relisez le cours).

Un fichier persistence.xml (configuration pour JPA) a été créé. Vous pouvez le voir en ouvrant l'entrée "Other Sources" du projet ; il est placé sous META-INF. Vous allez le modifier par la suite. Pour voir sa position dans l'arborescence des fichiers, clic sur l'onglet Files en haut ; il est placé dans le répertoire src/main/resources selon les recommandations pour un projet Maven. Revenez ensuite à l'onglet Projects.

Modifier l'entité CompteBancaire afin que chaque compte bancaire possède :

Pour faire afficher ces valeurs dans les pages JSF il faut créer des propriétés avec getter et setter. Pour cela vous pouvez utiliser le menu contextuel (clic droit dans le code de l'entité) "Insert Code... > Add Property" pour générer en même temps une variable d'instance, un getter et un setter. Si vous utilisez ce menu, réorganisez le code pour mettre les variables d'instance nom et solde au début de la classe, juste après la variable d'instance "id". Vous pouvez aussi commencer par écrire les variables d'instance pour le nom et le solde et ensuite utiliser ajouter les getter et les setter : Alt-Insert et "Getter and Setter...".

Ajouter des méthodes pour retirer et ajouter de l'argent et pour consulter le solde, ainsi qu'un constructeur prenant en paramètre le nom du propriétaire et le solde initial

Pour le moment on fait simple : si on retire plus d'argent que le solde, le solde passe à 0. Dans la suite du TP ette générosité sera tempérée en ajoutant du code dans l'application pour ne valider que les retraits qui ne dépassent pas le solde (pour le transfert entre 2 comptes et pour le mouvement sur un compte) et on reviendra aussi dessus plus tard dans la partie optionnelle de ce TP.

public CompteBancaire(String nom, int solde) {  
  this.nom = nom;  
  this.solde = solde;  
}  
                  
public void deposer(int montant) {  
  solde += montant;  
}  
                  
public void retirer(int montant) {  
  if (montant < solde) {  
    solde -= montant;  
  } else {
    solde = 0;
  }  
}

Si vous connaissez bien le cours sur JPA, vous savez que vous devez aussi ajouter un autre constructeur... N'oubliez pas de le faire.

Ce n'est pas grave s'il n'y a pas de table pour les comptes bancaires, vous allez bientôt modifier le fichier persistence.xml pour que le serveur la crée automatiquement lors du déploiement de l'application, dès qu'un EntityManager sera ajouté au code de l'application.

Écriture d'un EJB session stateless GestionnaireCompte et d'un EJB singleton Init

Vous allez maintenant écrire un EJB session GestionnaireCompte (sous-paquetage ejb du paquetage de base du projet) pour gérer les comptes bancaires dans la base de données. Ce sera un EJB stateless.

Créez l'EJB : clic droit sur le sous-projet EJB, New > Session Bean comme pour le TP 1.

Déclaration de la source de données

Cet EJB va utiliser une base de données pour conserver les informations sur les comptes bancaires. Il ne connait pas la base de données par son nom dans le SGBD mais plutôt par un nom JNDI de source de données (le nom qui va remplacer le nom actuellement dans persistence.xml), qui sera conservé sur le serveur d'application. Pour cela vous allez annoter la classe de l'EJB avec une déclaration de la source de données.

banque est le nom de la base de données que vous avez créée au début de ce TP. Vous retrouvez les propriétés non standards pour @DataSourceDefinition que vous avez utilisées lors de l'installation de l'environnement pour la définition du pool de connexions associé à MySQL ; n'oubliez de modifier le nom de l'utilisateur (user ; sans doute root) et le mot de passe (password) de MySQL :

@DataSourceDefinition (
    className="com.mysql.cj.jdbc.MysqlDataSource",
    name="java:app/jdbc/banque",
    serverName="localhost",
    portNumber=3306,
    user="votre nom",              // nom et
    password="votre mot de passe", // mot de passe que vous avez donnés lors de la création de la base de données
    databaseName="banque",
    properties= {
        "characterEncoding=UTF-8", 
        "nullCatalogMeansCurrent=true",
        "nullNamePatternMatchesAll=false",
        "serverTimezone=UTC",
        "useInformationSchema=true",
        "useSSL=false",
        "useUnicode=true",
        "zeroDateTimeBehavior=CONVERT_TO_NULL",
        "allowPublicKeyRetrieval=true"
    }
)
@Stateless
public class GestionnaireCompte {

Remarque : Lorsque l'application est déployée sur le serveur d'application, la base de données "banque" est associée sur le serveur d'application (Payara) au nom JNDI "java:app/jdbc/banque". La portée de ce nom JNDI sera l'application (java:app) et donc tout code Java de l'application, qui fera référence à ce nom JNDI désignera la base de données "banque". Cette annotation ne doit apparaître qu'une seule fois dans l'application pour chaque source de données. La base de données peut être alors utilisée pour tous les EJB par l'intermédiaire de l'unité de persistance définie dans persistence.xml.

Fichier persistence.xml

Maintenant que la source de données a été définie, il est temps d'aller modifier le fichier persistence.xml pour qu'il référence cette source de données.

Faites afficher le fichier persistence.xml (entrée "Other Sources" > META-INF du projet). Comme pour le TP 1, n'utilisez pas la vue "Design" qui ne fonctionne pas (au moment de l'écriture de ces lignes).

Commencez par changer le nom de l'unité de persistence pour lui donner un nom plus adapté, par exemple "banquePU".

Enlevez la balise <class> qui est inutile car il n'y aura qu'une seule unité de persistance et donc toutes les entités seront gérées par elle.

Dans une balise <jta-data-source>, donnez la valeur de l'attribut name de l'annotation @DataSourceDefinition ci-dessus : <jta-data-source>java:app/jdbc/banque</jta-data-source>. Il faudra faire un "deploy" du projet pour que le serveur d'application prenne en compte cette modification d'un fichier de configuration.

Vous allez ajouter une propriété standard pour que les tables de la base de données soient supprimées et recréées à chaque déploiement de l'application :

<properties>
  <property name="javax.persistence.schema-generation.database.action" value="drop-and-create"/>
</properties>
Cette option est utile au début du développement pour faire des tests mais il faudra évidemment la modifier par la suite. Vous pourrez passer en mode "create" lorsque les structures des tables seront fixées, pour ne pas perdre toutes les données déjà enregistrées dans la base de données, et il faudra passer en mode "none" lorsque toutes les tables auront été créées.

Code de l'EJB

Cet EJB va proposer pour le moment deux fonctionnalités :

Pour cela, il faut commencer par injecter un EntityManager. Vous pouvez vous aider de ce qui a été fait lors du TP 1.

Dès l'ajout du code pour injecter l'EntityManager, un déploiement du projet dans le serveur d'application (lancez un Run du projet, par exemple) suffit à créer la table pour les comptes bancaires dans la base de données (le serveur d'application doit évidemment être démarré). Vérifiez-le. Une autre table SEQUENCE est aussi créée ; elle servira à fournir des clés primaires lors des insertions de nouvelles lignes dans les tables.

Pour la méthode creerCompte il suffit de modifier la méthode persist en changeant son nom et le type du paramètre.

Pour écrire la méthode qui retourne tous les comptes vous pouvez ajouter une requête nommée à l'entité (inspirez-vous des entités du TP 1) ou donner le code de la requête directement dans l'EJB. Inspirez-vous des EJB session du TP 1 pour l'écriture de la méthode. Encore mieux : utilisez un TypedQuery<T> à la place d'un Query pour faire vérifier les types par le compilateur Java.

Singleton Init

Ajoutez un EJB session singleton Init (voir cours sur les EJB) pour créer 4 comptes au démarrage de l'application si la table des comptes est vide. Clic droit sur le module "EJB" et "New > Session Bean..." ; il y a une option pour un EJB singleton.

Les 4 comptes à créer : John Lennon, 150000 ; Paul McCartney, 950000 ; Ringo Starr, 20000 ; Georges Harrisson, 100000.

Un peu d'aide pour ce singleton ?

Passez en mode "create" à la place de "drop and create" dans persistence.xml pour tester cette initialisation en relançant plusieurs fois l'exécution du projet. Il ne doit y avoir que 4 comptes après chaque exécution.

Écriture des pages JSF et des backing beans associés

Configuration

Allez voir le fichier web.xml dans "Configuration Files". Comme pour le TP 1, modifiez-le pour mettre index.xhtml comme page "welcome".

Ajoutez aussi la classe de configuration de JSF.

Template

En vous inspirant du TP sur les templates écrivez un template avec une barre de titre en haut, un menu à gauche et une page principale au centre (le même type de template que pour le TP 1). Enregistrez-le dans WEB-INF pour plus de sécurité.

Une fois généré par NetBeans, ajoutez-y une nouvelle partie "metadata" avant <h:head> (<ui:insert name="metadata"/>) ; par défaut elle est vide mais les clients du template pourront y mettre une section <metadata>, en particulier pour les paramètres de vue.

N'oubliez pas de remplacer name="./css/default.css" par name="/css/default.css" et de même pour la ligne suivante.

Ce template utilise un fichier externe templates/menu.xhtml qui contient un menu, comme dans le TP sur les templates. Le menu va être rempli dans la suite du TP ; pour le moment ne mettez qu'une liste vide avec la balise <ul> dans menu.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">
<ui:composition xmlns="http://www.w3.org/1999/xhtml"
                xmlns:h="http://xmlns.jcp.org/jsf/html"
                xmlns:ui="http://xmlns.jcp.org/jsf/facelets">
    <ul>
        
    </ul>
</ui:composition>

Page qui liste tous les comptes

Indiquez que vous allez utiliser PrimeFaces. Le plus simple est de modifier directement pom.xml en ajoutant une dépendance :

<dependency>
   <groupId>org.primefaces</groupId>
   <artifactId>primefaces</artifactId>
   <version>7.0</version>
</dependency>

Indiquez la dernière version de PrimeFaces, 7.0 à la date de l'écriture de ces lignes (voir comment trouver le numéro de la dernière version dans le TP 1).

Vous allez commencer par écrire une page qui affiche la liste de tous les comptes dans une table. Vous utiliserez une table PrimeFaces. La page doit utiliser le template de présentation que vous venez de créer. Voici comment faire :

  1. Rappel du TP 1 : commencez par écrire un backing bean GestionComptesBean (New > "JSF CDI Bean") de portée view (la classe implémentera donc Serializable), avec une méthode getAllComptes() qui retourne la liste de tous les comptes (ce qui crée une propriété "read only" allComptes). Dans le code, injectez l'EJB GestionnaireCompte et utilisez-le pour récupérer la liste de tous les comptes.
  2. Comme dans le TP sur les templates, créez ensuite la page JSF qui va lister tous les comptes, comme page cliente du template (New > "Facelets Template Client"). Pas de section metadata pour cette page.
  3. Ensuite, comme dans le TP 1, générez dans la section "content" de cette page la table PrimeFaces qui va lister tous les comptes en utilisant la palette de NetBeans. Cette fois-ci indiquez tout de suite que vous voulez une table PrimeFaces :

Ajoutez un lien vers cette page dans le fichier des menus, avec <h:link> comme pour le TP sur les templates.

IMPORTANT : dans toutes vos pages il faut ajouter les zones d'affichage de message. Ajoutez donc <h:messages/> juste après le formulaire inséré dans la page par NetBeans.

Page index.xhtml et test de l'application

Ajoutez une page index.xhtml, cliente du template (n'oubliez pas, dans ce projet toutes les pages sont clientes du template), qui démarre l'application (modifiez le fichier web.xml).

Testez tout de suite en démarrant l'application ; n'oubliez pas de vérifier que Java DB est bien démarré.

Si vous avez ce message dans l'affichage de la page :
Warning: This page calls for XML namespace http://primefaces.org/ui declared with prefix p but no taglibrary exists for that namespace.
vérifiez que vous avez bien ajouté PrimeFaces au projet (Libraries doit contenir un fichier pour PrimeFaces).

Si vous ne voyez pas ce que vous devriez voir, vérifiez que de code pour le servlet "Faces" n'a pas été ajouté par NetBeans dans web.xml, en particulier un mapping <url-pattern>/faces/*</url-pattern> (ça m'est arrivé une fois mais je n'ai pas réussi à le reproduire...). En ce cas, enlevez les balises <servlet> et <servlet-mapping> qui ont été ajoutées.

Mise en forme de la datatable

On peut améliorer la présentation avec CSS pour cadrer les valeurs à droite ou à gauche, avec JSF pour présenter les nombres.

Réordonnez les colonnes selon votre convenance (dans l'image ci-dessous, l'id a été placé en premier).

Puisque vous allez utiliser PrimeFaces dans votre projet, ça serait bon de consulter la documentation, en particulier pour améliorer la présentation des tables. Etudiez la présentation ci-dessous. Remarquez la présentation des nombres (le rectangle rouge ne fait pas partie de la présentation), le cadrage à droite de leur colonne, la largeur des colonnes et la largeur de la table (elle ne couvre pas toute la largeur) :

Datatable formatée

Si vous avez le temps, cherchez un peu, mais il est plus important de terminer ce TP et le TP suivant. Je vous conseille donc d'étudier directement cette correction.

Autres pages et fonctionnalités

Implémentez les fonctionnalités suivantes (vous pouvez vous inspirer du TP 1 pour certaines des fonctionnalités).

Bien entendu, vous utiliserez un ou plusieurs backing beans et vous ajouterez dans l'EJB session GestionnaireComptes les méthodes nécessaires. Choisissez bien la portée de chaque backing bean pour la limiter au maximum.

N'oubliez pas d'utiliser le modèle PRG pour éviter les soumissions multiples de formulaire. Utilisez une requête POST pour les requêtes qui modifient le serveur et une requête GET sinon.

Options du menu

Parmi les options du menu sur la gauche du template on trouvera les fonctionnalités suivantes :

    1. Transfert d'argent d'un compte à l'autre.
      Vous allez créez une page JSF, cliente du template (n'oubliez pas...) pour transférer un certain montant d'un compte à un autre, avec un backing bean associé.
      Mais avant il faut bien réfléchir à la façon dont va se faire le transfert. En effet, un transfert ne peut se faire "à moitié" : on ne peut retirer l'argent de la source, enregistrer le retrait dans la base de données et ensuite ne pas pouvoir transférer l'argent dans la destination. Le transfert doit se faire dans une seule transaction. Comment allez-vous faire ? Revoyez le cours sur les transactions dans les EJB. Aide.

      Après avoir ajouté une méthode pour le transfert dans l'EJB, créez la page cliente du template. Décochez les sections "metadata" (ne sera pas utilisé pour cette page) et "left" du template (le code ne change pas par rapport au template, le menu est inséré dans cette section).
      La section "content" de la page affiche un formulaire dans lequel l'utilisateur entre les clés primaires du compte source, du compte destination, puis la somme à transférer. Ces informations sont enregistrées dans le backing bean de la page (il faut le créer) quand l'utilisateur soumet le formulaire en cliquant sur un bouton (<h:commandButton>).
      Comme il faudra récupérer les comptes à partir des id saisis par l'utilisateur, commencez par ajouter une méthode pour cela dans l'EJB qui gère les comptes (utilisez la méthode find de EntityManager) ; vous utiliserez cette méthode dans le backing bean de cette page.
      En résumé, ce backing bean aura la tâche d'enregistrer dans ses propriétés les informations saisies par l'utilisateur et de lancer le transfert (avec la méthode exécutée au moment de la soumission du formulaire).
      Quelle portée aura ce backing bean ? Si vous n'êtes pas sûr, commencez par la portée request ; si ça ne marche pas, vous élargissez la portée.
      Après la transfert, la liste de tous les comptes est affichée (rappel : la prochaine page à afficher est indiquée par la valeur retour de la méthode action exécutée à la soumission du formulaire).
      Dans la page prévoyez les emplacements pour l'affichage des messages d'erreur (<f:message>). Par exemple si un id tapé par l'utilisateur ne correspond à aucun compte, ou si l'utilisateur a oublié de donner un id ou le montant du transfert, ou si le solde est insuffisant dans le compte source.
      Pour le contenu de la page, le plus simple est d'utiliser un composant <h:panelGrid> à 3 colonnes : une pour le label, une pour la zone de saisie et une 3ème pour les messages d'erreur éventuels. Il faut aussi donner un id au composant <form>. C'est utile pour retrouver plus facilement les id "client" dans la page HTML ; cet id peut se lire dans le code source de la page HTML (voir fin du support de cours sur JSF).
      Un exemple de grid à 3 colonnes pour cette page de transfert      . Il vous reste juste à ajouter le code pour l'id de destination et le montant et à écrire le backing bean (nommé transfert dans cet exemple).
      Ajouter un lien dans le menu vers la page que vous venez de créer.

      2. Ensuite procédez par étape :
      1. Commencez par faire marcher un transfert en donnant des bonnes valeurs pour les id et le montant et testez.

        Dans les étapes suivantes vous allez gérer les erreurs éventuelles. A chaque étape testez pour voir si les bons messages d'erreur sont affichés.
      2. Les cas les plus simples sont gérés par JSF. Par exemple lorsque le montant ou une des clés primaires n'est pas un nombre (Remarque : si les messages standards d'erreur ne vous conviennent pas, vous pouvez les modifier ; si vous êtes en avance, relisez la fin du cours JSF pour savoir comment faire, sinon passez à la suite).
      3. Ensuite ajoutez la gestion des erreurs qui ne sont pas prises en compte automatiquement par JSF : cas où une clé primaire n'existe pas et cas où le solde de la source est insuffisant. La fin de cours JSF explique comment ajouter un message d'erreur qui sera affiché dans les zones d'affichage des erreurs. Les applications JSF comportent souvent une classe qui contient des méthodes utilitaires pour générer des messages (d'erreur ou de succès), ou pour d'autres tâches utiles. Voici un exemple d'une telle classe que vous pouvez rajouter dans votre application. Aide pour coder les messages d'erreur et de succès.
        Arrangez-vous pour que tous les messages d'erreur soient affichés et pas seulement le premier (par exemple si les 2 id ne correspondent pas à des comptes existants).
      4. Messages de succès.
        Important pour l'ergonomie : pour tout traitement qu'il a lancé, l'utilisateur doit savoir si tout s'est bien passé ou non. Le plus souvent le traitement doit être suivi d'un message d'erreur ou d'un message de succès si tout s'est bien passé.
        Ça serait bien de prévoir aussi une zone de message sous le menu pour les messages de succès. Aide.
        Faites afficher un message de succès dans le cas où le transfert s'est bien déroulé. Le message doit contenir les noms des clients titulaires des comptes et le montant du transfert.
      5. Vérifiez que vous n'avez pas de double soumission du formulaire si vous rechargez la page qui liste tous les comptes après avoir fait un transfert. Si vous devez modifier le code pour cela, vérifiez que le message de succès s'affiche toujours.
    2. Ajout d'un nouveau compte bancaire. Vous voulez de l'aide ?

Page qui liste tous les comptes

Ajoutez les fonctionnalités suivantes dans la page JSF qui liste tous les comptes :

    1. Le clic sur le numéro de compte dans la liste des comptes ouvre une page pour ajouter ou retirer de l'argent sur le compte. Lancez une requête GET vers une page qui permet à l'utilisateur de donner les caractéristiques de ce mouvement (retrait ou versement, montant). Utilisez un paramètre de vue pour récupérer l'identificateur du compte dans la page et chargez ensuite les informations sur le compte à partir de cet identificateur (avec une viewAction), comme dans le TP 1. Aide.
    2. Ajoutez une colonne dans la table de la liste des comptes, qui contient une icône sur laquelle on peut cliquer pour supprimer le compte. Vous pouvez choisir l'icône que vous voulez ou utiliser cette icône : icône suppression. Mettez un composant <h:graphicImage> (vous pouvez changer la taille de l'icône affichée avec l'attribut height ou width) dans un composant <h:commandLink> pour lancer une action quand l'utilisateur clique sur l'icône. Ajoutez un attribut title au lien pour faire apparaître une bulle d'aide quand l'utilisateur passe le pointeur de la souris sur l'icône.
      Utilisez une méthode "action" supprimerCompte dans le backing bean de la page qui liste tous les comptes, en passant le compte en paramètre (la valeur de l'attribut var de la table). Aide.
    3. Dans cette nouvelle colonne de la table, ajoutez la possibilité de modifier le nom du possesseur du compte bancaire. On pourrait de la même façon modifier le solde ou toute autre valeur associée à un compte. Lancez une requête GET vers une page qui permet de modifier le nom. Utilisez un paramètre de vue pour récupérer l'id du compte dans la page comme vous avez fait pour le point 1. ci-dessus.
      Choisissez bien la portée du backing bean.
      Vous ne devriez pas avoir besoin d'aide cette fois-ci pour terminer car vous avez déjà vu ce type de situation plusieurs fois...

Correction

Projet NetBeans qui contient les fonctionnalités demandées. Modifiez le nom et le mot de passe dans la définition de la source de données.

Pour ceux qui veulent aller encore plus loin (optionnel)

Avertissement : cette partie optionnelle vous prendra beaucoup de temps. Vous devez donc terminer d'abord tous les TPs suivants avant de la faire.

Ceux qui veulent aller plus loin dans l'étude et la pratique de Jakarta EE, et en particulier de JSF et PrimeFaces, peuvent améliorer l'application avec le fonctionnalités suivantes (qui pourront être utiles quand vous écrirez des projets) :

Correction

Projet NetBeans qui contient les fonctionnalités optionnelles décrites ci-dessus. Modifiez le nom et le mot de passe dans la définition de la source de données.

Dans le prochain TP nous allons utiliser des associations dans JPA pour enregistrer dans la base les opérations bancaires effectuées sur les comptes bancaires (débits, dépôts, transferts, créations des comptes, etc.).

Retour TPs