JavaEE 5 - Exercise - 2009 - FR

Contexte :

Vous êtes un développeur Java sous NetBeans avec pour serveur d’application GlassFish V2. Vous travaillez pour l’entreprise REAPERS & Co.

On vous demande de mettre en place une application à laquelle chaque employé pourra accéder. Le but de cette application est d’apporter un maximum d’informations sur les tournois organisés par la société REAPERS & Co.

Pour cela, il vous est demandé de mettre en place une base de données sous MySQL. Cette base aura pour nom : Twewy.Dans cette base, il vous ait demandé de gérer les éléments suivants :

- On veut avoir des informations sur les tournois : nom du tournoi, semaine du tournoi.- On veut avoir une liste définie des maîtres de jeux : nom du maître de jeu, puissance du

maître du jeu. - Sur un tournoi, il ne peut y avoir qu’un seul maître de jeu.

- Un maître de jeu peut être maître de plusieurs tournois.- Un tournoi demande la participation de candidats : nom du candidat, prénom du candidat,

score du candidat.- Un candidat doit avoir un compagnon de route considéré comme également comme

candidat. Pour un candidat, il n’y a qu’un seul compagnon de route pour un tournoi donné. Par contre, il y a plusieurs candidats pour un même tournoi. De même, plusieurs tournois sont disponibles pour un même candidat.

- Un candidat peut utiliser un ou plusieurs pins : nom du pin, prix du pin.- Un même pin peut être utilisé par plusieurs candidats.

