TP1 EJB : mise en place de l'environnement, premières

applications

Les différentes étapes pour réaliser ce TP :

1. 1. Installation logicielle
1.1. 1.1. Vérification de l'installation

2. 2. Création d'un nouveau projet

3. 3. Création d'un premier ejb de type session bean stateless : HelloWorld
4. 4. Ecriture d'une servlet client de test de ce bean
5. 5. Modifions la page par défaut et insérons un petit menu
6. 6. Ecriture d’un second bean appelé par le bean HelloWorld
7. 7. Accès à une base de donnée via un entity bean et un gestionnaire de persistence ("persistence manager")
7.1. 7.1. La base de données, prise de contact
7.2. 7.2. Création d'un entity bean proxy de la table MANUFACTURER

8. 8. Modification du bean HelloWorld pour qu'il fasse un findAll sur les manufacturers
9. 9. Affichage des résultats dans une page JSP
10. 10. Ajout d'un nouveau Manufacturer

1. Installation logicielle

Logiciels obligatoires :

• Un JDK version 1.8 ET Netbeans 8.0.2

• Le JDK : On a besoin d'un JDK et non pas d'un JRE.
Installez la version la plus récente à partir du site d'Oracle.
QUESTION : C'est quoi JDK ? C'est quoi JRE ? Pourquoi dans le cadre de ces TP doit on prendre
un JDK plutôt qu'un JRE ?
• Netbeans 8.0.2 : On a besoin d'une version qui contient les serveurs glassfish et tomcat.
Installez la version (en français si vous préférez) la plus complète sur le site de Netbeans
, https://dlc-cdn.sun.com/netbeans/8.0.2/final/ (dernière colonne à droite).
QUESTION : qu'est-ce qu'un IDE ?

1
2
NOTE : les photos d'écrans sont toutes avec Glassfish v3 prelude et avec netbeans 6.7.1, comme nous
allons utiliser glassfish v3.1 final et netbeans 6.9, il se peut qu'il y ait de petites différences.

NE CHANGEZ AUCUN MOT DE PASSE !

Note : si jamais les liens ci-dessus ont changé, google est votre ami pour récupérer des versions à jour.

Installez donc le JDK si vous ne l'avez pas, puis netbeans, et passons à la suite.
JE CONSEILLE DE DESINSTALLER LA VERSION PRECEDENTE DE NETBEANS ET DE GLASSFISH SI VOUS AVIEZ D
!

1.1. Vérification de l'installation

Lancez netbeans une fois l'installation terminée. Cliquez sur l'onglet "services" et ouvrez l'item
serveurs. Vous devez voir que tomcat et glassfish sont installés (si vous n'avez pas installé tomcat, ce
n'est pas grave) :

Vérifions maintenant que tout est ok... L'archive que nous avons installée comprend l'outil de
développement netbeans mais aussi le serveur d'application de Sun, appellé Glassfish. Lancez netbeans,
puis allez dans l'onglet "services". Nous allons lancer le serveur pour voir si tout est ok:

3
Puis, en demandant à voir la console d'administration, cela va ouvrir la page d'admin dans votre
navigateur. En entrant le mot de passe adminadmin, une belle page devrait s'afficher. J'espère que vous
n'avez pas modifié le mot de passe proposé par défaut, car dans une classe de TP, les statistiques
prouvent que la moitié des étudiants ne se souviennent plus de leur mot de passe très
rapidement!

4
Le screenshot ci-dessous présente la console d'administration. Nous en reparlerons plus tard. Le fait
qu'elle s'affiche dans votre navigateur prouve que l'installation est ok.

2. Création d'un nouveau projet

Nous allons créer maintenant un projet pour le TP d'aujourd'hui. Allez dans le menu file/new project,
puis dans la fenêtre suivante, sélectionnez JavaEE comme catégorie de projet et « enterprise
application » comme projet:

5
Cliquez sur « next », puis donnez un nom à votre projet, cliquez sur next ou suivant...

Indiquez maintenant que nous allons utiliser le serveur d'application de Sun (glassfish v3 ou v3.1 et le
mode Java EE6)
6
Une fois terminé, vous verrez dans l'onglet project « trois sous projets » :

