Quelle est la différence clé entre l'inversion de dépendance et l'injection de dépendance?

L'inversion de dépendances (principe d'inversion des dépendances) est l'un des principes SOLID, qui stipule que les modules de haut niveau ne doivent pas dépendre des modules de bas niveau, tous deux doivent dépendre d'abstractions. Les abstractions ne doivent pas dépendre des détails, les détails doivent dépendre des abstractions.

L'injection de dépendances est un motif ou une technique concrète qui met en œuvre le principe d'inversion des dépendances. C'est une façon de passer des dépendances (objets) à une classe ou une fonction depuis l'extérieur, plutôt que de les créer en interne.

En d'autres termes :

• L'inversion de dépendances est un concept ou un principe de conception.
• L'injection de dépendances est une façon de mettre en œuvre ce concept, lorsque les dépendances sont passées depuis l'extérieur.

Exemple en Go :

// Abstraction
 type Notifier interface {
    Notify(message string)
}

// Implémentation concrète
 type EmailNotifier struct {}

func (e EmailNotifier) Notify(message string) {
    fmt.Println("Envoi d'un email avec le message :", message)
}

// Module de haut niveau
 type UserService struct {
    notifier Notifier // dépend d'une abstraction
}

// Injection de dépendances via le constructeur
func NewUserService(n Notifier) *UserService {
    return &UserService{notifier: n}
}

func (s *UserService) RegisterUser(name string) {
    // logique d'enregistrement
    s.notifier.Notify("Utilisateur enregistré : " + name)
}

Ici, le principe d'inversion des dépendances est respecté par la dépendance à l'interface Notifier, et l'injection de dépendances se fait en passant une implémentation concrète de EmailNotifier dans le constructeur de UserService.