Utilisation du conteneur léger d'Indigo

Olivier Bugalotto

Dans ce tutoriel, nous allons voir comment utiliser le conteneur léger d'Indigo. ♪

- Titre : Utilisation du conteneur léger d'Indigo

- Auteur : Olivier Bugalotto

- Parution : 26 janvier 2009

- Licence : Copyright ® 2008 Olivier Bugalotto. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. La configuration du conteneur

- III. Déclarer des objets

- IV. Utiliser le conteneur

- V. Initialiser les propriétés des objets

- VI. Déclarer une dépendance entre deux objets

- VII. Conclusion

- VIII. Ressources

I - Introduction

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 ».

II - La configuration du conteneur

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.

Nous pouvons aussi configurer le conteneur léger à l'exécution sans passer par un fichier.

Voici la structure de base d'un descripteur :

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>

Si la syntaxe XML vous pose problème, rien ne vous empêche avec Indigo de créer votre propre fichier de configuration. Nous verrons cela dans un prochain tutoriel.

III - Déclarer des objets

Déclaration

<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.

ATTENTION : Il est important de noter que les classes qu'utilise le conteneur léger ne sont pas incluses à la compilation dans le SWF généré, il faut donc les ajouter manuellement en les déclarant au compilateur à l'aide de l'option suivante :

IV - Utiliser le conteneur

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é.

V - Initialiser les propriétés des objets

<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

VI - Déclarer une dépendance entre deux objets

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

VII - Conclusion

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.

VIII - Ressources

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

Ce projet a un dossier libs qui contient la librairie du framework indigo.

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