Ces derniers temps, ali_o_kan nous sort des billets sur LowRA. La partie un peu floue que je ne connaissais pas, c’est le IoC.

Mais en fait, je connaissais parfaitement, sauf que je ne savais pas que des gens avaient donné un nom à ces techniques de découplage.

Définition

D’après le célèbre Martin Fowler (que je connais depuis 2 jours :) ), on parle d’inversion lorsque ce n’est plus le programme qui s’occupe de coordonner et de gérer les contrôles utilisateur, mais le framework.

Donc, quand on parle d’inversion de contrôle, on parle de framework pratiquement. On choisit un framework pour gérer tous les blocs, le flux et tout le bazar.

Le “programme”, c’est ce qui lance le framework. C’est comme en PHP, au lieu de faire un echo pour afficher quelque chose, on utilise le framework.

C’est tout ?

Ben nan :)

Parce que IoC est un Design Pattern, ce n’est pas juste une définition comme ça pouf. Il y a donc des diagrammes et des exemples précis. Et oui, c’est au pluriel car pour arriver au résultat de la définition, il y a plusieurs techniques possibles.

Dans tous les cas, l’idée est de découpler un object de son algorithme. Il faut tout de même qu’on initialise quelque part l’algorithme qui se retrouve ailleurs. On parle alors d’injection de dépendance ou de localisateur de service.

Injection par le constructeur

Je l’utilise quelque fois, même si je suis très hésitant quand j’écris un constructeur. J’ai eu pas mal de cas où j’étais insatisfait lors d’un refactoring ou même à la création (le feeling du geek quoi).

L’algorithme est injecté par le constructeur:

public function Validator(analyzer:InterfaceAnalyzer)
{
    this.analyzer = analyzer;
}

Ainsi, l’objet utilisera toujours this.analyzer dans son code.

Injection par setter

C’est la technique que j’utilise le plus souvent.

L’algorithme est injecté par une fonction :

public function setAnalyzer(analyzer:InterfaceAnalyzer):void
{
    this.analyzer = analyzer;
}

C’est carrément pareil que le constructeur sauf que c’est dans une fonction.

Injection par interface

Je l’ai utilisé très rarement. On crée une interface pour implémenter l’injection par setter.

public interface HasAnalyzer
{
    function setAnalyser(analyzer:InterfaceAnalyzer):void;
}

public class Validator implements HasAnalyzer
{
    public function setAnalyzer(analyzer:InterfaceAnalyzer):void
    {
        this.analyzer = analyzer;
    }
}

Localisateur de service

L’idée est d’avoir un registre qui permet de référencer les objects utiles de l’application. Ensuite, il suffit de faire appel à ce registre pour récupérer ce qu’on a besoin.

public class ServiceLocator
{
    public function getAnalyzer():Analyzer
    {
        return this.analyzer;
    }
}

public class Validator
{
    public function Validator()
    {
        this.analyzer = ServiceLocator.getInstance().getAnalyzer();
    }
}

Conclusion

J’ai très résumé, il y a plusieurs variantes. Ils ont tous le même but, mais suivant la problématique, on choisit la solution adaptée.

Martin Fowler l’explique à la fin de son article, il compare les techniques et donne les avantages dans des situations. Mais après, ça relève du feeling et de l’expérience pour comprendre et appliquer quand il le faut.

Je voulais simplement faire un point sur des techniques plutôt classiques. Des gens intelligents leur ont donné des noms, c’est chouette.