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
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.
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
I
p. 5/47
Chapitre 6 : Conclusion..................................................................................................................46
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).
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/
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.
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.
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.
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.
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.
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
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.
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(…).
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.
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.
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.
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");
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
*/
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 {
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.
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.
<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>
</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.
I
p. 23/47
Après le déploiement, le contenu du fichier web.xml est :
<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 :
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).
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
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 {
// 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
}
}
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 :
<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");
getPortletContext().getRequestDispatcher(“/jsp/edit.jsp”);
}
}
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 :
<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 :
<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)){
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();
}
}
}
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");
getPortletContext().getRequestDispatcher(“/jsp/help.jsp”);
}
}
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.
<portlet>
<description>Hello portlet</description>
<portlet-name>HellodPortlet</portlet-name>
<portlet-class>org.jahia.portlet.HelloPortlet</portlet-class>
<supports>
<portlet-mode>edit</portlet-mode>
<portlet-mode>help</portlet-mode>
</supports>
<portlet-info>
<title>HelloPortlet</title>
</portlet-info>
<portlet-preferences>
I
p. 31/47
<preference>
<name>HelloPortlet</name>
<value>HelloPortlet</value>
</ preference >
</portletpreferences >
</portlet>
</portlet-app>
4 ET ENSUITE ?
Reportez-vous aux sections 3, 4 et 5 du Chapitre 2 « Développer un portlet de base ».
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.
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
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
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.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
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>
<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>
</servlet>
</web-app>
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>
</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 :
<portlet>
<description>Jahia WebApp Portlet Bridge</description>
<portlet-name>…</portlet-name>
<portlet-class>org.jahia.portlet.JahiaWebAppPortletBridge</portlet-class>

<init-param>
<name>jahiaWebAppClass</name>
<value>…</value>
</init-param>
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>
<servlet>
<servlet-name>
AdressBook
<portlet>
<description>
</servlet-name>
<servlet-class>
EntryPoint
</servlet-class>
<init-param>
</init-param>
</servlet>
Jahia WebApp Portlet Bridge
</description>
<portlet-name>AdressBook</portlet-name>
<portlet-class>
</portlet-class>
<init-param>
<servlet>
<value>
<servlet-name>
InitServlet
org.jahia.webapps.addressbook.AddressBookServlet
</value>
</servlet-name>
<servlet-class>
</init-param>
<init-param>
<name>name</name>
</servlet-class>
<value> value</value>
<web-app>
</init-param>
<servlet>
</portlet>
<servlet-name>
</portlet-app>
AdressBook
I
p. 39/47
Le fichier portlet.xml est donc :
<portlet>
<description>Jahia WebApp Portlet Bridge</description>
<portlet-name>AdressBook</portlet-name>
<portlet-class>org.jahia.portlet.JahiaWebAppPortletBridge</portlet-class>
<init-param>
<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.
I
p. 40/47
<web-app>
<servlet>
<servlet-name>
AdressBook
</servlet-name>
<servlet-class>
EntryPoint
</servlet-class>
<init-param>
</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>
</servlet-class>
</servlet>
</web-app>
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.
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.
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">
<init-param>
</init-param>
</servlet>
<servlet>
WebClippingServlet
</target>
</entrypoint>
</entrypoints>
</jahia>
<servlet-name>
InitServlet
</servlet-name>
<servlet-class>
</servlet-class>
</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.
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.).
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.).
http://sourceforge.jp/projects/pal/
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.
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.
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 CMS ET Portal Version 5.0 Développer un portlet JSR168

Transcription

Documents pareils

liferay-spring

Diplomatic-Cover - Top Interactive Agencies

Sites web institutionnels de l`UNIL avec Jahia Les bases de Jahia

tp liferay 2

Premier pas avec Jahia: édition

09/04/2013

Web conferences : la portlet BigBlueButton - ESUP

Portlet Alfresco