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

1. Installation logicielle

Logiciels obligatoires :

• un JDK version 1.6 ou supérieur ET Netbeans 6.9.x
  • 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 (février 2011 : Java SE 6 update 23)
    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 6.9.x : 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 (dernière colonne à droite).
    QUESTION : qu'est-ce qu'un IDE ?

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 DEJA UNE ANCIENNE VERSION !

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:

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

Indiquez maitenant que nous allons utiliser le serveur d'application de Sun (glassfish v3 ou v3.1 et le mode Java EE6)

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.

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) :

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 un 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).

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 le 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 !

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.

Rappel : URLs :

différentes parties :

obligatoire/facultatif :

exemple :

@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 la ligne 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 { 
   ...

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.

Voilà, vous avez exécuté votre première appli 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 le source comme ceci :

<%@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 .
  /div[6]/ul[2]/li/pre, line 1, column 8: EOF expected
• Modifiez le bean HelloWorld afin la méthode getMessage() récupère la valeur de la méthode getMessage() 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")

/*
 * 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 Manufacturer 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() {
    }

    public Manufacturer(Integer manufacturerId) {
        this.manufacturerId = manufacturerId;
    }

    public Integer getManufacturerId() {
        return manufacturerId;
    }

...

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

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

Ouvrez le 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é.

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 :

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 :

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;
  }

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 :

<%@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... action
on 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.

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 maitenant voir comment utiliser le persistence manager pour ajouter une 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 :

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...