Реализация DI в PHP

// Без DI - жосткая связанность
class UserService {
    private $repository;
    
    public function __construct() {
        $this->repository = new MySqlUserRepository(); // Жесткая зависимость
    }
}
 
// С DI - гибкая архитектура
class UserService {
    private $repository;
    
    public function __construct(UserRepositoryInterface $repository) {
        $this->repository = $repository; // Зависимость внедрена извне
    }
}

// Пример использования PHP-DI
$container = new \DI\Container();
$userService = $container->get(UserService::class); // Автоматически внедряет все зависимости

class NewsletterManager {
    private $mailer;
    private $userRepository;
    
    public function __construct() {
        $this->mailer = new SmtpMailer('smtp.example.com', 587);
        $this->userRepository = new MySqlUserRepository();
    }
    
    public function sendNewsletterToAllUsers() {
        $users = $this->userRepository->findAllSubscribed();
        foreach ($users as $user) {
            $this->mailer->send($user->getEmail(), 'Новый выпуск', 'Содержание...');
        }
    }
}

class NewsletterManager {
    private $mailer;
    private $userRepository;
    
    public function __construct(
        MailerInterface $mailer,
        UserRepositoryInterface $userRepository
    ) {
        $this->mailer = $mailer;
        $this->userRepository = $userRepository;
    }
    
    public function sendNewsletterToAllUsers() {
        $users = $this->userRepository->findAllSubscribed();
        foreach ($users as $user) {
            $this->mailer->send($user->getEmail(), 'Новый выпуск', 'Содержание...');
        }
    }
}

// Традиционный подход
$newsletterManager = new NewsletterManager(); // Внутренне создаёт все зависимости
$newsletterManager->sendNewsletterToAllUsers();
 
// Подход с IoC
$mailer = new SmtpMailer('smtp.example.com', 587);
$userRepository = new MySqlUserRepository();
$newsletterManager = new NewsletterManager($mailer, $userRepository);
$newsletterManager->sendNewsletterToAllUsers();

class OrderProcessor {
    private $paymentGateway;
    private $notifier;
    
    public function __construct(
        PaymentGatewayInterface $paymentGateway,
        NotifierInterface $notifier
    ) {
        $this->paymentGateway = $paymentGateway;
        $this->notifier = $notifier;
    }
    
    public function processOrder(Order $order) {
        $this->paymentGateway->processPayment($order->getTotal());
        $this->notifier->notify($order->getCustomer(), 'Заказ обработан');
    }
}

class Logger {
    private $formatter;
    
    public function setFormatter(FormatterInterface $formatter) {
        $this->formatter = $formatter;
        return $this;
    }
    
    public function log($message) {
        if ($this->formatter) {
            $message = $this->formatter->format($message);
        }
        
        // Логика логирования
    }
}
 
// Использование
$logger = new Logger();
$logger->setFormatter(new JsonFormatter());
$logger->log('Событие произошло');

class TemplateRenderer {
    public $cache;
    
    public function render($template, $data) {
        if ($this->cache && $cached = $this->cache->get($template)) {
            return $cached;
        }
        
        // Логика рендеринга
    }
}
 
// Использование
$renderer = new TemplateRenderer();
$renderer->cache = new FileCache();

class DependencyResolver {
    private $container = [];
    
    public function register($id, $concrete = null) {
        if ($concrete === null) {
            $concrete = $id;
        }
        $this->container[$id] = $concrete;
    }
    
    public function resolve($id) {
        // Если есть готовый экземпляр или фабрика, используем их
        if (isset($this->container[$id])) {
            $concrete = $this->container[$id];
            if ($concrete instanceof Closure) {
                return $concrete($this);
            }
            if (!is_string($concrete)) {
                return $concrete;
            }
        } else {
            $concrete = $id;
        }
        
        // Используем рефлексию для создания экземпляра
        $reflector = new ReflectionClass($concrete);
        if (!$reflector->isInstantiable()) {
            throw new Exception("Класс {$concrete} не может быть инстанциирован");
        }
        
        $constructor = $reflector->getConstructor();
        if (null === $constructor) {
            return new $concrete;
        }
        
        // Разрешаем аргументы конструктора
        $parameters = $constructor->getParameters();
        $dependencies = [];
        
        foreach ($parameters as $parameter) {
            $type = $parameter->getType();
            
            if (!$type || $type->isBuiltin()) {
                if ($parameter->isDefaultValueAvailable()) {
                    $dependencies[] = $parameter->getDefaultValue();
                } else {
                    throw new Exception("Не удалось разрешить параметр {$parameter->getName()}");
                }
            } else {
                $dependencies[] = $this->resolve($type->getName());
            }
        }
        
        return $reflector->newInstanceArgs($dependencies);
    }
}