La base devra donc gérer des relations entre chaque entité telle que défini ci-dessus.Au départ, l’application demandé sera une application lourde (c'est-à-dire installé sur un système d’exploitation et n’utilisant pas internet).Cependant, ceci risque de changer et on vous demande également de préparer une version légère de l’application.

Tout d'abord, vous souhaitez mettre en place l’ensemble de l’application c'est-à-dire avoir autant une version cliente lourde que client léger. Vous préparez l’ensemble des connexions.

Q1 : Comment mettre en place ce genre de projet sous NetBeans ? Créer un projet et nommer-le : TwewyApp .

Sous NetBeans, faire : File > New Project > Enterprise -> Enterprise Application :

Mettre un nom de projet : TwewyApp

Prendre en tant que serveur d’application, GlassFish v2 et tout cocher.

Q2 : Le projet mis en place, nous souhaitons prévoir la relation entre la base de données et notre serveur d’application. Quelles sont les étapes à mettre en place sachant que nous travaillons sur NetBeans en tant qu’outil, GlassFish en tant que serveur d’application et MySQL en tant que base de données ?

Les étapes sont :

Mettre en place la libraire MySQL (archive JAR).

Installer EasyPHP et le démarrer.

Mettre en place une base de données avec phpMyAdmin.

Mettre en place un utilisateur avec phpMyAdmin.

Redémarrer GlassFish.

Entrer dans la console d’administration GlassFish.

Mettre en place un pool de connexion sur GlassFish.

Mettre en place une ressource JDBC sur GlassFish.

Mettre en place sur NetBeans un Persistent Unit.

Q3 : Les étapes connues, commençons par mettre en place la relation entre NetBeans et notre future base de données. On sait qu’il existe une archive JAR gérant MySQL. Que faire avec celle-ci ?

Il faut la placer dans le dossier librairie de GlassFish : C:\Program Files\glassfish-v2ur2\lib

Q4 : Le JAR a été mis en place pendant que NetBeans et GlassFish étaient allumés. Va-t-il être pris en compte ? Que faire dans ce cas ?

Non. Il est nécessaire de le redémarrer sinon la libraire n’est pas prise en compte par GlassFish.

Q5 : Notre serveur d’application et NetBeans reconnaissant MySQL, il nous suffit de mettre en place notre base de données. Quelles sont les étapes pour administrer une base de données MySQL ? Comment mettre en place une base de données ? Nommer la base de données : Twewy .

Voici les étapes à faire avec l’aide de phpMyAdmin :

Créer une base de données. La nommer : Twewy.

Créer un utilisateur (page d’accueil de phpMyAdmin, dans « Privilèges »).

Q6 : La base créée, il nous manque encore une étape niveau MySQL. Laquelle ? Nommer l’utilisateur : Kitaniji . Donner lui tous les droits possibles.

Mettre en place un utilisateur.

Aller dans Privilèges et faire Ajouter un utilisateur.

Ajouter avec les informations suivantes :

Nom d’utilisateur : Kitaniji

Serveur : localhost

Mot de passe : someday

Mettre tous les droits.

Q7 : Tout étant fait sur MySQL, il ne reste plus qu’à faire la connexion entre le serveur d’application (GlassFish) et MySQL. Comment faire ?

Aller sur NetBeans, partie « Service » (côté gauche).

Aller sur GlassFish V2, clic droit et faire View Admin Console.

Q8 : Vous êtes dorénavant sur la page d’administration de GlassFish. Vous devez mettre en place la connexion entre le serveur d’application et MySQL. Vous savez qu’il s’agit de JDBC et que vous avez deux étapes à effectuer. Quelles sont ces deux étapes ?

Les deux étapes sont : mettre en place un pool de connexion et puis mettre en place le contexte JNDI.

Q9 : Mettez en place la première étape. Nommer le pool de connexion : ReapersGame .

Aller dans Ressources > JDBC :

Aller sur Pools de connexion, à gauche et créer un nouveau pool (à droite) :

A la première étape, mettre les éléments suivants :

Nom : ReapersGame

Type de ressource : javax.sql.DataSource

Fournisseur de base de données : MySQL

A la deuxième étape, mettez en place les propriétés suivantes :

DatabaseName : Twewy

Password : someday

ServerName : localhost

Url : jdbc:mysql://:3306/Twewy

URL : jdbc:mysql://:3306/Twewy

User : Kitaniji

Pour finir, revenez sur votre pool et faites un ping voir si celui-ci fonctionne.

Q10 : Mettez en place la deuxième étape. Nommer le contexte JNDI : TwewyDbConnection .

Aller dans Ressources > JDBC :

Aller sur le répertoire Ressources JDBC (à gaucher) et à droite, appuyer sur Nouveau :

Maintenant mettre les données suivantes :

Nom : TwewyDbConnection

Nom du pool : ReapersGame

Q11 : Maintenant que la configuration de la connexion GlassFish/MySQL est faite, vous devez préparer la connexion entre NetBeans et GlassFish. Pour cela, vous devez créer un fichier xml sur NetBeans.

Il faut créer un fichier Pesistent Unit. Celui-ci va se nommer persistent.xml.

Attention : Celui-ci sera à mettre côté serveur c'est-à-dire au niveau des EJB.

Dans NetBeans, aller sur la partie Projects (en haut à gauche). Rechercher notre projet d’application d’entreprise :

Notre projet d’application d’entreprise

La partie client lourd du projet

La partie serveur, le niveau EJB

La partie client léger du projet

Aller sur TwewyApp-ejb, c’est là où sont déposés les EJB et faire New > Other. Aller dans Persistence et choisir Persistence Unit :

Maintenant, mettre ceci au niveau du Persistent Unit :

DataSource : TwewyDbConnection

TableGenerationStrategy : Drop And Create

Les connexions mises en place, vous devez maintenant préparer l’ensemble des tables de la base de données à partir de NetBeans.

Q12 : Dans les recommandations de la société, il est demandé de mettre en place des tournois. Comment peut-on mettre en place un tournoi sur la base de données ? sur NetBeans ?

Sur une base de données, la logique serait de mettre en place une table Tournois concentrant les données de chaque tournoi.

Sur NetBeans, la logique serait de mettre en place une entité Tournois telle que celle-ci deviennent une table de la base de données.

Q13 : Créer l’entité Tournois sur NetBeans. Pensez à créer un package pour mettre en place toutes nos entités. Nommer le package : twewy.entities .

Tout d’abord se dire qu’une entité est créée à l’aide des EJB. Il faut donc se mettre sur la partie du projet gérant les EJB, soit dans notre cas : TwewyApp-ejb.

Maintenant, il faut mettre en place du code. Dans ce cas, il suffit de cliquer sur le « + » à côté de TwewyApp-ejb et de se mettre sur Source Packages.

Commençons par mettre en place un package :

1. Aller sur Source Packages :

2. Clic droit. Faire New > Java Package…

3. Nommer le package twewy.entities :

Mettons en place une entité dans le package créé :

1. Aller sur twewy.entities :

2. Clic droit. Faire New > Entity Class…

3. Nommer la classe Tournois :

4. Un élément Tournois.java devrait apparaître :

Q14 : Dans nos recommandations, un tournoi se caractérise par un nom et une semaine donnée. Comment mettre cela en place ? Mettez-le en place sur votre entité Tournois . Pour les noms de tournois, nommer le nomTournoi avec pour type String . Pour la semaine donnée, nommer la semaine avec pour type int . Mettre également en place les getters & setters.

Pour mettre le nom et la semaine donnée grâce à une entité, il suffit simplement de modifier le code de notre entité en y ajoutant le nom et la semaine comme des attributs.

-- Rappel : Un attribut est une variable présente dans une classe. Cet attribut se caractérise par une visibilité, un type de données et un nom de variable. Attention à bien être à l’intérieur d’une classe sans toutefois les mettre dans des méthodes (sinon les variables ne seront visibles qu’au niveau de la méthode).

Mise en place des deux attributs dans notre code Tournois.java :

-- Rappel : Un getter permet d’obtenir une valeur d’un attribut donné.Un setter permet de mettre en place une valeur pour un attribut donné.

Pour faire leurs Getters & Setters, dans le code Tournois.java, faire clic droit, Insert Code. Une fenêtre Generate s’ouvre, préciser Getter and Setter… . Une seconde fenêtre s’ouvre et il vous suffit de cocher les éléments auxquels vous souhaitez mettre en place des Getters et Setters :

Résultat actuel de Tournois.java :

(en surligné gris foncé ce qu’on a mis en place avec la question actuelle)

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package twewy.entities;

import java.io.Serializable;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

/**

*

* @author sonny

*/

@Entity

public class Tournois implements Serializable {

private static final long serialVersionUID = 1L;

private Long id;

//Attributs -> deviennent des colonnes dans la table "Tournois"

private String nomTournoi; //Nom du tournoi -> deviendra une colonne "nomTournoi"

private int semaine; //Numéro de semaine -> deviendra une colonne "semaine"

//Getters & Setters -> permettent d'accéder aux attributs qualifiés "private"

public String getNomTournoi() {

return nomTournoi;

} //Getter de l'attribut nomTournoi -> obtient un nom de tournoi.

public void setNomTournoi(String nomTournoi) {

this.nomTournoi = nomTournoi;

} //Setter de l'attribut nomTournoi -> met en place/inscrit un nom de tournoi.

public int getSemaine() {

return semaine;

}

public void setSemaine(int semaine) {

this.semaine = semaine;

}

public void setId(Long id) {

this.id = id;

}

@Id

@GeneratedValue(strategy = GenerationType.AUTO)

public Long getId() {

return id;

}

@Override

public int hashCode() {

int hash = 0;

hash += (id != null ? id.hashCode() : 0);

return hash;

}

@Override

public boolean equals(Object object) {

// TODO: Warning - this method won't work in the case the id fields are not set

if (!(object instanceof Tournois)) {

return false;

}

Tournois other = (Tournois) object;

if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {

return false;

}

return true;

}

@Override

public String toString() {

return "twewy.entities.Tournois[id=" + id + "]";

}

}

Q15 : Maintenant, il est demandé de mettre en place des maîtres de jeux. Pour cela, créer l’entité MaitresJeux sur NetBeans. Mettez en place en String nomMaitre et en int , puissanceMaitre .

Même logique que les 2 questions précédentes.

Résultat actuel de MaitresJeux.java :


/*



*/







/**

*

* @author sonny

*/

@Entity

public class MaitresJeux implements Serializable {


private Long id;

private String nomMaitre;

private int puissanceMaitre;

public String getNomMaitre() {

return nomMaitre;

}

public void setNomMaitre(String nomMaitre) {

this.nomMaitre = nomMaitre;

}

public int getPuissanceMaitre() {

return puissanceMaitre;

}

public void setPuissanceMaitre(int puissanceMaitre) {

this.puissanceMaitre = puissanceMaitre;

}


this.id = id;

}

@Id



return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof MaitresJeux)) {

return false;

}

