• Introduction
• Présentation générale de Lutece
• Description d'une webapp Lutece
• Description fonctionnelle des composants
• Description de l'architecture logicielle
• Description de la composition des plugins
• Généralités concernant le développement sur Lutece
• Construction et assemblage : les builds
• Règles de codage
• Règles de nommage et vérification
• Règles de documentation
• Gestion des faits techniques
• Gestion des sources sur GitHub
• Socle technique et principaux frameworks
• Le moteur de templates : Freemarker
• Le framework CSS responsive : Bootstrap
• L'injection de dépendances avec Spring
• Le framework MVC de Lutece
• La validation des formulaires
• L'internationalisation (i18n)
• L'écriture de logs
• Les tests unitaires
• Installation et configuration
• Installation de l'environnement de travail
• Test de construction et de déploiement d'un premier plugin
• Configuration Lutece avancée
• Initialisation de la base de données
• Guides de développement de composants
• Développer le squelette du plugin avec PluginWizard
• Créer une application Front Office (XPage)
• Créer ma première application Front Office : Mon plugin HelloWorld
• Créer un Portlet Front Office
• Créer un bloc dynamique de Page (PageInclude)
• Créer un service de fourniture de contenu (ContentService)
• Définir des filtres et servlets de plugin
• Créer une fonctionnalité Back Office (AdminFeature)
• Créer un bloc pour le tableau de bord Back-Office (DashboardComponent)
• Créer un service d'extension de l'éditeur de texte riche (HtmlService ou LinkService)
• Créer un traitement d'arrière-plan (Daemon)
• Créer une tâche de workflow
• Développements avancés
• L'authentification Front Office (MyLutece)
• Créer des Web Services REST
• Gérer et développer des services de caches
• Intégrer le moteur de workflow à un plugin
• Ajouter des extensions à des contenus (commentaires, notes, vues...)
• Conclusion

L'injection de dépendances avec Spring

Le framework Spring http://spring.io est utilisé très largement pour l’injection de dépendances dans Lutece.

Cette pratique de développement, aussi appelée inversion de contrôle (IoC), a pour but de créer dynamiquement (injecter) les dépendances entre les différentes classes en s'appuyant sur une description (le fichier de context pour Spring). Ainsi les dépendances entre composants logiciels ne sont plus exprimées dans le code de manière statique mais déterminées dynamiquement à l'exécution. Ce découplage permet de substituer une implémentation donnée par une autre par simple modification du fichier de configuration.

Ce choix technique confère à Lutece des possibilités d'adaptabilité très grandes. Tous les services injectés par Spring peuvent être substités par d'autres implémentations sans modification du code de Lutece.

De plus, en terme de modularité, chaque plugin dispose d’un fichier de context propre pour déclarer ses beans. Ces fichiers sont situés dans le répertoire  WEB-INF/conf/plugins. Ils contiennent la déclaration des beans fournis par le plugin et à charger dans le contexte global.

Le core dispose de son propre fichier de context : WEB-INF/conf/core_context.xml.

NB : Les noms des beans doivent être préfixés par le nom du plugin suivi d’un point pour éviter les conflits de nommage.

A titre d'exemple, tous les DAO (Data Access Object) sont par défaut « injectés » via Spring comme le montre le fichier context suivant :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="appstore.categoryDAO"  class="fr.paris.lutece.plugins.appstore.business.CategoryDAO" />  
    <bean id="appstore.applicationDAO"  class="fr.paris.lutece.plugins.appstore.business.ApplicationDAO" />  
    <bean id="appstore.componentDAO"  class="fr.paris.lutece.plugins.appstore.business.ComponentDAO" />  
    <bean id="appstore.iconDAO"  class="fr.paris.lutece.plugins.appstore.business.IconDAO" />  
</beans>

L'accès à un bean se fait de la manière suivante en Java :

private static final String BEAN_NAME = "myplugin.mybean";
MyInterface bean = SpringContextService.getBean( BEAN_NAME ); 

NB : Il est possible d'utiliser l’annotation @Inject si l'on se trouve dans une classe instanciée par Spring.

Une pratique souvent utilisée dans Lutece, est de charger une liste de beans qui implémentent la même interface.

List<MyInterface> beans = SpringContextService.getBeansOfType( MyInterface.class ); 

C'est par ce mécanisme par exemple que le moteur de Workflow de Lutece est capable de charger dynamiquement toutes les tâches fournies par tous les différents plugins installés ; Celles-ci implémentant toute l'interface Task.

Pour plus d'informations sur le framework Spring, reportez-vous à la documentation située à l'adresse suivante : http://spring.io/docs