class ProductController {
    #[Inject]
    private ProductRepository $repository;
    
    #[Inject]
    private Logger $logger;
    
    public function show(#[Inject] Request $request, int $id) {
        $this->logger->info("Запрошен продукт с ID: {$id}");
        return $this->repository->find($id);
    }
}

class ReportGenerator {
    public function generateReport(array $data, FormatterInterface $formatter) {
        // Генерируем отчет и форматируем его с помощью переданного форматтера
        $processedData = $this->processData($data);
        return $formatter->format($processedData);
    }
    
    private function processData(array $data) {
        // Обработка данных
        return $data;
    }
}
 
// Использование
$generator = new ReportGenerator();
$pdfReport = $generator->generateReport($salesData, new PdfFormatter());
$csvReport = $generator->generateReport($salesData, new CsvFormatter());

class PaymentProcessor {
    public function processPayment(Order $order, callable $paymentStrategyResolver) {
        $paymentMethod = $order->getPaymentMethod();
        $strategy = $paymentStrategyResolver($paymentMethod);
        
        return $strategy->execute($order);
    }
}
 
// Использование
$processor = new PaymentProcessor();
$result = $processor->processPayment($order, function($method) {
    switch ($method) {
        case 'credit_card': return new CreditCardPaymentStrategy();
        case 'paypal': return new PayPalPaymentStrategy();
        default: throw new UnsuportedPaymentMethodException();
    }
});

class A {
    public function __construct(B $b) {
        $this->b = $b;
    }
}
 
class B {
    public function __construct(A $a) {
        $this->a = $a;
    }
}
 
// Теперь попробуйте создать экземпляр A или B...
// Получите бесконечную рекурсию!

interface AInterface { /* ... */ }
interface BInterface { /* ... */ }
 
class A implements AInterface {
    public function __construct(BInterface $b) {
        $this->b = $b;
    }
}
 
class B implements BInterface {
    private $aFactory;
    
    public function __construct(callable $aFactory) {
        $this->aFactory = $aFactory;
    }
    
    public function someMethod() {
        $a = ($this->aFactory)();
        // Используем $a
    }
}

class LazyServiceProxy {
    private $container;
    private $serviceId;
    private $service;
    
    public function __construct($container, $serviceId) {
        $this->container = $container;
        $this->serviceId = $serviceId;
    }
    
    public function __call($method, $arguments) {
        if (!$this->service) {
            $this->service = $this->container->get($this->serviceId);
        }
        
        return call_user_func_array([$this->service, $method], $arguments);
    }
}

class ExpensiveService {
    public function __construct() {
        // Тяжелая инициализация
        sleep(2); // Имитация тяжелой работы
    }
    
    public function doSomething() {
        return "Результат";
    }
}
 
class ExpensiveServiceFactory {
    private $instance;
    
    public function getService() {
        if (!$this->instance) {
            $this->instance = new ExpensiveService();
        }
        
        return $this->instance;
    }
}
 
class Consumer {
    private $serviceFactory;
    
    public function __construct(ExpensiveServiceFactory $factory) {
        $this->serviceFactory = $factory;
    }
    
    public function rarlyUsedMethod() {
        $service = $this->serviceFactory->getService();
        return $service->doSomething();
    }
}

class UserRepositoryProxy implements UserRepositoryInterface {
    private $container;
    private $realRepository;
    
    public function __construct($container) {
        $this->container = $container;
    }
    
    public function findById($id) {
        $this->initializeRepository();
        return $this->realRepository->findById($id);
    }
    
