Création d'un projet de type Entreprise Application








télécharger 247.17 Kb.
titreCréation d'un projet de type Entreprise Application
page1/6
date de publication02.04.2017
taille247.17 Kb.
typeDocumentos
ar.21-bal.com > loi > Documentos
  1   2   3   4   5   6
TP1 2011 EJB 3.1/JPA/JSF2

  1. 1. Introduction

  2. 2. Logiciels utilisés

  3. 3. Création d'un projet de type Entreprise Application

  4. 4. Créations de classes entités à partir d'une base de données existante

  5. 5. Création d'un Stateless Session Bean CustomerManager pour la gestion des clients

  6. 6. Ajout de méthodes métier dans le session bean CustomerManager

  7. 7. Création de la partie front-end web

  8. 8. Ajout du Framework Java Server Faces (JSF2) au projet web

  9. 9. Création d'un Bean Managé en tant que "contrôleur web"

  10. 10. Ajout d'une page JSF pour afficher la liste des clients

  11. 11. Ajout d'une DataTable JSF dans la page

  12. 12. Exécution du projet et premier test

  13. 13. Remplacement de la DataTable par une provenant de la librairie de composants JSF PrimeFaces

    1. 13.1. Ajout de la librairie PrimeFaces dans le projet

    2. 13.2. Modification de la page JSF

  14. 14. Affichage des détails d'un client lorsqu'on clique sur une ligne

    1. 14.1. Ajout d'un lien dans le tableau pour déclencher l'affichage des détails d'un client

    2. 14.2. Ajout d'une page JSF pour afficher les détails d'un client

    3. 14.3. Executez le projet et testez que les détails s'affichent bien

    4. 14.4. Régler l'affichage des DiscountCodes dans le détail d'un client

  15. 15. Ajout de boutons pour la mise à jour et retour à la liste

  16. 16. Problèmes devant encore être réglés :

  17. 17. Correction de ce TP utilisant diverses améliorations vues en cours, et corrigeant la plupart des problèmes évoqués précédemment

  18. 18. Pour la semaine prochaine:

Introduction

Ce TP permet une prise de contact directe et violente avec les technologies EJB 3.1, JPA, et JSF 2.0 dans l'IDE NetBeans. Les cours et TPs suivants expliqueront le détail de ce que vous allez mettre en oeuvre aujourd'hui. Il s'agit d'une adaptation plus ou moins fidèle de l'article paru sur le site developer Zone : http://netbeans.dzone.com/articles/d...-ee-6-app-jsf2.

Voici l'architecture de l'application que vous allez développer :



Logiciels utilisés

Nous allons travailler avec la dernière version de netbeans, la version la plus complète (colonne de droite de : http://netbeans.org/downloads), qui vient avec la dernière version du serveur Java EE6 Glassfish Veillez à avoir un la dernière version du JDK installée sur votre machine. Nous utiliserons également à la fin de ce TP quelques composants JSF2 provenant du site http://www.primefaces.org/

Création d'un projet de type Entreprise Application

L'année dernière nous avions travaillé avec des projets de type "Web" qui incluaient tout dans un seul fichier .war, cette année nous allons aussi voir que l'on peut développer des applications de type "entreprise" qui font une séparation très nette entre les parties "web" et les parties métier/accès aux données d'une application.

Pour créer un projet "entreprise" utilisez le menu File/New Project puis choisissez la catégorie Java EE, et un projet de type "Enterprise Application".



Cliquez ensuite sur le bouton "Next" puis choisissez l'emplacement du projet et son nom. Attention, pas de caractères bizarres dans le chemin ni le nom s'il vous plait, pas de "_" par exemple, pas d'accents, etc. Ceci pour éviter les mauvaises surprises qui peuvent arriver par la suite (hibernate n'aime pas les noms de chemins bizarres, toplink n'aime pas les "_" dans les noms de projets, etc...)

J'ai choisi comme nom de projet TP1CustomerApplication (comme vous voyez : pas d'espace ou de caractère bizarre dans le nom) et j'ai conservé l'endroit où Netbeans place les projets par défaut (là aussi, je préfère un nom de chemin sans espaces...)



