1 / 59

Le Portails d’Entreprise

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

imogene-montana
Download Presentation

Le Portails d’Entreprise

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Le Portails d’Entreprise

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

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

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

  5. 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, ….)

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

  7. Les technologies classiques Servlet, JSP

  8. Servlet

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

  10. Servlet - Idiome import 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>"); } }

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

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

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

  14. 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>!"); }

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

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

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

  18. Bean User public 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; } }

  19. import javax.servlet.http.*; public class IdentificationControler { private String errorMessage = ""; publicvoid 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 } }

  20. 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() %>

  21. <html> <table> <tr> <td>… Portlet 1 </td> <td>… Portlet 2 </td> </tr> <tr> <td>… Portlet 3 </td> <td>… Portlet 4 </td> </tr> </table> </html> Portlet 1 Portlet 2 Portlet 3 Portlet 4 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 ? Page Flot de contrôle Flot de sortie Code HTML de Mise en Page

  22. Portlet 1 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 2 Portlet 3 Portlet 4

  23. XML

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

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

  26. 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é attribut <?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>

  27. Menu;Saumon Fumé;Canard Rôti... Compréhension des informations Seule la présentation et le sens permettent d ’identifier la structure Menu Saumon Fumé  Canard Rôti Pommes de Terres  Profiteroles Informations non explicites Des marqueurs (balises) explicitent 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> Seul le contenu est décrit (pas de présentation)

  28. Document Element Element Element Element Attribute Comment Text Text 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 de visite --> <carte id="56321"> <nom>Dupont</nom> <prenom>Alfred</prenom> </carte> </annuaire> annuaire carte carte de visite nom prenom 56321 Dupont Alfred

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

  30. <?xml version="1.0"?> <annuaire> <carte id="56321"> <nom>Dupont</nom> <prenom>Alfred</prenom> </carte> </annuaire> DOM Sérialiseur XML Application Java Utilisation d’un DOM Le Parser fournit une implémentation du DOM Parser XML L’application Java lit, modifie, ajoute, supprime des nœuds ou crée un DOM de toute pièce Le Sérialiseur utilise une implémentation du DOM

  31. 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) { } } }

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

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

  34. Ligne 2 Ligne 1 C3 C4 C5 C1 C2 C3 Données semi-structurées XML • 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, …) • 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 Document Table

  35. XSLT

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

  37. Document XML Source Feuille de style XSLT Document Cible Processeur XSLT 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

  38. 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 Partie condition <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 production

  39. <?xml version="1.0"?> <portlet name="stat" title="Stats"> <stats> <item> <semaine>43</semaine> <value>64</value> </item> <item> <semaine>44</semaine> <value>16</value> </item> </stats> </portlet> XPath • Normalise la façon de localiser des parties d’un document XML • Expressions XPath: • "/" 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

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

  41. <?xml version="1.0"?> <?xml-stylesheet href="p5.xsl" type="text/xsl"?> <?cocoon-process type="xslt"?> <portlet name="stat" title="Stats"> <stats> <item> <semaine>43</semaine> <value>64</value> </item> <item> <semaine>44</semaine> <value>16</value> </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>

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

  43. XForms

  44. Présentation Logique Données 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 ? <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 style XSLT Présentations alternatives / types de média <employe> <identite> <nom>Dubois</nom> <prenom>Pierre</prenom> <sexe> <value>Masculin</value> </sexe> </identite> </employe> Définition des types, Données calculées et contraintes Données stockées en XML

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

  46. Cocoon 1 http://xml.apache.org/cocoon/

  47. Source d’information Architecture Cocoon Méthode service() du Servlet Cocoon Requête HTTP DOM Chaîne de n Processeurs DOM Producteur Formateur Document HTML PDF WML …. Feuille de style XSLT Réponse à la requête HTTP • 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, …)

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

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

More Related