1. Le premier, "TP1", correspond au projet « global » qui contient en fait les archives des deux autres (il
correspond au fichier .ear du cours),
2. le second, "TP1-ejb", correspond au .jar qui va contenir tous vos ejbs
3. le troisième, "TP1-war", correspond au .war qui va contenir vos servlets, jsps et pages html.

Le fichier .ear est en fait une archive qui contient les deux autres fichiers : le .jar et le .war, il permet de
déployer l'ensemble de la web application d'un seul coup.
7
Nous verrons par la suite qu'on peut aussi mettre des EJBs dans une simple application web (nouveauté Java EE 6).

3. Création d'un premier ejb de type session bean stateless :

HelloWorld

Allez sur le sous projet TP1-ejb (celui avec l'icone en forme de haricot), qui correspond à la partie "ejb"
du projet) et faites bouton droit/new/session bean :

Puis dans la fenêtre suivante, indiquez le nom de votre Ejb, son type, et un nom de package
(obligatoire) :

8
 Une fois terminé, deux fichiers sont ajoutés dans le sous-projet : HelloWord.java et
HelloWorldLocal.java, qui correspondent à la classe du bean et à son interface « locale » (un bean avec
une interface locale ne peut être utilisé que par un client tournant dans la même JVM : une jsp, une
servlet ou un autre ejb).

NOTE : si jamais on ne coche pas d'interface, ce qui n'est possible qu'avec un serveur Java EE6, cela
suppose que le bean dispose par défaut d'une interface locale. Il est toujours nécessaire de créer
explicitement une interface remote dans le cas d'une application distribuée.

Ajoutons une méthode dans ce bean, la méthode getMessage() qui renvoie la chaîne de caractères
«Hello World» :

public String getMessage() {

System.out.println("Hello World qui va s'afficher dans la console du serveur, pour trace");
return "Hello World";
}

Dans l'éditeur, une petite lampe jaune doit apparaître sur la gauche de l'en-tête de la méthode.
Lorsqu'on clique dessus, une ou des actions sont proposées.
Choisissez "Expose method in local business interface HelloWorldLocal" pour indiquer que cette méthode
sera accessible au travers de l'interface locale du bean (ce n'est pas une méthode interne du bean).

9
Cette action ajoute automatiquement la déclaration de la méthode getMessage() dans l'interface
HelloWorldLocal.java.
(Si la petite lampe jaune n'apparaît pas, on peut obtenir le même résultat en déclarant manuellement la
méthode getMessage() dans l'interface.)

@Local
public interface HelloWorldLocal {
java.lang.String getMessage();
}

Rappel : les lignes commençant par @ sont des "attributs de code" ou encore des "annotations de
code". Ce sont en fait des méta-données… Elles serviront au compilateur à générer du code contextuel.
Ceci permet de n'avoir dans la source .java que du POJO (Plain Old Java Object, une classe java
"normale" en fin de compte !)

4. Ecriture d'une servlet client de test de ce bean

Sur le projet finissant par -war, faites clic-droit/new/Servlet :

N'oubliez pas de donner un nom de package !

10
Vous verrez que votre servlet est apparue dans les sources du projet. Dans un projet Java EE 6, les
caractéristiques des servlets ne se trouvent plus dans un descripteur web.xml, mais directement dans
le code source, sous la forme d'annotations de code (lignes commençant par @). Ouvrez donc le code
source de votre servlet et observez les annotations de code. Le second paramètre de l'annotation
WebServlet indique le chemin relatif de l'URL auquel la servlet va répondre (c.f., Rappel URL ci-
dessous). Vous pouvez modifier directement le code pour modifier l'URL, ou même utiliser des
expressions régulières, par exemple : /Servlet* etc.

