Как реализовать инъекцию зависимостей в сервисе?

Реализация инъекции зависимостей в сервисе

Инъекция зависимостей (Dependency Injection, DI) — это паттерн проектирования, при котором зависимости передаются объекту извне, а не создаются внутри него. Это повышает тестируемость, гибкость и соблюдает принцип инверсии зависимостей (D).

Основные подходы к реализации DI

1. Конструкторная инъекция

Наиболее предпочтительный способ, при котором зависимости передаются через конструктор класса.

class OrderService
{
    private PaymentProcessor $paymentProcessor;
    private NotificationService $notificationService;
    
    public function __construct(
        PaymentProcessor $paymentProcessor,
        NotificationService $notificationService
    ) {
        $this->paymentProcessor = $paymentProcessor;
        $this->notificationService = $notificationService;
    }
    
    public function processOrder(Order $order): void
    {
        $this->paymentProcessor->charge($order->getAmount());
        $this->notificationService->sendOrderConfirmation($order);
    }
}

2. Сеттерная инъекция

Зависимости устанавливаются через setter-методы. Полезно, когда зависимости опциональны.

class ReportGenerator
{
    private ?FormatterInterface $formatter = null;
    
    public function setFormatter(FormatterInterface $formatter): void
    {
        $this->formatter = $formatter;
    }
    
    public function generate(array $data): string
    {
        return $this->formatter 
            ? $this->formatter->format($data)
            : json_encode($data);
    }
}

3. Инъекция через метод

Зависимости передаются непосредственно в метод, который их использует.

class DataExporter
{
    public function exportToFormat(
        array $data, 
        ExportFormatterInterface $formatter
    ): string {
        return $formatter->format($data);
    }
}

Контейнер зависимостей

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

Базовый пример контейнера:

class Container
{
    private array $definitions = [];
    private array $instances = [];
    
    public function set(string $id, callable $factory): void
    {
        $this->definitions[$id] = $factory;
    }
    
    public function get(string $id): object
    {
        if (!isset($this->instances[$id])) {
            if (!isset($this->definitions[$id])) {
                throw new RuntimeException("Service $id not found");
            }
            $this->instances[$id] = $this->definitions[$id]($this);
        }
        
        return $this->instances[$id];
    }
}

// Использование
$container = new Container();
$container->set(PaymentProcessor::class, fn() => new StripeProcessor());
$container->set(OrderService::class, function(Container $c) {
    return new OrderService(
        $c->get(PaymentProcessor::class),
        $c->get(NotificationService::class)
    );
});

Автовайринг в современных фреймворках

Современные PHP-фреймворки (Laravel, Symfony) предоставляют продвинутые системы DI с автовайрингом:

// Laravel пример
class OrderService
{
    public function __construct(
        private PaymentProcessor $paymentProcessor,
        private NotificationService $notificationService
    ) {}
    
    // Сервис автоматически разрешит зависимости
}

// В сервис-провайдере
public function register(): void
{
    $this->app->bind(PaymentProcessor::class, StripeProcessor::class);
    $this->app->singleton(OrderService::class);
}

Практические рекомендации

• Используйте интерфейсы для абстракции зависимостей:

interface PaymentProcessorInterface
{
    public function charge(float $amount): bool;
}

class OrderService
{
    public function __construct(
        private PaymentProcessorInterface $paymentProcessor
    ) {}
}

• Внедряйте DI контейнер через композицию, а не наследование
• Избегайте сервис-локатора — это антипаттерн, скрывающий зависимости
• Используйте автоматическое внедрение для уменьшения boilerplate-кода
• Тестируемость — главное преимущество DI:

class OrderServiceTest
{
    public function testProcessOrder(): void
    {
        $mockProcessor = $this->createMock(PaymentProcessor::class);
        $mockNotification = $this->createMock(NotificationService::class);
        
        $service = new OrderService($mockProcessor, $mockNotification);
        // Тестирование с моками
    }
}

Проблемы и решения

• Циклические зависимости: решаются через рефакторинг, lazy loading или сеттерную инъекцию
• Производительность: кэширование конфигурации контейнера в production
• Сложность конфигурации: использование автоконфигурации и стандартных соглашений

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