1

Utiliser un Java Bean

© Kamal MOUMMADI

2

Sommaire1. Généralités2. Accès aux beans depuis les

pages JSP2.1. La balise jsp:useBean2.2. La balise jsp:setProperty2.3. La balise jsp:getproperty3. Les Beans formulaires4. Accés aux bases de données

3

Généralités Une des premières techniques permettant de séparer le code Java et le code HTML, consiste à

‘enlever’ du code Java de nos pages JSP, et à le déporter dans des classes spéciales les Java Beans.

Un Java bean est une classe concrète et publique, qui possède un constructeur public sans arguments, et qui permet de définir des propriétés dont les méthodes d’accès suivent les conventions de nommage ci-dessous. Par exemple :

Public class Client{

protected String nom = "" ;protected String adresse = "" ;

….public String getNom()….public void setNom(String name)….public String getAdresse()….public void setAdresse(String ad)….….} Les Java Beans sont utilisés pour séparer la logique métier des pages JSP, qui au bout du

compte, ne serviront qu’à générer du code HTML. Ils servent d’interface entre les objets métiers et les pages JSP. Les accès s’effectueront par les propriétés (les JSP n’ayant pas accès aux méthodes des beans, excepté les getters et les setters). Attention : ne pas mettre de contrôles dans les sets !

Une utilisation classique des Java Beans dans le cadre d’une application web est le Bean formulaire, qui va encapsuler la logique de validation d’un formulaire dans une méthode validate() (voir plus loin).

4

Accès aux beans depuis les pages JSPDes balises JSP spéciales permettent de

dialoguer avec les beans (par l’intermédiaire des getters et des setters), et ainsi de réduire le code Java contenu dans les pages JSP.

5

La balise jsp:useBean Cette balise permet d’utiliser un bean, et de créer une instance de la classe, si elle n’existe pas

déjà. La syntaxe est la suivante : <jsp:useBean id= "client" class="jweb.Client" scope="request" /> Ceci est équivalent à :

Client client = (Client)request.getAttribute("client") ;if (client==null){

client=new Client() ;request.setAttribute("client",client) ;

} Les paramètres sont : - id : nom du bean.

- class : class du bean (préciser le package). - scope : portée dans laquelle sera disponible le bean. Les valeurs possibles sont :

page (valable uniquement à l’intérieur de la page), request (pour la durée de la requête, c'est-à-dire depuis la page de départ jusqu’à la

page forwardée), session (durée de la session), Application (durée de l’application).

6

La balise jsp:setProperty Cette balise permet d’affecter une valeur à une propriété d’un bean :

La syntaxe est la suivante : <jsp:setProperty name="client" property="nom" value="Toto" />

qui est équivalent à : client.setNom("Toto") ; ou <jsp:setProperty name="client" property="nom " />

qui est équivalent à : client.setNom(request.getParameter("nom")) ;

ou <jsp:setProperty name="client" property="nom" param="parNom" /> qui est équivalent à : client.setNom(request.getParameter("parNom")) ;

ou <jsp:setProperty name="client" property="*" /> qui est équivalent à : client.setNom(request.getParameter("nom")) ;

client.setAdresse(request.getParameter("adresse")) ; …

Les paramètres de <jsp:setProperty> sont : - name : nom du bean. - property : nom de la propriété à définir (* remplit toutes les propriétés du bean à partir des paramètres de requête correspondants). - value : valeur de la propriété codée en dur. - ou param : valeur d’un paramètre de requête

7

La balise jsp:setProperty Si value et param ne sont pas renseignés, la propriété prendra la valeur d’un

paramètre de requête portant le même nom. (ceci implique que dans nos beans, on doit avoir des propriétés dont les noms sont identiques aux noms des paramètres de requête).

Deux utilisations de <jsp:setProperty> sont possibles : à l’intérieur de la balise <jsp:useBean> :

dans ce cas, les méthodes set ne seront exécutées que si le bean vient d’être créé :

<jsp:useBean id= "client" class="jweb.Client" scope="request"> <jsp:setProperty name="client" property="nom" value="Toto" /></jsp:useBean>

Ceci est équivalent à :Client client = (Client)request.getAttribute("client") ;if (client==null){

client=new Client() ;request.setAttribute("client",client) ;

client.setNom("Toto") ;}

en dehors de la balise <jsp:useBean> :dans ce cas, les méthodes set seront exécutées que le bean soit nouveau ou non :

<jsp:useBean id= "client" class="jweb.Client" scope="request" /><jsp:setProperty name="client" property="nom" value="Toto" />

Ceci est équivalent à :Client client = (Client)request.getAttribute("client") ;if (client==null){

client=new Client() ;request.setAttribute("client",client) ;

} client.setNom("Toto") ;

8

La balise jsp:getproperty Cette balise permet de récupérer la valeur d’une propriété d’un bean : La syntaxe est la suivante : <jsp:getProperty name="client" property="nom" />

ce qui est équivalent à : client.getNom() ; Les paramètres de <jsp:getProperty> sont : - name : nom du bean.

- property : nom de la propriété à obtenir.

9

