Utilisation du conteneur léger d'Indigo

Indigo est un framework qui propose toute la mécanique du principe d'injection de dépendances ou plus communément appelé injection de contrôles (IOC).

Pour faire simple, la framework Indigo contient une fabrique d'objets, configurable à l'aide d'un fichier XML dit « descripteur », qui s'occupe pour nous de créer des objets et leurs dépendances. Cette fabrique porte plus généralement le nom de « conteneur léger ».

Pour configurer le conteneur léger, nous utilisons un fichier dit « descripteur » XML qui lui indique, le type des objets à instancier, mais surtout leurs dépendances.

Voici la structure de base d'un descripteur :

<?xml version="1.0" encoding="utf-8"?>
<configuration xmlns="http://www.indigo-framework.org" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.indigo-framework.org http://www.iteratif.fr/projets/indigo/indigo-configuration.xsd">
    <objects>
        <!-- Déclarations des objets et dépendances -->
    </objects>
</configuration>

<objects>
    <object id="amfphp" type="services.AMFPHPService" />
</objects>

La balise <object> est une définition que le conteneur utilise pour créer l'objet correspondant. L'attribut id identifie cette définition dans le conteneur. L'attribut type indique le chemin complet vers la classe de l'objet à créer.

Créons un conteneur léger et configurons-le avec la configuration précédente :

import indigo.factory.xml.IXmlObjectFactory;
import indigo.factory.xml.XmlObjectFactory;
 
var factory:IXmlObjectFactory = new XmlObjectFactory();
factory.addEventListener(FactoryEvent.READY,onReady);
factory.loadDescriptor("app-config.xml");
 
function onReady(e:FactoryEvent):void {
    var amfphp:IAMFPHPService = factory.getObject("amfphp") as IAMFPHPService;
}

Lorsque l'événement READY se produit, le conteneur est complètement initialisé.

<objects>
    <object id="amfphp" type="services.AMFPHPService">
        <property name="gateway" value="http://www.monserveur.com/amfphp/gateway.php" />
    </object>
</objects>

Regardons un petit peu la classe AMFPHPService :

package services {
    public class AMFPHPService implements IAMFPHPService {
        private var _gateway:String;
 
        public function get gateway():String {
            return _gateway;
        }
 
        public function set gateway(value:String):void {
            _gateway = value;
        }        
 
        public function AMFPHPService() {
 
        }
    }
}

L'interface IAMFPHPService est des plus simples :

package services {
    public interface IAMFPHPService {
        function get gateway():String;
    }
}

La déclaration de l'objet, mais surtout de sa propriété gateway indique au conteneur comment l'initialiser, vérifions le résultat :

var amfphp:IAMFPHPService = factory.getObject("amfphp") as IAMFPHPService;
trace(amfphp.gateway); // http://www.monserveur.com/amfphp/gateway.php

Nous allons déclarer un nouvel objet avec une dépendance avec AMFPHPService :

L'utilisation de l'attribut ref indique au conteneur l'identifiant de l'objet correspondant.

Voici la classe Catalog :

package model {
    import services.IAMFPHPService;
 
    public class Catalog {
        private var _service:IAMFPHPService;
 
        public function get service():IAMFPHPService {
            return _service;
        }
 
        public function set service(value:IAMFPHPService):void {
            _service = value;
        }
 
        public function Catalog() {
 
        }
    }
}

Vérifions que le conteneur a bien créé la dépendance :

var catalog:Catalog = factory.getObject("catalog") as Catalog;
trace(catalog.service.gateway); // http://www.monserveur.com/amfphp/gateway.php

Comme vous pouvez le remarquer, l'utilisation du conteneur léger d'indigo est très simple, son grand intérêt est de découpler votre code, si on y regarde de plus près l'ensemble des classes de ce tutoriel sont simples dans le cas de la classe AMFPHPService nous lui implémentons une interface pour respecter un des principes de la Programmation Orienté Objet qui est :

Programmez des interfaces, non des implémentations

C'est cette simplicité qui fait que vos projets se construisent proprement, l'autre grand intérêt c'est de ne pas être dépendant du conteneur, vos classes peuvent être utilisées dans un autre projet qui n'utilise pas Indigo, ce ne sont pas les seuls intérêts bien entendu.

Mais nous verrons cela dans des prochains tutoriels.

Vous trouverez le projet Actionscript sous Flex de l'exemple du tutoriel, ici : Source.zip (miroir)

Pour ceux qui utilisent plutôt flash, vous pouvez aussi récupérer les codes source d'indigo, ici : INDIGO FRAMEWORK ou sur RIAForge.