当前位置：首页 > PHP

php容器实现

2026-02-14 11:22:02PHP

PHP容器的实现方法

依赖注入容器（Dependency Injection Container）

依赖注入容器是PHP中实现容器的核心机制。通过容器管理对象的创建和依赖关系，减少硬编码依赖。以下是一个简单的依赖注入容器实现示例：

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 = $constructor->getParameters();
        $instances = $this->resolveDependencies($dependencies);
        return $reflector->newInstanceArgs($instances);
    }

    protected function resolveDependencies($parameters) {
        $dependencies = [];
        foreach ($parameters as $parameter) {
            $dependency = $parameter->getClass();
            if (is_null($dependency)) {
                if ($parameter->isDefaultValueAvailable()) {
                    $dependencies[] = $parameter->getDefaultValue();
                } else {
                    throw new Exception("Cannot resolve dependency {$parameter->name}");
                }
            } else {
                $dependencies[] = $this->make($dependency->name);
            }
        }
        return $dependencies;
    }
}

使用PSR-11标准容器

PSR-11定义了容器接口规范，推荐使用符合该标准的容器实现。常见的PSR-11兼容容器包括：

php容器实现

PHP-DI
Symfony DependencyInjection
Laravel容器

use Psr\Container\ContainerInterface;

class MyContainer implements ContainerInterface {
    private $services = [];

    public function get($id) {
        if (!$this->has($id)) {
            throw new ServiceNotFoundException($id);
        }
        return $this->services[$id];
    }

    public function has($id) {
        return isset($this->services[$id]);
    }

    public function set($id, $service) {
        $this->services[$id] = $service;
    }
}

自动装配实现

现代PHP框架通常支持自动装配，容器可以自动解析类依赖关系而无需显式配置：

php容器实现

class AutowiringContainer extends Container {
    public function make($abstract, $parameters = []) {
        try {
            return parent::make($abstract, $parameters);
        } catch (Exception $e) {
            if (class_exists($abstract)) {
                return $this->resolve($abstract, $parameters);
            }
            throw $e;
        }
    }
}

服务提供者模式

在大型应用中，通常使用服务提供者来组织容器绑定逻辑：

interface ServiceProvider {
    public function register(Container $container);
}

class DatabaseServiceProvider implements ServiceProvider {
    public function register(Container $container) {
        $container->bind('db', function() {
            return new DatabaseConnection(config('database'));
        });
    }
}

容器性能优化

对于生产环境，可以考虑以下优化措施：

使用缓存解析结果
预编译容器
延迟加载服务

class OptimizedContainer extends Container {
    private $resolved = [];

    public function make($abstract, $parameters = []) {
        if (isset($this->resolved[$abstract])) {
            return $this->resolved[$abstract];
        }
        $instance = parent::make($abstract, $parameters);
        $this->resolved[$abstract] = $instance;
        return $instance;
    }
}

以上方法展示了PHP容器的主要实现方式，从基础依赖注入到符合PSR标准的容器，再到自动装配和服务提供者等高级用法。实际项目中可根据需求选择合适的实现方案。