PHP如何实现依赖注入容器_PHP依赖注入(DI)容器实现原理

Container

<?php

namespace App\Container;

use ReflectionClass;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Container\ContainerExceptionInterface;

class Container implements ContainerInterface
{
    /**
     * @var array 存储服务绑定关系，键是抽象，值是具体实现或工厂函数
     */
    protected $bindings = [];

    /**
     * @var array 存储单例实例
     */
    protected $singletons = [];

    /**
     * 绑定一个抽象到具体的实现。
     *
     * @param string $abstract 抽象（接口或类名）
     * @param mixed $concrete 具体实现（类名、实例或闭包）
     * @param bool $shared 是否作为单例共享
     */
    public function bind(string $abstract, $concrete = null, bool $shared = false)
    {
        // 如果没有指定具体实现，则假定抽象本身就是具体实现
        if (is_null($concrete)) {
            $concrete = $abstract;
        }

        $this->bindings[$abstract] = compact('concrete', 'shared');
    }

    /**
     * 绑定一个抽象作为单例。
     *
     * @param string $abstract 抽象
     * @param mixed $concrete 具体实现
     */
    public function singleton(string $abstract, $concrete = null)
    {
        $this->bind($abstract, $concrete, true);
    }

    /**
     * 从容器中解析一个服务实例。
     *
     * @param string $id 服务的标识符（类名或接口名）
     * @return mixed 服务实例
     * @throws NotFoundExceptionInterface 如果服务未找到
     * @throws ContainerExceptionInterface 如果解析过程中发生错误
     */
    public function get(string $id)
    {
        // 检查是否已存在单例实例
        if (isset($this->singletons[$id])) {
            return $this->singletons[$id];
        }

        // 检查是否有绑定关系
        if (!isset($this->bindings[$id])) {
            // 如果没有绑定，尝试直接解析这个ID，假定它是一个可实例化的类
            return $this->resolve($id);
        }

        $binding = $this->bindings[$id];
        $concrete = $binding['concrete'];

        // 如果具体实现是一个闭包，直接调用它
        if ($concrete instanceof \Closure) {
            $instance = $concrete($this);
        } else {
            // 否则，解析具体的类
            $instance = $this->resolve($concrete);
        }

        // 如果是单例，存储起来
        if ($binding['shared']) {
            $this->singletons[$id] = $instance;
        }

        return $instance;
    }

    /**
     * 检查容器中是否有某个服务。
     *
     * @param string $id 服务的标识符
     * @return bool
     */
    public function has(string $id): bool
    {
        return isset($this->bindings[$id]) || class_exists($id);
    }

    /**
     * 解析具体的类实例及其依赖。
     *
     * @param string $concrete 具体类名
     * @return mixed 类实例
     * @throws ContainerExceptionInterface
     */
    protected function resolve(string $concrete)
    {
        try {
            $reflector = new ReflectionClass($concrete);
        } catch (\ReflectionException $e) {
            throw new class extends \InvalidArgumentException implements NotFoundExceptionInterface {
                // Custom exception for clarity
            };
        }

        // 如果类不可实例化，抛出异常
        if (!$reflector->isInstantiable()) {
            throw new class extends \InvalidArgumentException implements ContainerExceptionInterface {
                // Custom exception
            };
        }

        $constructor = $reflector->getConstructor();

        // 如果没有构造函数，直接返回新实例
        if (is_null($constructor)) {
            return new $concrete;
        }

        $dependencies = $constructor->getParameters();
        $instances = $this->getDependencies($dependencies);

        return $reflector->newInstanceArgs($instances);
    }

    /**
     * 获取构造函数参数的依赖实例。
     *
     * @param \ReflectionParameter[] $parameters
     * @return array
     * @throws ContainerExceptionInterface
     */
    protected function getDependencies(array $parameters): array
    {
        $dependencies = [];
        foreach ($parameters as $parameter) {
            $dependency = $parameter->getType();

            // 如果参数没有类型提示，或者类型不是一个类/接口，
            // 并且没有默认值，那就麻烦了，我们不知道怎么提供
            if (is_null($dependency) || $dependency->isBuiltin()) {
                if ($parameter->isDefaultValueAvailable()) {
                    $dependencies[] = $parameter->getDefaultValue();
                } else {
                    // 这种情况通常意味着配置错误或者我们容器的局限性
                    throw new class extends \InvalidArgumentException implements ContainerExceptionInterface {
                        // Custom exception
                    };
                }
            } else {
                // 递归地从容器中解析依赖
                $dependencies[] = $this->get($dependency->getName());
            }
        }
        return $dependencies;
    }
}

bind

get

resolve

ReflectionClass

getDependencies

get

// 假设我们有一些类
interface LoggerInterface {
    public function log(string $message);
}

class FileLogger implements LoggerInterface {
    private string $filePath;

    public function __construct(string $filePath = 'app.log') {
        $this->filePath = $filePath;
    }

    public function log(string $message) {
        file_put_contents($this->filePath, date('[Y-m-d H:i:s] ') . $message . PHP_EOL, FILE_APPEND);
    }
}

class DatabaseLogger implements LoggerInterface {
    public function log(string $message) {
        // 模拟数据库日志记录
        echo "Logging to DB: " . $message . PHP_EOL;
    }
}

class UserService {
    private LoggerInterface $logger;

    public function __construct(LoggerInterface $logger) {
        $this->logger = $logger;
    }

    public function createUser(string $name) {
        $this->logger->log("User '{$name}' created.");
        return "User {$name} created successfully.";
    }
}

// 使用容器
$container = new Container();

// 绑定LoggerInterface到FileLogger
$container->bind(LoggerInterface::class, FileLogger::class);

// 如果FileLogger需要一个特定的文件路径，我们可以用闭包来提供
// $container->bind(LoggerInterface::class, function($c) {
//     return new FileLogger('/var/log/my_app.log');
// });

// 获取UserService实例，容器会自动注入LoggerInterface的实现
$userService = $container->get(UserService::class);
echo $userService->createUser("Alice"); // 输出: User 'Alice' created.
echo PHP_EOL;

// 改变绑定，不需要修改UserService代码
$container->bind(LoggerInterface::class, DatabaseLogger::class);
$userService2 = $container->get(UserService::class); // 这里会重新解析UserService，因为不是单例
echo $userService2->createUser("Bob"); // 输出: Logging to DB: User 'Bob' created.
echo PHP_EOL;

// 绑定一个单例
$container->singleton(LoggerInterface::class, FileLogger::class);
$container->bind('log_path', '/tmp/my_app_singleton.log'); // 绑定一个值

// 我们可以用闭包来创建单例，并注入其他依赖
$container->singleton(LoggerInterface::class, function($c) {
    return new FileLogger($c->get('log_path'));
});

$logger1 = $container->get(LoggerInterface::class);
$logger2 = $container->get(LoggerInterface::class);
var_dump($logger1 === $logger2); // true，因为是单例
$logger1->log("This is a singleton log message.");

new ClassB()