MaitresJeux other = (MaitresJeux) object;


return false;

}

return true;

}

@Override


return "twewy.entities.MaitresJeux[id=" + id + "]";

}

}

Q16 : On voit dans les recommandations que un tournoi ne peut avoir qu’un maître de jeu. On voit également qu’un maître de jeu peut être maître sur plusieurs tournois. A votre avis, quelle relation avons-nous ici ? Mettez en place la relation sur NetBeans (TIPS : N’oubliez pas que c’est à mettre sur les deux entités). Nommer la clé étrangère ainsi : FKIDMaitreJeu. Nommer la collection ainsi : tournois . Nommer l’objet ainsi : maitre .

Essayons de voir cela par un exemple :

Supposons que j’ai cinq tournois nommé A, B, C, D et E.J’ai trois maîtres de jeux nommé M1, M2 et M3.M1 est maître dans les tournois A et E.M2 est maître dans le tournoi C.M3 est maître dans les tournois B et D.

On remarque bien que M1, M2 et M3 ne peuvent pas avoir les même tournois car il est impossible d’avoir plus d’un maître de jeu sur un tournoi. Cela veut donc dire qu’au niveau base de données, un tournoi n’accepte qu’un maître de jeu : ce qui est représentable par une colonne du côté des tournois ! Cette colonne, c’est ce qu’on appelle la clé étrangère (ou foreign key).

On s’aperçoit également dans l’exemple que M1 est à la fois maître du tournoi A mais aussi du tournoi E. Il y a donc la possibilité d’avoir plusieurs tournois disponibles pour un maître !

C’est ce qu’on appelle une relation 1-1,1-n. Pour un tournoi il est possible d’avoir qu’un maître de jeu mais il est possible d’être maître de plusieurs tournois pour un même maître de jeu.

En gros, ça revient à ceci :

Ce type de relation au niveau des entités est gérée par les annotations suivantes : @OneToMany, @ManyToOne.

@OneToMany se met sur l’entité qui devra gérer une collection d’objets (provenant de l’autre entité). Dans notre cas, le @OneToMany sera dans notre entité MaitresJeux. Elle devra gérer une collection de Tournoi (en effet, un maître peut être maître de un ou plusieurs tournois).

@ManyToOne se met sur l’entité qui devra gérer un seul objet (provenant de l’autre entité). Dans notre cas, le @ManyToOne sera dans notre entité Tournois. Elle devra gérer un seul maître de jeu (en effet, un tournoi ne peut avoir qu’un seul maître de jeu).

