README

库，提供一系列类以实现控制反转（IoC）原则。

使用方法

首先创建一个工厂 \Koldown\InversionControl\Contracts\IDependenceFactory，在其中定义实例化类对象及其相应依赖项的策略。

class Factory implements \Koldown\InversionControl\Contracts\IDependenceFactory {

    public function build(string $class) {
        switch ($class) {
            case (Sumador::class) :
                return (new ClassInstance(Sumador::class))->setDependence("operacion", Suma::class);

            case (Restador::class) :
                return (new ClassInstance(Restador::class))->setDependence("operacion", Resta::class);

            default : return new $class();
        }
    }
}

在此示例中，我们已设定我们的工厂可以实例化任何请求的类，但我们有两个类需要依赖项才能执行其过程

class Sumador implements IOperador {

    private $operacion;

    public function setOperacion(IOperacionAritmetica $operacion): void {
        $this->operacion = $operacion;
    }

    public function ejecutar(int $a, int $b): int {
        return $this->operacion->ejecutar($a, $b);
    }
}

class Restador implements IOperador {

    private $operacion;

    public function setOperacion(IOperacionAritmetica $operacion): void {
        $this->operacion = $operacion;
    }

    public function ejecutar(int $a, int $b): int {
        return $this->operacion->ejecutar($a, $b);
    }
}

为了实现这一点，我们必须依赖类 Koldown\InversionControl\ClassInstance，它允许我们定义类及其相应依赖项的构建方式。

需要设定依赖项的键名和要实例化的类类型，其中键是一个重要的参数，用于执行此功能，因此库基于依赖注入的原则使用类型为 setter 的方法，因此在定义键为 "operacion" 的示例中，构建对象时将查找 "setOperacion" 函数以注入相应的依赖项。

定义好我们的对象工厂后，我们继续具体应用 IoC 流程，为此我们依赖类 \Koldown\InversionControl\ContainerContext，它负责管理所需类对象的构建。

$context  = \Koldown\InversionControl\ContainerContext::getInstance();
$sumador  = $context->create(Factory::class, Sumador::class);
$restador = $context->create(Factory::class, Restador::class);

echo "Función suma  (9 + 11) = {$sumador->ejecutar(9, 11)}";
echo "Función resta (15 - 6) = {$restador->ejecutar(15, 6)}";

我们已生成两个算术函数的实例，但现在需要将它们封装在一个名为 Calculadora 的单个类中。

class Calculadora {

    private $sumador;

    private $restador; 

    public function setSumador(IOperador $sumador): void {
        $this->sumador = $sumador;
    }

    public function setRestador(IOperador $restador): void {
        $this->restador = $restador;
    }

    public function sumar(int $a, int $b): int {
        return $this->sumador->ejecutar($a, $b);
    }

    public function restar(int $a, int $b): int {
        return $this->restador->ejecutar($a, $b);
    }
}

现在我们来到我们的工厂，并添加这个新案例

case (Calculadora::class) :
    return (new ClassInstance(Calculadora::class))
        ->setDependence("restador", Restador::class)
        ->setDependence("sumador", Sumador::class);

如我们所见，我们可以将之前定义的参数化类作为这个新类的依赖项，这个新类在其构建阶段也会注入其依赖项的依赖项。

这样我们就可以以以下方式执行我们的程序

$context     = \Koldown\InversionControl\ContainerContext::getInstance();

$calculadora = $context->create(Factory::class, Calculadora::class);

echo "Cálculo suma (4 + 8)  = {$calculadora->sumar(4, 8)}";
echo "Cálculo resta (9 - 2) = {$calculadora->restar(9, 2)}";

如果您想查看此练习的详细代码，请进入存储库中的 example 文件夹，您将找到示例文件。

注意

类 Koldown\InversionControl\ClassInstance 的 setDependence 函数接收一个第三参数 $shared，类型为 bool，这允许在从 \Koldown\InversionControl\ContainerContext 创建对象时，在请求该依赖项的类之间共享构建的依赖项实例。