Jahia CMS ET Portal Version 5.0 Développer un portlet JSR168
Transcription
Jahia CMS ET Portal Version 5.0 Développer un portlet JSR168
Jahia CMS ET Portal Version 5.0 Développer un portlet JSR168 Avec Jahia CMS et Portal Version 5.0 V.1 Français Jahia Ltd Suisse 9, route des jeunes 1227 Carouge I p. 2/47 TERMES ET CONDITIONS D’UTILISATION Copyright 2003/2004 Jahia Ltd. (http://www.jahia.org). Tous droits réservés. CETTE DOCUMENTATION EST UN ÉLÉMENT DU LOGICIEL JAHIA. EN INSTALLANT JAHIA, VOUS RECONNAISSEZ ACCEPTER SANS RÉSERVE LES CONDITIONS D’UTILISATION DE LA LICENCE DU LOGICIEL JAHIA (JAHIA COLLABORALITVE SOURCE LICENSE ou JCSL) POUR CONSULTER LA LICENCE : http://www.jahia.org/jahia/Jahia/pricing/pid/145 SI VOUS N’ACCEPTEZ PAS LES CONDITIONS D’UTILISATION, N’INSTALLEZ PAS LE LOGIGIEL JAHIA SUR VOTRE ORDINATEUR. Copyright 2007 Jahia Ltd. (http://www.jahia.org). Tous droits réservés. © Jahia Ltd. Tous droits réservés. I p. 3/47 PREFACE JAHIA joue le rôle de portail Internet et de système de gestion de contenu destiné aux entreprises (CMS and Enterprise Portal). Entièrement écrit en Java J2EE, JAHIA tourne d'origine sur un serveur Tomcat, mais peut être utilisé avec d’autres serveurs d’applications comme WebSphere d'IBM. L’une des caractéristiques principales de JAHIA est de permettre l’intégration d’applications Web appelées « portlets ». Ce manuel décrit comment développer un portlet JSR168 pour JAHIA. Chapitre 1 : Introduction au développement de portlets. Ce chapitre présente les définitions et les notions importantes relatives au développement de portlets JAHIA. Chapitre 2 : Développer un portlet de base. Ce chapitre présente un exemple de portlet simple, appelé HelloWorld! Chapitre 3 : Développer un portlet avancé. Ce chapitre présente un exemple de portlet avancé. Chapitre 4 : Portlets, frameworks et ponts. Chapitre 5 : Migrer des JahiaWebApp vers des portlets. Ce chapitre présente des techniques permettant de convertir une JahiaWebApp (portlet Jahia 4) en portlet JSR168 (portlet Jahia 5). Chapitre 6 : Liens utiles. Ce chapitre présente des liens utiles pour la communauté JSR168. CONVENTIONS UTILISEES DANS CE DOCUMENT Ce document utilise les conventions suivantes : L’italique est utilisé pour les : • commentaires La chasse fixe est utilisée pour les : • exemples de codes JAVA, HTML, JSP. Astuces et suggestions Notes Mises en garde Ce document a été rédigé pour être le plus précis possible. Cependant, de nouvelles fonctionnalités peuvent être disponibles pour les versions de JAHIA les plus récentes. © Jahia Ltd. Tous droits réservés. I p. 4/47 TABLE DES MATIERES Préface..............................................................................................................................................3 Table des matières............................................................................................................................4 Chapitre 1 : Introduction au développement de portlets ..................................................................6 1 Définitions........................................................................................................................................ 6 2 Norme et API JSR168 ...................................................................................................................... 8 3 Jahia et portlet JSR 168 .................................................................................................................. 17 Chapitre 2 : Développer un portlet de base ....................................................................................19 1 Introduction .................................................................................................................................... 19 2 Classe HelloWorldPortlet............................................................................................................... 19 3 Fichier portlet.xml.......................................................................................................................... 22 4 Fichier web.xml.............................................................................................................................. 22 5 Déploiement ................................................................................................................................... 23 6 Visualisation................................................................................................................................... 24 Chapitre 3 : Développer un portlet avancé.....................................................................................25 1 Introduction .................................................................................................................................... 25 2 Classe HelloPortlet......................................................................................................................... 26 3 Fichier portlet.xml.......................................................................................................................... 30 4 Et ensuite ? ..................................................................................................................................... 31 Chapitre 4 : Portlets, frameworks et ponts .....................................................................................32 1 Introduction .................................................................................................................................... 32 2 Framework Struts ........................................................................................................................... 32 3 Framework JSF .............................................................................................................................. 32 4 Autres ponts : PHP, PERL, etc....................................................................................................... 33 Chapitre 5 : Migrer des JahiaWebApp vers des portlets................................................................34 1 Introduction .................................................................................................................................... 34 2 Pont JahiaWebAppPortlet .............................................................................................................. 34 3 Utiliser les frameworks standard.................................................................................................... 41 4 Convertir le code java et jsp ........................................................................................................... 42 5 Ajouter le fichier jahia.xml ............................................................................................................ 42 Chapitre 6 : Liens utiles .................................................................................................................44 1 Portlets Open Source...................................................................................................................... 44 2 Listes de diffusion .......................................................................................................................... 45 3 Bibliothèques utiles ........................................................................................................................ 45 © Jahia Ltd. Tous droits réservés. I p. 5/47 Chapitre 6 : Conclusion..................................................................................................................46 © Jahia Ltd. Tous droits réservés. I p. 6/47 CHAPITRE 1 : INTRODUCTION AU DEVELOPPEMENT DE PORTLETS Ce chapitre présente différentes définitions et notions importantes relatives au développement de portlets JAHIA. 1 DEFINITIONS 1.1 CMS ET PORTAIL Les systèmes de gestion de contenu (Content Management System ou CMS) sont des outils informatiques dédiés à l’édition et l’organisation de textes, d'informations, de rapports et d’éléments multimédia dans un système d’information. Les CMS assurent les services suivants : • édition commune de contenus par diverses personnes décentralisées (collaboration) • mise en place de processus de gestion du contenu (workflow) • impossibilité de manipulation par des personnes n’en ayant pas l’autorisation (sécurité) • gestion des révisions (statistiques, gestion des versions) • possibilité de décider quand l'information doit être publiée (planification) • présentation dans le bon format (gabarits) • publication sur différents sites (syndication) • affichage différencié en fonction du visiteur (personnalisation) • diffusion du contenu sur différents médias (omnimedia) Un portail est un CMS exclusivement orienté Internet avec des capacités d'intégration de contenus provenant de sources extérieures, dans un environnement informatique distribué (bases de données, intégration XML, XLS, etc.). En outre, les portails offrent en général aux utilisateurs finaux des fonctions simples de recherche et de publication sur le Web. Les portails peuvent être utilisés par des sociétés entières (par exemple, Jahia Solutions), ou par des départements tels que le Marketing, les Ressources humaines ou les Ventes. Les portails, sous forme de tableaux de bord interactifs personnalisés, peuvent aussi être utilisés par des utilisateurs individuels. JAHIA joue le rôle de portail Internet et de système de gestion de contenu destiné aux entreprises (CMS et Enterprise Portal). © Jahia Ltd. Tous droits réservés. I 1.1.1 p. 7/47 PORTLET Les portlets sont des composants réutilisables intégrés à un portail d'entreprise. Ils permettent à un utilisateur de disposer, depuis la même fenêtre, d'un accès centralisé et convivial à différentes ressources (données, applications, sites Web, etc.), de modifier l'interface du portail selon ses besoins et de personnaliser ainsi son environnement de travail. Les portlets facilitent ainsi l’accès aux informations intéressant un groupe d’utilisateurs. D’un point de vue technique, les portlets sont des applications qui génèrent des portions actives et dynamiques de HTML aggrégées par le portail. Illustration 1 : Exemple de pages JAHIA avec des portlets Afin de permettre l’interopérabilité des différents portails, la communauté internationale Java (JCP, Java Community Process) a spécifié le comportement d’un portlet pour tous les aspects qui le définissent : agrégation, personnalisation, présentation et sécurité. Le résultat de ce travail a abouti en août 2003, en donnant lieu à la spécification JSR 168 (Java Specification Request) qui définit l’API de portlet, et que doivent à termes respecter tous les portails Java au monde, qu’ils soient à vocation libre ou commerciale. Cette spécification est brièvement présentée au chapitre suivant. Vous retrouverez l’intégralité du texte définissant la norme JSR168 à l’adresse : http://jcp.org/aboutJava/communityprocess/review/jsr168/ © Jahia Ltd. Tous droits réservés. I p. 8/47 JAHIA 5 intègre le portail Open Source Jetspeed 2 et est compatible avec la norme JSR168. Pour obtenir plus d’informations sur Jetspeed 2, connectez-vous sur : http://portals.apache.org/jetspeed-2/ JAHIA 5 supporte également un autre type de portlets : les JahiaWebApp. Celles-ci sont spécifiques à JAHIA et compatibles avec JAHIA 4. Pour obtenir plus d’informations sur les JahiaWebApp, consultez le PDF disponible à l’adresse : http://www.jahia.org/jahia/webdav/site/jahia_org/shared/documentation/WebAppGuideDRAFT1.pdf. Dans un objectif de compatibilité totale avec la norme portlet, les versions futures de JAHIA ne supporteront pas les JahiaWebApp. Pour cette raison, nous vous conseillons de développer des portlets JSR168 et non des JahiaWebApp pour JAHIA 5, et de convertir vos JahiaWebApps en portlets JSR168 lors de la migration de JAHIA 4 vers JAHIA 5. 1.1.2 PREREQUIS Ce manuel suppose que vous êtes familier avec : • le language Java • la norme Servlet, spécialement les servlets http • Apache Tomcat • HTML, XML • Javascript, JSP et tagLib • le modèle de contenu Jahia 2 NORME ET API JSR168 2.1 PORTAIL Un portail (JAHIA) est une application Web qui assure généralement les fonctions de personnalisation, d’administration centralisée (single sign-on), d’agrégation de contenu à partir de différentes sources et de prise en charge de la couche de présentation des systèmes d’information. L’agrégation se définit comme l’action d’intégrer du contenu provenant de différentes sources au sein d’une même page Web. Un portail peut comporter un ensemble de portlets pour la création de contenu pour différents utilisateurs. © Jahia Ltd. Tous droits réservés. I p. 9/47 2.2 PORTLET Les portlets sont des composants Web réutilisables, contrôlés par un conteneur de portlet, et qui traitent des requêtes et produisent du contenu dynamique. Utilisés par les portails en tant que composants de l'interface utilisateur, les portlets fournissent une couche de présentation aux systèmes d'information. Le contenu produit par un portlet s'appelle un « fragment ». Un fragment est un morceau de balisage (par exemple HTML, XHTML, WML) régi par certaines règles et qui peut être agrégé avec les fragments d’autres portlets pour former un document complet. Le contenu produit par un portlet peut changer d'un utilisateur à l'autre, en fonction de ses préférences (reportez-vous à la section Concepts). Techniquement, les portlets sont des fichiers war , qui sont déployés comme des servlets. À l'instar des servlets, un portlet est défini pour le serveur d'applications à l'aide du descripteur de déploiement de servlet web.xml. Outre le descripteur de servlet, les portlets doivent aussi fournir un descripteur de déploiement de portlet (portlet.xml) afin de définir les fonctionnalités du portlet pour le serveur de portail. Le schéma ci-dessous illustre la structure d’un fichier war représentant un portlet : Illustration 2 : Contenu standard d'un fichier war représentant un portlet Les informations définies dans le fichier portlet.xml comprennent des paramètres de configuration spécifiques, comme le type de balisage pris en charge par le portlet, les valeurs des paramètres d’initilialisation, etc. Ces informations permettent au serveur de portail d'offrir des services au portlet. Par exemple, si un portlet enregistre une prise en charge des modes Aide et Édition (reportez-vous à la section « Concepts ») dans le descripteur de déploiement de portlet, le serveur de portail affiche des icônes qui permettent à l'utilisateur d'appeler les pages d'aide et de modification du portlet. © Jahia Ltd. Tous droits réservés. I p. 10/47 Voici un exemple de fichier portlet.xml : <?xml version="1.0" encoding="UTF-8"?> <portlet-app> <portlet> <description>query_portlet</description> <portlet-name>query_portlet</portlet-name> <display-name>query_portlet</display-name> <portlet-class> sql.portlet.QueryPortlet</portlet-class> <init-param> <name>view_url</name> </value> </init-param> <init-param> <name>help_url</name> <value>/templates/help.jsp</value> </init-param> <expiration-cache>-1</expiration-cache> <supports> <mime-type>text/html</mime-type> <portlet-mode>view</portlet-mode> </supports> <supported-locale>en</supported-locale> <portlet-info> <title>Query Portlet</title> <short-title>Query Portlet</short-title> </portlet-info> <portlet-preferences> <preferences-validator> sql.portlet.QueryPreferencesValidator </preferences-validator> </portlet-preferences> </portlet> </portlet-app> Côté utilisateur, un portlet est une fenêtre contenue dans un site de portail, qui fournit un service ou des informations spécifiques, par exemple un agenda ou des actualités. © Jahia Ltd. Tous droits réservés. I p. 11/47 Illustration 3 : Page d’un portail avec des portlets Dans une optique de développement d'une application, les portlets sont des modules d'extension conçus pour s'exécuter dans un conteneur de portlet appartenant à un serveur de portail. JAHIA 5 utilise Jetspeed comme conteneur de portlet. 2.3 CONTENEUR DE PORTLET Le conteneur de portlet (Jetspeed) fournit un environnement d'exécution dans lequel les portlets sont instanciés, utilisés puis finalement détruits. Les portlets dépendent de l'infrastructure du portail pour accéder aux caractéristiques des profils utilisateur, participer aux événements d'action et de fenêtre, communiquer avec d'autres portlets, accéder à du contenu distant, consulter les accréditations et stocker les données rémanentes. L'API de portlet fournit des interfaces standard pour ces fonctions. Cependant, le conteneur n’est pas responsable de l’agrégation du contenu généré par les portlets. Ceci est géré par le portail. Le portail et le conteneur peuvent être mis en œuvre en même temps, comme un simple module ou bien comme deux modules distincts. © Jahia Ltd. Tous droits réservés. I p. 12/47 2.4 GENERATION DE LA PAGE DU PORTAIL Les portlets s’exécutent dans un conteneur. Celui-ci reçoit les contenus générés par les portlets et les envoie au serveur de portail. Enfin, le serveur de portail construit la page du portail et l’envoie au client (par exemple, au navigateur). Illustration 4 : Architecture de base d'un portail Site in 5 Minutes 2.5 CONCEPTS 2.5.1 CYCLE DE VIE Le cycle de vie d’un portlet est très proche de celui d’un servlet. Il se décompose en trois phases : • initialisation • traitement des requêtes • destruction Le portlet reçoit les requêtes basées sur l'interaction de l’utilisateur avec le portlet ou la page du portail. Le traitement de la requête se divise en deux phases : • Traitement de l’action (processAction(…)) : si un utilisateur clique sur un lien généré par le portlet, une action est lancée. Le traitement de l’action est terminé avant que le portlet ne commence à générer le contenu. • Génération du contenu (renderAction(…)) : dans cette phase, le portlet génère le contenu envoyé à la page du portail. Tous les portlets contenus dans la page du portail peuvent exécuter cette phase en parallèle. © Jahia Ltd. Tous droits réservés. I p. 13/47 Illustration 5 : Traitement de requêtes par les portlets Un portlet est une classe qui doit mettre en œuvre l’interface javax.portlet.Portlet et qui fournit quatre méthodes (init(…), processAction(…), render(…) et destroy(…)) pour pouvoir être géré correctement par le conteneur. Pour obtenir plus d’informations sur l’interface javax.portlet.Portlet, consultez la page : http://portals.apache.org/pluto/multiproject/portlet-api/apidocs/javax/portlet/Portlet.html La classe javax.portlet.Generic est une classe qui met en œuvre l’interface Portlet. La méthode render(…) est décomposée en 3 méthodes : doView(…), doEdit(…) et doHelp(…). Il est conseillé de dériver cette classe pour développer un portlet. Pour obtenir plus d’informations, consultez la page : http://portals.apache.org/pluto/multiproject/portlet-api/apidocs/javax/portlet/GenericPortlet.html © Jahia Ltd. Tous droits réservés. I 2.5.2 p. 14/47 GESTION DE LA SESSION Comme les objets HttpSession utilisés par les servlets, les portlets définisssent l’objet PortletSession qui permet d’enregistrer des objets au cours de la session du client. Deux portées sont définies lors de l’enregistrement d’un objet en session : • • 2.5.3 PORTLET_SESSION : l’objet est accessible uniquement par le portlet et l’utilisateur en cours APPLICATION_SESSION : l’objet est accessible par tous les portlets, servlet et jps de l’application, mais uniquement par l’utilisateur en cours PORTLETURL Contrairement aux servlets, un portlet n’est pas directement lié à une URL. La norme JSR168 a défini la notion de PortletURL. Ceux-ci permettent de générer des URL qui pointent vers le portlet (à travers le point d’entrée/sortie du portail). Il existe deux types d’URL : • actionsURL : les méthodes processAction(…) et renderAction(…) sont exécutées dans cet ordre. • renderURL 2.5.4 SECURITE : seule la méthode render est executée. 2.5.4.1 AUTHENTIFICATION L’authentification est gérée par le portail (JAHIA). 2.5.4.2 AUTORISATION Les portlets se basent sur le modèle de rôles défini par la norme J2EE/Servlet. Il est possible de vérifier le rôle de l’utilisateur connecté via les méthodes isUserInRole(). Les méthodes getUserPrincipal() et getRemoteUser() permettent d’obtenir le nom d’utilisateur d’un utilisateur. 2.5.5 MODE DE PORTLET Grâce à différents modes, un portlet peut afficher différentes interfaces utilisateur, en fonction de la tâche qu'il doit effectuer. Un portlet dispose de trois modes d'affichage qui sont définis dans le descripteur de déploiement de portlet. Le conteneur de portlet conserve le mode du portlet dans l'objet PortletMode. © Jahia Ltd. Tous droits réservés. I p. 15/47 Les modes suivants sont fournis par l'API de portlet : • Affichage : lorsqu'un portlet est initialement construit sur une page de portail, pour un utilisateur, il apparaît en mode Affichage. Il s'agit du mode de fonctionnement normal du portlet. • Édition : si ce mode est pris en charge par le portlet, ce dernier fournit une page permettant aux utilisateurs de personnaliser le portlet en fonction de leurs besoins. Par exemple, un portlet peut fournir une page permettant aux utilisateurs d'indiquer le lieu où ils se trouvent afin d'obtenir des informations sur la météo ou les événements locaux. Les utilisateurs doivent être connectés au portail pour accéder au mode Édition. • Aide : si ce mode est pris en charge par le portlet, ce dernier fournit une page d'aide offrant aux utilisateurs de plus amples informations sur le portlet. L'API de portlet offre plusieurs méthodes au portlet pour déterminer le mode en cours. Tous les portlets doivent prendre en charge le mode Affichage. Le portail inclut des commandes qui permettent aux utilisateurs de modifier le mode en cours. Voici un exemple de la barre d'un portlet en mode Affichage. Illustration 6 : Mode du portlet Cette barre affiche les modes Affichage, Édition et Aide. Le portlet passe en mode Édition lorsque l’utilisateur clique sur l’onglet . L’API offre une la classe javax.portlet.PortletMode pour gérer le mode d’un portlet. Pour obtenir plus d’informations sur la classe javax.portlet.PortletMode, consultez la page : http://portals.apache.org/pluto/multiproject/portlet-api/apidocs/javax/portlet/PortletMode.html Il n’est possible d’enregistrer des préférences que pendant la phase processAction(…). © Jahia Ltd. Tous droits réservés. I 2.5.6 p. 16/47 ÉTATS DU PORTLET Les différents états d'un portlet permettent aux utilisateurs de modifier l'affichage de la fenêtre du portlet sur le portail. Dans un navigateur, les utilisateurs accèdent à ces différents états grâce aux onglets de la barre de titre, comme dans les applications Windows. Les états d’un portlet sont conservés dans l'objet PortletWindowState, sous la forme d'une valeur booléenne. Les états suivants sont fournis par l'API de portlet : • Normal : lors de sa construction initiale sur la page de portail, le portlet apparaît en mode Normal et est organisé sur la page, avec les autres portlets. • Réduit : lorsque le portlet est réduit, seule la barre de titre s'affiche sur la page du portail. Illustration 7 : État du portlet L'API de portlet offre plusieurs méthodes au portlet pour déterminer l’état en cours. Pour obtenir plus d’informations sur la classe javax.portlet.WindowState, consultez la page : http://portals.apache.org/pluto/multiproject/portlet-api/apidocs/javax/portlet/WindowState.html 2.5.7 PREFERENCES DU PORTLET Le portlet peut stocker des données permanentes pour un utilisateur spécifique en utilisant l’objet PortletPreferences. Les préférences peuvent utiliser des valeurs par défaut, définies dans le descripteur de déploiement (fichier portlet.xml). Le mode conseillé pour la définition des préférences est le mode Édition. Ce mode fournit à l'utilisateur un écran de personnalisation. © Jahia Ltd. Tous droits réservés. I p. 17/47 Il est possible de définir des validateurs utilisés par le conteneur pour s’assurer que les valeurs des préférences sauvegardées sont conformes à certains critères. 2.5.8 LIMITATIONS IMPOSEES Les portlets génèrent des fragments HTML agrégés dans une page de portail. Par conséquence, la norme JSR168 interdit qu’un portlet génère des balises de type Base, body, frame, frameset, head, html et title. 3 JAHIA ET PORTLET JSR 168 3.1 ATTRIBUTS DE LA REQUETE Jahia ajoute des attributs dans la requête qui peuvent être très utils pour les développeurs. Il est à noter que si ces attributs sont utilisés alors la portlet n’est plus compatible avec d’autres portails. La table ci-dessous présente ces attributs. Ceux-ci sont accessibles à partir de la portlet grâce à la méthode renderRequest.getAttribute(String attributeName) de l’API Portlet. Attribute name Type Value Description "org.portletapi.portal" String “true” Toujours à “true”. Permet de déterminer si l’application est lancée en "standalone" ou dans le context de Jahia "org.portletapi.userlist" Vecteur d’objets String Liste des noms de tous les utilisateurs Contient la liste de tous les utilisateurs. Par exemple, permet de gérer l’assignation des droits à partir de la portlet. Cependant, il est préférable d’utiliser les rôles si c’est possible. "org.portletapi.contextid" String == fieldID Le contextid est un String qui permet d’obtenir un identifiant unique pour différencier les instances de portlet. Jahia permet à une portlet d’être instanciée plusieurs fois dans une même page. Dans la version actuelle de Jahia, le contextid correspond au fieldID qui contient l’application. Il est aussi possible (et préférable) d’obtenir un identifiant unique grâce à la méthode getNamespace() de l’objet renderResponse (JSR168) "org.portletapi.fullscreen" String “true” / “false” Pas complètement implémenté. Cet attribut permet de savoir si l’application est dans le mode full screen ou non. "org.jahia.sitekey" String jParams.getSiteKey () L’identifiant unique du site dans lequel la portlet est instanciée "org.jahia.siteurl" String jParams.getSiteURL () Un objet de type String qui contient l’url du site qui correspond généralement au domaine du site comme par exemple : www.jahia.org, www.jahia.com, etc "org.jahia.siteid" String Integer.toString (jParams.getSiteID ()) Un objet de type String qui contient un entier qui correspond à l’identifiant du site stocké dans la base de donnée. © Jahia Ltd. Tous droits réservés. I p. 18/47 "org.jahia.pageid" String Integer.toString (jParams.getPageID ()) Un objet de type String contenant un entier qui correspond à l’identifiant de la page dans laquel la portlet est affichée. "org.jahia.operationmode" String jParams.getOperationMode () Permet de determiner le mode actuelle de la page. Les valeurs possibles pour Jahia 4/5 sont : "normal" (appelé aussi Live dans les templates), "edit" (mode d’édition), "debug" (pas utilisé mais encore accepté dans l’urls des pages), "preview" (prévisualistion de la page avant d’être publiée), et "compare" (un mode spécial qui permet de comparer deux versions de la page) 3.2 ATTRIBUTS DE SESSION DEFINIS DANS UN TEMPLATE Par défaut, Jahia ne partage pas les attributs mis en session avec la portlet. Ceci implique que si vous ajoutez un attribut dans la session Jahia (à traver un scriplet ou un template) en utilisant cette instruction : request.getSession().setAttribute(“name”, “value”); vous ne pourrez pas y accéder à partir de la portlet avec cette instruction : renderRequest.getPortletSession().getAttribute(“name”); Cette limitation existe pour des questions de sécurité. L’application doit être au maximum indépendante pour éviter les conflits de nom des attributs qui peuvent engendrer des comportements inattendus. Cependant, il est possible de désactiver cette limitation grâce à une propriété qu se trouve dans le fichier de configuration, jahia.properties : webapps.dispatcher.inheritJahiaSessionAttributes = true Par défaut, cette propriété est à false. La valeur true permet aux portlets d’accéder aux attributs de session de Jahia. © Jahia Ltd. Tous droits réservés. I p. 19/47 CHAPITRE 2 : DEVELOPPER UN PORTLET DE BASE Ce chapitre présente un exemple de développement et de déploiement d’un portlet sous JAHIA 5, à l’aide d’un modèle de base. 1 INTRODUCTION Le but de ce portlet est d’afficher le message Hello World !. Les différentes étapes sont les suivantes : • écriture de la classe HelloWorldPortlet qui implémente l’interface javax.portlet.Portlet • écriture des fichiers portlet.xml et web.xml • archivage du portlet dans un fichier war • déploiement du portlet • affichage dans une page Jahia Le développement d’un portlet requiert la présence de la bibliothèque portlet.api. Celle-ci est disponible sur à cette adresse : http://jcp.org/aboutJava/communityprocess/final/jsr168/index.html. 2 CLASSE HELLOWORLDPORTLET Comme pour tout portlet, la classe doit implémenter l’interface javax.portlet.Portlet. L’API du portlet propose une classe, appelée GenericPortlet, qui implémente cette interface. Cette classe décompose la méthode render(…) en trois méthodes : • doView(…) : portlet en mode Affichage • doHelp(…) : portlet en mode Aide • doEdit(…) : portlet en mode Édition Notre portlet n’est utilisable qu’en mode Affichage. Nous allons surchager la méthode doview(…). public void doView(RenderRequest req, RenderResponse resp) { try { response.setContentType("text/html"); PrintWriter out = resp.getWriter(); out.print("Hello world"); © Jahia Ltd. Tous droits réservés. I p. 20/47 } catch (Exception ex) { ex.printStackTrace(); } } La méthode doview(…) est similaire aux méthodes doGet(…) et doPost(…) des servlets. L’objet PrintWriter permet d’écrire dans le flux renvoyé par le portail. Celui-ci est ensuite agrégé avec celui des autres portlets et le modèle Jahia, afin de former une page Jahia complète. Voici le code complet du portlet : package org.jahia.portlet; import javax.portlet.*; import java.io.PrintWriter; import java.io.*; import java.lang.StringBuffer; /** * HelloWorldPortlet * *@author Khaled TLILI */ public class HelloWorldPortlet extends GenericPortlet { /** * Init portlet method * *@param config *@exception PortletException Description of Parameter Description of Exception */ public void init(PortletConfig config) throws PortletException { super.init(config); } /** * processAction method */ © Jahia Ltd. Tous droits réservés. I p. 21/47 public void processAction(ActionRequest request, ActionResponse response) { System.out.println("====== Begin process method ======"); } /** * render method */ public void doView(RenderRequest request, RenderResponse response) { try { response.setContentType("text/html"); PrintWriter out = response.getWriter(); PortletURL url = response.createRenderURL(); PortletURL actionURL = response.createActionURL(); out.print("Hello world!"); } catch (Exception ex) { ex.printStackTrace(); } } /** * destroy method */ public void destroy() { super.destroy(); } } Pour compiler ce portlet, il est nécessaire d’ajouter la bibliothèque portlet.jar au classpath. Pour ajouter les modes Édition et Aide, il est nécessaire de mettre en œuvre respectivement les méthodes doEdit(…) et doHelp(…) et de mettre à jour les fichiers portlet.xml. © Jahia Ltd. Tous droits réservés. I p. 22/47 3 FICHIER PORTLET.XML Ce fichier sert à décrire les portlets qui vont être déployés dans JAHIA, sous la forme d’une application Web. <?xml version="1.0" encoding="UTF-8"?> <portlet-app version="1.0"> <portlet> <description>Hello World portlet</description> <portlet-name>HelloWorldPortlet</portlet-name> <portlet-class>org.jahia.portlet.HelloWorld</portlet-class> <supports> <mime-type>text/html</mime-type> <portlet-mode>view</portlet-mode> </supports> <portlet-info> <title>SimplePortlet</title> </portlet-info> </portlet> </portlet-app> Ce descripteur contient diverses informations sur le portlet, comme son nom, la classe qui contient sa mise en œuvre, les modes qu’il supporte (dans notre exemple : uniquement le mode Affichage), ainsi que des informations le décrivant. Le fichier portlet.xml est placé au même niveau que le ficher web.xml, c’est-à-dire dans le répertoire WEB-INF. Une application peut déclarer plusieurs portlets. Ceci permet de n’avoir qu’un seul fichier *.war ou de regrouper des portlets similaires (fonctionnalités, back end, etc.). 4 FICHIER WEB.XML Dans notre exemple, le ficher web.xml est vide. JAHIA (via Jetspeed) y ajoute certaines informations après le déploiement. © Jahia Ltd. Tous droits réservés. I p. 23/47 Après le déploiement, le contenu du fichier web.xml est : <?xml version="1.0" encoding="UTF-8"?> <web-app> <display-name>HelloWorldPortlet</display-name> <description>Hello World Portlet </description> <servlet> <servlet-name>JetspeedContainer</servlet-name> <display-name>Jetspeed Container</display-name> <description>MVC Servlet for Jetspeed Portlet Applications</description> <servlet-class>org.apache.jetspeed.container.JetspeedContainerServlet</servlet-class> <init-param> <param-name>contextName</param-name> <param-value> HelloWorldPortlet</param-value> </init-param> <load-on-startup>0</load-on-startup> </servlet> <servlet-mapping> <servlet-name>JetspeedContainer</servlet-name> <url-pattern>/container/*</url-pattern> </servlet-mapping> <taglib> <taglib-uri>http://java.sun.com/portlet</taglib-uri> <taglib-location>/WEB-INF/tld/portlet.tld</taglib-location> </taglib> </web-app> Si le fichier web.xml avait déjà contenu des informations, celles-ci auraient étés agrégées avec le contenu ci-dessus. 5 DEPLOIEMENT Les portlets ont la même structure que les applications Web classiques. L’arborescence suivante doit être respectée : © Jahia Ltd. Tous droits réservés. I p. 24/47 + HelloWorldPortlet + META-INF + WEB-INF + classes +… + lib porlet.xml web.xml Après sa création, le fichier HelloWorld.war doit être placé dans le répertoire suivant : ${TOMCAT_HOME}\webapps\jahia\WEB-INF\var\new_webapps. JAHIA déploie automatiquement le portlet. Ce déploiement automatique effectue les actions suivantes : • déplacement du fichier HelloWorld.war dans : ${TOMCAT_HOME}\webapps\jahia\WEB-INF \etc\jetspeed\deploy • ajout d’une entrée dans la base de données • réécriture du fichier web.xml • déploiement de l’application dans tomcat La génération du fichier peut se faire à l’aide de la commande jar de java, ou des outils ant ou maven. La procédure de redéploiement est identique. Cependant, il est nécessaire de s’assurer qu’aucun fichier n’est verrouillé (jar, fichier de propriétés, fichier de la base de données Hsql, etc.) NE PLACEZ JAMAIS LE FICHER *.WAR DIRECTEMENT DANS ${TOMCAT_HOME}\webapps. JAHIA DOIT AU MINIMUM RÉÉCRIRE LE FICHIER WEB.XML 6 VISUALISATION Pour visualiser le portlet, il faut ajouter le portlet à une page JAHIA (reportez-vous au document JahiaEndUserGuide.pdf). © Jahia Ltd. Tous droits réservés. I p. 25/47 CHAPITRE 3 : DEVELOPPER UN PORTLET AVANCE Ce chapitre présente le développement d’un portlet avancé. Nous allons étudier comment utiliser les JSP, les attributs, les préférences et les modes. 1 INTRODUCTION Le but de ce portlet est d’afficher le message : Hello <nom de l’utilisateur> ! Votre film préféré est <nom du film>. Le portlet doit permettre à l’utilisateur connecté de spécifier le nom de son film préféré. Cette portlet utilisera 3 modes : • Affichage : pour afficher le message ci-dessus. • Édition : pour éditer les préférences • Aide : pour afficher un message d’aide Nous vous conseillons de n’autoriser la mise à jour des valeurs des préférences par l’utilisateur que dans le mode Édition. Les différentes étapes sont les suivantes : • écriture de la classe HelloPortlet qui met en œuvre l’interface javax.portlet.Portlet • écriture des fichiers portlet.xml et web.xml • archivage du portlet dans un fichier *.war • déploiement du portlet • affichage dans une page Jahia © Jahia Ltd. Tous droits réservés. I p. 26/47 2 CLASSE HELLOPORTLET Contairement à l’exemple précédent, nous allons utiliser uniquement des JSP pour générer les fragments HTML. L’API de portlet met à la disposition des développeurs l’objet PortletRequestDispatcher qui permet de déléguer la génération du rendu HTML à un fichier JSP. Celui-ci s’utilise de la même manière que l’objet RequesDispatcher de la norme servlet. 2.1 MODE AFFICHAGE Dans ce mode, le portlet récupère la valeur de la préférence <film>, enregistre la valeur dans la session et dispatche vers un JSP. Le code de la méthode doView(…) est alors : public void doView(RenderRequest req, RenderResponse resp) { try { response.setContentType("text/html"); // Obtenir le valeur de la préférence PortletPreferences pp = req.getPreferences() ; String film = pp.getValue("film","valeur par défaut" ); // Stocker dans la session PortletSession ss = req.getPortletSession(); ss.setAttribute(“film”,film,PortletSession.APPLICATION_SCOPE); // Dispatcher PortletRequestDispatcher d = getPortletContext().getRequestDispatcher(“/jsp/view.jsp”); d.include(req,resp); } catch(Exception e){ // Gérer l’exception } } © Jahia Ltd. Tous droits réservés. I p. 27/47 Le fichier view.jsp se présente comme suit : <%@ taglib uri=“http://java.sun.com/portlet“ prefix=“p“%> <p:defineObjects/> <div> Hello <%=renderRequest.getRemoteUser()%> ! </div> <br/> <div> Votre film préféré est <%=renderRequest.getPortletSession().getAttribute(“film“)%>. </div> N’oubliez pas les 2 premières lignes du fichier JSP : <%@ taglib uri=“http://java.sun.com/portlet“ prefix=“p“%> <p:defineObjects/> Ce taglib permet d’instancier les objets renderRequest et renderResponse. Leur utilisation est similaire à celle des objets request et response de la norme servlet. 2.2 MODE ÉDITION Le mode Édition permet au portlet de stocker les préférences. La méthode doEdit(…) ne fait que dispatcher vers un fichier JSP. public void doEdit(RenderRequest req, RenderResponse resp) { try { resp.setContentType("text/html"); PortletRequestDispatcher d = getPortletContext().getRequestDispatcher(“/jsp/edit.jsp”); d.include(req,resp); } catch(Exception e){ // Gérer l’exception } } © Jahia Ltd. Tous droits réservés. I p. 28/47 Le fichier edit.jsp est un formulaire qui permet d’entrer une valeur pour le nom du film. Il se présente comme suit : <%@ taglib uri=“http://java.sun.com/portlet“ prefix=“p“%> <p:defineObjects/> <form action=”<p:actionURL/>”> <div> Nom du film préféré : <input type=“text“ name=”film”/> </div> <br/> <div> <input type=“submit“/> </div> </form> Nous avons utilisé la balise <p :actionURL/> pour générer un portletURL de type ACTION. Ainsi, la méthode processAction(…) est exécutée. N’oubliez pas les 2 premières lignes du fichier JSP : <%@ taglib uri=“http://java.sun.com/portlet“ prefix=“p“%> <p:defineObjects/> Cet argument taglib permet d’instancier les objets renderRequest et renderResponse. Leur utilisation est similaire à celle des objets request et response de la norme servlet. Outre la méthode doEdit(…), la méthode processAction(…) est exécutée. Dans notre application, son rôle principal est d’enregistrer la valeur de la préférence. L’API de portlet propose un ensemble de méthodes qui permettent d’enregistrer les préférences. public void processAction(ActionRequest req, ActionResponse resp) { try { // Identifier le mode PortletMode pm = req.getPortletMode(); // Mettre à jour les préférences. Seulement pour le mode EDIT if(pm.equals(PortletMode.EDIT)){ © Jahia Ltd. Tous droits réservés. I p. 29/47 // Récupérer la valeur String film = request.getParameter(“film”); // Récupérer l’objet préférence PortletPreferences pp = req.getPreferences(); // Mettre à jour la valeur pp.setValue(“film”,film); // Stocker de manière permanente pp.store(); } } catch(Exception e){ // Gérer l’exception } } Il est possible de forcer le passage en mode Affichage après l’enregistrement, en ajoutant resp.setPortletMode(PortletMode.VIEW) à la fin de la méthode processAction. 2.3 MODE AIDE Dans ce mode, le portlet affiche un message. La méthode doHelp(…) dispatche vers le JSP help.jsp. Le code associé est alors le suivant : public void doHelp(RenderRequest req, RenderResponse resp) { try { resp.setContentType("text/html"); PortletRequestDispatcher d = getPortletContext().getRequestDispatcher(“/jsp/help.jsp”); d.include(req,resp); } catch(Exception e){ // Gérer l’exception } } © Jahia Ltd. Tous droits réservés. I p. 30/47 Le fichier help.jsp se présente comme suit : <div> Ce portlet permet à l’utilisateur connecté d’enregistrer le nom de son film préféré. </div> Contrairement aux JSP destinés aux servlets, ce JSP génère seulement un fragment HTML. Par conséquent, elle ne contient pas de balises <html>, <head>, <body>, etc. 3 FICHIER PORTLET.XML Ce fichier sert à décrire les portlets qui vont être déployés dans Jahia, sous la forme d’une application Web. <?xml version="1.0" encoding="UTF-8"?> <portlet-app version="1.0"> <portlet> <description>Hello portlet</description> <portlet-name>HellodPortlet</portlet-name> <portlet-class>org.jahia.portlet.HelloPortlet</portlet-class> <supports> <mime-type>text/html</mime-type> <portlet-mode>view</portlet-mode> <portlet-mode>edit</portlet-mode> <portlet-mode>help</portlet-mode> </supports> <portlet-info> <title>HelloPortlet</title> </portlet-info> <portlet-preferences> © Jahia Ltd. Tous droits réservés. I p. 31/47 <preference> <name>HelloPortlet</name> <value>HelloPortlet</value> </ preference > </portlet- preferences > </portlet> </portlet-app> 4 ET ENSUITE ? Reportez-vous aux sections 3, 4 et 5 du Chapitre 2 « Développer un portlet de base ». © Jahia Ltd. Tous droits réservés. I p. 32/47 CHAPITRE 4 : PORTLETS, FRAMEWORKS ET PONTS Ce chapitre présente différents frameworks (cadres d’applications) du monde J2EE qui peuvent être utilisés pour développer des portlets. 1 INTRODUCTION La plupart des applications Web sont développées à l’aide de frameworks comme Struts ou JSF. Pour intégrer ces technologies, des ponts ont été développés. Pour la plupart, ils permettent de convertir une application (par exemple, un servlet) en portlet sans avoir besoin de modifier le code Java. La plupart des ponts sont développés par la communauté open source et peuvent contenir quelques bugs. Avant d’utiliser un pont, assurez-vous de sa stabilité (grâce aux mailing listes, forums,…) 2 FRAMEWORK STRUTS Ce pont permet de transformer une application Struts en portlet JSR 168 assez rapidement. Il suffit d’écrire le fichier portlet.xml et un fichier de configuration du pont, appelé struts-portlet.xml. Le fichier struts-portlet.xml permet de spécifier au framework le type d’URL générées : actionURL ou renderURL. De plus, il est nécessaire de modifier les JSP de sorte que les URL générées soient des PortletURL Pour obtenir plus d’informations sur l’utilisation du pont Struts, consultez la page : http://portals.apache.org/bridges/multiproject/portals-bridges-struts/index.html 3 FRAMEWORK JSF Ce pont permet de transfomer une application JSF en portlet. Il suffit d’écrire le fichier portlet.xml et d’ajouter la bibliothèque jsf-bridge. La classe org.apache.portals.bridges.jsf. FacesPortlet est configurée de façon à mettre en œuvre le portlet, à la place de la classe GenericPortlet. © Jahia Ltd. Tous droits réservés. I p. 33/47 Nous vous conseillons d’utiliser le framework JSF pour le développement de portlets JSR168. Celui-ci a été spécifiquement développé orienté portlet. Pour plus d’informations à propos du pont JSF, veuillez consulter le site suivant: http://portals.apache.org/bridges/multiproject/portals-bridges-jsf/index.html 4 AUTRES PONTS : PHP, PERL, ETC. La communauté JSR168 fournit un grand effort pour donner la possibilité aux développeurs d'intégrer des applications existantes, codées dans des langages autres que Java. La majorité des solutions proposées se base sur l'utilisation de ponts. La complexité principale est la configuration de ces ponts. Pour obtenir plus d’informations sur l’utilisation de ces ponts, consultez la page : http://portals.apache.org/bridges/release-notes.html © Jahia Ltd. Tous droits réservés. I p. 34/47 CHAPITRE 5 : MIGRER DES JAHIAWEBAPP VERS DES PORTLETS Ce chapitre présente différentes méthodes de migration de JahiaWebApp vers des portlets. 1 INTRODUCTION JAHIA 4 supporte des portlets spécifiques à JAHIA, appelés « JahiaWebApp ». Avec la définition de la norme JSR168, nous vous conseillons de migrer vos JahiaWebApp vers des portlets. Cette section présente des méthodes standard pour faciliter la migration : • utilisation du pont jahiaWebAppPortlet • utilisation des ponts des différents frameworks • conversion du code Java • ajout du fichier jahia.xml (déconseillé) Attention, le portlet ne sera pas un portlet JSR168 2 PONT JAHIAWEBAPPPORTLET Le pont JahiaWebAppPortlet permet de convertir une JahiaWebApp sans modification du code Java et des JSP. Les étapes sont les suivantes : • ajout du fichier portlet.xml • modification du fichier web.xml N’oubliez pas d’ajouter la bibliothèque jahiaWebAppPortlet.jar dans WEB-INF/lib 2.1 COMMENT FONCTIONNE LE PONT ? Le pont JahiaWebAppPortlet se compose d’un ensemble d’enveloppes (wrappers) qui encapsulent les objets principaux des portlets RenderRequest, RenderResponse, PortletContext, PortletSession, etc. dans des objets de type HttpServletRequest, HttpServletResponse, ServletContext, HttpSession, etc. La classe principale est org.jahia.portlet.JahiaWebAppPortletBridge. Celle-ci est de type et permet d’encapsuler une JahiaWebApp dans un portlet JSR168. javax.portlet.Portlet © Jahia Ltd. Tous droits réservés. I p. 35/47 org.jahia.portlet.JahiaWebAppPortletBridge Portlet JSR168 org.jahia.jahiawebapp.Simple JahiaWebApp Le pont fonctionne selon le schéma suivant : org.jahia.portlet.JahiaWebAppPortletBridge org.jahia.jahiawebapp.Simple init(Porletconfig conf) init (new ServletConfigWrapper(conf)) init (…) render (RenderRequest req, RenderResponse resp) service(new HttpServletRequestW(req), new HttpServletResponseW(resp)) service(…) Fragment html html À l’initialisation, le conteneur appelle la méthode init(…) du portlet org.jahia.portlet. JahiaWebAppPortletBridge avec PortletConfig comme paramètre. Le pont encapsule l’objet PorletConfig dans un objet de type ServletConfig et appelle la méthode init(…) de la JahiaWebApp. À chaque appel du conteneur de la méthode render(…), le pont encapsule les objets RenderRequest et © Jahia Ltd. Tous droits réservés. I p. 36/47 dans des objets de type HttpServletRequest et HttpServletResponse, puis appelle la méthode service de la JahiaWebApp. RenderResponse Le pont ne génère que des URL de type actionUrls. La méthode sendRedirect(…) est simulée à l’aide de javascript. 2.2 COMMENT L’UTILISER ? 2.2.1 EXEMPLE DE MIGRATION Dans les sections suivantes, nous allons prendre comme exemple une JahiaWebApp dont le fichier web.xml est le suivant : <web-app> <servlet> <servlet-name> AdressBook </servlet-name> <servlet-class> org.jahia.webapps.addressbook.AdressBook </servlet-class> <load-on-startup>1</load-on-startup> <init-param> <param-name>name</param-name> <param-value>value</param-value> </init-param> </servlet> <servlet> <servlet-name> InitServlet </servlet-name> <servlet-class> org.jahia.webapps.InitServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> </web-app> © Jahia Ltd. Tous droits réservés. I 2.2.2 p. 37/47 AJOUTER LE FICHIER PORTLET.XML Tout d’abord, à partir du fichier web.xml, il faut déterminer le servlet qui représente la JahiaWebApp, c'est-à-dire entryPoint. Dans notre exemple, entryPoint correspond au servlet dont le nom est AdressBook. Une fois entryPoint identifié, tout l’exercice revient à écrire le fichier portlet.xml en respectant ces règles : • <servlet-name> • <servlet-class> • <init-param><param-name><param-value> Æ <portlet-name> Æ valeur du paramètre jahiaWebAppClass. Æ <init-param><name>< value> La valeur de <portlet-class> est org.jahia.portlet.JahiaWebAppPortletBridge. Dans un servlet, on observe : <init-param> <param-name>name</param-name> <param-value>value</param-value> </init-param> Dans un portlet, on observe : <init-param> <name>name</name> <value>value</value> </init-param> Le fichier portlet.xml de base se présente sous la forme suivante : <?xml version="1.0" encoding="UTF-8"?> <portlet-app version="1.0"> <portlet> <description>Jahia WebApp Portlet Bridge</description> <portlet-name>…</portlet-name> <portlet-class>org.jahia.portlet.JahiaWebAppPortletBridge</portlet-class> <!-- jahia webapp class --> <init-param> <name>jahiaWebAppClass</name> <value>…</value> </init-param> © Jahia Ltd. Tous droits réservés. I p. 38/47 <init-param> <name>name</name> <value>value</value> </init-param> </portlet> </portlet-app> Pour l’exemple ci-dessus, le fichier portlet.xml est donc : <web-app> <?xml version="1.0" encoding="UTF-8"?> <servlet> <servlet-name> AdressBook <portlet-app version="1.0"> <portlet> <description> </servlet-name> <servlet-class> org.jahia.webapps.addressbook.AdressBook EntryPoint </servlet-class> <load-on-startup>1</load-on-startup> <init-param> <param-name>name</param-name> <param-value>value</param-value> </init-param> </servlet> Jahia WebApp Portlet Bridge </description> <portlet-name>AdressBook</portlet-name> <portlet-class> org.jahia.portlet.JahiaWebAppPortletBridge </portlet-class> <!-- jahia webapp class --> <init-param> <name>jahiaWebAppClass</name> <servlet> <value> <servlet-name> InitServlet org.jahia.webapps.addressbook.AddressBookServlet </value> </servlet-name> <servlet-class> org.jahia.webapps.InitServlet </init-param> <init-param> <name>name</name> </servlet-class> <value> value</value> <web-app> </init-param> <servlet> </portlet> <servlet-name> </portlet-app> AdressBook © Jahia Ltd. Tous droits réservés. I p. 39/47 Le fichier portlet.xml est donc : <?xml version="1.0" encoding="UTF-8"?> <portlet-app version="1.0"> <portlet> <description>Jahia WebApp Portlet Bridge</description> <portlet-name>AdressBook</portlet-name> <portlet-class>org.jahia.portlet.JahiaWebAppPortletBridge</portlet-class> <!-- jahia webapp class --> <init-param> <name>jahiaWebAppClass</name> <value>org.jahia.webapps.addressbook.AddressBookServlet</value> </init-param> <init-param> <name>name</name> <value> value</value> </init-param> </portlet> </portlet-app> 2.2.3 METTRE A JOUR LE FICHIER WEB.XML Dans le fichier web.xml, il faut supprimer le servlet correspondant à la JahiaWebApp. © Jahia Ltd. Tous droits réservés. I p. 40/47 <web-app> <servlet> <servlet-name> AdressBook </servlet-name> <servlet-class> EntryPoint org.jahia.webapps.addressbook.AdressBook </servlet-class> <load-on-startup>1</load-on-startup> <init-param> <param-name>name</param-name> <param-value>value</param-value> </init-param> </servlet> <servlet> <servlet-name> InitServlet </servlet-name> … Dans notre exemple, le fichier web.xml devient : <web-app> <servlet> <servlet-name> InitServlet </servlet-name> <servlet-class> org.jahia.webapps.InitServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> </web-app> © Jahia Ltd. Tous droits réservés. I 2.2.4 p. 41/47 ARBORESCENCE DES REPERTOIRES Après écriture du fichier portlet.xml, la structure de l’application est la suivante : Applicatin dir. WEB-INF lib classes … jahiaWebappPortletBridge.jar web.xml web.xml portlet.xml Other dir. Other dir. 3 UTILISER LES FRAMEWORKS STANDARD Certaines JahiaWebApp sont développées à l’aide d’un framework comme Struts. Pour ce type d’applications, il est possible de convertir la JahiaWebApp en utilisant des ponts standard (reportez-vous au chapitre consacré aux ponts). La plupart de ces ponts ont la particularité d’être paramétrables grâce à des fichiers xml. Il est conseillé d’utiliser cette méthode pour les JahiaWebApp développées à l’aide d’un framework. © Jahia Ltd. Tous droits réservés. I p. 42/47 4 CONVERTIR LE CODE JAVA ET JSP Enfin, il est possible de convertir la JahiaWebApp en vrai portlet. Il n’existe pas de méthodes standard. Cependant, certaines règles de mappage doivent être définies : • HttpSession • ServletContext Æ PortletSession Æ PortletContext La classe qui met en œuvre l’interface servlet doit mettre en œuvre l’interface portlet. La méthode service(…) est divisée entre la méthode processAction(…) et render(…). Dans les JSP, l’argument tagtlib des portlets doit être importé et les objets request et response doivent être remplacés par renderRequest et renderResponse. 5 AJOUTER LE FICHIER JAHIA.XML Jahia 5 supporte toujours les JahiaWebApp. Cependant un fichier définissant l’entrypoint de l’application est nécessaire pour migrer une JahiaWebApp développée pour Jahia 4 vers Jahia 5: jahia.xml 5.1 ÉCRITURE DU FICHIER JAHIA.XML Le fichier jahia.xml permet de spécifier à Jahia le servlet qui représente l’entrypoint. © Jahia Ltd. Tous droits réservés. I <?xml version="1.0" encoding="ISO-8859-1"?> <web-app> <servlet> <servlet-name> WebClippingServlet EntryPoint p. 43/47 <jahia> <entrypoints> <entrypoint> </servlet-name> <name>WebClipping</name> <servlet-class> <display-name> WebClipping com.codeva.webapps.webclipping.servlet .WebClippingServlet </servlet-class> </display-name> <description></description> <target type="servlet-name"> <load-on-startup>1</load-on-startup> <init-param> <param-name>name</param-name> <param-value>value</param-value> </init-param> </servlet> <servlet> WebClippingServlet </target> </entrypoint> </entrypoints> </jahia> <servlet-name> InitServlet </servlet-name> <servlet-class> org.jahia.webapps.InitServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> 5.2 AJOUTER LE FICHIER JAHIA.XML Une fois le fichier jahia.xml écrit, placez-le dans le répertoire WEB-INF du portlet Le portlet n’est pas une JSR168. Cette méthode n’est pas recommandée. Les futures versions de Jahia ne supporteront pas les JahiaWebApps. © Jahia Ltd. Tous droits réservés. I p. 44/47 CHAPITRE 6 : LIENS UTILES La communauté JSR168 ne cesse de se développer. Ce chapitre répertorie les différents sites, listes de diffusion et sources d’informations utiles au développement de portlets. 1 PORTLETS OPEN SOURCE 1.1 PORTLETS JAHIA L’équipe de Jahia a développé un ensemble de portlets utiles, comme un serveur de calendrier ou encore un forum de discussion, qui sont mis à diposition en Open Source. Ces portlets sont télechargeables à l’adresse suivante : http://www.jahia.net/jahia/page571.html 1.2 PORTLET REPOSITORY PortletRepository est un espace de travail pour développeurs Open Source qui contribuent au développement de divers projet JSR168. Cet espace de travail contient des portlets JSR168 utiles, des technologies Web 2.0, etc. Pour obtenir plus d’informations, consultez le site : https://portlet-repository.dev.java.net/public/Portlets.html 1.3 GEMS Le projet Gems met à la diposition des développoeurs un ensemble de portlets JSR1168 utiles (AdressBook, FileUpload, GoogleSearch, etc.). Pour obtenir plus d’informations, consultez le site : https://gems.dev.java.net/ 1.4 PA-LAB Le projet Pa-Lab fournit des portlets JSR-168 utiles (gestionnaire, blog, portlets de recherches Yahoo! du Japon, etc.). Pour obtenir plus d’informations, consultez le site : http://sourceforge.jp/projects/pal/ © Jahia Ltd. Tous droits réservés. I p. 45/47 2 LISTES DE DIFFUSION Les listes de diffusion permettent aux développeurs de partager leurs connaissances et d’obtenir les réponses à leurs questions. Voici quelques listes intéressantes sur les portlets jsr168 : • Yahoo : http://tech.groups.yahoo.com/group/portlets/ • Bridge portlet : http://portals.apache.org/bridges/mail-lists.html 3 BIBLIOTHÈQUES UTILES 3.1 BOITE A OUTILS POUR PORTLETS Vous trouverez à l’adresse : http://www.doc.ic.ac.uk/~mo197/portlets/index.php une liste de bibliothèques offrant des outils intéressants pour le développement de portlets. 3.2 BLOG Vous trouverez à l’adresse http://www.portlets-jsr168.blogspot.com/ un blog relatif aux portlets jsr168. © Jahia Ltd. Tous droits réservés. I p. 46/47 CHAPITRE 6 : CONCLUSION Ce document a pour objectif de vous guider lors de vos premiers développements de portlets JSR168 sous JAHIA. Les exemples présentés sont simples pour vous permettre d’appréhender rapidement les notions de base relatives aux porlets. Nous vous encourageons à vous documenter sur la norme JSR168 avant de commencer à développer des applications plus élaborées. © Jahia Ltd. Tous droits réservés. I p. 47/47 LISTE DES ILLUSTRATIONS Illustration 1 : Exemple de pages JAHIA avec des portlets ............................................. 7 Illustration 2 : Contenu standard d'un fichier war représentant un portlet ........................ 9 Illustration 3 : Page d’un portail avec des portlets ......................................................... 11 Illustration 4 : Architecture de base d'un portail ............................................................. 12 Illustration 5 : Traitement de requêtes par les portlets................................................... 13 Illustration 6 : Mode du portlet ....................................................................................... 15 Illustration 7 : État du portlet .......................................................................................... 16 © Jahia Ltd. Tous droits réservés.