Dependency Injection в Rust: руководство с примерами кода

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Введение в Dependency Injection в Rust

Dependency Injection (DI) — это паттерн проектирования, при котором объект получает свои зависимости извне, а не создает их самостоятельно. В Rust, где на первом месте стоят безопасность и производительность, DI помогает создавать гибкий, тестируемый и слабосвязанный код. В этой статье мы разберем, как реализовать внедрение зависимостей в Rust, используя трейты, дженерики и контейнеры.

В отличие от языков с рефлексией (Java, C#), Rust не предоставляет встроенных DI-фреймворков. Однако его система типов и владения позволяет создавать элегантные решения без потери производительности.

Основные подходы к Dependency Injection

В Rust существует несколько способов реализовать DI. Рассмотрим три основных подхода.

1. Внедрение через конструктор (Constructor Injection)

Самый простой и распространенный способ — передавать зависимости в конструктор структуры. Это гарантирует, что объект всегда находится в валидном состоянии.

// Определяем трейт для отправки уведомлений
trait Notifier {
    fn send(&self, message: &str);
}

// Реализация для Email
struct EmailNotifier {
    smtp_server: String,
}

impl Notifier for EmailNotifier {
    fn send(&self, message: &str) {
        println!("Отправка email через {}: {}", self.smtp_server, message);
    }
}

// Реализация для SMS
struct SmsNotifier {
    api_key: String,
}

impl Notifier for SmsNotifier {
    fn send(&self, message: &str) {
        println!("Отправка SMS с ключом {}: {}", self.api_key, message);
    }
}

// Сервис, который использует Notifier
struct NotificationService {
    notifier: Box<dyn Notifier>,
}

impl NotificationService {
    // Внедрение зависимости через конструктор
    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. Внедрение через дженерики (Generic Injection)

Использование дженериков позволяет избежать динамической диспетчеризации и повысить производительность за счет мономорфизации.

// Тот же трейт Notifier, но сервис теперь обобщенный
struct 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. Внедрение через контейнер зависимостей

Для сложных проектов удобно использовать контейнер зависимостей, который управляет созданием и временем жизни объектов. В Rust можно реализовать простой контейнер вручную.

use std::collections::HashMap;

// Трейт для фабрик зависимостей
trait Factory<T> {
    fn create(&self) -> T;
}

// Простой контейнер зависимостей
struct 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| {
            let factory = f.downcast_ref::<Box<dyn Factory<T>>>()?;
            Some(factory.create())
        })
    }
}

// Пример использования
fn main() {
    let mut container = Container::new();

    // Регистрируем фабрику для EmailNotifier
    container.register("email_notifier", Box::new(|| {
        EmailNotifier {
            smtp_server: "smtp.example.com".to_string(),
        }
    }));

    // Регистрируем фабрику для NotificationService
    container.register("notification_service", Box::new(|| {
        let notifier = Box::new(EmailNotifier {
            smtp_server: "smtp.example.com".to_string(),
        });
        NotificationService::new(notifier)
    }));

    // Получаем сервис из контейнера
    if let Some(service) = container.resolve::<NotificationService>("notification_service") {
        service.notify("Hello from DI container!");
    }
}

Преимущества использования DI в Rust

Тестируемость — легко подменять реальные зависимости на моки или заглушки.
Гибкость — можно менять поведение системы без изменения кода, который ее использует.
Слабая связанность — модули зависят от абстракций (трейтов), а не от конкретных реализаций.
Управление временем жизни — Rust гарантирует безопасное освобождение ресурсов.

Продвинутые техники: использование библиотеки `shaku`

Для больших проектов стоит рассмотреть библиотеку shaku, которая предоставляет DI-контейнер с поддержкой времени жизни и асинхронных зависимостей.

// Пример с shaku
use shaku::{module, Component, Interface, Provider};

trait Logger: Interface {
    fn log(&self, message: &str);
}

#[derive(Component)]
#[shaku(interface = Logger)]
struct ConsoleLogger;

impl Logger for ConsoleLogger {
    fn log(&self, message: &str) {
        println!("LOG: {}", message);
    }
}

trait UserService: Interface {
    fn greet(&self, name: &str);
}

#[derive(Component)]
#[shaku(interface = UserService)]
struct UserServiceImpl {
    #[shaku(inject)]
    logger: Box<dyn Logger>,
}

impl UserService for UserServiceImpl {
    fn greet(&self, name: &str) {
        self.logger.log(format!("User {} greeted", name).as_str());
        println!("Hello, {}!", name);
    }
}

module! {
    MyModule {
        components = [ConsoleLogger, UserServiceImpl],
        providers = []
    }
}

fn main() {
    let module = MyModule::builder().build();
    let user_service: Box<dyn UserService> = module.resolve().unwrap();
    user_service.greet("Alice");
}