php如何实现一个依赖注入容器 php依赖注入容器实现原理与步骤

new

new

Container

<?php

class Container
{
    protected array $definitions = [];
    protected array $instances = []; // 存储已经创建的单例实例

    /**
     * 绑定一个服务定义到容器。
     *
     * @param string $id 服务的标识符 (例如: 'UserService', 'App\Services\UserService')
     * @param mixed $concrete 服务具体的实现，可以是类名、匿名函数或一个已经实例化的对象。
     * @param bool $singleton 是否作为单例管理
     */
    public function bind(string $id, mixed $concrete = null, bool $singleton = false): void
    {
        // 如果concrete是null，默认绑定到id本身（即id就是类名）
        if (is_null($concrete)) {
            $concrete = $id;
        }

        $this->definitions[$id] = compact('concrete', 'singleton');
    }

    /**
     * 从容器中解析并获取一个服务实例。
     *
     * @param string $id 服务的标识符
     * @return mixed 服务实例
     * @throws ReflectionException
     * @throws Exception 如果服务无法解析
     */
    public function get(string $id): mixed
    {
        // 如果是单例且已存在，直接返回
        if (isset($this->instances[$id])) {
            return $this->instances[$id];
        }

        // 检查服务定义是否存在
        if (!isset($this->definitions[$id])) {
            // 如果没有明确定义，尝试直接解析类名
            if (class_exists($id)) {
                $this->bind($id, $id); // 临时绑定，以便后续解析
            } else {
                throw new Exception("Service [{$id}] is not defined in the container.");
            }
        }

        $definition = $this->definitions[$id];
        $concrete = $definition['concrete'];

        $object = null;
        if ($concrete instanceof Closure) {
            // 如果是匿名函数，直接执行它，并将容器自身作为参数传入（可选）
            $object = $concrete($this);
        } elseif (is_string($concrete) && class_exists($concrete)) {
            // 如果是类名，通过反射解析其依赖
            $object = $this->resolveClass($concrete);
        } elseif (is_object($concrete)) {
            // 如果直接绑定了一个对象实例
            $object = $concrete;
        } else {
            throw new Exception("Cannot resolve service [{$id}]. Invalid concrete type.");
        }

        // 如果是单例，存储实例
        if ($definition['singleton']) {
            $this->instances[$id] = $object;
        }

        return $object;
    }

    /**
     * 通过反射解析一个类及其构造函数依赖。
     *
     * @param string $class 类名
     * @return object 类实例
     * @throws ReflectionException
     * @throws Exception
     */
    protected function resolveClass(string $class): object
    {
        $reflector = new ReflectionClass($class);

        // 检查类是否可以实例化
        if (!$reflector->isInstantiable()) {
            throw new Exception("Class [{$class}] is not instantiable.");
        }

        $constructor = $reflector->getConstructor();

        // 如果没有构造函数，直接创建实例
        if (is_null($constructor)) {
            return new $class;
        }

        // 获取构造函数的所有参数
        $parameters = $constructor->getParameters();
        $dependencies = $this->resolveDependencies($parameters);

        // 使用解析出的依赖创建实例
        return $reflector->newInstanceArgs($dependencies);
    }

    /**
     * 解析方法或构造函数参数的依赖。
     *
     * @param ReflectionParameter[] $parameters
     * @return array
     * @throws ReflectionException
     * @throws Exception
     */
    protected function resolveDependencies(array $parameters): array
    {
        $dependencies = [];

        foreach ($parameters as $parameter) {
            $type = $parameter->getType();

            if ($type instanceof ReflectionNamedType && !$type->isBuiltin()) {
                // 如果是类类型，尝试从容器中解析
                $dependencies[] = $this->get($type->getName());
            } elseif ($parameter->isDefaultValueAvailable()) {
                // 如果有默认值，使用默认值
                $dependencies[] = $parameter->getDefaultValue();
            } else {
                // 无法解析的依赖，抛出异常
                throw new Exception("Cannot resolve dependency [{$parameter->getName()}] for service.");
            }
        }

        return $dependencies;
    }

    /**
     * 获取一个单例服务。
     *
     * @param string $id
     * @param mixed $concrete
     * @return void
     */
    public function singleton(string $id, mixed $concrete = null): void
    {
        $this->bind($id, $concrete, true);
    }
}

<?php
// 假设有这样的服务
interface LoggerInterface {
    public function log(string $message): void;
}

class FileLogger implements LoggerInterface {
    public function log(string $message): void {
        echo "Logging to file: " . $message . PHP_EOL;
    }
}

class DatabaseLogger implements LoggerInterface {
    public function log(string $message): void {
        echo "Logging to database: " . $message . PHP_EOL;
    }
}

class UserService {
    private LoggerInterface $logger;

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

    public function createUser(string $name): void {
        $this->logger->log("User '{$name}' created.");
        echo "User '{$name}' has been created." . PHP_EOL;
    }
}

// 初始化容器
$container = new Container();

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

// 或者绑定一个匿名函数来创建实例（更灵活，可以传递额外参数）
// $container->bind(LoggerInterface::class, function() {
//     return new FileLogger();
// });

// 获取UserService实例，容器会自动注入LoggerInterface
$userService = $container->get(UserService::class);
$userService->createUser("Alice");

// 我们可以随时更改Logger的实现，而无需修改UserService的代码
$container->bind(LoggerInterface::class, DatabaseLogger::class);
$userService2 = $container->get(UserService::class); // 这里会重新解析，因为UserService不是单例
$userService2->createUser("Bob");

// 如果UserService也是单例
$container->singleton(UserService::class);
$userService3 = $container->get(UserService::class);
$userService3->createUser("Charlie"); // 第一次创建

$userService4 = $container->get(UserService::class); // 获取的是同一个实例
echo "Are userService3 and userService4 the same instance? " . ($userService3 === $userService4 ? "Yes" : "No") . PHP_EOL;

?>

new

UserService

LoggerInterface

FileLogger

UserService

new