Tout ceci effectué, mettons donc en place ces deux annotations sur nos classes.

-- Rappel : Penser à importer chaque élément !Pour ceci, vous remarquerez souvent une lampe avec un point d’exclamation.Cliquer dessus et choisir « Add import … ».

Commençons par @OneToMany sur MaitresJeux.java :

Cette fois, faisons la relation @ManyToOne sur Tournois.java :

Maître Tournoi1,n 1,1

Résultat actuel de MaitresJeux.java :


/*



*/



import java.util.Collection;

import javax.persistence.CascadeType;





import javax.persistence.OneToMany;

/**

*

* @author sonny

*/

@Entity

public class MaitresJeux implements Serializable {


@Id


private Long id;

private String nomMaitre;

private int puissanceMaitre;

public String getNomMaitre() {

return nomMaitre;

}

public void setNomMaitre(String nomMaitre) {

this.nomMaitre = nomMaitre;

}

public int getPuissanceMaitre() {

return puissanceMaitre;

}

public void setPuissanceMaitre(int puissanceMaitre) {

this.puissanceMaitre = puissanceMaitre;

}

//Relation entre les maitres et les tournois

@OneToMany(mappedBy="maitre",cascade=CascadeType.ALL)

private Collection<Tournois> tournois;

public Collection<Tournois> getTournois() {

return tournois;

}

public void setTournois(Collection<Tournois> tournois) {

this.tournois = tournois;

}


this.id = id;

}


return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof MaitresJeux)) {

return false;

}

MaitresJeux other = (MaitresJeux) object;


return false;

}

return true;

}

@Override


return "twewy.entities.MaitresJeux[id=" + id + "]";

}

}

Résultat actuel de Tournois.java :


/*



*/








import javax.persistence.JoinColumn;

import javax.persistence.ManyToOne;

/**

*

* @author sonny

*/

@Entity

public class Tournois implements Serializable {


@Id


private Long id;

//Attributs -> deviennent des colonnes dans la table "Tournois"

private String nomTournoi; //Nom du tournoi -> deviendra une colonne "nomTournoi"

private int semaine; //Numéro de semaine -> deviendra une colonne "semaine"

//Getters & Setters -> permettent d'accéder aux attributs qualifiés "private"

public String getNomTournoi() {

return nomTournoi;

} //Getter de l'attribut nomTournoi -> obtient un nom de tournoi.

public void setNomTournoi(String nomTournoi) {

this.nomTournoi = nomTournoi;

} //Setter de l'attribut nomTournoi -> met en place/inscrit un nom de tournoi.

public int getSemaine() {

return semaine;

}

public void setSemaine(int semaine) {

this.semaine = semaine;

}

//Relation entre tournois et maîtres du jeu

@ManyToOne(cascade=CascadeType.ALL)

@JoinColumn(name="FKIDMaitreJeu")

private MaitresJeux maitre;

public MaitresJeux getMaitre() {

return maitre;

}

public void setMaitre(MaitresJeux maitre) {

this.maitre = maitre;

}


this.id = id;

}


return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof Tournois)) {

return false;

}

Tournois other = (Tournois) object;


return false;

}

return true;

}

@Override


return "twewy.entities.Tournois[id=" + id + "]";

}

}

Q17 : Créer les entités Candidats et Pins . En ce qui concerne l’entité Candidats , mettre en String : nomCandidat , prenomCandidat . Niveau Candidats , mettre en int : scoreCandidat . En ce qui concerne l’entité Pins , mettre en String nomPins et mettre en float prixPins .

Même logique que les questions 14 & 15.

Résultat actuel de Candidats.java :


/*



*/







/**

*

* @author sonny

*/

@Entity

public class Candidats implements Serializable {


private Long id;

private String nomCandidat;

private String prenomCandidat;

private int scoreCandidat;

public String getNomCandidat() {

return nomCandidat;

}

public void setNomCandidat(String nomCandidat) {

this.nomCandidat = nomCandidat;

}

public String getPrenomCandidat() {

return prenomCandidat;

}

public void setPrenomCandidat(String prenomCandidat) {

this.prenomCandidat = prenomCandidat;

}

public int getScoreCandidat() {

return scoreCandidat;

}

public void setScoreCandidat(int scoreCandidat) {

this.scoreCandidat = scoreCandidat;

}


this.id = id;

}

@Id



return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof Candidats)) {

return false;

}

Candidats other = (Candidats) object;


return false;

}

return true;

}

@Override


return "twewy.entities.Candidats[id=" + id + "]";

}

}

Résultat actuel de Pins.java :


/*



*/







/**

*

* @author sonny

*/

@Entity

public class Pins implements Serializable {


private Long id;

private String nomPins;

private float prixPins;

public String getNomPins() {

return nomPins;

}

public void setNomPins(String nomPins) {

this.nomPins = nomPins;

}

public float getPrixPins() {

return prixPins;

}

public void setPrixPins(float prixPins) {

this.prixPins = prixPins;

}


this.id = id;

}

