当前位置：首页 > PHP

php 实现 ioc

2026-02-28 14:05:00PHP

PHP 实现 IoC（控制反转）容器

控制反转（IoC）是一种设计模式，用于解耦组件依赖关系。在 PHP 中，可以通过依赖注入（DI）或服务容器实现 IoC。以下是具体实现方法：

基础 IoC 容器实现

创建一个简单的 IoC 容器类，用于管理依赖关系：

class Container {
    protected $instances = [];

    public function bind($abstract, $concrete = null) {
        if (is_null($concrete)) {
            $concrete = $abstract;
        }
        $this->instances[$abstract] = $concrete;
    }

    public function make($abstract, $parameters = []) {
        if (!isset($this->instances[$abstract])) {
            $this->bind($abstract);
        }

        return $this->resolve($this->instances[$abstract], $parameters);
    }

    protected function resolve($concrete, $parameters) {
        if ($concrete instanceof Closure) {
            return $concrete($this, $parameters);
        }

        $reflector = new ReflectionClass($concrete);

        if (!$reflector->isInstantiable()) {
            throw new Exception("Class {$concrete} is not instantiable");
        }

        $constructor = $reflector->getConstructor();
        if (is_null($constructor)) {
            return new $concrete;
        }

        $dependencies = $this->resolveDependencies(
            $constructor->getParameters(),
            $parameters
        );

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

    protected function resolveDependencies($parameters, $customParameters) {
        $dependencies = [];
        foreach ($parameters as $parameter) {
            if (array_key_exists($parameter->name, $customParameters)) {
                $dependencies[] = $customParameters[$parameter->name];
            } else {
                $dependencies[] = $this->make($parameter->getClass()->name);
            }
        }
        return $dependencies;
    }
}

使用示例

定义接口和实现类：

interface LoggerInterface {
    public function log($message);
}

class FileLogger implements LoggerInterface {
    public function log($message) {
        file_put_contents('app.log', $message, FILE_APPEND);
    }
}

class UserController {
    protected $logger;

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

    public function register($user) {
        $this->logger->log("User registered: {$user}");
    }
}

配置和使用容器：

$container = new Container();
$container->bind(LoggerInterface::class, FileLogger::class);

$controller = $container->make(UserController::class);
$controller->register('John Doe');

高级功能实现

实现单例绑定：

public function singleton($abstract, $concrete = null) {
    $this->bind($abstract, function($container) use ($concrete) {
        static $instance;
        if (is_null($instance)) {
            $instance = $container->make($concrete);
        }
        return $instance;
    });
}

实现接口绑定：

public function bindInterface($interface, $implementation) {
    $this->bind($interface, $implementation);
}

自动依赖解析

通过反射自动解析未绑定的依赖：

protected function resolveUnboundDependency(ReflectionParameter $parameter) {
    if ($parameter->getClass()) {
        return $this->make($parameter->getClass()->name);
    }
    throw new Exception("Cannot resolve dependency {$parameter->name}");
}