le portails d’entreprise

STIME/DT - Alain Paoli - 2000 1

Le Portails d’Entreprise


Plan

• Les Portails d’Entreprise– Définition

– Les problèmes à résoudre

• Les technologies, leur apports, leurs limitations – Servlet,

– JSP

– XML, DOM, DTD et Schema, XSLT, XForms

– Cocoon

• Récapitulatif– Apports / Limitations des technologies présentées

– Problèmes / Solutions

• Proposition


Portails d’Entreprise (EIP)

• Objectif: Intégrer l’information pour améliorer la productivité et la réactivité de l’entreprise– Premières applications: rapports financiers, statistiques

ventes / achats

• Définition: Un point d’accès unique et personnalisé à des sources d’informations variées

• Forte croissante:– 80% des 500 premières entreprises mondiales sont en

train de déployer un portail (estimation Gartner Group)


Degrés de variabilités• Deux niveaux de personnalisation

– Page • Style

• Choix des portlets et leur mise en page (lignes, colonnes)

– Portlet• Contenu du Portlet (peut être dynamique)

• Deux types de contenus pour un Portlet– résumé

– complet

• Deux types de pages– Bureau : montre plusieurs portlets

– Zoom: montre un seul portlet + Bannière et barre de navigation


Portails d’Entreprise

• Fonctionnalités– Bureau personnalisé

– Pages composées de modules indépendants (Portlets)

– Agrégation d’informations en provenance de sources très variées

• Bases de données, Bases documentaires, Messagerie, Sites Web

– Applications simples• Formulaires de saisie

• Requêtes (dans annuaire LDAP, base documentaire, …)

– Accessible via divers types de terminaux (Navigateur sur PC, Organiseur, Téléphone WAP, ….)


Les Problèmes à résoudre• Maintenir une session

• Maintenir un profil utilisateur– Préférences du bureau personnalisé (liste des portlets composant la page

bureau)

– Droits aux diverses sources d’informations et applications (portlets)

– La structure du profil doit pouvoir évoluer

• Agréger des sources d’informations très diverses– La composition d’une page nécessite de multiples requêtes

• Gérer des formulaires

• Composer dynamiquement les pages par un assemblage de portlets– En fonction du profil utilisateur

– En fonction du type de terminal


Les technologies classiques

Servlet, JSP


Servlet


Servlet - Principe• Une instance d’une classe qui implémente l’interface

javax.servlet.http.HttpServer reçoit les requêtes HTTP.

• Les requêtes HTTP transmises spécifient le nom (ou classe du Servlet) appelé.

• Quand l’objet javax.servlet.http.HttpServer reçoit une requête HTTP:– S'il n'existe pas encore d'instance du Servlet correspondant à la

requête HTTP, il en crée une.

– Il appelle une méthode de cette instance, pour traiter la requête, à l'intérieur d'un nouveau processus léger (ou "thread") qui est créé pour l'occasion:

• doGet (pour les requêtes HTTP GET)

• doPost (pour les requêtes HTTP POST)


Servlet - Idiomeimport java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class MonServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

// Utiliser l’objet "request" pour lire les headers HTTP (e.x. cookies)

// et les paramètres transmis par un formulaire HTML

// Utiliser l’objet "response" pour écrire la ligne HTTP réponse avec ses headers

// (e.x. spécifier le MIME type, passer des cookies).

PrintWriter out = response.getWriter();

// Utiliser l’objet "out" pour écrire la page réponse envoyée au navigateur

out.println("<HTML>\n" + "<HEAD><TITLE>Hello WWW</TITLE></HEAD>\n" + "<BODY>\n" +

"<H1>Hello WWW</H1>\n" +

"</BODY></HTML>");

}

}


Session

• Session: maintenue par cookie temporaire ou insertion d ’un paramètre dans la requête.

– Un contexte est maintenu pour un utilisateur• HttpSession session = request.getSession(true);

// récupère la session courante. En crée une si besoin est

• session.setAttribute("o1", objet1); // stocke un objet

