В чем различия паттернов Service Locator и Dependency Injection?

Service Locator и Dependency Injection (DI) — это два популярных паттерна проектирования, используемые для управления зависимостями между компонентами системы. Оба направлены на уменьшение связанности (coupling), но достигают этого разными способами.

Service Locator (Локатор Сервисов)

• Принцип: Компонент (клиент) активно запрашивает необходимые ему зависимости у центрального реестра (локатора сервисов). Локатор хранит ссылки на сервисы и предоставляет их по имени или типу.
• Как работает: Клиент знает о существовании локатора и вызывает его метод get() для получения нужного сервиса.
• Преимущества:
  • Простота реализации для небольших проектов.
  • Централизованное управление сервисами.
• Недостатки:
  • Скрытые зависимости: Зависимости класса не видны в его конструкторе или сигнатуре метода, что затрудняет понимание того, что требуется классу.
  • Усложнение тестирования: Для тестирования класса, использующего Service Locator, часто приходится мокать сам локатор, что может быть громоздко.
  • Нарушение принципа Inversion of Control (IoC): Класс сам контролирует получение своих зависимостей, а не получает их извне.
  • Проблемы с жизненным циклом: Локатор может скрывать, как и когда создаются и уничтожаются сервисы.

Пример Service Locator (Python):

class Database:
    def connect(self):
        return "Connected to DB"

class ServiceLocator:
    _services = {}

    @classmethod
    def register(cls, name, service_instance):
        cls._services[name] = service_instance

    @classmethod
    def get(cls, name):
        if name not in cls._services:
            raise ValueError(f"Service '{name}' not found.")
        return cls._services[name]

# Регистрация сервиса
ServiceLocator.register('db', Database())

class UserRepository:
    def __init__(self):
        # Зависимость запрашивается внутри класса
        self.db = ServiceLocator.get('db')

    def find_user(self, user_id):
        return f"Finding user {user_id} using {self.db.connect()}"

user_repo = UserRepository()
print(user_repo.find_user(1))
# Вывод: Finding user 1 using Connected to DB

Dependency Injection (DI - Внедрение Зависимостей)

• Принцип: Зависимости компонента (клиента) передаются ему извне, а не запрашиваются им самим. Компонент пассивно получает то, что ему нужно.
• Как работает: Зависимости могут быть внедрены через конструктор (Constructor Injection), методы (Method Injection) или свойства (Property Injection).
• Преимущества:
  • Явные зависимости: Все зависимости класса четко видны в его конструкторе или сигнатуре метода, что улучшает читаемость и понимание кода.
  • Упрощение тестирования: Легко подменять реальные зависимости моками или заглушками во время тестирования, так как они передаются извне.
  • Следование принципу IoC: Контроль над созданием и предоставлением зависимостей переносится на внешний механизм (DI-контейнер или фабрику).
  • Повышенная гибкость и поддерживаемость: Легче изменять или заменять реализации зависимостей без изменения кода клиента.

Пример Dependency Injection (Python):

class Database:
    def connect(self):
        return "Connected to DB"

class UserRepository:
    # Зависимость внедряется через конструктор
    def __init__(self, db: Database):
        self.db = db

    def find_user(self, user_id):
        return f"Finding user {user_id} using {self.db.connect()}"

# Создание и внедрение зависимости
db_instance = Database()
user_repo_di = UserRepository(db_instance)
print(user_repo_di.find_user(2))
# Вывод: Finding user 2 using Connected to DB

Ключевые различия и выбор

Вывод: В большинстве современных архитектур Dependency Injection является предпочтительным паттерном. Он способствует созданию более чистого, тестируемого и поддерживаемого кода, делая зависимости явными и инвертируя контроль над их созданием. Service Locator может быть приемлем в очень простых случаях, но его недостатки часто перевешивают преимущества в более сложных системах.