Внедрение зависимостей (Dependency Injection) в Rust для начинающих

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

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

Начать курс

Введение: Почему Dependency Injection важен в Rust?

При написании программ на Rust рано или поздно вы столкнетесь с ситуацией, когда один модуль (например, сервис или контроллер) должен использовать возможности другого модуля (базы данных, API, логгера). Простейший способ — создать нужный объект прямо внутри использующего его кода:

struct UserService;

impl UserService {
    fn get_user(&self, id: u32) -> String {
        let db = Database::new(); // ❌ Жесткая связь
        db.query_user(id)
    }
}

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

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

1. Базовый подход: Передача зависимостей через конструктор

Самый простой способ внедрить зависимость в Rust — передать её в качестве аргумента конструктора или функции. Рассмотрим пример с логгером.

Плохой пример (без DI)

struct ConsoleLogger;

impl ConsoleLogger {
    fn log(&self, msg: &str) {
        println!("[LOG]: {}", msg);
    }
}

struct OrderService {
    logger: ConsoleLogger, // ❌ Жесткая привязка к конкретному типу
}

impl OrderService {
    fn new() -> Self {
        Self {
            logger: ConsoleLogger, // Создаем внутри
        }
    }

    fn place_order(&self, item: &str) {
        self.logger.log(&format!("Заказ: {}", item));
    }
}

Хороший пример (с DI)

struct ConsoleLogger;

impl ConsoleLogger {
    fn log(&self, msg: &str) {
        println!("[LOG]: {}", msg);
    }
}

struct OrderService {
    logger: ConsoleLogger, // Зависимость передается извне
}

impl OrderService {
    // Конструктор принимает зависимость
    fn new(logger: ConsoleLogger) -> Self {
        Self { logger }
    }

    fn place_order(&self, item: &str) {
        self.logger.log(&format!("Заказ: {}", item));
    }
}

fn main() {
    let logger = ConsoleLogger;
    let service = OrderService::new(logger);
    service.place_order("Книга по Rust");
}

Что изменилось? Теперь OrderService не создает логгер сам. Он получает его готовым. Это уже DI, но есть нюанс: мы все еще привязаны к конкретному типу ConsoleLogger. Чтобы сделать код гибким, нужно использовать трейты.

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

Трейты в Rust — аналог интерфейсов в других языках. Они позволяют определить контракт, которому должны следовать зависимости.

Определяем трейт Logger

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

struct ConsoleLogger;
impl Logger for ConsoleLogger {
    fn log(&self, msg: &str) {
        println!("[Консоль]: {}", msg);
    }
}

struct FileLogger {
    filename: String,
}
impl Logger for FileLogger {
    fn log(&self, msg: &str) {
        // Симуляция записи в файл
        println!("[Файл {}]: {}", self.filename, msg);
    }
}

Внедряем трейт через обобщения (generics)

struct OrderService<L: Logger> {
    logger: L, // Обобщенный тип, реализующий трейт Logger
}

impl<L: Logger> OrderService<L> {
    fn new(logger: L) -> Self {
        Self { logger }
    }

    fn place_order(&self, item: &str) {
        self.logger.log(&format!("Заказ: {}", item));
    }
}

fn main() {
    let console_logger = ConsoleLogger;
    let console_service = OrderService::new(console_logger);
    console_service.place_order("Ноутбук");

    let file_logger = FileLogger { filename: "orders.log".into() };
    let file_service = OrderService::new(file_logger);
    file_service.place_order("Монитор");
}

Преимущества:

Полная гибкость: можно подставить любую реализацию Logger.
Статическая диспетчеризация (мономорфизация) — высокая производительность.
Типобезопасность: компилятор проверяет, что передан правильный тип.

Недостаток: Если вам нужно хранить несколько разных реализаций в одной коллекции, такой подход не подойдет.

3. Динамическая диспетчеризация: Box<dyn Trait>

Когда тип зависимости неизвестен на этапе компиляции или нужно хранить разные реализации в одном векторе, используйте динамическую диспетчеризацию через Box<dyn Trait> или &dyn Trait.

struct OrderService {
    logger: Box<dyn Logger>, // Динамический тип
}

impl OrderService {
    fn new(logger: Box<dyn Logger>) -> Self {
        Self { logger }
    }

    fn place_order(&self, item: &str) {
        self.logger.log(&format!("Заказ: {}", item));
    }
}

fn main() {
    let console_logger = Box::new(ConsoleLogger);
    let service1 = OrderService::new(console_logger);

    let file_logger = Box::new(FileLogger { filename: "log.txt".into() });
    let service2 = OrderService::new(file_logger);

    // Можно хранить в векторе
    let services: Vec<OrderService> = vec![service1, service2];
    for s in &services {
        s.place_order("Тест");
    }
}

Когда использовать?