Dans la fenêtre suivante, on indique le nom du serveur et la version de java EE que l'on souhaite pour le projet. Prenez les valeurs par défaut, si elles sont différentes de celles ci-dessous, assurez-vous que cela correspond bien à la dernière version de glassfish et à la version 6 de java EE (qui est celle étudiée en cours).

 

Cliquez ensuite sur le bouton "finish", normalement netbeans génère un projet pour votre application. En réalité, une application "enteprise" se compose de trois projets :

  1. un projet précédé par un triangle bleu qui est en fait celui qui réunit les deux autres projets au sein d'un même fichier .ear (enterprise archive), équivalent du .war mais pour les applications enteprises,

  2. Un projet précédé par un grain de café, c'est le projet "métier" qui va contenir la partie métier de l'application ainsi que la partie accès aux données, il est précédé d'un grain de café (un "bean") car il contiendra certainement des "beans", des "composants java" de type "managed beans" "enterprise java beans (EJBs)" ou "entities".

  3. Un projet précédé par une icône en forme de globe terrestre, c'est le projet "web" qui va contenir le front-end web de l'application : les jsps, servlets, pages jsf ou html, les web services, etc.



Créations de classes entités à partir d'une base de données existante

Dans ce projet nous allons utiliser une base de données. Comme nous l'avons vu en cours, on ne manipulera pas des données directement en SQL mais sous forme d'objets particuliers qu'on appelle des "classes entités". Généralement une classe entité correspond à une table, porte le même nom (aux majuscules/minuscules près), et ses attributs correspondent aux colonnes de la table. Les instances de cette classe entité seront des objets correspondant à des lignes dans cette table.

Dans un premier temps nous allons utiliser un wizard de netbeans pour générer une classe entité à partir d'une table.

On va ajouter la classe entité dans le projet "EJBs", celui précédé d'un grain de café. Faire clic droit puis New/Entity Class from Database :



Une fenêtre apparait dans laquelle vous allez indiquer la source de données (le "nom" de la base de données sur laquelle vous allez travailler. Par défaut le jdk vient avec un SGBD qui s'appelle JavaDB (ou "Derby") qui contient une base "sample" dont le nom est "jdbc/sample". Elle contient quelques tables correspondant à un magasin de produits informatiques. Choisissez donc jdbc/sample dans la liste des sources de données :



Normalement dès que vous avez choisi le nom de la base, les tables s'affichent dans la colonne de gauche. Choisissez "CUSTOMER" et cliquez sur le bouton "add", cela va ajouter en fait deux tables : la table CUSTOMER mais aussi la table DISCOUNT_CODE car il existe une jointure entre ces deux tables :



Cliquez sur le bouton "Next". Maintenant on va vous proposer de changer le nom des classes entités correspondants à chacune des tables. Je conseille de laisser tout par défaut, cependant je conseille aussi de faire générer ces classes dans un package "entities" pour mieux structurer le projet :



Cliquez sur le bouton "Next". L'étape suivante propose de modifier les valeurs par défaut pour les types de données correspondant à la relation 1-N entre les deux tables :



Laissez tout par défaut et cliquez sur le bouton Finish. Netbeans va un peu travailler puis vous verrez trois nouvelles choses dans le projet :

  1. Les classes correspondant aux deux tables, dans le package "entities", regardez donc à quoi elles ressemblent...

  2. Un fichier persistence.xml sous "configuration", qui correspond à la définition d'une "persistence unit" par défaut. En réalité la persistence unit est l'objet qui va s'occuper de manipuler les données relationnelles à travers les classes et instances des entités. C'est la persistence unit qui connait la base, qui génère le SQL, qui va syncrhroniser les objets en mémoire et les données dans les tables, etc.

Double cliquez sur le fichier persistence.xml, vous devriez voir un formulaire de configuration (une "vue" sur le fichier xml, en réalité) :



Sans entrer dans les détails, nous voyons ici que :

  1. On autorise pas la création de nouvelles tables ni la suppression (None)

  2. On va utiliser les transactions JTA (Java Transaction API) lors de l'accès aux données,

  3. Cette persistence Unit va gérer les accès BD pour toutes les classes entités du projet.

Création d'un Stateless Session Bean CustomerManager pour la gestion des clients

On va centraliser la gestion des Customers (clients, en français) dans un Stateless Session Bean. De manière classique on crée une "façade" pour les opérations élémentaires sur les clients : création, suppression, recherche, modification.

Faire clic droit New/Session Bean sur le projet EJB (celui précédé par un grain de café) :



Donnez un nom à votre gestionnaire de client, et indiquez que vous le voulez dans le package "sessions" qui contiendra les session beans. On ne va pas préciser d'interface (locale ou remote) pour le moment (on verra plus tard à quoi cela peut servir) :



Ajout de méthodes métier dans le session bean CustomerManager

Double cliquez sur "CustomerManager.java" dans le projet pour voir le source dans l'éditeur. Cliquez ensuite dans le source de la classe, entre les { et } de la classe et faites clic droit/insert code (ou Alt+Insert). Une fenêtre propose alors diverses options, choisissez "add business method" :



Un menu apparait proposant diverses options de génération automatique de code, choisir "business méthod" puis créez une méthode getAllCustomers qui renvoie une collection de Customer. Cette méthode servira à afficher la liste des clients :





Dans le source, ajoutez les imports qui vont bien pour ne plus avoir d'erreurs (un par un: en cliquant sur la petite lampe jaune, ou tous d'un coup: en faisant clic droit/fix imports, ou Alt-Shift-I, ou ⌘-Shift-I pour les Mac). Ajoutez de la même manière une méthode "update" qui prend en paramètre un Customer. Cette méthode servira à mettre à jour un client.