11
 @WebServlet(name="ServletTest", urlPatterns={"/ServletTest"})
public class ServletTest extends HttpServlet {

Dans les sources de cette servlet, on va indiquer que l'on va « parler » au bean HelloWorld. Pour cela,
cliquez avec le bouton droit dans le code de la servlet (n'importe où) et selectionnez « insert code ».

Un menu apparait, choisissez "call enterprise bean" :

Cela va insérer dans la Servlet deux lignes de code qui vont correspondre à la fois à la déclaration et à
l'initialisation d'une variable référençant un objet du type de l'interface du Bean que l'on souhaite
appeler. Le @EJB est l'annotation de code qui va procéder à "l'injection de code" lors de la compilation
ou du déploiement. La variable helloWorld sera initialisée par le code injecté et ne vaudra pas "null"
comme cela pourrait sembler :

public class ServletTest extends HttpServlet {

@EJB
private HelloWorldLocal helloWorld;

Notons aussi que quelques imports ont étés rajoutés, ce sont ceux dont le code généré aura besoin. La
variable helloWorld référençant un objet du type de l'interface du Bean HelloWorld va, à partir de
maintenant pouvoir être utilisé directement dans la servlet, sans que l'on ait besoin de l'initialiser.

Ajoutons les lignes suivantes dans la méthode processRequest de la servlet, après avoir décommenté les
lignes de processRequest() :

...
try {
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet ServletTest</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Servlet ServletTest at " + request.getContextPath () + "</h1>");
out.println("L'ejb HelloWorld a renvoyé : <em>" + helloWorld.getMessage() + "</em>");
out.println("</body>");
out.println("</html>");
} finally {
...

12
 Sauvegardons le tout, et exécutons le projet principal : clic droit sur le projet-TRIANGLE, puis
"exécuter"

Cela va avoir pour effet de lancer le serveur d'application, (cette opération peut prendre un certain
temps, des lignes vont s'afficher et au final, vous devriez avoir la ligne ci-dessous :

GÉNÉRATION TERMINÉE (durée totale X seconde)

INFO : si on fait plusieurs fois "exécuter", alors que le serveur tourne déjà, le serveur ne sera pas
relancé
INFO : si on se trompe et qu'on "exécute" un sous-projet, il faut "arréter" ce sous-projet avant
d'exécuter le projet compet (projet-triangle)

Votre projet a été déployé. Normalement après un certain temps, le navigateur ouvre une page par
défaut.
L'URL par défaut est le context de l'application web, (e.g., http://localhost:8080/TP1-war/ ) .
L'appel de cette URL appelle la page JSP index.jsp, "home page" du projet.

INFO : le fichier index.jsp se trouve dans le dossier "Web Pages" du sous-projet "TP1-war".
INFO : dans JEE5 et antérieur, un fichier web.xml présent dans le war du projet permettait de
configurer l'application web de différentes manières. Par exemple, il permettait de définir le nom de la
"home page" en éditant le fichier web.xml
POUR ALLER PLUS LOIN : que pouvait on configurer d'autre dans le web.xml ?
Rajoutons juste l'URL relatif de la servlet à la fin : (e.g., http://localhost:8080/TP1-war/ServletTest ).
Cela invoque la servlet.

13
Voilà, vous avez exécuté votre première application web utilisant des EJBs !!!!

5. Modifions la page par défaut et insérons un petit menu

La page par defaut est la page index.jsp du projet. Modifions là pour ajouter un menu avec une entrée
qui permet de lancer la servlet facilement. Pour cela, double cliquez sur la page index.jsp dans le
dossier Web Pages du sous-projet war.

Nous pouvons simplifier l'ajout de HTML en utilisant la palette disponible à partir de Outils>palette
(CTRL+MAJ+8)

Modifiez la source comme ceci :

14
 <%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP accueil TP1</title>
</head>
<body>
<h1>Menu du TP1</h1>
<ul> <li><a href="ServletTest">Appeler la Servlet de test</a></li> </ul>
</body>

</html>

6. Ecriture d’un second bean appelé par le bean HelloWorld

• Procédez comme précédemment (paragraphe 3.) pour créer un second bean, semblable à HelloWorld,
appelez-le MonSecondBean, ajoutez une méthode getMessage() qui renvoie « Je suis le second bean,
appelé par le bean HelloWorld ».

• Modifiez le bean HelloWorld afin de lui attribuer un bean MonSecondBean .

• Modifiez le bean HelloWorld afin que la méthode getMessage() récupère la valeur de la
méthodegetMessage() de monSecondBean, et l'ajoute à la fin du message qu’elle renvoie.
• Une fois vos modifications terminées, sauvegardez, déployez, testez la servlet. (pour redéployer, il
suffit de cliquer droit sur le projet-triangle, puis "exécuter".)
Au final, lorsqu’on exécute la servlet de test, cela doit afficher : L'ejb HelloWorld a renvoyé : Hello
World Je suis le second bean, appelé par le bean HelloWorld

7. Accès à une base de donnée via un entity bean et un

gestionnaire de persistence ("persistence manager")
7.1. La base de données, prise de contact

Sans aller trop loin, nous allons un peu jouer avec une base de données d'exemple livrée avec le JDK.
Les outils dont vous disposez viennent en effet en standard avec une petite base de données d'exemple.
Vous pouvez la consulter en cliquant sur l'onglet Services et en allant dans Bases de données/
jdbc:derby://localhost:1527/sample

15
Si jamais l'icône est cassée, faite clic droit/se connecter, (si nécessaire, le mot de passe est "app")

Dans la base APP, vous allez trouver les tables CUSTOMER, MANUFACTURER etc... en faisant clic droit/
"afficher les données" sur les tables vous pouvez également consulter les données qui sont déjà
disponibles.

Nous allons jouer pendant plusieurs TPs avec cette petite base de données.

16
7.2. Création d'un entity bean proxy de la table MANUFACTURER

Passons aux choses sérieuses. Nous allons créer un entity bean proxy vers la table MANUFACTURER.
Pour cela : clic droit sur le sous-projet ejb et choisissez entity Classes entités provenant de la base de
donnée, dans la fenêtre qui s'ouvre choisissez jdbc/sample comme datasource et parmi les tables
proposées choisissez MANUFACTURER.

Cliquez sur Suivant et vérifiez que le bouton create persistence unit est coché.
ça va avoir pour effet de créer un Persistence Manager pour le projet.
Persistence Manager = un module qui va gérer le mapping entre le monde des objets java et le monde des
base de données relationnelles.

17
 INFO : l'outil externe qui va assurer le mapping relationnel/objet est l'outil Toplink par défaut
(autrefois payant et développé par Oracle). Il est également possible de choisir l'outil très populaire
Hibernate développé par JBoss. Si le serveur d'application a besoin de nouvelles tables, il les créera.
Cliquez sur bouton "terminer". On peut voir :
• Un fichierpersistence.xml a été rajouté au projet EJB (celui avec l'icone en forme de grain de café),
sous l'entrée "Configuration files".
• Un fichier Manufacturer.java a été créé dans le package "tp1". La source est la suivante :
 /*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

 package tp1;

 import java.io.Serializable;
 import javax.persistence.Basic;
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.NamedQueries;
 import javax.persistence.NamedQuery;
 import javax.persistence.Table;

@Entity@Table(name = "MANUFACTURER")@NamedQueries({ @NamedQuery(name = "Manufacturer.findAll", query = "SELECT m FROM Manufacture

r m"),
 @NamedQuery(name = "Manufacturer.findByManufacturerId", query = "SELECT m FROM Manufacturer m WHERE
 m.manufacturerId = :manufacturerId"),
 @NamedQuery(name = "Manufacturer.findByName", query = "SELECT m FROM Manufacturer m WHERE m.name = :name"),
 @NamedQuery(name = "Manufacturer.findByAddressline1", query = "SELECT m FROM Manufacturer m WHERE m.addressline1 = :addressline1"),
 @NamedQuery(name = "Manufacturer.findByAddressline2", query = "SELECT m FROM Manufacturer m WHERE m.addressline2 = :addressline2"),
 @NamedQuery(name = "Manufacturer.findByCity", query = "SELECT m FROM Manufacturer m WHERE m.city = :city"),
 @NamedQuery(name = "Manufacturer.findByState", query = "SELECT m FROM Manufacturer m WHERE m.state = :state"),
 @NamedQuery(name = "Manufacturer.findByZip", query = "SELECT m FROM Manufacturer m WHERE m.zip = :zip"),
 @NamedQuery(name = "Manufacturer.findByPhone", query = "SELECT m FROM Manufacturer m WHERE m.phone = :phone"),
 @NamedQuery(name = "Manufacturer.findByFax", query = "SELECT m FROM Manufacturer m WHERE m.fax = :fax"),
 @NamedQuery(name = "Manufacturer.findByEmail", query = "SELECT m FROM Manufacturer m WHERE m.email = :email"),
 @NamedQuery(name = "Manufacturer.findByRep", query = "SELECT m FROM Manufacturer m WHERE m.rep = :rep")})
 public class Manufacturer implements Serializable {
 private static final long serialVersionUID = 1L; @Id
 @Basic(optional = false)
 @Column(name = "MANUFACTURER_ID")
 private Integer manufacturerId;
 @Column(name = "NAME") private String name;
 @Column(name = "ADDRESSLINE1")
 private String addressline1;
 @Column(name = "ADDRESSLINE2")
 private String addressline2;
 @Column(name = "CITY")
 private String city;
 @Column(name = "STATE")
 private String state;
 @Column(name = "ZIP")
 private String zip;
 @Column(name = "PHONE")
 private String phone;
 @Column(name = "FAX")
 private String fax;
 @Column(name = "EMAIL")
 private String email;
 @Column(name = "REP")
 private String rep;

 public Manufacturer() {

18
 }

 public Manufacturer(Integer manufacturerId) {
 this.manufacturerId = manufacturerId;
 }

 public Integer getManufacturerId() {
 return manufacturerId;
 }

 ...

Vous verrez que des méthodes permettant de rechercher des informations ont été automatiquement
créées, que les attributs de la classe ont été associé (via des attributs de code) avec des colonnes, que la
table sur laquelle se mappe ce bean est MANUFACTURER, etc... Remarquez les requêtes nommées qui
ont été générées, notamment la requête "FindAll" qui correspond à un select * from MANUFACTURER
en SQL :

@NamedQuery(name = "Manufacturer.findAll", query = "SELECT m FROM Manufacturer m")

L'URL de la base de données est connue du serveur d'application (pour en avoir le coeur net, ouvrez
l'interface d'administration du serveur et allez voir dans
Resources/JDBC/Resources JDBC/jdbc/sample vous verrez que le nom JNDI jdbc/sample est associé à un
connexion pool appelé SamplePool,
allez voir dans Resources/JDBC/Pools de connexion/Sample Poolset vous verrez le détail de cette
connexion.

INFO : Si vous avez besoin d'ajouter par exemple une base mySQL ou Postgres ou Oracle, il faudra
utiliser ces outils d'administration pour configurer la connexion afin qu'elle soit connue du serveur
d'application (il faudra également installer le .jar du driver jdbc dans le serveur d'application).

8. Modification du bean HelloWorld pour qu'il fasse un findAll sur

les manufacturers

Ouvrez la source du bean HelloWorld. On va lui indiquer que nous allons utiliser le persistence manager
que nous venons de créer pour utiliser des requêtes.

Pour cela: bouton droit n'importe où/Persistence/utiliser le gestionnaire d'entité.

19
Cela va insérer deux lignes dans le code de l'EJB :

@Stateless
public class HelloWorldBean implements HelloWorldLocal {
@PersistenceContext(name="TP1-ejbPU") private EntityManager em;

Ces deux lignes déclarent que l'objet em est un entity manager, et qu'on utilise un persistence manager
particulier dont le nom est TP1-ejbPU. On peut vérifier le nom du persistance manager en cliquant sur
le fichier persistence.xml dans le projet ejb :

20
 INFO : Dans un projet on peut avoir plusieurs persistence managers qui travaillent sur des bases de
données différentes. Leurs caractéristiques se trouvent dans le fichier persistence.xml. Si plusieurs
persistence managers sont déclarés dans le fichier persistence.xml, le premier est celui par défaut et il
n'est pas la peine de le nommer. Comme c'est notre cas ici, on peut simplement écrire :

@Stateless
public class HelloWorldBean implements HelloWorldLocal {
@PersistenceContext private EntityManager em;

Maintenant, ajoutez ce bout de code dans le bean:

public void printAllManufacturers() {

Query query = em.createNamedQuery("Manufacturer.findAll");
Collection< Manufacturer > result = query.getResultList();

for(Manufacturer cust:result ) {
System.out.println(cust.getName());
}
}

Ajoutez les importations nécessaires : javax.persistence.Query ; et java.util.Collection.

Cette méthode utilise l'entity manager em pour exécuter la requête Manufacturer.findAll.

Déclarez cette méthode dans l'interface,
puis appelez-là depuis la servlet ServletTest.
Sauvez, déployez, testez.
Dans la console du serveur d'application (dans netbeans), vous devez avoir la liste des
fournisseurs qui s'affiche :

21
 INFO: Google
INFO: Sun MicroSystems
INFO: Acer
INFO: Matrox
INFO: 3Com
INFO: CBX Cables
INFO: Sony
INFO: Getaway
INFO: SoftClip
INFO: Toshiba
INFO: Sams Publishing
INFO: Computer Cables & More
INFO: BMC
...

9. Affichage des résultats dans une page JSP

Nous allons modifier votre projet pour que la liste des manufacturers soit affichée dans une page Jsp
une fois que l'on a cliqué sur le bouton de la "home page" index.jsp, au lieu de s'afficher dans la console
avec des printlns...

En effet, les servlets ne sont pas faites pour afficher des résultats mais pour effectuer des traitements.
L'endroit où l'on va écrire des résultats, proposer des formulaires, ce sont les pages JSP.

Nous allons donc modifier notre bean HelloWorld en ajoutant une méthode qui au lieu de faire des
printlns avec les noms des manufacturers, va renvoyer une collection de Manufacturers:
Ajoutez donc cette méthode dans le bean HelloWorld:

public Collection getAllManufacturers() {

Query query = em.createNamedQuery("Manufacturer.findAll");
Collection< Manufacturer > result = query.getResultList();

return result;
}

22
Ajoutez les importations nécessaires : javax.persistence.Query ; et java.util.Collection.
N'oubliez pas de dire qu'elle doit figurer dans l'interface locale du bean, afin de pouvoir être appelée
depuis la servlet (lampe jaune à gauche ou bien copier/coller dans le fichier HelloWorldLocal.java)
Puis modifions la servlet en remplaçant le code de la méthode processRequest par le code suivant :

protected void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {
Collection manufacturers = helloWorld.getAllManufacturers();
request.setAttribute("Manufacturers", manufacturers);
RequestDispatcher dp = request.getRequestDispatcher("DisplayManufacturers.jsp");
dp.forward(request, response);
}

Ajoutez les importations nécessaires : java.util.Collection ; javax.servlet.ServletDispatcher.

La première ligne appelle la méthode du bean et récupère en retour une Collection de manufacturers.
Afin de la "faire passer à la JSP d'affichage", on la met dans la requête HTTP, à l'aide de la
méthode setAttribute (seconde ligne en rouge).

Les deux dernières lignes "passent la main" à la JSP "DisplayManufacturers.jsp". La méthode

forward permet de chaîner des servlets et des JSPs en conservant le même objet request.
Rappel : on a le droit de rien faire après un forward, surtout pas de générer un affichage.

La servlet n'affiche rien, elle se contente de faire un traitement, puis de passer la main ("forwarder").

Reste maintenant à écrire la JSP. Faire clic droit/Nouveau/JSP sur le sous-projet war et nommer la JSP :
DisplayManufacturers.jsp.

Puis modifier son code ainsi :

23
 <%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%--
The taglib directive below imports the JSTL library. If you uncomment it, you must also add
the JSTL library to the project. The Add Library... actionon Libraries node in Projects
view can be used to add the JSTL 1.1 library.
--%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>

<body>
<h1>List of Manufacturers</h1>
<ul>
<c:forEach var="u" items="${requestScope['Manufacturers']}">
<li>${u.name}</li>
</c:forEach>
</ul>
</body>
</html>

La ligne <%@taglib... %> indique que nous allons utiliser une librairie de tag JSP particulière : la JSP
Standard Tag Library (JSTL), livrée en standard avec J2EE. Cette librairie fournit des mécanismes pour
manipuler les paramètres HTTP, etc... sans avoir besoin d'écrire du java.

24
La ligne avec le foreEach par exemple récupère un paramètre intitulé Manufacturers (ça tombe bien,
c'est celui que nous avons passé depuis la servlet) et itère sur chaque élément (forEach...), puis on peut
appeler les méthodes getName() etc... juste en les nommant, au travers de ce que l'on appelle "une
variable JSP" : ${u.name}. Cette écriture est équivalent à un System.out.println(elem.getName()); ou
elem est de type Manufacturer. C'est plus simple quand même ${u.name} que ce long println...

Le lien suivant pointe vers un excellent tutorial sur la librairie JSTL et sur le langage d'expression EL
("Expression Language"). Voir aussi le support de cours fourni sur la page principale.

• Tutorial sur la librairie de tags jsp JSTL (Jsp Standard Tag Library).

Exécutez, cela doit afficher dans le navigateur la liste des Manufacturers.

10. Ajout d'un nouveau Manufacturer

Nous allons, maintenant, voir comment utiliser le persistence manager pour ajouter un nouveau
manufacturer dans la table.

Le scénario est le suivant : si lors de l'appel de la servlet la chaîne de requête contient le paramètre
insert (http://localhost:8080/TP1-war/ServletTest?insert=NewManufacturerName) alors la valeur de la
variable définira le nom d'un nouveau Manufacturer qu'on ajoutera à la table.

Pour cela, ajoutez la méthode addManufacturer(String name) suivante dans le bean HelloWorld,
n'oubliez pas de déclarer la méthode dans l'interface.

@Override
public void addManufacturer(String name) {
// On crée un nouveau manufacturer
Manufacturer m = new Manufacturer();
m.setName(name);
m.setManufacturerId(getAllManufacturers().size());em.persist(m);
System.out.println("Le nouveau manufacturer d'identifiant " + m.getManufacturerId() + " et de nom " + m.getName() + "
a été ajouté à la table.");
}

Remplacez également la méthode processRequest de la servlet par la méthode suivante :

25
 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String name = request.getParameter("insert");

if(name!=null) {
helloWorld.addManufacturer(name);
}

Collection manufacturers = helloWorld.getAllManufacturers();

request.setAttribute("Manufacturers", manufacturers);
RequestDispatcher dp = request.getRequestDispatcher("DisplayManufacturers.jsp");
dp.forward(request, response);
}

Essayez, et vérifiez que les ajouts ont bien eu lieu dans la table MANUFACTURER

Simple non ? La méthode persist permet d'ajouter un nouveau manufacturer dans la table.

Nous verrons que le persistence manager permet de faire des updates (méthode merge()), des delete, etc...

26