    private function initializeRepository() {
        if (!$this->realRepository) {
            $this->realRepository = $this->container->get('user.repository');
        }
    }
}

#[LazyDependency]
private ExpensiveService $service;

$container->set('database.host', 'localhost');
$container->set('database.port', 3306);

class DatabaseConnection {
    private $host;
    private $port;
    
    public function __construct(
        #[Inject('database.host')] string $host,
        #[Inject('database.port')] int $port
    ) {
        $this->host = $host;
        $this->port = $port;
    }
}

$container->set(DatabaseConnection::class, function($container) {
    return new DatabaseConnection(
        $container->get('database.host'),
        $container->get('database.port')
    );
});

// Без контейнера
$logger = new FileLogger('/var/log/app.log');
$mailer = new SmtpMailer('smtp.example.com', 587, 'user', 'pass');
$userRepository = new UserRepository(new MySqlConnection('localhost', 'root', 'password', 'mydb'));
$notificationService = new NotificationService($mailer, $logger);
$userService = new UserService($userRepository, $notificationService);
 
// С контейнером
$container = new Container();
$userService = $container->get(UserService::class);

// Конфигурация через PHP
$containerBuilder = new \DI\ContainerBuilder();
$containerBuilder->addDefinitions([
   Logger::class => \DI\create()->constructor('/var/log/app.log'),
   UserRepository::class => \DI\autowire(),
   NotificationService::class => \DI\create()
       ->constructor(\DI\get(Mailer::class), \DI\get(Logger::class)),
]);
$container = $containerBuilder->build();

// PHP-DI автоматически определит, какие объекты нужно создать и внедрить
$userService = $container->get(UserService::class);

// Пример конфигурации в PHP
$container = new ContainerBuilder();
 
$container->register('logger', Logger::class)
    ->setArguments(['/var/log/app.log']);
 
$container->register('mailer', SmtpMailer::class)
    ->setArguments(['smtp.example.com', 587, 'user', 'pass']);
 
$container->register('notification_service', NotificationService::class)
    ->setArguments([new Reference('mailer'), new Reference('logger')]);

// Регистрация в провайдере сервиса
$this->app->bind(LoggerInterface::class, function ($app) {
    return new FileLogger('/var/log/app.log');
});
 
// Использование
$logger = app(LoggerInterface::class);
// или через автоматическое разрешение в конструкторе контроллера
public function __construct(LoggerInterface $logger) { ... }

// Включение компиляции в Symfony
$container = new ContainerBuilder();
// ...настройка контейнера...
$container->compile();
 
// Сохраняем скомпилированный контейнер
$dumper = new PhpDumper($container);
file_put_contents('CompiledContainer.php', $dumper->dump());

$containerBuilder = new \DI\ContainerBuilder();
$containerBuilder->enableCompilation(__DIR__ . '/cache');
$containerBuilder->writeProxiesToFile(true, __DIR__ . '/cache/proxies');

class SimpleContainer {
private $services = [];
private $singletons = [];
 
public function bind($id, callable $factory) {
    $this->services[$id] = $factory;
}
 
public function singleton($id, callable $factory) {
    $this->services[$id] = function($container) use ($factory, $id) {
        if (!isset($this->singletons[$id])) {
            $this->singletons[$id] = $factory($container);
        }
        return $this->singletons[$id];
    };
}
 
public function get($id) {
    if (!isset($this->services[$id])) {
        throw new Exception("Сервис не найден: $id");
    }
    
    return $this->services[$id]($this);
}
}
 
// Использование
$container = new SimpleContainer();
 
$container->singleton(Logger::class, function() {
    return new FileLogger('/var/log/app.log');
});
 
$container->bind(UserRepository::class, function() {
    return new UserRepository();
});
 
$container->bind(UserService::class, function($container) {
    return new UserService(
        $container->get(UserRepository::class),
        $container->get(Logger::class)
    );
});
 
$userService = $container->get(UserService::class);

class UserProfileService {
private $userId;
private $userRepository;
 
public function __construct($userId, UserRepository $userRepository) {
    $this->userId = $userId;
    $this->userRepository = $userRepository;
}
 
public function getProfileData() {
    return $this->userRepository->findById($this->userId);
}
}

