php diy实现

PHP DIY 实现

PHP DIY（依赖注入）可以通过手动实现或使用容器来实现。以下是几种常见的方法：

手动依赖注入

手动依赖注入是最基础的方式，通过构造函数或方法参数传递依赖对象。

class Database {
    public function query($sql) {
        // 数据库查询逻辑
    }
}

class UserRepository {
    private $db;

    public function __construct(Database $db) {
        $this->db = $db;
    }

    public function getUsers() {
        return $this->db->query('SELECT * FROM users');
    }
}

$db = new Database();
$userRepository = new UserRepository($db);

使用容器实现依赖注入

容器可以自动管理依赖关系，避免手动创建对象。

class Container {
    private $bindings = [];

    public function bind($abstract, $concrete) {
        $this->bindings[$abstract] = $concrete;
    }

    public function make($abstract) {
        if (!isset($this->bindings[$abstract])) {
            throw new Exception("No binding found for {$abstract}");
        }

        $concrete = $this->bindings[$abstract];
        if (is_callable($concrete)) {
            return $concrete($this);
        }
        return new $concrete();
    }
}

$container = new Container();
$container->bind(Database::class, function() {
    return new Database();
});

$container->bind(UserRepository::class, function($container) {
    return new UserRepository($container->make(Database::class));
});

$userRepository = $container->make(UserRepository::class);

使用反射实现自动依赖注入

反射可以自动解析类的依赖关系并注入。

class DependencyInjector {
    public function resolve($class) {
        $reflection = new ReflectionClass($class);
        $constructor = $reflection->getConstructor();
        if (!$constructor) {
            return new $class();
        }

        $parameters = $constructor->getParameters();
        $dependencies = [];
        foreach ($parameters as $parameter) {
            $dependencyClass = $parameter->getClass();
            if (!$dependencyClass) {
                throw new Exception("Cannot resolve dependency for {$parameter->getName()}");
            }
            $dependencies[] = $this->resolve($dependencyClass->getName());
        }

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

$injector = new DependencyInjector();
$userRepository = $injector->resolve(UserRepository::class);

使用接口绑定

通过接口绑定可以实现更灵活的依赖注入。

interface DatabaseInterface {
    public function query($sql);
}

class MySQLDatabase implements DatabaseInterface {
    public function query($sql) {
        // MySQL 查询逻辑
    }
}

class UserRepository {
    private $db;

    public function __construct(DatabaseInterface $db) {
        $this->db = $db;
    }
}

$container = new Container();
$container->bind(DatabaseInterface::class, MySQLDatabase::class);
$userRepository = $container->make(UserRepository::class);

使用 Pimple 容器

Pimple 是一个轻量级的 PHP 依赖注入容器。

require_once 'vendor/autoload.php';

$container = new Pimple\Container();
$container['database'] = function() {
    return new Database();
};

$container['userRepository'] = function($c) {
    return new UserRepository($c['database']);
};

$userRepository = $container['userRepository'];

以上方法可以根据项目需求选择适合的方式实现 PHP 的依赖注入。