@Id



return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof Pins)) {

return false;

}

Pins other = (Pins) object;


return false;

}

return true;

}

@Override


return "twewy.entities.Pins[id=" + id + "]";

}

}

Q18 : En regardant les recommandations, vous remarquez qu’un candidat peut avoir un seul compagnon de route. Or un compagnon de route est lui-même un candidat. Quelle relation est mis en place dans ce cas ?

Prenons un exemple :

Prenons les 5 candidats suivants : Neku, Shiki, Beat, Rhyme et Joshua.Le candidat Neku a pour partenaire (= compagnon de route) Shiki. Il ne peut pas avoir Beat, Rhyme ou Joshua sachant que Shiki est son partenaire.Le candidat Beat a pour partenaire Rhyme. Il ne peut pas avoir Neku, Shiki ou Joshua sachant que Rhyme est son partenaire.

On a donc un exemple d’une relation très simple : la relation 1-1,1-1. Cette relation, dans le cas présent se fait sur la même entité qui est Candidats.

En gros, ça se schématise ainsi :

Candidats1,1

1,1

Q19 : Vous remarquez également qu’un candidat à un compagnon de route différent selon les tournois. De quelle relation s’agit-il ? Comment donc mettre en place la recommandation précédente (TIPS : Le compagnon dépend d’un tournoi) ?

Expliquons cette relation à partir d’exemples :

Nous avons nos couples (= candidat – partenaire) Neku-Shiki, Beat-Rhyme pour le tournoi A.Nous avons notre couple Neku-Joshua pour le tournoi B.Au tournoi A, impossible d’avoir le couple Neku-Joshua car Neku est déjà en couple avec Shiki.

Entre candidat et tournoi, la relation est simple : il peut y avoir autant de candidats dans un tournoi et ces candidats peuvent participer à tous les tournois. Il s’agit donc d’une relation 1-n,1-n.

Or nous avons également vu la relation entre un candidat et son compagnon.

Une relation 1-n,1-n se définie par la mise en place d’une table d’association. La solution la plus logique pour faire dépendre un couple d’un tournoi serait de tout simplement disposer l’identifiant du compagnon de route sur la table d’association !

Q20 : Mettez en place, sur NetBeans, les relations entre candidats, compagnon de route et tournois. Nommer la table d’association : Candidat-Tournoi . Nommer la clé étrangère ainsi : FK-ID- CandidatCompagnon .

En cours.

Q21 : Il ne reste plus qu’à faire une relation : celle entre les candidats et les pins. Il est dit qu’un candidat peut posséder plusieurs pins. Cependant il est également cité qu’un pin peut appartenir à plusieurs candidats. De quelle relation parle-t-on ? Mettez la en place sur NetBeans en n’oubliant pas que celle-ci se met sur les deux entités. Nommer la table d’association ainsi : CandidatsPins . Nommer les collections : candidats, pins.

La relation traitée est une relation 1-n,1-n.

Pour la gérer à partir des entités, il est nécessaire d’utiliser l’annotation @ManyToMany. Celle-ci demande la mise en place d’une collection sur les deux entités.

Résultat actuel de Candidats.java :


/*



*/









import javax.persistence.JoinTable;

import javax.persistence.ManyToMany;

/**

*

* @author sonny

*/

@Entity

public class Candidats implements Serializable {


@Id


private Long id;

//Mise en place de la relation Candidats-Pins

@ManyToMany(cascade=CascadeType.ALL)

//Ajout de la liaison de table

@JoinTable(name="CandidatsPins")

private Collection<Pins> pins;

public Collection<Pins> getPins() {

return pins;

}

public void setPins(Collection<Pins> pins) {

this.pins = pins;

}

private String nomCandidat;

private String prenomCandidat;

private int scoreCandidat;

public String getNomCandidat() {

return nomCandidat;

}

public void setNomCandidat(String nomCandidat) {

this.nomCandidat = nomCandidat;

}

public String getPrenomCandidat() {

return prenomCandidat;

}

public void setPrenomCandidat(String prenomCandidat) {

this.prenomCandidat = prenomCandidat;

}

public int getScoreCandidat() {

return scoreCandidat;

}

public void setScoreCandidat(int scoreCandidat) {

this.scoreCandidat = scoreCandidat;

}


this.id = id;

}


return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof Candidats)) {

return false;

}

Candidats other = (Candidats) object;


return false;

}

return true;

}

@Override


return "twewy.entities.Candidats[id=" + id + "]";

}

}

Résultat actuel de Pins.java :


/*



*/









import javax.persistence.ManyToMany;

/**

*

* @author sonny

*/

@Entity

