Dependency Injection в JavaScript: Полное руководство с примерами

Dependency Injection в JavaScript: Полное руководство

Dependency Injection (DI) — это мощный паттерн проектирования, который лежит в основе принципа Инверсии Управления (IoC). Вместо того чтобы объект самостоятельно создавал свои зависимости, DI «внедряет» их извне. Это делает код более гибким, тестируемым и поддерживаемым. В этой статье мы разберем, как реализовать Dependency Injection в JavaScript и Node.js, используя простые и наглядные примеры.

Что такое Dependency Injection и зачем он нужен?

Представьте, что у вас есть класс UserService, который работает с базой данных. Без DI вы, скорее всего, создадите экземпляр базы данных прямо внутри сервиса:

class UserService {
  constructor() {
    this.db = new Database(); // Жесткая связь
  }

  getUser(id) {
    return this.db.findUser(id);
  }
}

Этот код нарушает Принцип Инверсии Зависимостей (Dependency Inversion Principle). При тестировании UserService вы не сможете подменить реальную базу данных на мок-объект, не изменяя код класса. DI решает эту проблему:

class UserService {
  constructor(database) {
    this.db = database; // Зависимость передается извне
  }

  getUser(id) {
    return this.db.findUser(id);
  }
}

// Использование
const db = new Database();
const userService = new UserService(db);

Основные преимущества DI:

• Тестируемость: Легко подменять зависимости на моки или стабы.
• Слабая связанность: Классы зависят от абстракций (интерфейсов), а не от конкретных реализаций.
• Гибкость: Можно легко менять поведение системы, заменяя реализации.
• Переиспользование кода: Компоненты становятся независимыми и могут использоваться в разных контекстах.

Способы внедрения зависимостей в JavaScript

В JavaScript существует три основных способа внедрения зависимостей:

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

Самый распространенный и рекомендуемый способ. Зависимости передаются в момент создания объекта.

class Logger {
  log(message) {
    console.log(`[LOG]: ${message}`);
  }
}

class OrderService {
  constructor(logger) {
    this.logger = logger;
  }

  createOrder(data) {
    this.logger.log('Создан новый заказ');
    // Логика создания заказа
  }
}

const logger = new Logger();
const orderService = new OrderService(logger);
orderService.createOrder({ product: 'Laptop', price: 1500 });

2. Внедрение через сеттеры (Setter Injection)

Зависимости устанавливаются после создания объекта через методы-сеттеры. Подходит для опциональных зависимостей.

class EmailService {
  constructor() {
    this.transporter = null;
  }

  setTransporter(transporter) {
    this.transporter = transporter;
  }

  send(email) {
    if (!this.transporter) {
      throw new Error('Transporter не установлен');
    }
    this.transporter.sendMail(email);
  }
}

const emailService = new EmailService();
emailService.setTransporter(someMailTransporter);

3. Внедрение через интерфейс (Interface Injection — условно)

В JavaScript нет нативных интерфейсов, но можно использовать TypeScript или документацию для описания контрактов. На практике это сводится к проверке наличия методов.

Создание простого DI-контейнера в Node.js

Для управления зависимостями в больших приложениях удобно использовать DI-контейнер. Он хранит все зависимости и автоматически разрешает их. Вот минимальная реализация:

class Container {
  constructor() {
    this.services = new Map();
    this.singletons = new Map();
  }

  // Регистрация фабрики для сервиса
  register(name, factory, isSingleton = false) {
    this.services.set(name, { factory, isSingleton });
  }

  // Получение экземпляра сервиса
  get(name) {
    const service = this.services.get(name);
    if (!service) {
      throw new Error(`Сервис "${name}" не зарегистрирован`);
    }

    if (service.isSingleton) {
      if (!this.singletons.has(name)) {
        this.singletons.set(name, service.factory(this));
      }
      return this.singletons.get(name);
    }

    return service.factory(this);
  }
}

// Использование
const container = new Container();

// Регистрируем зависимости
container.register('db', () => new Database());
container.register('logger', () => new Logger(), true); // Singleton
container.register('userService', (c) => new UserService(c.get('db'), c.get('logger')));

// Получаем сервис
const userService = container.get('userService');

Этот контейнер поддерживает два типа регистрации: singleton (один экземпляр на всё приложение) и transient (новый экземпляр при каждом запросе).

Продвинутые техники: Автоматическое разрешение (Autowiring)

В сложных проектах ручная регистрация каждой зависимости может стать утомительной. Autowiring позволяет контейнеру автоматически определять зависимости на основе имен параметров или типов (в TypeScript).

Пример с использованием рефлексии и Reflect.construct:

class AutowiredContainer extends Container {
  autowire(Constructor) {
    const paramTypes = Reflect.getMetadata('design:paramtypes', Constructor) || [];
    const dependencies = paramTypes.map((type) => this.get(type.name));
    return new Constructor(...dependencies);
  }
}

// Для TypeScript нужно включить emitDecoratorMetadata
// @Injectable()
// class UserService {
//   constructor(private db: Database, private logger: Logger) {}
// }

В чистом JavaScript без декораторов можно использовать соглашения по именованию или явные аннотации.

Практический пример: Приложение для отправки уведомлений

Давайте соберем всё вместе и создадим небольшое приложение, которое использует DI для отправки уведомлений через разные каналы (Email, SMS).

// 1. Определяем интерфейс (абстракцию)
class NotificationChannel {
  send(recipient, message) {
    throw new Error('Метод send должен быть реализован');
  }
}

// 2. Конкретные реализации
class EmailChannel extends NotificationChannel {
  send(recipient, message) {
    console.log(`Email отправлен на ${recipient}: ${message}`);
  }
}

class SMSChannel extends NotificationChannel {
  send(recipient, message) {
    console.log(`SMS отправлен на ${recipient}: ${message}`);
  }
}

// 3. Сервис, использующий DI
class NotificationService {
  constructor(channel) {
    this.channel = channel;
  }

  notify(user, message) {
    this.channel.send(user.contact, message);
  }
}

//