Injection de dépendances en Rust : guide avec exemples de code

Introduction à l'Injection de Dépendances en Rust

L'Injection de Dépendances (DI) est un patron de conception dans lequel un objet reçoit ses dépendances de l'extérieur, plutôt que de les créer lui-même. En Rust, où la sécurité et la performance sont primordiales, la DI aide à créer un code flexible, testable et faiblement couplé. Dans cet article, nous allons voir comment implémenter l'injection de dépendances en Rust en utilisant des traits, des génériques et des conteneurs.

Contrairement aux langages avec réflexion (Java, C#), Rust ne fournit pas de frameworks DI intégrés. Cependant, son système de types et de possession permet de créer des solutions élégantes sans perte de performance.

Approches principales de l'Injection de Dépendances

Il existe plusieurs façons d'implémenter la DI en Rust. Examinons trois approches principales.

1. Injection par constructeur (Constructor Injection)

La méthode la plus simple et la plus courante consiste à passer les dépendances dans le constructeur de la structure. Cela garantit que l'objet est toujours dans un état valide.

// Définissons un trait pour envoyer des notificationstrait Notifier {    fn send(&self, message: &str);}

// Implémentation pour Emailstruct EmailNotifier {    smtp_server: String,}

impl Notifier for EmailNotifier {    fn send(&self, message: &str) {        println!("Envoi d'email via {}: {}", self.smtp_server, message);    }}

// Implémentation pour SMSstruct SmsNotifier {    api_key: String,}

impl Notifier for SmsNotifier {    fn send(&self, message: &str) {        println!("Envoi de SMS avec la clé {}: {}", self.api_key, message);    }}

// Service qui utilise Notifierstruct NotificationService {    notifier: Box<dyn Notifier>,}

impl NotificationService {    // Injection de dépendance via le constructeur    fn new(notifier: Box<dyn Notifier>) -> Self {        NotificationService { notifier }    }

    fn notify(&self, message: &str) {        self.notifier.send(message);    }}

fn main() {    let email_notifier = Box::new(EmailNotifier {        smtp_server: "smtp.example.com".to_string(),    });    let service = NotificationService::new(email_notifier);    service.notify("Hello, Rust!");}

2. Injection par génériques (Generic Injection)

L'utilisation de génériques permet d'éviter la dispatch dynamique et d'améliorer les performances grâce à la monomorphisation.

// Même trait Notifier, mais le service est maintenant génériquestruct NotificationService<T: Notifier> {    notifier: T,}

impl<T: Notifier> NotificationService<T> {    fn new(notifier: T) -> Self {        NotificationService { notifier }    }

    fn notify(&self, message: &str) {        self.notifier.send(message);    }}

fn main() {    let email_notifier = EmailNotifier {        smtp_server: "smtp.example.com".to_string(),    };    let service = NotificationService::new(email_notifier);    service.notify("Hello from generic Rust!");}

3. Injection via conteneur de dépendances

Pour les projets complexes, il est pratique d'utiliser un conteneur de dépendances qui gère la création et la durée de vie des objets. En Rust, on peut implémenter un conteneur simple manuellement.

use std::collections::HashMap;

// Trait pour les fabriques de dépendancestrait Factory<T> {    fn create(&self) -> T;}

// Conteneur de dépendances simplestruct Container {    factories: HashMap<String, Box<dyn std::any::Any>>,}

impl Container {    fn new() -> Self {        Container {            factories: HashMap::new(),        }    }

    fn register<T: 'static>(&mut self, name: &str, factory: Box<dyn Factory<T>>) {        self.factories.insert(name.to_string(), Box::new(factory));    }

    fn resolve<T: 'static>(&self, name: &str) -> Option<T> {        self.factories.get(name).and_then(|f|