Injection de dépendances

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

L'injection de dépendances (Dependency Injection) est un mécanisme qui permet d'implémenter le principe de l'inversion de contrôle. Il consiste à créer dynamiquement (injecter) les dépendances entre les différentes classes en s'appuyant sur une description (fichier de configuration ou métadonnées) ou de manière programmatique. 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.

Exemple[modifier | modifier le code]

En programmation objet, les objets de type A dépendent d'un objet de type B si au moins une des conditions suivantes est vérifiée :

  • A possède un attribut de type B (dépendance par composition) ;
  • A est de type B (dépendance par héritage) ;
  • A dépend d'un autre objet de type C qui dépend d'un objet de type B (dépendance par transitivité) ;
  • une méthode de A appelle une méthode de B.

Si A dépend de B, cela implique que pour créer A, on a besoin de B ce qui, en pratique, n'est pas toujours le cas.

Pour supprimer la dépendance, un moyen possible consiste à

  • créer une interface I qui contiendra toutes les méthodes que A peut appeler sur B,
  • indiquer que B implémente l'interface I,
  • remplacer toutes les références au type B par des références à l'interface I dans A.

Un problème qui se pose est de disposer dans A d'un objet implémentant I alors que l'on ne sait pas comment l'instancier. La solution consiste à créer, par exemple, un objet b de type B et de l'injecter dans un objet de type A. L'injection proprement dite peut se faire

  • à l'instanciation : on passe l'objet b à l'instanciation de A
  • par modificateur : on passe l'objet b à une méthode de A qui va par exemple modifier un attribut (setter)