Vous devriez avoir un code source comme celui-ci :

view plainprint?

  1. package session;  

  2.   

  3. import entities.Customer;  

  4. import java.util.Collection;  

  5. import javax.ejb.Stateless;  

  6. import javax.ejb.LocalBean;  

  7.   

  8. @Stateless  

  9. @LocalBean  

  10. public class CustomerManager {  

  11.   

  12.     public List getAllCustomers() {  

  13.         return null;  

  14.     }  

  15.   

  16.     public Customer update(Customer customer) {  

  17.         return null;  

  18.     }  

  19.       

  20. }  

Bien sûr vous auriez pu aussi bien taper les méthodes à la main... C'est juste pour vous montrer quelques trucs avec netbeans...

Maitenant nous allons modifier le contenu de ces méthodes. Les explications sont dans le cours. On va commencer par ajouter un "PersistenceContext" à l'application, c'est une variable qui correspond à la persistence unit et qui va nous servir à envoyer des requêtes, insérer/supprimer des objets ou faire des mises à jour. Faites clic droit dans le source/insert code/Use Entity Manager. Cela va ajouter automatiquement dans le code une variable avec une annotation, et une méthode :

view plainprint?

  1. @PersistenceContext(unitName = "TP1CustomerApplication-ejbPU")  

  2.  private EntityManager em;  

  3.  public void persist(Object object) {  

  4.     em.persist(object);  

  5.  }  

La variable em n'a pas besoin d'être initialisée, en réalité son code d'initialisation va être "injecté" par l'annotation. Regardez le nom "TP1CustomerManager-ejbPU", on le retrouve dans le fichier persistence.xml, en gros, ce que l'on doit comprendre par ces deux lignes :

  1. La variable em correspond à une persistence unit (celle dont le nom est précisé, qui gère la base jdbc/sample),

  2. Je n'ai pas besoin de l'initialiser.

On va maintenant modifier le code des deux méthodes pour qu'elles jouent leur rôle :

