Fiches / Articles

Cadre Fonctionnel

Développement de JSP et présentation de données

Cadre Technique

NT/WebLogic 6.0

Identifiant 

SYS_JSP_01

Référent technique 


Version 

1.0

Auteur 

Alexandre Brillant

Date

09/10
Source

Documentation WebLogic 6


La conception de JSP (Java Server Pages) sert à :


Son principale inconvénient est la difficulté de mise à jour de la présentation à travers un éditeur HTML et la tendance à faire trop de traitement complexe Java.


Exemple de JSP insérant respectivement ver4.html et ver3.html pour un navigateur de version 4 et un navigateur de version 3 : 


<%@page language= "java" info= "Test"%>
<html>
<body>

<!	String agent ;	%>
<%	agent = request.getHeader(
"User-Agent" ) ;
if (
agent.startsWith("Mozilla/4.0" ) { %>
<%-- Page pour Netscape 4 --%>

<%@include file= "ver4.html"%>

<% } else { %>

<%@include file="ver3.html"%>

<% } %>

</body>

</html>


Lorsque le serveur d'application reçoit une requête pour cette page JSP, il effectue un premier traitement de conversion du JSP en un code de servlet qu'il compile. Cette opération est aussi effectuée sur une mise à jour de la page JSP. On peut également compiler avant tout accès à la JSP (JSP 1.1).


Tous les tags JSP sont sous la forme <% Tag JSP %>. Il existe 4 déclinaisons pour ce format :

seront conservés dans la page HTML finale.


Exemple pour chaque catégorie :

Directive : <%@ page language="java" imports="java.util.*" %>

Déclaration : <% String agent; %>

Scriplet : <% if ( true { %> OK <% } %>

Expression : <%= agent %>


Listes des directives accessibles depuis 1.1


language="java"


extends="une classe"

Classe parent de la servlet générée

import="packaque1,package2…"

Liste de classe ou de package à inclure

session="true|false"

Si true (par défaut), alors la page peut accéder aux données de la session

buffer="none|8kb|sizeKb"

Tampon pour le flot de sortie

autoFlush="true|false"

Vide le tampon de sortie lorsqu'il est plein

isThreadSafe="true|false"

Si true alors plusieurs utilisateurs peuvent accéder à la page en même temps. Les accès uniques sur une ressource peuvent se faire à l'aide du mot clé synchronized.

info="text"


errorPage="pathToErrorPage"

Chemin relatif vers la page JSP traitant les requêtes

isErrorPage="true|false"

Définit le type de page

contentType="text/html;charset=ISO-8859-1"

En début de fichier

import

Insertion d'une autre page. Cela peut être employé pour toutes les parties communes de pages

taglib

Localisation du descripteur XML des composants JavaBean associés à des tags.


Listes des objets accessibles depuis une scriplet


request

classe dérivée de la classe HttpServletRequest

response

classe dérivée de la classe HttpServletResponse

pageContext

forme de factory permettant l'obtention de la plupart des objets de cette liste

session

Session HTTP liée à la requête, cet objet peut contenir un nombre non défini d'objets pour un utilisateur donné, ces objets seront par défaut supprimés après expiration au bout de 30 minutes. Pour des raisons de performances, il faut limiter le nombre d'objet en mémoire

application

Contexte de la servlet

out

Flot de sortie

config

Objet de type ServletConfig

page

Correspondant à la servlet courante

exception

Exception non interceptée


Chaînage JSP-Servlet / JSP-JSP


Le tag jsp:forward permet d'appeler une autre JSP ou une servlet tout en conservant le contexte courant (session, paramètres,…).


La méthode la plus simple est l'utilisation du tag jsp:forward. Par exemple <jsp:forward page="page1.jsp"/>. Ce tag peut recevoir des paramètres simulant des champs HTML avec la syntaxe <jsp:param name="Un paramètre" value="Une valeur"/>.


Exemple de chaînage avec passage de paramètres :


<jsp:forward page="/test.jsp"> <jsp:param name="param1" value="value1"/> </jsp:forward>


Un autre intérêt est le passage d'un composant JavaBean vers une servlet pour un enrichissement de contenu et le retour vers une JSP pour la présentation.


Exemple de chaînage JSP-Servlet avec un composant java bean :


1. Création d'un JSP JSP1.jsp et d'un composant JavaBean bean avec chaînage sur la servlet servletTest


<jsp:useBean id="bean" class="com.airial.tool.DataBean" scope="request"/> <jsp:setProperty name="bean" property="*"/> <jsp:forward page="/servlet/ServletTest"/>


2. Réception dans la servlet ServletTest de la requête, modification du composant JavaBean et chaînage sur un JSP JSP2.jsp 


public void doPost(
HttpServletRequest request, HttpServletResponse response ) {
try {
DataBean db =
(DataBean)request.getAttribute( "bean");
db.setData( "Data1" );
getServletConfig().getServletContext().getRequestDispatcher(
"/jsp/JSP2.jsp" );
} catch( Exception exc ) { …
}
}

3. Récupération du composant JavaBean bean et affichage du résultat dans la JSP JSP2.jsp. 


<html>
<body>
<jsp:useBean id="bean"
class="com.airial.tool.DataBean" scope="request"/>
<jsp:getProperty name="bean"
property="data"/>
</body>
</html>

Exploitation JavaBean Pour éviter le mélange de tag HTML et du code Java, on a recourt aux composants JavaBean sous deux formats : - Le format JSP tag pour la lecture et l'écriture de propriétés Java Beans - Le format TagLib introduisant un tag utilisateur Le format JSP tag (ou JSP action) permettant d'effectuer la lecture et l'écriture de propriétés Java Beans. On peut délimiter la portée du composant Java Bean sur :


Syntaxe JSP tag :


Déclaration

<jsp:bean id="Un identifiant" scope="application" class="classe Java Bean"/>

Affectation d'une propriété

<jsp:setProperty name="Nom du composant" property="Nom de la propriété" value="Valeur">

Lecture d'une propriété

<jsp:getProperty name="Nom du composant" property="Nom de la propriété">


Exemple complet JSP tag : 


<%@page language="java"%>
<html>
<body>
<jsp:useBean
id="currentDate" scope="application"
class="com.airial.tool.DateBean"/>
<jsp:setProperty
name="currentDate" property="Format"
value="dd/MM/yyyy"/>
La date courante est :
<jsp:getProperty name="currentDate"
property="Date"/>
</body>
</html>

Le code du composant Java Bean est : package com.airial.tool;
public class DateBean { private String format;
public void setFormat( String format ) { this.format = format; }
public String getDate() { SimpleDateFormat formatter = new SimpleDateFormat ( format ); Date currentTime_1 = new Date(); return formatter.format(currentTime_1); } } Le format TagLib offre un meilleur niveau d'encapsulation. On décrit un tag à l'aide d'un fichier XML (.tld) nommé descripteur de librairie de tag (Tag Library Descriptor). Ce fichier contient la liste des tags avec les classes de traitement associés les attributs disponibles.


La classe associée doit hériter de javax.servlet.jsp.tagext.TagSupport avec deux fonctions principales : doStartTag et doEndTag. L'objet javax.servlet.jsp.tagext.PageContext permet d'accéder à tous les objets courants (session, flux de sortie…). Exemple d'utilisation de TagLib :

Page JSP d'exploitation. Le composant Test affiche la chaîne "TAG OK" : 


<%@language="java"%>
<%@taglib url="testTag.tld"
prefix="tag"%>
<html>
<body>
<tag:test
color="#ff0000 "/>
</body>
</html>

Descripteur taglib.tld. Ce fichier décrit le composant JavaBean associé au tag test:Test. Il est déclaré la classe du composant com.airial.TestTag et la propriété color : 


<?xml version="1.0"
encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
    PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
    "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

<taglib>
  <tlibversion>1.0</tlibversion>
  <jspversion>1.1</jspversion>
  <shortname>Test de
TagLib</shortname>
  <info>
     This tag library contains several tag extensions 
     useful for formatting content for HTML. 
  </info>

  <tag>
    <name>test</name>

<tagclass>com.airial.TestTag</tagclass>
   
<bodycontent>empty</bodycontent>
    <attribute>
      <name>color</name>
    </attribute>
  </tag>

</taglib>



Remarque : Le tag bodycontent n'est pas obligatoire et peut contenir les valeurs tagdependent, JSP ou empty respectivement pour indiquer un tag contenant pas de tag JSP, un tag contenant des tag JSP et un tag vide.


Composant TestTag. La propriété Color est utilisée dans la méthode doStartTag 


package com.airial;

import java.io.*;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;

/**
 * Describe class
<code>TestTag</code> here.
 *
 * @author "Alexandre
Brillant" <brillant@hexadev.com>
 * @version 1.0
 * @since 1.0
 * @see TagSupport */

public class TestTag extends TagSupport {
    private String color = null;

    public void setColor( String color ) {
      this.color = color;
    }

    public int doStartTag() throws JspException {
    try {
      if ( color != null )
        pageContext.getOut().println( "<font color=\"" +
	  color + "\">" );
	  
        pageContext.getOut().println( "TAG OK" );
	if ( color != null )
	pageContext.getOut().println( "</font>" );
    } catch( IOException exc ) {}
       return SKIP_BODY;
    }
}

La valeur de retour des méthodes doStartTag et doEndTag permet de décider de traiter ou non le contenu du tag (SKIP_BODY et EVAL_BODY_INCLUDE).

Remarques : Les tagLib ne fonctionnent pas avec WebLogic 6 si le descripteur de librairie n'est pas nommé taglib.tld. D'autre part, il est obligatoire d'utiliser des packages même pour une exploitation sous forme de jar.

Déploiement des tagLibs :

La méthode la plus simple pour exploiter un taglib est la création d'un jar. Ce jar sera déposé dans le répertoire WEB-INF/lib du répertoire d'accès.


Le jar (par exemple testTag.jar) contient :



Il faut notifier l'exploitation du jar dans le fichier WEB-INF/web.xml. L'uri déclaré dans la page HTML se rapporte à l'uri déclaré dans ce fichier.


Exemple de conception du fichier web.xml pour l'exemple précédent :


<?xml version="1.0" ?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 1.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd"> 


<web-app>

<taglib>
   
<taglib-uri>testTag.tld</taglib-uri>
    <taglib-location>
      /WEB-INF/lib/testTag.jar
    </taglib-location>
</taglib>

</web-app>

Lorsque les pages se ressemblent, il est possible de définir une architecture à base de template.

Le mécanisme le plus simple est l'utilisation du tag include pour incorporer des parties de pages communes.

Exemple de construction d'une page : 

<%@ page language="java"%>
<html><body>
<%@include
file="header.html"%>
<%@include
file="body.html"%>
</body></html>

Cette solution a le désavantage de définir une présentation pour chaque page même si quelques éléments changent. On exploitera plutôt à mécanisme réduisant la présentation et l'agencement d'une page par l'usage d'un ou de plusieurs templates. Un template comprenant la présentation et quelques éléments génériques traités à l'aide de tags JSP (issus de la taglib).


Exemple de construction d'un template template.jsp : 


<%@page language="java"%>
<%@taglib uri='template.tld'
prefix='template'%>



<html>
<body>
<template:get name='title'/>
<template:get name='header'/>
	<template:get
name='content'/>
</body>
</html>


Exemple de construction d'une page
avec le template template.jsp


<%@page language="java"%>
<%@taglib uri='template.tld'
prefix='template'%>

<template:insert template='template.jsp'>
<template:put name='header'content='header.html'/>
<template:put name='title' content='Page 1' direct='true'/>
<template:put name='content' content='content.html'/>
</template:insert>

Cette page met à jour les champs header, title et content grâce aux tags put, une mise à jour du template est ensuite réalisée grâce aux tags get.


Appel d'un JSP à partir d'une servlet


Exemple d'appel d'un JSP dataView1.jsp 


public void doGet( HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
  // Récupération et traitement des données
  …
  // Stockage dans la session
  …
  // Transmission à un JSP
  RequestDispatcher rd = getServletContext().getRequestDispatcher( « /jsp/dataView1.jsp ») ;
  rd.forward( req, res ) ;
  …
}