Les Beans formulairesLa logique de validation des formulaires est codée en Java, à l’intérieur des pages JSP. Une bonne utilisation des beans consiste à créer un Java Beans, qui servira à traiter la validation du formulaire.Un tel bean est appelé un Bean formulaire. Il possède une propriété pour chaque contrôle du formulaire, et contient une méthode validate() permettant la validation, et la création d’une map contenant les différentes erreurs (tableau propriété/messaged’erreur).Par exemple, si l’on a un formulaire de saisie des informations d’un client (nom, adresse…), on va créer un java bean associé comme suit :

10

Les Beans formulaires

11

Accés aux bases de données Une des principales utilisations des scripts serveurs consiste en l’accès

à des bases de données, afin de récupérer ou mettre à jour des informations.

On pourrait directement accèder aux bases de données (via JDBC) depuis les servlets ou les pages JSP, mais ceci est fortement déconseillé et il est préférable de déconnecter l’accès aux données de l’affichage HTML.

On va donc utiliser des beans qui interagissent avec le SGBD. Ces Beans données peuvent être utilisés dans d’autres contextes que les applications web. Ils servent d’interface avec une table de la base de données, et structurent l’écriture des applications métier. Dans une architecture J2EE utilisant des serveurs d’application, ces beans données peuvent être des EJB et le développement du mapping objet/relationnel (classes d’accès aux tables de la base de données) peut être fait à l’aide de framework (Hibernate ou Toplink par exemple).

Concrètement, un bean d’accès à la base permettra la connexion à la base de données, l’exécution de la requête, le parcours du résultat (ResultSet) de cette requête. Des optimisations pourront être effectuées afin d’obtenir des connexions gérées en pools (JDBC2.0).

12

Exercice1 Nous allons reprendre l’exercice de conversion de devise (A-C-004), et rajouter un bean

formulaire qui s’occupera de la validation des valeurs saisies dans le formulaire. 1ère étape

Développer le Java Bean. Ce bean aura les attributs suivants :

monnaiedep de type String

monnaiefin de type String

montant de type String

montantfin de type String

errors de type Map

Il comportera les méthodes get et set correspondantes, ainsi qu’une méthode validate() de validation des champs du formulaire, qui renverra un booléen, et positionnera le cas échéant les messages d’erreur dans la Map errors. Si tous les champs sont corrects, l’attribut montantfin sera calculé.

2ième étape

Modifier la page saisie.jsp pour appeller le bean, et exécuter la méthode validate(). Si la saisie est bonne, la page resultat.jsp sera forwardée, sinon la page sera réaffichée avec les messages d’erreur correspondants, que l’on ira chercher dans le bean.

3ième étape

Modifier la page resultat.jsp pour afficher les informations depuis le bean.

Le diagramme de composant est le suivant :

13

Exercice1

14

Exercice2

Part 1:

Nous allons tester dans cet exercice, les accès aux bases de données. Nous travaillerons sur un cas très classique dans les applications de type e-commerce, d’affichage d’un catalogue :

15

Exercice2

Nous utiliserons une base de données dont le script de création vous est fourni. Cette base de données comporte (entre autres) la table Article définie comme suit :

16

Exercice2 Il vous faudra créer un lien ODBC vers cette base de données. Dans un premier temps, nous allons faire les choses trés simplement : nous allons créer

une seule page catalogue.jsp, dans laquelle nous allons ouvrir une connection via jdbc, exécuter la requête et balayer le resultSet contenant les articles à afficher.

<% // ouverture de la connection et execution de la requete et récupération des résultats dans le résultset rs……..

%> <TABLE border=0> …….. <% while (rs.next()) { %> <TR> <TD><%=rs.getString("referenceart")%></TD> ………. </TR> <% } %>……<% //fermeture de la connexion….. %> Attention : Cette manière de faire est la plus simple, et on la retrouve donc dans un

certain nombre de sites et de petites applications web. Elle n’est cependant pas satisfaisante, et nous allons dans un second temps, structurer notre exercice de manière un peu plus propre.

17

Exercice2Part 2:

Nous allons structurer nos différentes classes proprement, et notamment séparer les classes d’accès aux données des classes beans utilisées pour l’affichage. Cette structure semble sans doute un peu lourde, mais est conforme au modèle MVC et témoigne d’une ‘bonne pratique’.

1ère étape Dans un package accesBase, créer une classe particulière connexion, avec une méthode

ouvrirCon() qui renverra un objet Connection. Cette méthode se charge de définir le pilote ODBC et d’ouvrir la connection.

package accesBase;

import java.sql.*;

public class Connection {public static java.sql.Connection ouvrirCon()throws ClassNotFoundException,SQLException{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); return DriverManager.getConnection("jdbc:odbc:mybase"); }}

18

Exercice2Part 2:

Dans le même package, créer une classe d’accès à la table article (classe ArticleBdd). Cette classe comprend uniquement une méthode lirecat, qui a en paramètre un objet Catalogue cat. Cette méthode va exécuter la requete sql de lecture de la table Article, et pour chaque article trouvé, l’ajouter dans le Catalogue cat.

package accesBase;

import beans.Catalogue;import java.sql.*;import java.util.logging.Level;import java.util.logging.Logger;