public class Pins implements Serializable {


@Id


private Long id;

//Mise en place de la relation Candidats-Pins

@ManyToMany(mappedBy="pins",cascade=CascadeType.ALL)

private Collection<Candidats> candidats;

public Collection<Candidats> getCandidats() {

return candidats;

}

public void setCandidats(Collection<Candidats> candidats) {

this.candidats = candidats;

}

private String nomPins;

private float prixPins;

public String getNomPins() {

return nomPins;

}

public void setNomPins(String nomPins) {

this.nomPins = nomPins;

}

public float getPrixPins() {

return prixPins;

}

public void setPrixPins(float prixPins) {

this.prixPins = prixPins;

}


this.id = id;

}


return id;

}

@Override


int hash = 0;


return hash;

}

@Override



if (!(object instanceof Pins)) {

return false;

}

Pins other = (Pins) object;


return false;

}

return true;

}

@Override


return "twewy.entities.Pins[id=" + id + "]";

}

}

Nous venons de finir la mise en place de nos entités pour former notre base de données. Maintenant, vous savez qu’il est nécessaire qu’un client puisse agir sur les entités. Pour cela, vous savez qu’il faut mettre en place des sessions.

Q22 : Avant de mettre en place les sessions, il est nécessaire de savoir quelles dispositions donner à nos sessions. On sait que nos clients se connectent à distance. Quel type de session est-il donc préférable de créer ?

Il faut mettre en place une session avec l’annotation @Remote, sur l’interface.

Q23 : Maintenant, on nous dit également que les sessions sont indépendantes des clients connectés dessus. En quelque sorte, toute action est disponible de manière publique. Quelle annotation faut-il appliquer à nos sessions ?

Il faut mettre en place une session avec l’annotation @Stateless, sur la classe.

Q24 : On va se contenter d’abord de créer une session pour l’entité Tournoi . Il est possible de faire cette session de manière automatique sur NetBeans. Trouver comment faire une session automatiquement. Garder les noms d’origines de NetBeans. Penser également à placer toutes les sessions crées dans le package suivant : twewy.sessions .

Dans la partie Projects, aller sur TwewyApp-ejb, sur les Source Packages, ajouter un package nommé twewy.sessions (voir la question n° 13).

Maintenant, mettons en place une session à partir des entités :

Sur le package twewy.sessions, clic droit, faire New > Other > aller sur le répertoire Persistence et prendre Session Beans For Entity Classes.

Ajouter toutes les entités pour faire des sessions pour chaque entité.

Finir par créer une session telle qu’elle soit en Remote uniquement.

Q25 : La session créée via NetBeans propose deux éléments : une interface nommée TournoiFacadeRemote et une classe nommée TournoiFacade. A quoi sert chacune d’elle ? Pouvez- vous décrire à quoi sert chaque méthode appelée ?

Pour mettre en place une session, il existe deux éléments :

Une interface : c’est elle qui met en place la session et qui précise si celle-ci est en Remote ou Local. Etant donné que c’est une interface, on ne peut pas y implémenter de code. C’est pour cela que nous avons un second élément. Souvent nommé xxxFacadeRemote.

Une classe : c’est elle qui implémente le code pour l’interface. On doit préciser ici si c’est du Stateful ou Stateless. Souvent nommé xxxFacade.

Au niveau des méthodes appelées par nos sessions, voici un petit descriptif de chacune :

Méthode void create(Tournois tournoi) : permet d’ajouter un enregistrement sur notre table Tournois. C’est une sorte de INSERT INTO.

Méthode void edit(Tournois tournoi) : permet de mettre à jour un enregistrement sur notre table Tournois. C’est une sorte de UPDATE.

Méthode Candidats find(Object id) : permet de rechercher un enregistrement en fonction d’un identifiant (à mettre en Long. Si je recherche donc l’identifiant 5, il faut préciser : 5l).

Méthode List<Candidats> findall() : permet de voir tous les enregistrements. C’est comme un SELECT * FROM Tournois.

Q26 : Mettez en place l’ensemble des sessions pour toutes les entités.

Déjà fait à la question 24.

Q27 : Il ne reste plus qu’à déployer et lancer la partie EJB de votre application d’entreprise. Comment faire ceci ? Après cette étape, regarder votre base de données. Que constatez-vous ?

Aller sur TwewyApp-ejb et faire clic droit, Undeploy and Deploy (si NetBeans 6.5 : Deploy) et enfin Run.

Si on va sur notre base de données, on constate la présence des entités :

Vous avez terminé la mise en place côté serveur. Vos EJB sont fonctionnels. Il ne reste plus qu’à gérer nos clients. Pour le moment, vous vous concentrez sur le client lourd.

Q28 : Parmi la liste de notre application d’entreprise, lequel des éléments est le client lourd ?

Celui nommé TwewyApp-app-client.

Q29 : Dans ce client lourd, vous apercevez par défaut un paquet et une classe Main. A votre avis, à quoi cette classe sert-elle ?

La classe Main sert à gérer le lancement d’un client lourd : il est celui qui va permettre de mettre en place le lancement de nos ajouts, suppressions etc.

Q30 : Pour le moment, nous allons préparer côté client des classes de gestion de nos sessions (qui elles vont gérer les entités). Ces classes seront à placer dans le package : twewy.managers . Créer donc le package.