$container->bind(UserProfileService::class, function($container) use ($userId) {
    return new UserProfileService($userId, $container->get(UserRepository::class));
});

class UserProfileServiceFactory {
private $container;
 
public function __construct($container) {
    $this->container = $container;
}
 
public function create($userId) {
    return new UserProfileService(
        $userId,
        $this->container->get(UserRepository::class)
    );
}
}
 
// Регистрация фабрики
$container->singleton(UserProfileServiceFactory::class, function($container) {
    return new UserProfileServiceFactory($container);
});
 
// Использование
$factory = $container->get(UserProfileServiceFactory::class);
$service = $factory->create($userId);

$container->register('heavy_service', HeavyService::class)
    ->setLazy(true);

// Псевдокод сгенерированного прокси
class HeavyServiceProxy extends HeavyService
{
    private $container;
    private $realInstance;
    
    public function __construct($container)
    {
        $this->container = $container;
    }
    
    public function someMethod($arg)
    {
        if (null === $this->realInstance) {
            $this->realInstance = $this->container->createHeavyService();
        }
        
        return $this->realInstance->someMethod($arg);
    }
}

$containerBuilder = new DI\ContainerBuilder();
$containerBuilder->writeProxiesToFile(true, __DIR__ . '/cache/proxies');
$containerBuilder->addDefinitions([
    HeavyService::class => \DI\create()->lazy(),
]);

$this->app->bind('heavy', function ($app) {
    return new HeavyService();
});
 
// Где-то в коде
$service = app()->make('heavy'); // Создастся только здесь

interface PaymentHandlerInterface {
    public function supports($method): bool;
    public function handle(Payment $payment);
}
 
class StripeHandler implements PaymentHandlerInterface { /* ... */ }
class PayPalHandler implements PaymentHandlerInterface { /* ... */ }
class BitcoinHandler implements PaymentHandlerInterface { /* ... */ }

// config.php или services.yaml
$container->register(StripeHandler::class)
    ->addTag('payment.handler');
$container->register(PayPalHandler::class)
    ->addTag('payment.handler');
$container->register(BitcoinHandler::class)
    ->addTag('payment.handler');
 
// Получение всех обработчиков
$handlers = $container->findTaggedServiceIds('payment.handler');

$containerBuilder->addDefinitions([
    'payment.handlers' => \DI\get([
        \DI\get(StripeHandler::class),
        \DI\get(PayPalHandler::class),
        \DI\get(BitcoinHandler::class)
    ])
]);

$container->register('logger.admin', FileLogger::class)
    ->setArguments(['/var/log/admin.log']);
$container->register('logger.public', FileLogger::class)
    ->setArguments(['/var/log/public.log']);
 
// В админ-контроллерах
$container->register(AdminController::class)
    ->setArguments([new Reference('logger.admin')]);
 
// В публичных контроллерах
$container->register(PublicController::class)
    ->setArguments([new Reference('logger.public')]);

$containerBuilder->addDefinitions([
    LoggerInterface::class => \DI\autowire(FileLogger::class)
        ->constructorParameter('path', '/var/log/default.log'),
        
    // Переопределение для конкретного класса
    AdminController::class => \DI\autowire()
        ->constructorParameter('logger', \DI\autowire(FileLogger::class)
            ->constructorParameter('path', '/var/log/admin.log'))
]);

$container->register(UserRepository::class, MySqlUserRepository::class);
 
$container->register('user_repository.cached', CachedUserRepository::class)
    ->setDecoratedService(UserRepository::class)
    ->setArguments([new Reference('user_repository.cached.inner')]);

$containerBuilder->addDefinitions([
    UserRepository::class => \DI\decorate(function ($previous, $container) {
        return new CachedUserRepository($previous);
    })
]);

public function __construct(
    LoggerInterface $logger,
    string $logPath,  // Откуда контейнеру знать это значение?
    bool $enableDebug // И это?
) { 
    // ...
}

// Какой именно логер должен быть внедрен?
$container->register('file_logger', FileLogger::class);
$container->register('syslog_logger', SyslogLogger::class);
// Оба реализуют LoggerInterface

