Résumé de l'épisode précédent (Les Servlets) XVII-1
servlet =? Une servlet est un programme (plug-in) à ajouter à un serveur (quel qu'il soit). Ce cours a trait à la programmation Java coté serveur (Java EE ) Pour l'instant les serveurs acceptant des servlets sont plutôt des serveurs Web. XVII-2
Comment ça marche? Le serveur (Web) possède désormais un interpréteur Java (JVM) => il n'y a pas de processus créé lors de l'exécution de code Java Cf. les clients Web possèdent un interpréteur Java permettant de lancer des applets. D'où le nom de servlets. XVII-3
Moteurs de servlets (et de JSP) : les pages JSP et la JSTL Tomcat Plug-in d'autres serveurs web (apache, Microsoft IIS, ) Est aussi un mini-serveur Web Version 7.0.33 au 1er décembre 2012 Voir à http://tomcat.apache.org/tomcat-7.0- doc/index.html XVII-4
Une servlet : code complet import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class MaPremiereServlet extends HttpServlet { public void doget(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException { // Etape 1. Spécifier le type MIME du contenu de la réponse response.setcontenttype("text/html"); // Etape 2. Récupère le PrintWriter pour envoyer des données au client PrintWriter out = response.getwriter(); } // Step 3. Envoyer l information au client out.println("<html>"); out.println("<head><title>bonjour Servlet</title></head>"); out.println("<body>"); out.println("<h1> Bonjour à tous </h1>"); out.println("il est : " + new java.util.date()); out.println("</body></html>"); } public void dopost(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException { doget(request, response); } XVII-5
application web =? "Une application web est une extension dynamique d'un serveur web ou applicatif" Par exemple : les application web orientées présentation qui génèrent des pages web (HTML, XML) dynamiquement XVII-6
Architecture d'une application web 1/3 Une bonne référence est : http://tomcat.apache.org/tomcat-7.0- doc/appdev/deployment.html Depuis la version 2.2 des spécifications des servlets, les ressources doivent être rangées comme indiqué diapo suivante : XVII-7
Architecture d'une application web 2/3 Les fichiers.html et.jsp doivent être rangés à partir de la racine de votre site web (= application web). /WEB-INF/web.xml : le fichier descripteur de déploiement de votre application web /WEB-INF/classes/ : le répertoire racine de rangement des.class (servlets compilés, etc.). Si les classes sont dans des packages, la hiérarchie des packages doit être respectée à partir de /WEB-INF/classes/. Par exemple la classe cnam.ihm.maservlet doit être mise dans /WEB-INF/classes/cnam/ihm/MaServlet.class XVII-8
Architecture d'une application web 3/3 /WEB-INF/lib/ : le répertoire contenant les.jar nécessaires à votre application web (driver JDBC, etc.) RACINE WEB-INF web.xml classes lib *.html, *.jsp On peut mettre tout cela dans un fichier compressé : un.war XVII-9
Bibliographie Page de départ de la technologie servlets : http://java.sun.com/products/servlet/in dex.html Java servlets, Jason Hunter, ed O'Reilly traduit en français XVII-10
Fin du résumé de l'épisode précédent XVII-11
JavaServer Pages (JSP) XVII-12
ssi : la technique server side include Une page ssi (shtml) est demandée par un client web Le serveur Web passe la main au programme adéquat qui traite la partie de la page le concernant. Ce programme génère la partie dynamique La page HTML créée dans son ensemble est retournée au serveur puis au client Web. XVII-13
JavaServer Pages = JSP = la technique des ssi en Java = une page HTML contenant du code Java => meilleure division des tâches : présentation générale par les graphistes coté dynamique par des programmeurs (Java) XVII-14
Comment ça marche? Concrêtement : toute la page HTML est convertie en une servlet cette servlet est traitée par le moteur Java intégré au serveur Web (technologie des servlets) et retourne la page HTML construite XVII-15
JSP vs. Servlets Servlet = du code Java contenant de l'html JSP = une page HTML contenant du code Java Concrètement avec les JSP : les parties statiques de la page HTML sont écrites en HTML les parties dynamiques de la page HTML sont écrites en Java XVII-16
Notre première JSP fichier MaDate.jsp <html><head><title>obtenu par une JSP</title></head> <body> <h3>bonjour de ma part </h3> <hr> La date courante est : <%= new java.util.date() %> </body> </html> Traité quand le client demande l URL de la JSP : http://serveurweb:<port>/.../madate.jsp XVII-17
Tomcat et JSP Des exemples de JSP (code + liens pour l'exécution) sont disponibles à partir de REP_INSTALL_TOMCAT/webapps/examples/jsp pour Tomcat XVII-18
Exécution de JSP Il faut mettre les pages JSP dans un endroit particulier du serveur Web Cet endroit dépend du serveur Web et de sa configuration Pour tomcat en configuration standard, http://localhost: 8080/examples/jsp/MaDate.jsp ~ REP_INSTAL_TOMCAT\webapps\examples\jsp\ MaDate.jsp pour tomcat Et sans bidouille!! XVII-19
Exécution de JSP (suite) Une démo: Le résultat de MaDate.jsp est : Une autre exécution donne une autre date => dynamicité XVII-20
Que s'est il passé? Le moteur de JSP a construit une servlet (MaDate_jsp.java sous l'arborescence work pour Tomcat) Cette phase est parfois appelée la traduction de la JSP (en servlet) Puis a compilé et exécuté la servlet XVII-21
La servlet construite package org.apache.jsp;... public class MaData_jsp extends HttpJspBase {... public void _jspservice(httpservletrequest request, HttpServletResponse response) throws IOException, ServletException {... pagecontext = _jspxfactory.getpagecontext(...); session = pagecontext.getsession(); out = pagecontext.getout(); // HTML // begin [file="c:\\...\\examples\\jsp\\madate.jsp";from=(0,0);to=(4,24)] out.write("<html><head><title>obtenu par une JSP</title></head>\r\n <body>\r\n\r\n<h3>bonjour de ma part</h3> <hr>\r\n La date courante est : "); // end //begin [file="c:\\...\\examples\\jsp\\madate.jsp";from=(4,27)to=(4,49)] out.print( new java.util.date() ); // end // HTML // begin [file="c:\\...\\examples\\jsp\\date.jsp";from=(4,51);to=(6,7)] out.write("\r\n</body>\r\n</html>"); // end... } } XVII-22
Algorithme d'exécution de la JSP Requête client Conteneur de JSP La servlet associée à la JSP demandée est-elle chargée en mémoire du moteur de servlets? Non Oui Oui servlet à jour précompilée disponible? Non Traduire en servlet et compiler Oui Le fichier JSP a- t-il été modifié depuis la dernière traduction en servlet? Charger la servlet Non Réponse au client Exécuter la servlet XVII-23
3 parties d'une JSP scriptlets <% %> déclarations <%! %> expressions <%= %> XVII-24
Scriptlets <% %> contient du code Java insérer dans _jspservice() de la servlet, donc peut utiliser out, request, response, etc. Exemple : <% %> String[] langages = {"Java", "C++", "Smalltalk", "Simula 67"}; out.println("<h3>principaux langages orientés objets : </h3>"); for (int i=0; i < langages.length; i++) { out.println("<p>" + langages[i] + "</p>"); } XVII-25
Déclarations <%! %> Sont des déclarations Java. Seront insérées comme des membres de la servlet Permet de définir des méthodes ou des données membres Exemples : <%! %> int random4() { return (int)(math.random() * 4); } <%! %> int nombrefetiche = 2; XVII-26
Expressions <%= %> En fait expression Java qui renvoie un objet String ou un type primitif. Un raccourci pour <% out.println( ); %> <%= XXX %> ~ <% out.println(xxx); %> attention au ; est donc converti en out.println( ) dans la méthode _jspservice( ) de la servlet. La somme est: <%= (195 + 9 + 273) %> Je vous réponds à l'adresse : <%= request.getparameter("email_address") %> XVII-27
Objets prédéfinis dans une JSP 3 objets peuvent être immédiatement utilisés dans une expression ou une scriptlet d'une JSP : out : le canal de sortie request (HttpServletRequest) : l'objet requête response (HttpServletResponse) : l'objet réponse Il y en a d'autres Cf. ces mêmes objets dans une servlet XVII-28
Un exemple complet : complet.jsp <html><head><title>jsp complet</title></head> <body> <%! String[] langages = {"Java", "C++", "Smalltalk", "Simula 67"}; int random4() { return (int) (Math.random() * 4); } %> <p>parmi tous les langages orientés objets :</p> <ol> <% for (int i=0; i < langages.length; i++) { out.println("<li>" + langages[i] + "</li>"); } %> </ol> <p>le prochain que j'apprends est <b><%= langages[random4()] %> </b></p> </body> </html> XVII-29
complet.jsp XVII-30
Déboguer les JSP La fenêtre de lancement du serveur Web donne des indications. Suivant les serveurs, une page HTML est retournée avec des indications. Ces éléments sont très souvent relatifs à la servlet et pas à la page JSP. Directives <%@ page errorpage=...%> et <%@ page iserrorpage="true"%> XVII-31
Déboguer les JSP (suite) Un page JSP peut référencer une page erreur par <%@ page errorpage="page.jsp"%> La page erreur est indiquée par l'entête <%@ page iserrorpage="true"%> Si une exception est levée le traitement est dérouté vers la page erreur qui connaît la référence exception qui repère l'exception XVII-32
Déboguer les JSP : exemple langages.jsp <%@ page errorpage="erreur.jsp"%> <%! String[] langages = {"Java", "C++", "Smalltalk", "Simula 67"}; %> <p>parmi tous les langages orientés objets :</p> <ol> <% // levée d'une ArrayIndexOutOfBoundsException for (int i=0; i < 7; i++) { out.println("<li>" + langages[i] + "</li>"); } %> XVII-33
Déboguer les JSP : exemple (suite) erreur.jsp <%@ page iserrorpage="true"%> <html><body> exception levée <b> <%= exception %> </b> <hr> <h3>trace de la pile</h3> <pre> <% java.io.printwriter mywriter = new java.io.printwriter(out); exception.printstacktrace(mywriter); %> </pre> </body></html> XVII-34
Déboguer les JSP : exemple (fin) Charger la page langages.jsp amène à : XVII-35
Enchaîner les pages Un page JSP peut en appeler une autre par la directive : <jsp:forward> Syntaxe : <jsp:forward page="pagederedirection" /> lanceforward.jsp <% String reputilisateur = request.getparameter("reptextfield"); int rep = Integer.parseInt(repUtilisateur); if ((rep % 2) == 0) { %> <jsp:forward page="gagne.jsp"/> <% } else { %> <jsp:forward page="perdu.jsp"/> <% } %> On n'affiche jamais cela XVII-36
Enchaîner les pages (suite) Après un <jsp:forward>, le traitement est entièrement pris en charge par nouvelle page Navigateur 1. lanceforward.jsp Serveur Web lanceforward.jsp <jsp:forward page="gagne.jsp"/> 3. Retourner gagne.jsp gagne.jsp worker.jsp Transmis à gagne.jsp XVII-37
Inclusion de fichiers par <%@ include file=" " %> Utilisé pour faire des inclusions statiques de fichiers : en-tête ou pied de page... Syntaxe : <%@ include file="path to relative URL" %> Le fichier est inclus au moment de la traduction main.jsp <%@ include file="header.html" %> <h3>bienvenue en GLG 203</h3> header.html <%@ include file="footer.jsp" %> footer.jsp
Inclusion de pages <jsp:include page=" " /> Pour inclure des sorties de servlets ou JSPs Le contenu du servlet ou de la JSP est traité avant l inclusion La page est incluse au moment de la requête Syntaxe : <jsp:include page="path to relative URL" /> Le traitement de la page courante continue après l inclusion des ressources header.html main.jsp <jsp:include > <jsp:include > questions.jsp Components Permet aussi d inclure du HTML On préférera <%@ include %> pour inclure du HTML
Différences entre les 2 include <%@ include... > est un simple inclusion, c'est à dire une copie (à la #include des langages C, C++) <jsp:include...> peut faire le même travail que <%@ include... > mais fait l'inclusion à chaque requête donc dynamique. On peut donc inclure une autre page JSP, qui sera exécutée à la requête. De plus avec <jsp:include...>, on peut passer des paramêtres à la page à inclure, voire faire de la programmation qui sera exécutée à la requête. XVII-40
Passage de paramêtres grâce à jsp:include Une page JSP peut passer des paramètres supplémentaires à la page de destination Par exemple page1.jsp envoie un paramètre supplémentaire à travail.jsp <jsp:include page="travail.jsp"> <jsp:param name="niveautraitement" value="important" /> </jsp:include> travail.jsp récupère le paramètre à l'aide de request.getparameter("nomvariable") Ce traitement est : <%= request.getparameter("niveautraitement") %> XVII-41
Programmation (conditionnelle) grâce à jsp:include Ayant récupéré un paramêtre on peut s'en servir! <% String typevacanceschoisi = request.getparameter("typevac"); String choixdestinations; if ( (typevacanceschoisi!= null) && (typevacanceschoisi.equalsignorecase("nature"))) { choixdestinations = "vacancesalacampagne.jsp"; } else { choixdestinations = "vacancescitadines.jsp"; } %> <jsp:include page="<%= choixdestinations %>"/> XVII-42
Conclusion <%@ include...> vs. <%@ include %> <jsp:include...> Inclusion statique de page HTML ou JSP = le contenu est inclus au moment de la traduction Le nom du fichier à inclure doit être connu au moment de la traduction Souvent utilisé pour les en-têtes et pieds de page <jsp:include> Inclusion dynamique de JSP ou sortie de servlet = le contenu est traité au moment de la requête Le nom de la page à inclure peut être déterminé au moment de la requête Peut passer des paramètres aux pages incluses XVII-43
JSP et Java beans But : avoir le moins de code Java possible dans une page JSP (HTML) Sous-traiter le code à un Java bean balise XML : <jsp:usebean> XVII-44
JSP et Java beans (suite) Syntaxe générale : <jsp:usebean id="nominstancejavabean" class="nomclassedubean" scope="request session application page"> </jsp:usebean> Le bean est alors utilisable par nominstancejavabean balise sans corps donc utilisation de <jsp:usebean /> XVII-45
page l'attribut scope Il indique la portée du bean. valeur request session application Description Le bean est valide pour cette requête. Il est utilisable dans les pages de redirection de la requête (<jsp:forward>). Il est détruit à la fin de la requête. Similaire à request, mais le bean n'est pas transmis aux pages de redirection <jsp:forward>. C'est la portée par défaut Le bean est valide pour la session courante. S il n existe pas encore dans la session courante, il est créé et placé dans la session du client. Il est réutilisé jusqu à ce que la session soit invalidée Le bean est valide pour l application courante. Il est créé une fois et partagé par tous les clients des JSP. XVII-46
JSP et Java beans : exemple Soit le bean : package cnam; public class SimpleBean implements java.io.serializable { } private int compter; public SimpleBean() { compter = 0; } public void setcompter(int thevalue) { compter = thevalue; } public int getcompter() { return compter; } public void increment() { compter++; } XVII-47 Remarque : il faut mettre le bean dans un package
Utilisation du bean dans une JSP Utilisation à l'aide de son nom Récupération des propriétés : Par appel de méthode getxxx() : Par la balise <jsp:getproperty > <p> on repere le bean par le nom nombean<br> <jsp:usebean id="nombean" class="cnam.simplebean" scope="session" /> <p> On accede a une propriéte avec une expression: <br> compteur = <%= nombean.getcompter() %> <hr> On incrémente le compteur <% nombean.increment(); %> <p>on peut accéder à la propriété par une balise :<br> <jsp:getproperty name="nombean" property="compter" /> XVII-48
Positionner les propriétés du bean dans une JSP Par appel de méthode setxxx(...) : Par la balise <jsp:setproperty > <p> on repere le bean par le nom nombean<br> <jsp:usebean id="nombean" class="cnam.simplebean" scope="session" /> <p> On positionne une propriéte avec une expresion: <br> compteur = <%= nombean.setcompter(6) %> <p>ou par une balise :<br> <jsp:setproperty name="nombean" property="compter" value="6" /> Une demo? OK! XVII-49
Architecture MVC modèle = les données accédées par un code Java (JDBC, RMI, EJB, etc.) vues = JSP contrôleur = servlets XVII-50
Architecture MVC (suite) Syntaxe dans la servlet pour lancer la JSP : public void dopost(httpservletrequest request, HttpServletResponse response){ ServletContext context = getservletcontext(); // héritée de GenericServlet RequestDispatcher dispatcher = context.getrequestdispatcher("/mapagemiseenforme.jsp"); dispatcher.forward(request, response); } XVII-51
Architecture MVC (suite) La servlet peut passer des valeurs à la JSP appelée grâce à setattribute() public void dopost(httpservletrequest request, HttpServletResponse response) { // appelle les méthodes sur les objets métiers ArrayList thelist = // un objet à passer // ajoute à la requête request.setattribute("nomdelobjet", thelist); ServletContext context = getservletcontext(); RequestDispatcher dispatcher = context.getrequestdispatcher("/jspaappeler.jsp"); dispatcher.forward(request, response); } La JSP extrait les objets de request grâce à getattribute() <% ArrayList thelist = (ArrayList) request.getattribute("nomdelobjet"); // maintenant, utiliser l'arraylist %> XVII-52
La JSTL (JSP Standard Tag Library) XVII-53
Développer ses propres balises On plus des balises jsp:usebean, jsp:setproperty, etc, on peut développer ces propres balises Le but? Ne manipuler qu'un langage de balises dans les pages JSP Première technique : avec des classes Java. C'est lourd et délicat mais cela fonctionne Seconde technique : avec les bibliohèques de balises (tags libraries) XVII-54
Développer ses balises avec une "tag library" Une "tag library" est une bibliothèque de balises. Concrètement, c'est un répertoire qui contient des descriptions de balises L'application web a l'architecture : racine de l'appli web WEB-INF tags dictons.tag dictons_test.jsp XVII-55
dictons_test.jsp C'est la page JSP qui utilise la balise : <%@ taglib prefix="ez" tagdir="/web-inf/tags"%> <html><body> <b>formule du soir</b> <hr/> <i> <ez:dictons/> </i> </body></html> Une démo : OK. URL http://localhost:8080/glg203/dictons_test.jsp XVII-56
dictons.tag Pour cela, il faut avoir le fichier dictons.tag Sa syntaxe est aisée et proche du langage Java : <%! String[] lesdictons = {"Bonsoir!", "GLG203, c'est vraiment super", "Le CNAM, quel pied!"}; %> <% %> int index = (int) (Math.random() * lesdictons.length); out.print(lesdictons[index]); XVII-57
Balises avec attribut On peut développer des balises plus complexes (avec attribut par exemple) et avoir une page JSP comme : <%@ taglib prefix="ez" tagdir="/web-inf/tags"%> <html><body> <b>formule du soir</b> <hr/> <i> <ez:dictonsavecattributs nompersonne="toto"/> </i> </body></html> Un démo OK : URL http://localhost: 8080/GLG203/dictonsAvecAttributs_test.jsp XVII-58
dictonsavecattriburs.tag Pour cela, il faut avoir le fichier dictonsavecattributs.tag Les suppléments en gras <%@ attribute name="nompersonne" type="java.lang.string" required="false" %> <%! String[] lesdictons = {"Bonsoir!", "GLG203, c'est vraiment super", "Le CNAM, quel pied!"}; %> <% %> int index = (int) (Math.random() * lesdictons.length); if (nompersonne!= null) { out.print("pour monsieur " + nompersonne + ", "); } out.print(lesdictons[index]); XVII-59
Et avec des classes Java? "C'est lourd et délicat, mais cela fonctionne"! L'idée principale est que, quand le conteneur de pages JSP lit une page JSP, il peut déclencher le lancement de certaines méthodes d'une classe associée à une balise (cf. les traitements JAXP) Par exemple, on définit la classe Hello.java : package cnam; import javax.servlet.jsp.tagext.*; public class Hello extends TagSupport{ public int dostarttag() throws JspException { try { pagecontext.getout().print("hello World"); } catch (Exception ex) { throw new JspException("IO problems"); } return SKIP_BODY; } } XVII-60
Association classe Java et balise C'est dans le fichier de description de bibliothèques de balises (tld = tag library descriptor) qu'est indiqué l'association classe Java, balise : <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <tag> <name>bonjour</name> <tag-class>cnam.hello</tag-class> </tag> <tag> </tag> </taglib> XVII-61 fichier balisescnam.tld L élément <taglib> contient un ou plusieurs sous-éléments <tag>
Classe Java, tld, où ranger tout cela? La classe compilée est mise (évidemment) dans WEB- INF/classes Les fichiers.jsp et.tld sont mis dans une arborescence de l'application web, cohérente avec les URL d'accès Par exemple : app root WEB-INF classes tagme cnam balisescnam.tld pagedetest.jsp Hello.class XVII-62
Utilisation de balises de Fichier : pagedetest.jsp bibliothèque dans une JSP <html><body> <%@ taglib uri="/tagme/balisescnam.tld" prefix="ez" %> <b>horoscope du Jour</b> <hr/> <i> <ez:bonjour/> </i> </body></html> Vous choisissez le préfixe Fichier : balisescnam.tld <taglib> <tag> <name>bonjour</name> <tagclass>cnam.hello</tagclass> </tag> </taglib> Nom complet de la classe
la JSTL Il n'est donc pas trop étonnant d'avoir des bibliothèques standard qui ont été développées pour les usages courants "The JavaServer Pages Standard Tag Library (JSTL) encapsulates as simple tags the core functionality common to many Web applications" (*) La première est la JSTL (JSP Standard Tag Library) Elle amène des structures de contrôle (tests, boucle), l'internationalisation, l'accès aux bases de données et les traitements XML Les spécifications de la JSTL sont téléchargeables à partir de http://jcp.org/aboutjava/communityprocess/final/j sr052/index.html (*) source : http://www.oracle.com/technetwork/java/jstl-137486.html XVII-64
Utiliser la JSTL Pour utiliser la JSTL il faut récupérer une ou des archives.jar suivants les versions que vous voulez utiliser. Voir à http://stackoverflow.com/tags/jstl/info Pour la version 1.2, le seul fichier jstl-1.2.jar est nécessaire Pour la version 1.0, il en fallait 2 : récupérer (ou avoir) les archives jstl.jar et standard.jar, par exemple à l'url http://jakarta.apache.org/site/downloads/down loads_taglibs-standard.cgi (prendre le.zip) installer ces archives dans votre application web. Pour tomcat, il faut installer ces archives dans WEB-INF\lib de l'application web ou, plus généralement, dans %TOMCAT_HOME %\lib (et dans ce cas, toutes les applications web pourront utiliser la JSTL) XVII-65 Essentiellement ces archives contiennent des classes Java compilées correspondant aux balises utilisées
Une première page avec la JSTL fichier iterer.jsp mis dans l'appli web GLG203 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <html> <head> <title>iterer avec la JSTL</title> </head> <body> <h3>une simple iteration</h3> <h4>de 1 à 10</h4> <c:foreach var="i" begin="1" end="10"> ${i} </c:foreach> </body> </html> résultat : XVII-66
JSTL : syntaxe <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>...... <c:foreach var="i" begin="1" end="10"> ${i} </c:foreach> La ligne <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> indique que la bibliothèque de balises de nom http://java.sun.com/jsp/jstl/core sera référencée par le préfixe c Dans cette bibliothèque, il y a la balise foreach (d'où son utilisation c:foreach) avec 3 attributs : nom de variable, valeur de début, valeur de fin On récupére la valeur courante de la variable dans le corps de cette balise par ${nomvariable} XVII-67
Les noms de bibliothèques de balises Ce sont des URI (Uniform Resource Identifier), bref un identificateur. Dans le fichier standard.jar, se trouve un répertoire META- INF (bravo!), contenant des fichiers.tld. Ce sont dans ces fichiers que sont indiqués l'uri d'une bibliothèque. Par exemple le fichier c.tld XVII-68
Noms de bibliothèques de balises : c.tld fichier META-INF\c.tld dans standard.jar <?xml version="1.0" encoding="utf-8"?> <taglib... version="2.0"> <description>jstl 1.1 core library</description> <display-name>jstl core</display-name> <tlib-version>1.1</tlib-version> <uri>http://java.sun.com/jsp/jstl/core</uri>... <tag> <description> The basic iteration tag,... </description> <name>foreach</name> <tag-class>org.apache.taglibs.standard.tag.rt.core.foreachtag</tag-class>... </tag>... </taglib> XVII-69
JSTL : exemples de balises Les principales balises de la bibliothèque core associé au préfixe c sont : c:out, c:set, c:catch, c:if, c:foreach : <c:out value="expression" /> est équivalent à <%= expression %> <c:set var="nomvariable" scope="application" value="valeur" /> est équivalent à <% pagecontext.setattribute("nomvariable", valeur, PageContext.APPLICATION_SCOPE)%> <c:catch var="expression" /> est équivalent à actions à surveiller </c:catch> <% try { actions à surveiller } catch (Throwable expression) {} %> XVII-70
JSTL : exemples de balises (suite) Le si(condition) en JSTL : est équivalent à : <% if(user.visitcount == 1) { %> <%= "première visite" %> <% } %> <c:if test="${user.visitcount == 1}"> <c:out value="première visite" /> </c:if> Le si / alors en JSTL : XVII-71 (c'est plutôt un switch!) <c:choose> <c:when test="${user.category == 'invite'} >... </c:when> <c:when test="${user.category == 'membre'} >... </c:when> <c:when test="${user.category == 'vip'} >... </c:when> <c:otherwise>... </c:otherwise> </c:choose>
Itération avec la JSTL La boucle : est équivalente à : <c:foreach var= user items= sessionscope.members > <c:out value="nom: ${user.name}" /> </c:foreach> <%@page import="java.util.*" %>.... <% Member user = null; Collection users = session.getattribute("members"); Iterator it = users.iterator(); while(it.hasnext()){ user = (Member) it.next(); %> <%= "nom: "+user.getname() %> <% } %> Bon, OK, c'est plus lisible! XVII-72
Les autres bibliothèques de la JSTL On a des pratiques similaires avec les bibliothèques Formatage des données et internationalisation (URI http://java.sun.com/jstl/xml préfixe conseillé x) Manipulation de XML (URI http://java.sun.com/jstl/fmt préfixe conseillé fmt) Accès au bases de données (URI http://java.sun.com/jstl/sql préfixe conseillé sql) XVII-73
Bibliographie JavaServer Pages. Hans Bergsten; ed O'Reilly. ISBN 1-56592-746-X Technologie Apache/Tomcat à http://jakarta.apache.org Tutorial sur la JSTL : http://onjava.com/pub/a/onjava/2002/08/14/j stl1.html XVII-74
Fin XVII-75