view plainprint?

  1. package session;  

  2.   

  3. import entities.Customer;  

  4. import java.util.Collection;  

  5. import javax.ejb.Stateless;  

  6. import javax.ejb.LocalBean;  

  7. import javax.persistence.EntityManager;  

  8. import javax.persistence.PersistenceContext;  

  9.   

  10. @Stateless  

  11. @LocalBean  

  12. public class CustomerManager {  

  13.   

  14.     @PersistenceContext  

  15.     private EntityManager em;  

  16.   

  17.     public List getAllCustomers() {  

  18.         Query query = em.createNamedQuery("Customer.findAll");  

  19.         return query.getResultList();  

  20.     }  

  21.   

  22.     public Customer update(Customer customer) {  

  23.         return em.merge(customer);  

  24.     }  

  25.   

  26.     public void persist(Object object) {  

  27.         em.persist(object);  

  28.     }  

  29. }  

Voilà, on a rempli les deux méthodes avec pour la première un code qui va exécuter une requête JPQL dont le nom est "findAll" et qui est définie dans la classe Customer.java (allez voir, la requête correspond à un select * sur les clients), la seconde, la méthode update indique que l'on souhaite modifier un client dans la table avec les valeurs de celui qui est passé en paramètre. Cela suppose que l'attribut id du client passé en paramètre correspond à une clé primaire dans la table des clients.

Normalement vous devez ajouter un import pour enlever l'erreur de syntaxe sur le type Query. Attention, un piège classique est d'ajouter le mauvais import. Faites clic droit/fix import :



Voilà, on a terminé pour la partie "métier"/EJB dans ce projet. On va passer au front-end web.

Création de la partie front-end web

Dans cette partie on va utiliser le framework MVC de java EE6 qui se base sur l'utilisation de backing beans et de pages JSF2.

Ajout du Framework Java Server Faces (JSF2) au projet web

Faites clic droit/properties sur le projet web (celui proposé par un globe terrestre bleu) et ajoutez le framework Java Server Faces au projet :



Vérifiez bien que JSF 2.0 est bien le choix par défaut (JSF 2.1 convient aussi) puis cliquez OK :



Création d'un Bean Managé en tant que "contrôleur web"

Faites sur le projet web clic droit/new/other et choisissez dans la catégorie "java server faces", "jsf managed bean" :



