L'inversion de contrôle avec Spring

L'un des principaux avantages de cette méthode de conception : rendre indépendants les modules d'une application. Elle consiste à injecter les composants dans l'instanciation des classes. Illustration en Java.

L'inversion de contrôle est un motif de conception logicielle (ou design pattern en anglais) commun à tous les frameworks, devenu populaire avec l'adoption des conteneurs dits "légers". Cette notion fait partie des principes de la programmation orientée aspect.

Selon le mécanisme du design pattern, ce n'est plus l'application qui appelle les fonctions d'une librairie, mais un framework qui, à l'aide d'une couche abstraite mettant en œuvre un comportement propre, va appeler l'application en l'implémentant. L'inversion de contrôle s'utilise par héritage de classes du framework ou par le biais d'un mécanisme de plug-in.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

L'idée principale est que les modules de hauts et bas niveaux doivent dépendre d'interfaces, et non les modules dépendre les uns des autres. Les modules dérivent des interfaces. L'inversion de contrôle les rend donc indépendants entre eux. L'utilisation d'une interface permet de s'abstraire de la source de données. Ainsi les composants ou les services, qui sont des composants distants, forment des entités autonomes et réutilisables sans avoir modifier l'ensemble des codes sources.

 

Ce motif de conception découpe l'application en plusieurs blocs de code indépendants, pris en charge par l'API fournie avec le framework. L'application gère l'IHM et le traitement, et le framework prend en charge l'exécution de ce traitement. Au lieu d'appeller une classe pour exécuter une action, un plug-in de n'importe quel utilisateur injecte l'implémentation dans l'instanciation. Ce modèle autorise plusieurs implémentations de classes différentes.

 

En développement classique, l'implémentation s'effectue par l'appel de fonctions :

$exemple=new objet();

 

Avec l'inversion de contrôle, une fonction getObject(«InterfaceObjet») va chercher la classe implémentant InterfaceObjet, crée une instance, crée les objets dépendants et les définit dans l'objet conteneurIoc. Elle fait ensuite la même chose récursivement pour toutes les dépendances des dépendances.

$exemple=conteneurIoc.getObjet(«InterfaceObjet»);

 

L'inversion de contrôle la plus connue est l'inversion de dépendances. Il existe trois types d'injection de dépendances. L'injection par accesseur est une des méthodes utilisées par Spring. Il est également possible de faire de l'injection de dépendances par constructeur. Avec le framework Spring, le programme d'initialisation du conteneur lit en premier un fichier de configuration XML où les dépendances sont enregistrées. Lorsqu'une méthode de type JavaBean (accesseur set, mutateur get) est trouvée dans un composant, le programme l'instancie à l'aide du bean correspondant dans le fichier de configuration.

 

<?xml version="1.0" encoding="utf-8" ?> 

<beans>

<bean id="Livre" class="Livre">

<property name="bibliotheque">

<ref local="Bibliotheque" />

</property>

</bean>

</beans>

 

Objet = new MyLivre();

Bibliotheque nom=new BibliothequeImpl();

Objet.setBibliotheque(nom);

 

public class Livre {

 

Bibliotheque _biblio;

 

    public void setBibliotheque (Bibliotheque nom){ 

          _biblio=nom;

    }

}

 

Le regard de l'expert

 

"L'inversion de contrôle est très utilisée avec Spring", commente Michael Isvy, consultant sénior pour SpringSource. "Elle facilite les tests unitaires de son code car elle permet d'injecter une fausse implémentation. L'autre avantage est de pouvoir changer des points d'implémentation sans avoir à modifier le programme. Depuis Spring 2.5, il est possible de faire de l'injection de dépendances par annotation dans le code Java. Il n'y a alors plus besoin de créer de fichier de configuration en XML. Le choix est laissé à l'utilisateur."