I. Présentation

La séparation des tâches de Cocoon 2.2 est issue d'une implémentation de l'architecture MVC (Model View Controller). Cette séparation permet de scinder un projet en fonction de compétences, ainsi infographistes, développeurs Web et rédacteurs de contenus peuvent travailler de manière quasiment indépendante. Un chef d'orchestre pourra harmoniser les liens de dépendances entre les différentes couches d'un projet.

Les données d'un projet Cocoon sont au format XML. Il suffit d'appliquer une transformation XSL à celles-ci et de choisir un sérialisateur pour modifier l'apparence ou le format du rendu final, on peut ainsi obtenir des formats tels que HTML, XHTML, CHTML, WML, SVG, PDF, PS, texte, etc. Parfois, on doit partir d'un existant dont les données ne sont pas sous la forme de XML. Dans ce cas, sous certaines conditions, on peut utiliser JTidy afin de les transformer dans un format XML propre au projet.

Cocoon a été utilisé pour divers projets. Ainsi, les systèmes de gestion de contenu Apache Lenya, Daisy et Hippo sont construits à partir de Cocoon. L'article que vous êtes en train de lire est un exemple concret de document généré à l'aide d'un bloc de Cocoon : FOP. J'ai écrit cet article une seule fois, puis FOP a décliné cet article sous les formats HTML, PDF et eBook.

En production, Cocoon est déployé sous la forme d'une servlet, il nécessite donc un moteur de servlets tel que Tomcat, JBoss, ou encore Jetty.

Courant 2012, Cocoon propose une version 2.2 stable. Une version 3.0 est en cours de développement. Elle implémentera l'architecture XRX (Xform-Rest-Xquery) qui est une architecture d'application qui utilise XForms côté client, ainsi que les interfaces ReST et XQuery côté serveur.

II. Prérequis

Note : dans cette introduction, j'indique les commandes sous Debian (pour les Linuxiens) ainsi que leur équivalent avec Maven (pour les Windowsiens).

On supposera que Java 1.5 ou supérieure est installée sur votre poste. Si c'est le cas alors, on peut lancer la commande suivante pour vérifier le numéro de la version de Java :

 
Sélectionnez
java -version

Les impatients pourront télécharger les binaires disponibles sur la page Versions & Download et passer les deux étapes suivantes.

On peut utiliser Subversion pour télécharger Cocoon 2.2. On peut tester la présence de SVN à l'aide de la commande suivante :

 
Sélectionnez
svn --version

On notera que pour les amateurs de Git, il existe aussi un repository Git pour Cocoon.

On peut aussi télécharger les sources à la main, sur le site de Cocoon.

Puis, on installe une version de Maven postérieure à la version 2.09 afin de nous simplifier certaines tâches d'administration. Pour tester son installation, il suffit de lancer la commande :

 
Sélectionnez
mvn --version

Enfin, dans le cadre de mon serveur Debian, je crée un espace pour un projet Cocoon. J'utilise la commande useradd pour créer un compte d'utilisateur afin de réserver un espace disque et d'attribuer des permissions correctes. L'option -g users de cette commande attribue à l'utilisateur le groupe d'utilisateurs users ; l'option -d /home/cocoon crée le répertoire personnel /home/cocoon ; enfin cocoon est le login de mon utilisateur.

 
Sélectionnez
useradd -g users -d /home/cocoon cocoon

Le but de cette étape étant de choisir un répertoire d'installation qui soit fidèle à l'organisation de l'existant, dans la suite de l'article, le répertoire /home/cocoon devra donc être adapté à son environnement favori.

III. Installation et compilation

Nos outils étant en place, on peut télécharger les sources de Cocoon 2.2 :

 
Sélectionnez
cd /home/cocoon
svn co http://svn.apache.org/repos/asf/cocoon/trunk cocoon
 U   cocoon
Revision 952962 extraite.

La prochaine étape consiste à compiler les sources de Cocoon 2.2 :

Soit à partir des sources de Cocoon 2.2 :

 
Sélectionnez
cd cocoon
export MAVEN_OPTS=-Xmx256m
./build.sh clean install
...

Soit avec Maven, on utilisera alors les cibles clean et install :

 
Sélectionnez
mvn clean install

Une fois la commande lancée, on restera zen avec la machine à café : il y a environ 30 à 45 minutes de compilation.

Finalement, on obtient :

 
Sélectionnez
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time : 41 minutes 34 seconds
[INFO] Finished at: Wed Jun 16 14:28:07 CEST 2010
[INFO] Final Memory: 125M/254M
[INFO] ------------------------------------------------------------------------

IV. Lancement de Cocoon

Pour lancer Cocoon 2.2 avec le serveur Jetty, soit on utilise directement la commande :

 
Sélectionnez
cocoon.sh

Soit on passe par Maven :

 
Sélectionnez
cd core\cocoon-webapp      
mvn jetty:run

Enfin, on fait pointer son navigateur favori vers l'URL http://localhost:8888/.

Image non disponible

Cette installation par défaut propose de nombreux exemples d'utilisation de Cocoon 2.2.

V. Exemples

Les exemples utilisant le noyau de Cocoon permettent de découvrir ses concepts et ses composants. Ils sont disponibles sous l'URL http://localhost:8888/samples/core/.

Le concept de pipeline est illustré par les exemples de la page http://localhost:8888/samples/core/hello-world/. On y apprend comment générer différents types de contenu à partir d'un document XML ou d'une source de données. Après une lecture détaillée de ces exemples, pour un document XML fixé, on sera en mesure d'obtenir un format de rendu final tel que HTML ou XHTML pour notre site Web, PDF pour faire bonne impression, ou encore OpenOffice. Mieux encore, on pourra archiver automatiquement nos documents ainsi générés dans un fichier zip.

Les concepts de carte de site (de l'anglais "sitemap") et de modules se dévoilent dans la deuxième série d'exemples. La carte du site joue le rôle du contrôleur dans l'architecture MVC (Model View Controller). Elle contient, entre autres, la définition des pipelines. Les modules permettent, entre autres, d'accéder à des données via la carte du site. On peut par exemple obtenir un nombre aléatoire ou la date du jour à partir du module correspondant. On apprendra aussi l'agrégation et l'inclusion de documents XML.

Vient ensuite le concept de flot qui permet de construire des formulaires élaborés.

L'internationalisation et la localisation sont aussi au rendez-vous. Ces concepts permettent de gérer la langue d'un document, les formats de date, la translittération...

Les exemples illustrant les autres blocs accompagnant le noyau de Cocoon montrent qu'il est aussi possible de construire des documents XML dynamiques à l'aide du langage XSP (comparable au JSP), de les générer à partir d'une base documentaire telle que BaseX ou eXist.

Sans être exhaustif, bien d'autres possibilités sont présentées dans ces exemples :

  • la gestion des erreurs HTTP (pages 404, etc.) ;
  • la gestion du cache ;
  • la prise en charge de proxy ;
  • la mise en oeuvre de l'authentification et de session pour une application Web ;
  • la création de formulaires élaborés ;
  • la génération dynamique d'images ;
  • les captchas, etc.

VI. Source et liens utiles

Le site officiel de Cocoon 2.2.

Des outils :

Des bases de données XML :

Des moteurs de servlets :

VII. Remerciements

Je remercie, en particulier, Eric Grimois, Erwan Amoureux et mlny84 pour leur relecture technique et leurs conseils avisés , Claude Leloup pour sa relecture orthographique, et Maxime Gault pour son soutien. :)