// Старый код, который нельзя сразу переписать
class LegacyUserRepository {
    public function findById($id) { /* ... */ }
}
 
// Обёртка для интеграции в DI-систему
class UserRepository implements UserRepositoryInterface {
    private $legacyRepository;
    
    public function __construct() {
        $this->legacyRepository = new LegacyUserRepository();
    }
    
    public function findById($id) {
        return $this->legacyRepository->findById($id);
    }
}

class OrderProcessor {
    private $paymentGateway;
    private $inventoryManager;
    
    public function __construct() {
        $this->paymentGateway = new StripeGateway(
            getenv('STRIPE_API_KEY'),
            getenv('STRIPE_SECRET')
        );
        $this->inventoryManager = new InventoryManager(
            new MySqlConnection(/* ... */)
        );
    }
    
    public function processOrder($order) {
        // Логика обработки заказа
    }
}

interface PaymentGatewayInterface {
    public function processPayment($amount, $paymentDetails);
}
 
interface InventoryManagerInterface {
    public function updateStock($productId, $quantity);
}

class OrderProcessor {
    private $paymentGateway;
    private $inventoryManager;
    
    public function __construct(
        PaymentGatewayInterface $paymentGateway,
        InventoryManagerInterface $inventoryManager
    ) {
        $this->paymentGateway = $paymentGateway;
        $this->inventoryManager = $inventoryManager;
    }
    
    public function processOrder($order) {
        // Логика обработки заказа
    }
}

class OrderProcessorFactory {
    public static function create() {
        return new OrderProcessor(
            new StripeGateway(
                getenv('STRIPE_API_KEY'),
                getenv('STRIPE_SECRET')
            ),
            new InventoryManager(
                new MySqlConnection(/* ... */)
            )
        );
    }
}
 
// Использование в существующем коде
$processor = OrderProcessorFactory::create();

// AppServiceProvider.php
public function register()
{
    $this->app->bind(PaymentGatewayInterface::class, function ($app) {
        return new StripeGateway(
            config('services.stripe.key'),
            config('services.stripe.secret')
        );
    });
    
    $this->app->bind(InventoryManagerInterface::class, InventoryManager::class);
}

$container = new \DI\Container();
$container->set(PaymentGatewayInterface::class, \DI\create(StripeGateway::class)
    ->constructor(getenv('STRIPE_API_KEY'), getenv('STRIPE_SECRET')));
 
$app = \Slim\Factory\AppFactory::createFromContainer($container);

class BadExampleController {
    private $container;
    
    public function __construct($container) {
        $this->container = $container;
    }
    
    public function showUser($id) {
        // Антипаттерн! Запрашиваем сервисы напрямую из контейнера
        $userRepository = $this->container->get(UserRepository::class);
        $logger = $this->container->get(LoggerInterface::class);
        
        $logger->info("Запрошен пользователь: {$id}");
        return $userRepository->find($id);
    }
}

class GoodExampleController {
    private $userRepository;
    private $logger;
    
    public function __construct(
        UserRepository $userRepository,
        LoggerInterface $logger
    ) {
        $this->userRepository = $userRepository;
        $this->logger = $logger;
    }
    
    public function showUser($id) {
        $this->logger->info("Запрошен пользователь: {$id}");
        return $this->userRepository->find($id);
    }
}

// Не очень хорошо
class ApiClient {
    public function __construct(
        #[Inject('api.base_url')] string $baseUrl,
        #[Inject('api.token')] string $token
    ) { /* ... */ }
}

// Лучше
class ApiConfig {
    public function __construct(
        public readonly string $baseUrl,
        public readonly string $token
    ) {}
}
 
class ApiClient {
    public function __construct(ApiConfig $config) { /* ... */ }
}

public function testOrderProcessing()
{
    // Создаем моки зависимостей
    $paymentGateway = $this->createMock(PaymentGatewayInterface::class);
    $paymentGateway->expects($this->once())
                  ->method('processPayment')
                  ->willReturn(true);
    
    // Передаем моки в тестируемый сервис
    $processor = new OrderProcessor($paymentGateway, $this->createMock(InventoryManagerInterface::class));
    
    // Проверяем результат
    $this->assertTrue($processor->processOrder(new Order()));
}