Dependency Injection в PHP: простое руководство для начинающих

Dependency Injection в PHP: для начинающих

Представьте, что вы собираете компьютер. Вы не впаиваете процессор прямо в материнскую плату навсегда — вы вставляете его в специальный разъем, чтобы при необходимости заменить на более мощный. Dependency Injection (DI) в PHP работает по тому же принципу: вместо того чтобы создавать зависимости внутри класса, вы «внедряете» их извне.

В этой статье мы разберем, что такое Dependency Injection, зачем он нужен, и как его применять в PHP. Вы узнаете, как сделать ваш код гибким, тестируемым и удобным для поддержки.

Что такое Dependency Injection простыми словами

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

Давайте посмотрим на проблему, которую решает DI. Рассмотрим класс UserService, который напрямую создает соединение с базой данных:

<?php
class UserService {
    private $db;
    
    public function __construct() {
        // Жесткая связь с конкретной реализацией
        $this->db = new MySQLConnection('localhost', 'user', 'pass');
    }
    
    public function getUser($id) {
        return $this->db->query("SELECT * FROM users WHERE id = $id");
    }
}
?>

Проблемы такого подхода очевидны:

• Жесткая связь (tight coupling) — класс UserService привязан к MySQLConnection. Чтобы переключиться на PostgreSQL, придется менять код класса.
• Сложность тестирования — вы не сможете подменить базу данных на mock-объект в юнит-тестах.
• Нарушение принципа единственной ответственности — класс занимается не только работой с пользователями, но и созданием соединения с БД.

Теперь перепишем этот класс с использованием Dependency Injection:

<?php
interface DatabaseInterface {
    public function query($sql);
}

class MySQLConnection implements DatabaseInterface {
    public function query($sql) {
        // Реализация для MySQL
    }
}

class PostgreSQLConnection implements DatabaseInterface {
    public function query($sql) {
        // Реализация для PostgreSQL
    }
}

class UserService {
    private $db;
    
    // Зависимость внедряется через конструктор
    public function __construct(DatabaseInterface $db) {
        $this->db = $db;
    }
    
    public function getUser($id) {
        return $this->db->query("SELECT * FROM users WHERE id = $id");
    }
}

// Использование
$db = new MySQLConnection('localhost', 'user', 'pass');
$userService = new UserService($db);
?>

Теперь UserService не знает, с какой именно базой данных он работает. Он просто использует интерфейс DatabaseInterface. Это и есть суть Dependency Injection.

Три основных типа внедрения зависимостей

В PHP существует три основных способа внедрения зависимостей. Рассмотрим каждый из них.

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

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

<?php
class Logger {
    private $writer;
    
    public function __construct(LogWriterInterface $writer) {
        $this->writer = $writer;
    }
    
    public function log($message) {
        $this->writer->write($message);
    }
}
?>

Плюсы: зависимости явно видны, объект всегда находится в валидном состоянии (все зависимости обязательны).

Минусы: если зависимостей много, конструктор становится громоздким.

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

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

<?php
class MailService {
    private $mailer;
    
    public function setMailer(MailerInterface $mailer) {
        $this->mailer = $mailer;
    }
    
    public function send($to, $subject, $body) {
        if (!$this->mailer) {
            throw new \RuntimeException('Mailer not set');
        }
        $this->mailer->send($to, $subject, $body);
    }
}
?>

Плюсы: зависимости могут быть опциональными, можно менять зависимости во время выполнения.

Минусы: объект может быть в невалидном состоянии, если забыли вызвать сеттер.

3. Внедрение через метод (Method Injection)

Зависимость передается непосредственно в метод, где она используется.

<?php
class ReportGenerator {
    public function generate(DataProviderInterface $provider, $format = 'pdf') {
        $data = $provider->getData();
        // Генерация отчета
    }
}
?>

Плюсы: идеально для одноразовых зависимостей, не загрязняет состояние объекта.

Минусы: метод получает дополнительную ответственность — знание о том, какую зависимость передавать.

Почему Dependency Injection важен для архитектуры приложения

Dependency Injection — это не просто модный паттерн. Он является основой для соблюдения принципа инверсии зависимостей (Dependency Inversion Principle) из SOLID. Давайте разберем ключевые преимущества.

1. Слабая связанность (Loose Coupling)

Классы перестают зависеть от конкретных реализаций. Они зависят только от абстракций (интерфейсов). Это позволяет легко заменять одни компоненты на другие без изменения кода клиента.

2. Тестируемость

DI делает ваш код тестируемым. Вы можете подменять реальные зависимости на mock-объекты в юнит-тестах:

<?php
// Тест для UserService
class UserServiceTest extends PHPUnit\Framework\TestCase {
    public function testGetUser() {
        $mockDb = $this->createMock(DatabaseInterface::class);
        $mockDb->method('query')->willReturn(['id' => 1, 'name' => 'John']);
        
        $service = new UserService($mockDb);
        $result = $service->getUser(1);
        
        $this->assertEquals('John', $result['name']);
    }
}
?>

3. Гибкость и расширяемость

Вы можете легко