• MaClasse o = session.getAttribute ("o1"); // retrouve l’objet

• Enumeration enumAttNames = session. getAttributeNames();

– Méthodes:• getCreationTime(): long Date de création de la session

• getId(): String Identifiant de la session

• getLastAccessedTime() : long Date dernière requête

• get/setMaxInactiveInterval(int): nb de millisecondes d’inactivité

• isNew(): boolean vrai si la session vient d’être crée


JSP

• But:– Séparer les parties statiques des parties dynamiques

d’une page• Pouvoir utiliser les outils classiques pour la partie statiques des

pages HTML

– Inclusion de code Java dans les pages HTML• Le code Java est inclus entre des tags ‘<%’ et ‘%>’

• L’extension de la page doit être ‘.jsp’

• Le code HTML et le code Java sont compilés dans un servlet dont le source est généré automatiquement lors de la première requête sur la page


Expression JSP

• Sert à inclure une valeur dans le flot de sortie (page réponse)

• Syntaxe:– <%= expresssion Java %>

• Exemple:– <p>Aujourd’hui: <%= new java.util.Date() %> </p>

• L’expression Java est évaluée, convertie en une string, et insérée dans la page. Cette évaluation est faite lors du traitement de la requête HTTP.


Scriptlet JSP• Permet d’insérer n’importe quel code Java

– Syntaxe: <% code Java %>

<% if (Math.random() < 0.5) { %>

Vous avez <B>gagné</B>!

<% } else { %>

Vous avez <B>perdu</B>!

<% } %>

