php 实现IOC

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

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

基本容器实现

创建一个简单的 IoC 容器类，用于注册和解析依赖：

class Container {
    protected $bindings = [];

    public function bind($abstract, $concrete = null, $shared = false) {
        if (is_null($concrete)) {
            $concrete = $abstract;
        }
        $this->bindings[$abstract] = compact('concrete', 'shared');
    }

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

        $concrete = $this->bindings[$abstract]['concrete'];
        if ($concrete === $abstract || is_string($concrete)) {
            $concrete = $this->build($concrete, $parameters);
        }

        return $concrete;
    }

    protected function build($concrete, $parameters) {
        $reflector = new ReflectionClass($concrete);
        if (!$reflector->isInstantiable()) {
            throw new Exception("Target [$concrete] is not instantiable.");
        }

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

        $dependencies = $constructor->getParameters();
        $instances = $this->resolveDependencies($dependencies, $parameters);
        return $reflector->newInstanceArgs($instances);
    }

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

使用示例

定义服务接口和实现：

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

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

注册并解析依赖：

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

class UserService {
    protected $logger;

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

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

$userService = $container->make(UserService::class);
$userService->register('John Doe');

高级特性扩展

实现单例绑定：

public function singleton($abstract, $concrete = null) {
    $this->bind($abstract, $concrete, true);
}

protected $instances = [];

public function make($abstract, $parameters = []) {
    if (isset($this->instances[$abstract])) {
        return $this->instances[$abstract];
    }
    // ...原有逻辑
    if ($this->bindings[$abstract]['shared']) {
        $this->instances[$abstract] = $concrete;
    }
    return $concrete;
}

实现自动依赖解析：

protected function resolveDependencies($dependencies, $parameters) {
    $results = [];
    foreach ($dependencies as $dependency) {
        if (isset($parameters[$dependency->name])) {
            $results[] = $parameters[$dependency->name];
        } elseif ($dependency->getClass()) {
            $results[] = $this->make($dependency->getClass()->name);
        } elseif ($dependency->isDefaultValueAvailable()) {
            $results[] = $dependency->getDefaultValue();
        } else {
            throw new Exception("Unresolvable dependency: {$dependency->name}");
        }
    }
    return $results;
}

容器优化建议

使用闭包延迟加载：

$container->bind('service', function($container) {
    return new HeavyService();
});

实现接口绑定到多个实现：

$container->bind(LoggerInterface::class, function($container) {
    return new CompositeLogger([
        $container->make(FileLogger::class),
        $container->make(DatabaseLogger::class)
    ]);
});

通过以上方法可以实现一个功能完整的 PHP IoC 容器，支持依赖注入、单例管理和自动解析等功能。实际项目中可以考虑使用成熟的框架如 Laravel 的服务容器，它提供了更完善的实现。