Aller sur TwewyApp-app-client, l’ouvrir et aller dans Sources Packages. Clic droit et faire New > Java Packages… .

Pour les étapes exactes, voir question 13.

Q31 : Après création du package, mettez en place une classe de gestion sous le nom suivant : GestionTournois . Faite de même pour toutes les autres entités (nommer les : GestionXxxx avec Xxxx = nom de l’entité).

Aller sur twewy.managers et faire New > Java Class… .

Donner le nom : GestionTournois.

Faite de même pour les autres entités.

Q32 : Dans GestionTournois , nous souhaitons pouvoir mettre en place un procédé qui permet tout d’abord d’ouvrir une session pour le client. Comment faire ? (TIPS : Il existe plusieurs choix mais supposons qu’on préfère mettre en place cette ouverture dans le constructeur par défaut de notre classe de gestion).

Pour mettre cela en place, il faudra penser à mettre dans notre GestionTournois.java (présent dans twewy.managers de Source Packages de TwewyApp-app-client), les choses suivantes :

L’attribut : private Tournois tournoi on pourra donc gérer l’entité Tournois dans notre classe GestionTournois.

L’attribut : private TournoisFacadeRemote tfr on pourra grâce à l’interface mettre en place une session pour le client. Ceci va permettre au client de gérer la base de données à partir de notre interface. Tout ceci dans la classe GestionTournois.

Un constructeur par défaut contenant :

o L’instanciation de l’attribut tournoi : tournoi = new Tournois() ;

o Un contexte pour pouvoir se connecter à notre interface : Context c = new InitialContext() ;

o La mise en place de l’interface via le contexte (méthode Lookup) : tfr = (TournoisFacadeRemote) c.lookup(« twewy.sessions.TournoisFacadeRemote ») ;

Résultat actuel de GestionTournois.java :


/*



*/

package twewy.managers;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import twewy.entities.Tournois;

import twewy.sessions.TournoisFacadeRemote;

/**

*

* @author sonny

*/

public class GestionTournois {

private Tournois tournoi;

private TournoisFacadeRemote tfr;

public GestionTournois() throws NamingException {

tournoi = new Tournois();

// Mise en place de la connexion client-serveur pour client lourd

Context c = new InitialContext();

tfr = (TournoisFacadeRemote) c.lookup("twewy.sessions.TournoisFacadeRemote");

}

public TournoisFacadeRemote getTfr() {

return tfr;

}

public void setTfr(TournoisFacadeRemote tfr) {

this.tfr = tfr;

}

public Tournois getTournoi() {

return tournoi;

}

public void setTournoi(Tournois tournoi) {

this.tournoi = tournoi;

}

}

Q33 : Dans GestionTournois , nous souhaitons pouvoir mettre en place un procédé qui va gérer l’ajout d’un tournoi en précisant son nom et sa semaine. Comment faire ? Nommer la méthode : ajoutTournoi (String nomT , int week ).

Pour cela, on sait que c’est l’interface qui s’occupe de l’insertion des données dans notre entité. Ceci veut donc dire qu’il faut utiliser l’interface.

Cependant, la gestion d’ajout des noms et des semaines pour le client lourd n’est pas faite automatiquement et nécessite de passer par l’entité elle-même.

C’est pour cela que nous allons créer dans notre GestionTournois, une méthode qui non seulement va permettre d’ajouter des données dans notre entité vide mais en plus de l’appliquer sur notre base de données via l’interface.

On devra donc ajouter ceci à notre classe :

Q34 : Dans GestionTournois , nous souhaitons également mettre en place un procédé de gestions de la mise à jour et de la suppression des tournois précédemment entrés. Comment faire ? Nommer les méthodes : majTournoi (Tournois turn ) & suppTournoi (Tournois turn ).

En cours.

Q35 : Faire de même pour toutes les autres classes de gestion.

En cours.

Q36 : Maintenant, nous souhaitons pouvoir faire les actions. Pour cela, nous avons créé des classes de gestions. Mais où allons-nous utiliser ces classes pour gérer les actions ?

Les actions seront à mettre dans la méthode main de la classe Main. En effet, c’est ici que le client est lancé sur une application lourde.

Q37 : Dans la méthode main de Main, instancier un objet de la classe GestionTournois qu’on nommera : gestTournoi .

Q38 : Mettez en place une insertion dans notre Main.

Q39 : Mettez en place la modification de l’insertion effectuée précédemment dans notre Main. (TIPS : Vous pouvez vous facilitez cette tâche via les EJB-QL).

En cours.

Q40 : Mettez en place la suppression de l’insertion effectuée précédemment dans notre Main. (TIPS : Vous pouvez vous facilitez cette tâche via les EJB-QL).

En cours.

Q41 : Maintenant, effectuons une modification de notre GestionTournoi . On a vu qu’un tournoi dépend d’un maître de jeu et que pour un même maître, il peut apparaître sur plusieurs tournois. On va donc demandé à notre méthode ajoutTournoi d’ajouter un maître de jeu. Comment faire ? Nommer l’argument : maitreJeu .

