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 Filesglassfish-v2ur2lib
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 Tournoi
1,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 :
Candidats
1,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 :?

JavaEE 5 - Exercise - 2009 - FR

Contenu connexe

En vedette (20)

Similaire à JavaEE 5 - Exercise - 2009 - FR (20)

Plus de Sonny Brabez (12)

Dernier (20)

JavaEE 5 - Exercise - 2009 - FR