PHPackages                             koldown/ioc - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Framework](/categories/framework)
4. /
5. koldown/ioc

ActiveLibrary[Framework](/categories/framework)

koldown/ioc
===========

Librería que proporciona un conjunto de clase para implementar los principios de inversión de control (IoC)

1.0.0(6y ago)017MITPHP

Since Dec 26Pushed 6y ago1 watchersCompare

[ Source](https://github.com/ingdacastillop/koldown-ioc)[ Packagist](https://packagist.org/packages/koldown/ioc)[ RSS](/packages/koldown-ioc/feed)WikiDiscussions master Synced 5d ago

READMEChangelog (1)DependenciesVersions (2)Used By (0)

Koldown IoC
-----------

[](#koldown-ioc)

Librería que proporciona un conjunto de clase para implementar los principios de inversión de control (IoC).

Modo de uso
-----------

[](#modo-de-uso)

Lo primero es crear una fábrica `\Koldown\InversionControl\Contracts\IDependenceFactory`, donde se definiran las politicas para instanciar los objetos de clases con sus respectivas dependencias.

```
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();
        }
    }
}

```

En este ejemplo hemos establecido que nuestra fábrica podrá instanciar cualquier clase que se le solicite, sin embargo tenemos dos clases que requieren dependencias para poder realizar su proceso:

```
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);
    }
}

```

Para lograr esto debemos apoyarnos en la clase `Koldown\InversionControl\ClassInstance` que nos permite definir la manera como se construirá una clase con sus respectivas dependencias.

Se debe establer nombre de clave de la dependencia y el tipo de clase a instanciar, donde la clave es un parámetro relevante para realizar esta funcionalidad, por lo que la librería se basa en los principios de inyección de dependencias usando métodos tipo `setter`, por lo tanto en el ejemplo donde definimos que la clave es "operacion", a la hora de construir el objeto se buscará la función "setOperacion" para inyectarle la respectiva dependencia.

Una vez definido nuestra fábrica de objetos, procedemos aplicar el proceso de IoC en concreto, para esto nos apoyamos en la clase `\Koldown\InversionControl\ContainerContext` que es la encargada de gestionar la construcción de los objetos de clases solicitados:

```
$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)}";

```

Hemos generado instancias de dos funciones aritméticas, sin embargo ahora se requiere encapsular esto en una sola clase llamada `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);
    }
}

```

Ahora vamos a nuestra fábrica y agregamos este nuevo caso:

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

```

Como podemos notar podemos definir las clases parametrizadas anteriormente como dependencias de esta nueva clase, la cual durante su etapa de construcción también inyectará las dependencias de sus dependencias.

De tal manera que ya podemos ejecutar nuestro programa de la siguiente manera:

```
$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)}";

```

Si desea ver en detalles el código de este ejercicio entre a la carpeta `example` del repositorio y encontrará los ficheros del ejemplo.

Notas
-----

[](#notas)

La función `setDependence` de la clase `Koldown\InversionControl\ClassInstance` recibe un tercer parámetro `$shared` de tipo `bool`, lo cual permite establecer que la instancia de la dependencia construida será compartida entre las clases que la soliciten durante la ejecución de creación de objetos desde el `\Koldown\InversionControl\ContainerContext`.

###  Health Score

25

—

LowBetter than 37% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity6

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity57

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

2333d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/8c14af889c6a44e0d53695ce5bb020b7f719e8a109fc3273a1c9ec7096e101d6?d=identicon)[kold0410](/maintainers/kold0410)

---

Top Contributors

[![ingdacastillop](https://avatars.githubusercontent.com/u/17519301?v=4)](https://github.com/ingdacastillop "ingdacastillop (6 commits)")

### Embed Badge

![Health badge](/badges/koldown-ioc/health.svg)

```
[![Health](https://phpackages.com/badges/koldown-ioc/health.svg)](https://phpackages.com/packages/koldown-ioc)
```

###  Alternatives

[laravel/telescope

An elegant debug assistant for the Laravel framework.

5.2k67.8M192](/packages/laravel-telescope)[spiral/roadrunner

RoadRunner: High-performance PHP application server and process manager written in Go and powered with plugins

8.4k12.2M84](/packages/spiral-roadrunner)[nolimits4web/swiper

Most modern mobile touch slider and framework with hardware accelerated transitions

41.8k177.2k1](/packages/nolimits4web-swiper)[laravel/dusk

Laravel Dusk provides simple end-to-end testing and browser automation.

1.9k36.7M259](/packages/laravel-dusk)[laravel/prompts

Add beautiful and user-friendly forms to your command-line applications.

708181.8M596](/packages/laravel-prompts)[cakephp/chronos

A simple API extension for DateTime.

1.4k47.7M121](/packages/cakephp-chronos)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)