Q42 : Dans le Main, préparer une instanciation de la gestion d’un maître de jeu. Nommé son objet : gestMJ . Permetter l’ajout de deux maîtres : Higashizawa de niveau 1 et Minamimoto de niveau 2 .

Q43 : Maintenant, faîtes le lien entre l’ajout d’un tournoi et de son maître de jeu.

Q44 : Mettez en place toutes les relations possibles dans vos classes de gestion.

En cours.

Le client lourd a bien été mis en place. Cependant, on vous demande maintenant de vous concentrez sur le client léger. Celui-ci sera en JSF.

Q45 : Pour commencer, le client léger a besoin d’utiliser les librairies JSF 1.2. Comment faire pour ajouter ceci à notre client léger ? Par ailleurs, quel est le client léger parmi notre application d’entreprise ?

Q46 : Dans notre client léger, nous souhaitons mettre en place une gestion des tournois. Créer un package nommé twewy.managers et une classe GestionTournois . Pour faciliter la tâche, faîte un copier-coller de celle présente dans le client lourd.

Q47 : Ce copier-coller a quelques erreurs à corriger pour le faire fonctionner côté client léger. Vous savez qu’un contexte se fait automatiquement via une annotation. Laquelle ?

Q48 : Nous allons configurer notre client léger pour qu’il puisse reconnaître notre classe GestionTournois. Dans quel fichier aller ? Que faut-il ajouter ?

Q49 : Maintenant, mettons en place une page JSP. Celle-ci sera nommé : accueil.jsp . Dans celle-ci, nous souhaitons pouvoir se rediriger vers trois pages à créer : listingTournois.jsp , ajoutTournois.jsp , ajoutMaitre.jsp .

Q50 : Dans la page ajoutTournois.jsp , créer deux champs en InputText précédé par des OutputText . Le premier sera le nom du tournoi, le second sera le numéro de semaine . Penser également à ajouter un bouton de commande. Dans celui-ci, donner une valeur (provisoire) action « ajout » et la valeur du bouton « Envoyer ».

Q51 : Pour faire fonctionner l’ajout nous aurons besoin dans notre classe GestionTournois de gérer l’ajout de manière différente que sur un client lourd. Pour cela il faut créer une méthode envoyant un String tel que celui-ci devienne une action à proprement parler. Nommer cette méthode : ajoutTournoi(). Elle devra retourner « ajout ». Penser également à modifier sur votre page JSP ajoutTournois.jsp tel que celui-ci puisse utiliser cette méthode.

Q52 : Ceci fait, il faut retourner sur faces-config.xml. Dans celui-ci il faut mettre en place notre navigation. Pour ceci il est nécessaire de créer des règles via la balise <navigation-rule>. Faîte une règle demandant de passer de la page ajoutTournois.jsp à la page listingTournois.jsp . Regarder votre base de données et voyez si le tournoi a bien été intégré.

Q53 : Maintenant, nous allons configurer la page listingTournois.jsp . Pour ceci, il faut penser à mettre en place tout d’abord sur notre classe GestionTournois un DataModel qui sera capable de connaître la liste de nos tournois. Ce DataModel sera ensuite mis en place sur la page JSP listingTournois.jsp grâce au tableau dynamique DataTable . Mettez donc en place tout ceci. Penser à ajouter des liens vers la page d’ajout pour vérifier si la liste apparaît bien.

Q54 : Tout ceci fait, il faut maintenant envisager la présence de suppression de tournois. Pour ceci, faire tout d’abord une méthode au niveau de notre classe GestionTournois (TIPS : ce qui permet de reprendre la ligne souhaitée du DataTable est une méthode du DataModel ). Ensuite, il faut penser à ajouter un bouton « Supprimer » appelant cette méthode dans notre DataTable et que celui-ci redirige sur le page listingTournois.jsp .

Q55 : Il nous reste à gérer la relation entre un maître et un tournoi. Pour ceci, penser à d’abord créer une page ajoutMaitre.jsp . Sachant qu’un maître est forcément unique sur un tournoi, il faudra penser à créer un maître avant de créer un tournoi. Pour cela, penser à créer une classe GestionMaitre (à peu prêt la même structure que GestionTournois ).

Q56 : Maintenant, au niveau des tournois, il faut ajouter un maître. Pour cela, prévoir dans la classe GestionMaitre un moyen de garder les infos du maître sélectionné. Ensuite, envoyer vers la page d’ajout de tournois.

Q57 : Finir sur notre page JSP ajoutTournois.jsp avec un repêchage de notre info sur le maître sélectionné comme valeur par défaut. Attention : pour mettre en place cette solution vous devez appeler de votre entité Tournois un maître et prendre son identifiant. Penser à instancier un maître dans votre entité Tournois.

La dernière étape est de préparer le renvoi de message sur les portables des Reapers. Pour cela, il faut mettre en place un système de Java Message sur notre application.

Q58 : ?

Q59 : ?

Q60 :?

Education

JavaEE 5 - Exercise - 2009 - FR