Ensuite, renseignez le nom de la classe que vous souhaitez ainsi que le package où va se trouver la classe générée (Attention, pas de majuscule dans le nom de package à cause d'un bug de NetBeans):



Si tout va bien vous devriez obtenir une classe CustomerMBean.java dans le package "managedbeans" , et le source devrait être celui-ci :

view plainprint?

  1. package managedbeans;  

  2.   

  3. import javax.inject.Named;  

  4. import javax.enterprise.context.SessionScoped;  

  5. import java.io.Serializable;  

  6.   

  7. @Named(value = "customerMBean")  

  8. @SessionScoped  

  9. public class CustomerMBean implements Serializable {  

  10.   

  11.     public CustomerMBean() {  

  12.     }  

  13. }  

Notez l'annotation @SessionScoped qui indique clairement que les instances de cette classe seront placées dans la session HTTP. Si vous n'avez pas cette annotation, c'est que vous avez dû oublier de la spécifier dans le wizard de génération, ce n'est pas grave, vous pouvez la rajouter à la main ou utiliser la complétion automatique (ctrl-espace). Nous allons maintenant rajouter de la fonctionnalité dans ce bean :

  1. Le préparer pour qu'il puisse communiquer avec le session bean stateless de l'autre projet (celui avec les EJBs) : CustomerManager,

  2. Ajouter un attribut correspondant à un customer dans la session, utile pour afficher dans une page web les détails d'un clients, ou encore lors de la mise à jour d'un client à partir d'un formulaire,

  3. Ajouter des méthodes de contrôle qui seront appelées depuis une page web (une page JSF en fait).

Pour que le bean soit client d'un EJB, faites dans le code clic droit/insert code/call enterprise bean, et sélectionnez l'EJB CustomerManager, ceci devrait insérer dans le source les lignes suivantes :

view plainprint?

  1. @EJB  

  2.   private CustomerManager customerManager;  

Là aussi, l'annotation @EJB injectera le code d'initialisation, vous n'avez pas à faire de "new" (vous ne DEVEZ PAS faire de "new" !) sur des session beans. Voir le cours pour plus de détails sur ce mécanisme.

Maitenant, complétons  le code du bean de manière à ce qu'il ressemble à ceci (on a rajouté des properties et action handlers utilisés par les pages JSF par la suite, vous allez comprendre) :

view plainprint?

  1. package managedbeans;  

  2.   

  3. import entities.Customer;  

  4. import javax.ejb.EJB;  

  5. import javax.inject.Named;  

  6. import javax.enterprise.context.SessionScoped;  

  7. import java.io.Serializable;  

  8. import java.util.List;  

  9. import session.CustomerManager;  

  10.   

  11. @Named(value = "customerMBean")  

  12. @SessionScoped  

  13. public class CustomerMBean implements Serializable {  

  14.   

  15.     @EJB  

  16.     private CustomerManager customerManager;  

  17.     /* Client courant dans la session, utilisé pour afficher ses détails ou 

  18.      * pour faire une mise à jour du client modifié dans la base */  

  19.     private Customer customer;  

  20.   

  21.     public CustomerMBean() {  

  22.     }  

  23.   

  24.     /** 

  25.      * Renvoie la liste des clients pour affichage dans une DataTable 

  26.      * @return 

  27.      */  

  28.     public ListgetCustomers() {  

  29.         return customerManager.getAllCustomers();  

  30.     }  

  31.   

  32.     /** 

  33.      * Renvoie les détails du client courant (celui dans l'attribut customer de 

  34.      * cette classe), qu'on appelle une propriété (property) 

  35.      * @return 

  36.      */  

  37.     public Customer getDetails() {  

  38.         return customer;  

  39.     }  

  40.   

  41.     /** 

  42.      * Action handler - appelé lorsque l'utilisateur sélectionne une ligne dans 

  43.      * la DataTable pour voir les détails 

  44.      * @param customer 

  45.      * @return 

  46.      */  

  47.     public String showDetails(Customer customer) {  

  48.         this.customer = customer;  

  49.         return "CustomerDetails";  

  50.     }  

  51.   

  52.     /** 

  53.      * Action handler - met à jour la base de données en fonction du client 

  54.      * passé en paramètres 

  55.      * @return 

  56.      */  

  57.     public String update() {  

  58.         System.out.println("###UPDATE###");  

  59.         customer = customerManager.update(customer);  

  60.         return "CustomerList";  

  61.     }  

  62.   

  63.     /** 

  64.      * Action handler - renvoie vers la page qui affiche la liste des clients 

  65.      * @return 

  66.      */  

  67.     public String list() {  

  68.         System.out.println("###LIST###");  

  69.         return "CustomerList";  

  70.     }  

  71. }  

Ajout d'une page JSF pour afficher la liste des clients

Pour ajouter une page JSF, faire sur le projet web clic droit/new/other/Java Server Faces et choisir "JSF Page" :

 

Puis faites "next" et renseignez le nom de la page :



Notez que cela ajoute un fichier CustomerList.xhtml dans le projet, à côté de la page index.jsp. Double cliquez pour voir le source. Modifiez le Title pour mettre "Liste des clients", vous pouvez rajouter un titre HTML 
  1   2   3   4   5   6

similaire:

Création d\Instruction ministérielle dgas/2C/dhos/dss/2010/06 du 7 janvier 2010...
«capacité à faire» du porteur de projet de création de pasa qui est visée. Les projets retenus devront être réalisables dès 2011

Création d\Création d’entreprise, auto-entrepreneuriat, reprise

Création d\Création d’entreprise, auto-entrepreneuriat, reprise

Création d\Création d’entreprise, auto-entrepreneuriat, reprise

Création d\Création d’entreprise, auto-entrepreneuriat, reprise

Création d\Résumé L'application des Nouvelles Technologies de l'Information...

Création d\Création de l’activité «BlobsActivity»
«Global». Ce token est stocké sous la forme d’un objet de type «wazserviceAccount»

Création d\Preface™ Système d’aide à la décision pédagogique et opérationnel...

Création d\Projet appli-cr application d'enregistrement et de suivi des comptes-rendus de visite

Création d\I- présentation de l’entreprise et du projet








Tous droits réservés. Copyright © 2016
contacts
ar.21-bal.com