public class ArticleBdd {

static ResultSet getResult()throws ClassNotFoundException,SQLException{ Statement st =accesBase.Connection.ouvrirCon().createStatement(); return st.executeQuery("select * from article"); }

public static void lirecat(Catalogue cat) throws ClassNotFoundException{ ResultSet rs;

19

Exercice2Part 2:1ère étape

Dans le même package, créer une classe d’accès à la table article (classe ArticleBdd). Cette classe comprend uniquement une méthode lirecat, qui a en paramètre un objet Catalogue cat. Cette méthode va exécuter la requete sql de lecture de la table Article, et pour chaque article trouvé, l’ajouter dans le Catalogue cat.

try { rs = getResult();

String referenceart; double prix; int quantite; String photo ; String titre ; String auteur; String editeur; int annee; int seuil ; String genre; beans.Article a; while(rs.next()){ referenceart=rs.getString(1); prix=rs.getDouble(2); quantite=rs.getInt(3); photo =rs.getString(4); titre =rs.getString(5); auteur=rs.getString(6); editeur=rs.getString(7); annee=rs.getInt(8); seuil =rs.getInt(9); genre=rs.getString(10); a=new beans.Article( referenceart, prix, quantite, photo, titre, auteur, editeur, annee, seuil, genre); cat.ajouter(a); } } catch (SQLException ex) { Logger.getLogger(ArticleBdd.class.getName()).log(Level.SEVERE, null, ex); }}}

20

Exercice2 2ième étape Dans un package beans, créer un bean Article, contenant les données de l’article et les méthodes

get et set associées.package beans;

public class Article {private String referenceart; private double prix; private int quantite; private String photo ; private String titre ; private String auteur; private String editeur; private int annee; private int seuil ; private String genre; public Article(String referenceart,double prix, int quantite,String photo,String titre,String auteur,String editeur,int annee,int seuil,String genre){ this.referenceart=referenceart; this.prix=prix; this.quantite=quantite; this.photo =photo; this.titre =titre; this.auteur=auteur; this.editeur=editeur; this.annee=annee; this.seuil =seuil; this.genre=genre; }public Article(){

}

public String toString(){ return "<tr><td>"+referenceart+"</td><td>" +prix+"</td><td>" +quantite+"</td><td><img src=\"./image/" +photo+"\"></td><td>" +titre+"</td><td>" +auteur+"</td><td>" +editeur+"</td><td>" +annee+"</td><td>" +seuil+"</td><td>"

+genre+"</td></tr>";} /** * @return the referenceart */ public String getReferenceart() { return referenceart; }

/** * @param referenceart the referenceart to set */ public void setReferenceart(String referenceart) { this.referenceart = referenceart; }…..

21

Exercice2 2ième étape Dans le même package, créer un bean Catalogue qui contiendra une collection d’articles

(Vector arts), une méthode lire() qui appellera la méthode lirecat de la classe ArticleBdd, et une méthode ajouter() qui ajoutera un article (passé en paramètre) dans la collection arts d’articles du catalogue.

package beans;

import accesBase.ArticleBdd;import java.util.Vector;import java.util.logging.Level;import java.util.logging.Logger;

public class Catalogue {private Vector<Article> v= new Vector<Article>();public void lire(){ try { ArticleBdd.lirecat(this); } catch (ClassNotFoundException ex) { Logger.getLogger(Catalogue.class.getName()).log(Level.SEVERE, null, ex); }}public void ajouter(Article a){ getV().add(a) ;}

/** * @return the v */ public Vector<Article> getV() { return v; }}

22

Exercice2 3ième étape Ecrire le script serveur catalogue.jsp, qui utilisera le bean Catalogue et appelera sa

méthode lire(). <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <% if ( request.getAttribute("affiche")==null){

RequestDispatcher disp =request.getRequestDispatcher("Controler"); disp.forward(request, response); } %> <%= request.getAttribute("affiche")

%><body> <h1>Hello World!</h1> </body></html>

23

Exercice2 3ième étape Ecrire le script serveur catalogue.jsp, qui utilisera le bean Catalogue et appelera sa méthode lire(). La servlet controler:package controler;import beans.Article;import beans.Catalogue;import java.io.IOException;import java.io.PrintWriter;import java.util.Vector;import javax.servlet.RequestDispatcher;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class Controler extends HttpServlet { Vector <beans.Article> v;protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); beans.Catalogue cat =new Catalogue(); cat.lire(); v=cat.getV(); PrintWriter out = response.getWriter(); try { String s =" <table border=\"2\" width=\"2\" cellspacing=\"2\" cellpadding=\"3\"> <thead><tr><th>referenceart</th><th>prix</th><th>quantite</th><th>photo</

th><th>titre</th><th>auteur</th><th>editeur</th><th>annee</th><th>seuil</th> <th>genre</th> </tr> </thead> <tbody>"; for (Article article : v) { s+=article.toString(); } s+="</tbody></table>"; request.setAttribute("affiche", s); RequestDispatcher disp =request.getRequestDispatcher("index.jsp"); disp.forward(request, response); } finally { out.close(); } }

24

Conclusion