• Sera compilé en quelque chose comme:if (Math.random() < 0.5) {

out.println(”Vous avez <B>gagné</B>!");

} else {

out.println(" Vous avez <B>perdu</B>!");

}


Actions• jsp:useBean:

– <jsp:useBean id="user" class="appli.User" scope="session"/>

– Cette action associe un Bean, instance de la classe spécifiée par ‘class’, avec une portée spécifiée par ‘scope’, avec la référence spécifiée par ‘id’.

– Si une instance associée avec la même référence n’est pas trouvée dans la portée, une nouvelle instance est crée.

– Portée: quatre valeurs possibles• application: bean visible de toutes les pages, pour toutes les sessions

• session: bean visible de toutes les pages pour une session considérée

• requête: bean visible de toutes les pages participant à une requête

• page: bean visible dans la page considérée

• jsp:setProperty– <jsp:setProperty name="user" property="*" />

– Positionne toutes les propriétés du Bean avec les valeurs passées en paramètres dans la requête, de telle façon qu’un paramètre de nom ‘prop’ positionnera la valeur d’une propriété de nom ‘property’ (i.e. ce Bean est muni d’un ‘setter’ setProp()), en faisant au préalable des conversions implicites.


Exemple

• Gérer un formulaire d’identification– L’utilisateur doit saisir son logon et son mot de passe, puis cliquer

sur ’OK’• Si pas de logon ou de mot de passe saisi: message d’erreur affiché

dans la page réponse.

• Si utilisateur inconnu (logon ou mot de passe non enregistré): message d’erreur affiché dans la page réponse.

• Si erreur, on affiche à nouveau le formulaire avec valeurs saisies et message d’erreur

• Sinon, on affiche la page d’accueil.

– Architecture• Une page JSP affichant le formulaire + message d’erreur

• Un Bean User + un Bean Contrôleur du dialogue

Page JSP<jsp:useBean id="user" class="User" scope="session"/>

<jsp:setProperty name="user" property="*"/>

<jsp:useBean id="controler" class="IdentificationControler" scope="page"/>

<% controler.process(request, response); %> <!-- appel du contrôleur - ->

<html> <body>

<form method="post" action="identification.jsp?state=control">

<p>Votre email

<input type="text" name="logon" size="40" value="<%= user.getLogon() %>">

<p>Mot de passe

<input type="password" name="pass" maxlength="10" size="10" value="<%= user.getPass() %>">

<p><input type="submit" name="submit" value="Entrée">

</form>

<p><%= controler.getErrorMessage() %>

</body>

</html>


Bean Userpublic class User {

private String logon = "";

private String pass = "";

public User() { // constructeur

}

public String getLogon() {

return logon;

}

public String getPass() {

return pass;

}

public void setLogon(String logon) {

this.logon = logon;

}

public void setPass(String pass) {

this.pass = pass; }

}


import javax.servlet.http.*;

public class IdentificationControler {

private String errorMessage = "";

public void process(HttpServletRequest request, HttpServletResponse response) {

try {

if (request.getParameter("state") == null) { // état: initialisation

return;

String logon = request.getParameter("logon"); String pass = request.getParameter("pass");

if (logon.equals("") || pass.equals("")) {

errorMessage = "<b>Erreur: vous n'avez pas saisi votre identifiant ou votre mot de passe</b>";

return; }

User user = (User) request.getSession().getAttribute("user");

if (!isRegistred(user)) {

errorMessage = "<b>Erreur: vous n'êtes pas enregistré comme utilisateur</b>";

return; }

response.sendRedirect("accueil.jsp"); //sendRedirect() doit être fait avant écriture du tag <html>

} // end try

catch(IOException e) { errorMessage = "<b>Erreur: Fichier " + nextJSP + " introuvable.</b>"; }

}

}

public boolean isRegistred(User user) { // retourne true si l’utilisateur est connu, et false sinon

}

}


Exécution• (1) Affichage du formulaire pour la première fois / session:

– requête HTTP GET: http://localhost:8080/MyPortal/Identification.jsp

– Création du bean User (logon et pass initialisé à "")

– Création d’une instance du contrôleur (sa portée est "page")• attribut errorMessage initialisé à ""

• sa méthode process ne fait rien (pas de paramètre "state" dans la requête).

• (2) Saisie du logon et du pass et envoi– Récupération du bean User (logon et pass contiennent les valeurs saisies)

– Création d’une instance du contrôleur (sa portée est "page")• attribut errorMessage initialisé à ""

• il y a un paramètre "state" avec la valeur "control" : la méthode process vérifie les valeurs saisie et vérifie que l ’utilisateur est enregistré

– Si OK: redirige la requête vers "accueil.jsp"

– Sinon positionne un message d’erreur dans errorMessage . Le message sera affiché par l’exécution du l’expression : <%= controler.getErrorMessage() %>


JSP: Limitations• Insertion de code Java dans du code HTML

– Pas de séparation entre contenu et présentation

– Le flot de contrôle du code Java doit suivre l’ordre d’écriture dans le flot de sortie

– Comment gérer plusieurs types de terminaux ?

Portlet 1

Code HTML de Mise en Page

Portlet 2

Portlet 3 Portlet 4

<html><table> <tr> <td>… Portlet 1 </td> <td>… Portlet 2 </td> </tr> <tr> <td>… Portlet 3 </td> <td>… Portlet 4 </td> </tr></table></html>

Page

Flot decontrôle

Flot desortie


Solution• Deux étapes:

– (1) Générer le contenu sous la forme d’une arborescence Page / Portlets, chaque Portlet ayant sa structure propre.

• Pouvoir construire le contenu des portlet dans n’importe quel ordre.

– (2) Générer la présentation pour l’ensemble en fonction du type de terminal

Page

Portlet 1 Portlet 2 Portlet 3 Portlet 4


XML


Définition• XML est une norme (recommandation) du W3C (World Wide

Web Consortium): http://www.w3.org– En charge de la définition de standards du Web (HTML)

– Rassemble des entreprises et des chercheurs• Labos: Massachusetts Institute of Technology (MIT), Institut

National de Recherche en Informatique et Automatique (INRIA), Keio University of Japan.

• Nombreux standards connexes à XML:– Définis par le W3C (XSL, DOM, Schema, RDF)

– Définis par des entreprises ou consortiums indépendants du W3C : OASIS, Biztalk, WAP Forum

– Des standards de fait : SAX


Définition

• XML: eXtensible Markup Language– Méta-langage permettant de définir des documents ou

messages (flots) structurés.

– Documents édités (sérialisés) sous forme de données encadrées par des balises (Tags).

• Les balises sont exprimées comme en HTML

<hello>Hello World !</hello>

• XML permet de définir des informations:– semi-structurées

– extensibles: on peut définir ses propres balises

– auto-documentées (par les balises)


Définition• XML définit les règles syntaxiques que doivent

respecter les documents XML bien formés.– Le document a une structure d ’arbre

• une seule balise (racine) au sommet

• à chaque balise ouvrante correspond une balise fermante

• tout élément fils est entièrement contenu dans son père

Document bien formé Document mal formé

<?xml version="1.0"?><livre isbn="1-55860-622-x"> <titre>Data on the Web</titre> <auteur>Serge Abiteboul</auteur> <resume>Des relations aux données semi-structurées et XML </resume></livre>

<?xml version="1.0"?><livre isbn="1-55860-622-x"> <titre>Data on the Web</titre> <auteur>Serge Abiteboul</auteur> <resume>Des relations aux données semi-structurées et XML</livre> </resume><annexe>…</annexe>

attribut


Compréhension des informationsMenu

Saumon Fumé

Canard Rôti Pommes de Terres

Profiteroles

Seule la présentationet le sens permettentd ’identifier la structure

<?xml version="1.0"?><menu date="12-02-00"> <entree>Saumon fumé</entree> <plat> <viande>Canard Rôti</viande> <garniture>Pommes de Terre</garniture> </plat> <dessert>Profiteroles</dessert> </menu>

Des marqueurs (balises)explicitent la structure

Seul le contenu est décrit(pas de présentation)

Menu;Saumon Fumé;Canard Rôti...

Informations non explicites

Document Object Model• Le DOM est une recommandation du W3C fixant les

types d’objets utilisés pour représenter en mémoire les nœuds d’une arborescence XML

<?xml version="1.0"?>

<annuaire>



<carte id="56321">

<nom>Dupont</nom>

<prenom>Alfred</prenom>

</carte>

</annuaire>

Document

Element

Attribute

Text

annuaire

Element

Element carteComment

carte de visite

56321 nom prenom

Dupont Alfred

Element

Text


Document Object Model

• Dans le modèle DOM, tout objet est un nœud de type Node. Le nœud racine du document est un objet Document.– L’objet Element représente les balises contenues dans le document

XML. Le nœud Document ne peut posséder qu’un seul fils de type Element.

– Le nœud Text traduit le contenu textuel d’un Element ou d’un Attribute (autre sous-classe de Node).

• Ces types sont définis en IDL et sous formes d’interfaces Java– Nombreuses méthodes réparties sur les différents types pour:

• Créer les différents types de nœuds

• Ajouter / Supprimer / Remplacer un fils ; obtenir la liste des fils

• Accéder / Positionner le père

• Accéder / Positionner un attribut ; obtenir la liste des attributs

• Cloner un nœud.


Utilisation d’un DOM


<annuaire>

<carte id="56321">

<nom>Dupont</nom>

<prenom>Alfred</prenom>

</carte>

</annuaire>

Parser XML

DOM

Sérialiseur XML

Application Java

Le Parser fournitune implémentationdu DOM

Le Sérialiseur utiliseune implémentationdu DOM

L’application Javalit, modifie, ajoute, supprime des nœudsou crée un DOM detoute pièce


import java.io.*; import org.w3c.dom.*; import org.apache.xerces.parsers.*;

import org.apache.xml.serialize.*; import org.xml.sax.*;

public class UseDom {

public static void main(String[] args) {

try {

DOMParser parser = new DOMParser(); // crée le parser

parser.parse("annuaire.xml"); // parse

Document doc = parser.getDocument(); // récupère le DOM

Element annuaire = doc.getDocumentElement(); // récupère la racine annuaire

Element carte = doc.createElement("carte"); // crée un élément <carte>

carte.setAttribute("id", "12345"); // ajoute un attribut à <carte>

annuaire.appendChild(carte); // ajoute le fils <carte> à <annuaire>

Element nom = doc.createElement("nom"); // crée l’élément <nom>

nom.appendChild(doc.createTextNode("Durand")); // positionne valeur de <nom>

carte.appendChild(nom); // ajoute le fils <nom> à <carte>

XMLSerializer serializer = new XMLSerializer(); // crée le sérialiseur

FileWriter fw = new FileWriter("annuaire2.xml"); // crée le flot de sortie

serializer.setOutputCharStream(fw); // positionne le flot dans le sérialiseur

OutputFormat of = new OutputFormat(); // définit un format de sortie

serializer.setOutputFormat(of); // positionne format de sortie dans le sérialiseur

serializer.serialize(doc); // sérialise

fw.close(); // clos le flot de sortie

} catch(IOException e) { } catch(SAXException e) { } }

}


Utilisation d’un DOM

• Le programme précédent produit le document XML suivant:

<?xml version="1.0" encoding="UTF-8"?><annuaire> <carte id="56321"> <nom>Dupont</nom> <prenom>Alfred</prenom> </carte> <carte id="12345"> <nom>Durand</nom> </carte></annuaire>


Validation d’un Document XML• Via un DTD:

– Déclarer les éléments fils d’un élément, et leur cardinalité

– Déclarer les noms d’attributs d ’un élément, et leur caractère obligatoire ou facultatif ou valeur par défaut

• Définir un attribut de type clé unique (ID)

• Définir un attribut de type référence à une clé (IDREF)

• Via un Schema:– Déclarer des types élémentaires et complexe en utilisant des

constructeur de types (union, liste, séquence, agrégation)

– Définir des clés et leur référence

– Définir des types dérivés• par extension: ajout d’éléments ou d’attributs à la structure

• par restriction: en rajoutant des contraintes sur un type

– Utilisation des espaces de noms (namespaces)


Données semi-structurées XML• Relationnel

– Structure de table• Le sens d’une cellule se définit par

rapport au tuple auquel elle appartient et au schéma.

– Algèbre fondée sur relation universelle + {dépendances}

– Contraintes:• Toutes les lignes d’une table possèdent la

même structure

• Toute cellule est d’un type pré-défini atomique

• XML– Structure d’arbre quelconque

• Le sens d’un nœud se définit par rapport à ses ancêtres (contextuellement auto-descriptif)

– Propositions d’algèbres (Datalog)– Contraintes:

• Un nœud a un nombre quelconque de fils

• Types pré-définis de nœuds (Document, Element, Text, …)

TableDocument

Ligne 2

C3 C4 C5

Ligne 1

C1 C2 C3


XSLT


Définition

• XSLT (XML Stylesheet Language Transformation) est un standard XML qui permet de générer un document cible à partir d’un document source– par des opérations de filtrage

– par des transformations

– par des calculs simples

– par des appels à des objets Java

• Il fait partie de XSL (XML Stylesheet Language) qui se décompose en:– XSLT pour la transformation des documents XML (recommandation du

W3C)

– XSL-Formating Object pour la description des informations de mise en page (Working Draft)


Principe de Fonctionnement• La feuille de style décrit

comment le processeur XSLT doit transformer le document XML source.– Elle contient des règles

décrivant les transformations à appliquer sur un nœud (sous-arbre).

• Le résultat de la transformation peut:– être un document XML

– être un document HTML

– être un document texte

– respecter un format propriétaire

Processeur XSLT

Document XML

Source

Feuillede styleXSLT

Document

Cible


Mécanisme de transformation• L’application d’une règle de transformation à un

nœud génère une partie du document cible• Pour transformer un nœud, le processeur

– Trouve la règle la plus prioritaire s’appliquant à ce nœud

– applique la règle de transformation

– lorsqu’une règle s’applique à un nœud, ce nœud est le contexte de référence pour les instructions XSL contenues dans le corps de la règle

<xsl:template match="expression XPath de sélection"> instructions XSLT ou texte littéral à produire ou éléments XML bien formés à insérer</xsl:template>

Partie condition

Partie production


XPath• Normalise la façon de localiser des parties d’un document XML

• Expressions XPath:


<portlet name="stat" title="Stats"> <stats> <item>

<semaine>43</semaine><value>64</value>

</item> <item>


</item> </stats></portlet>

– "/" sélectionne la racine <portlet>

– "item" sélectionne tous les nœuds <item>

– "item/@title" sélectionne l’attribut "title" pour tous les nœuds <item>

– "item[@title=‘Stats’]" sélectionne tous les nœuds <item> possédant un attribut "title" avec la valeur ‘Stats’

– "item/value" sélectionne les fils <value> pour tous les nœuds <item>

– "." identifie le nœud contexte courant

– ".." identifie le père du nœud contexte courant


Instructions XSLT• <xsl:apply-template/>

– Cette instruction sélectionne les fils du nœud courant (contexte courant) et provoque le traitement sur chacun de ces nœuds.

– Elle peut comporter un attribut select contenant une expression XPath pour ne sélectionner que certains nœuds fils.

• <xsl:value-of select="requête XPath"/>– Traduit le résultat de la requête XPath (un nœud ou un attribut),

appliqué au contexte courant en une chaîne de caractères qui est insérée en lieu et place de cette balise.

• Insère le contenu du nœud ou la valeur de l’attribut sélectionné

• {requête XPath}– Idem <xsl:value-of select="requête XPath"/>, mais doit être utilisé

lorsque la chaîne de caractères résultat doit être insérée en tant que valeur d’attribut d’un élément XML.


<?xml version="1.0"?><?xml-stylesheet href="p5.xsl" type="text/xsl"?><?cocoon-process type="xslt"?>

<portlet name="stat" title="Stats"> <stats> <item>


</item> <item>


</item> </stats></portlet>

<?xml version="1.0"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/"> <html> <body>

<table bgcolor="#CCCCCC"> <tr><td colspan="3" align="center"> <xsl:value-of select="@title"/> </td></tr> <xsl:apply-templates/>

</table> </body> </html> </xsl:template>

<xsl:template match="item"> <tr> <td width="20"> <xsl:value-of select="./value"/>%</td> <td width="60">S <xsl:value-of select="./semaine"/></td> <td width="40"> <img src="o.gif" width="{./value}" height="10"/></td> </tr> </xsl:template></xsl:stylesheet>


Code HTML Généré<html><body><table bgcolor="#CCCCCC"> <tr><td align="center" colspan="3">Stats</td></tr> <tr> <td width="20">64%</td> <td width="60">S43</td> <td width="40"><img height="10" src="o.gif" width="31"></td> </tr>

<tr> <td width="20">16%</td> <td width="60">S44</td> <td width="40"><img height="10" src="o.gif" width="9"></td> </tr>

</table></body></html>


XForms


XForms• XForms est la redéfinition des formulaires HTML en XML

– Recommandation du W3C en cours d’élaboration– Modèle en couches, définition des types et contraintes en Schema ?

Présentation

Logique

DonnéesDonnées stockées

en XML

Définition des types, Données calculées

et contraintes

Présentations alternatives / types de

média

<employe> <identite> <nom>Dubois</nom> <prenom>Pierre</prenom> <sexe> <value>Masculin</value> </sexe> </identite></employe>

<group name="employe"> <group name="identite"> <string name="nom"/> <string name="prenom"/> <string name="sexe"> <value>Masculin</value> <value>Féminin</value> </string> </group></group>

Feuilles de styleXSLT


XForms• Au niveau logique, un modèle décrit la structure du

formulaire (Working Draft du 6 Avril 2000)– Les données sont regroupées en groupes et sous-groupes.

– Données typées (string, date, durée, nombre, booléen)• données mono et multi valuées

– Facettes exprimant :• des contraintes sur les données

– min, max, integer, decimals, format, caractère obligatoire de la donnée

• des règles de calcul simples– extension envisagées pour intégrer des langages de scripts (javascript)

• Problème:– Définition incomplète et déclarée obsolète. Attente nouvelle version


Cocoon 1

http://xml.apache.org/cocoon/


Architecture Cocoon

Requête HTTP DOMDOM Chaîne de n Processeurs

Producteur Formateur

DocumentHTML

PDFWML

….

Méthode service() du Servlet Cocoon

Sourced’information

• La chaîne de production de la page réponse se compose d’un Producteur, de 0 à n Processeur et d’un Formateur:– Le rôle du Producteur est de produire le DOM de la page réponse à la requête

HTTP (à partir d’une ou plusieurs sources d’informations)

– Le rôle d’un Processeur est de traiter le DOM fournit en entrée, et de retourner le DOM modifié ou enrichit. Les processeurs sont spécialisés (LDAP, SQL, …)

– Le rôle du Formateur est d’appliquer une transformation XSLT pour fabriquer la présentation au format ad hoc (HTML, PDF, WML, …)

Feuille destyle XSLT

Réponse à la requête HTTP


Cocoon: Fonctionnalités• Producteurs, Processeurs et Formateur sont des objets Java

– Implémentent une interface donnée. On peut définir ses propres classes.

– Le nom du Producteur est spécifié dans le fichier paramètre ou bien est passé en paramètre dans la requête HTTP

– Les noms des Processeurs et Formateur sont spécifiés dans le document XML retourné par le producteur. Les processeurs sont exécutés dans l’ordre de leur déclaration dans ce DOM

• XSP: c’est le ‘JSP’ de Cocoon pour traiter les parties dynamiques– Syntaxe purement XML.

– Chaque page contenant des balises XSP est compilée sous la forme d’un objet Java qui est utilisé par le processeur XSP.

• Système de cache mémoire– Feuilles de style XSLT parsées une fois, leur DOM est stocké dans le cache.

– Une seule instance de Producteur, Processeur et Formateur par classe, mémorisée dans le cache. Idem pour le parseur XML (Xercès) et le processeur XSLT (Xalan).

– La page réponse produite est stockée dans le cache. Si la même requête est traitée, avec les mêmes paramètres, Cocoon retourne la page stockée dans le cache.


Cocoon: Limitations• Peu adapté à la personnalisation:

– Cache de type tout ou rien (version 1.8): si les pages sont personnalisées, il y a peu de chances qu’on réutilise une même page. Et de plus toute nouvelle page produite est stockée dans le cache (risque de dépassement de capacité mémoire).

– L’unité de la chaîne de production est la page et non le portlet : • L’unité stockée dans le cache est la page

• Compilation de la page en classe Java si utilisation de balises XSP dans la page. Conséquence: si n pages dynamiques, alors il y a n compilations.

• Conséquences, si personnalisation:– On ne peut utiliser le cache (nuit aux performances)

– On ne peut utiliser le mécanisme XSP.


Publication / Composition

• Définitions– La publication consiste à mettre à jour des sources d’informations.

– La composition consiste à fabriquer une page qui agrège des informations en provenance de sources diverses.

• Constat:– Les sources d’informations sont rafraîchies à des intervalles de

temps très divers (de la seconde à plusieurs jours).• La plupart des informations ont une fréquence basse de

rafraîchissement (plusieurs heures à plusieurs jours)

– Les processus de publication et de compositions ne sont donc pas synchrones.

• Ex: arrivée d’un e-mail publication de l’e-mail sous format XML ad hoc (1 fois), puis n composition de pages affichant le contenu de cet e-mail.


Récapitulatif

Problèmes / Solution


Apports / Limitations

Techno Apports Limitations

Servlet Gère la session utilisateur Pas de distinction entreparties statiques etdynamiques des pages

JSP Distinction entre partiesstatiques et dynamiques despages

Pas de distinction entrecontenu et présentation

Cocoon 1.xXMLXSLTXForms

Distinction entre contenu etprésentation.Chaîne de production dont lesmaillons (Producteur,Processeurs, Formateurs)sont ‘plugables’.

Mal adapté à lapersonnalisation : l’unité dela chaîne de production est lapage.Pas de distinction entrepublication et composition depages (sera pris en comptepar Cocoon 2)


Problèmes / Solutions

Problèmes SolutionsMaintient d’une session Utiliser l’API Java Servlet

Maintenir profil utilisateur évolutif Définit le profil en XML

Gérer les droits Définir droits dans annuaire LDAP

Gérer des formulaires Implémenter XForms

Distinguer Contenu / Présentation Cocoon 1.x (XML + XSLT)

Adapter la présentation et filtrer le contenuen fonction du type de terminal

Cocoon 1.x (XSLT)

Personnalisation par assemblage deportlets

? ? ?

Distinguer publication / Composition ? ? ? ou Cocoon 2


Proposition

Pour un Portail

d’Information

d’Entreprise

Mécanisme<?xml version="1.0"?><?xml-stylesheet href="home_page.xsl" type="text/xsl"?><?cocoon-process type="xslt"?>

<page name="/portal/pages/home_page.xml">  <insert-portlet name="stat" content="resume"/> </page>

<portlet name="stat" title="Stats"> <resume> <item>


</item> <item>


</item> </resume>

<complete> <item>  </item> </complete></portlet>

<?xml version="1.0"?><?xml-stylesheet href="home_page.xsl" type="text/xsl"?><?cocoon-process type="xslt"?>

<page name="/portal/pages/home_page.xml">  <insert-portlet name="banniere" content="complete"/>  <portlet name="stat" title="Stats"> <stats> <item>


</item> </stats></portlet> </page>

+

=


Mécanisme• (0) A l’initialisation du serveur, tous les portlets sont parsés et les DOM

résultats sont chargés dans un cache mémoire commun à tous les utilisateurs.– Contrainte: les portlets ont le même état persistant pour tous les utilisateurs.

• (1) Suite à la réception d’une demande de page (requête HTTP), le Producteur:– Parse le fichier XML décrivant la page et charge le DOM dans la session utilisateur.

– Remplace les balises <insert-portlet> de la page par les balises <portlet> correspondantes (copie / coller).

• Suivant la valeur de l’attribut "content" de la balise <portlet> n’insère que la partie "résumé" ou la partie "complète".

• (2) Si besoin les processeurs traitent le DOM retourné par le Producteur– Un processeur peut être définit pour un portlet donné. Si l’on utilise XSP dans le

portlet, c’est le processeur du portlet qui appelle le processeur XSP.

• (3) Le formateur recherche dans le cache session le flot de caractères HTML.– Si non trouvé, crée la présentation et la stocke dans la session

– Si le contenu d’un des portlets à changé reconstruit la présentation que pour ce portlet


Implémentation XForms<group name="employe"> <group name="identite"> <string name="nom"/> <string name="prenom"/> <string name="sexe"> <value>Masculin</value> <value>Féminin</value> </string> </group>

</group> Formulaire XForms

<form method="post" action="home_page.xml"> Formulaire HTML <input type="text" name="employe/identite/nom" value=""/> <input type="text" name="employe/identite/prenom" value=""/> <input type="radio" name="employe/identite/sexe" value="Masculin"/> <input type="radio" name="employe/identite/sexe" value="Féminin"/> <input type="submit" name="submit" value="OK"/></form>

• Une classe abstraite FormProcessor:– Récupérer la liste des paramètres/valeurs dans la

requête HTTP• Pour chaque paramètre, contrôler la valeur par

rapport aux contraintes définies dans le formulaire, et construire le nœud correspondant dans le DOM Data.

– Appeler la méthode abstraite process()• Un formulaire doit avoir une classe héritant de

FormProcessor et implémentant la méthode process() pour traiter le DOM Data.Correspondances

des noms


Architecture

RequêteHTTP

PageHTML

Moteur de Portail

Producteur Processeur Formateur

Mécanisme de cache

PublicationSQL

PublicationLDAP

PublicationLotus

PublicationEmail

BDRAnnuaire

LDAP Lotus Email

Référentiel XMLA base de fichiers ou base de données XML

Système de publicationGère la fréquence de rafraîchissement suivant les sources d’informations