PHPackages                             wlib/dibox - 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. [PSR & Standards](/categories/psr-standards)
4. /
5. wlib/dibox

ActiveLibrary[PSR & Standards](/categories/psr-standards)

wlib/dibox
==========

DiBox is a Dependency Injection Container.

v1.3.1(1y ago)0321CECILL-2.1PHPPHP >=7.4.0

Since Jul 14Pushed 11mo ago1 watchersCompare

[ Source](https://github.com/SamRay1024/wlib-dibox)[ Packagist](https://packagist.org/packages/wlib/dibox)[ RSS](/packages/wlib-dibox/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (5)Dependencies (2)Versions (7)Used By (1)

wlib/dibox
==========

[](#wlibdibox)

DiBox est un conteneur d'injection de dépendances. Il suit la directive [PSR-11](https://www.php-fig.org/psr/psr-11/).

Installation
------------

[](#installation)

```
composer require wlib/dibox
```

Utilisation
-----------

[](#utilisation)

```
use wlib\Di\DiBox;

$box = new DiBox();
```

### Instancier vos objets

[](#instancier-vos-objets)

Le conteneur peut servir pour simplement instancier vos objets :

```
// Créer une instance de Foo\Bar
$bar = $box->make(Foo\Bar::class);

// Passer des arguments au constructeur
$bar = $box->make(Foo\Bar::class, ['a', 'b']); // indexés
$bar = $box->make(Foo\Bar::class, ['sGreetings' => 'Hello']); // nommés, ici, le constructeur attend l'entrée `$sGreetings`
```

L'avantage de passer par le conteneur est de disposer de la **résolution automatique des classes** que vos constructeurs attendent :

```
class Bar { public function __construct(public Baz $baz); }
class Baz {}

$bar = $box->make(Bar::class);

// $bar->baz sera une instance de Baz
```

### Déclarer vos dépendances

[](#déclarer-vos-dépendances)

Instancier c'est déjà pas mal, mais définir des dépendances c'est encore mieux, surtout pour construire votre application :

#### Dépendance directe

[](#dépendance-directe)

Pas forcément le plus utile, mais ça fonctionne :

```
$box->bind(Foo\Bar::class);
$bar = $box->get(Foo\Bar::class); // instance de Foo\Bar
```

#### Créer un alias

[](#créer-un-alias)

Pour mettre des surnoms à tout le monde (ou mettre de l'ordre dans votre conteneur, c'est selon) :

```
$box->bind('MyBar', Foo\Bar::class);
$bar = $box->get('MyBar'); // toujours une instance de Foo\Bar mais depuis son p'tit nom
```

#### Instance existante

[](#instance-existante)

Si besoin :

```
$bar = new Foo\Bar();
$box->bind('MyBar', $bar);
$samebar = $box->get('MyBar'); // toujours pareil !
```

#### Fermeture de création

[](#fermeture-de-création)

Ou `Closure` pour les initiés ;-). C'est là que les choses sérieuses commencent et que ça devient intéressant :

```
$box->bind('MyBaz', function($box, $args)
{
	return new Foo\Baz($box->get('MyBar'));
});

$baz = $box->get('MyBaz'); // instance de Foo\Baz prête à bosser, classe non ?

```

Vous voyez donc l'étendue des possibles qui s'offre devant vos yeux ébahis !

#### Valeurs scalaires

[](#valeurs-scalaires)

Qui peut le plus, peut le moins, vous pouvez aussi stocker de simples valeurs dans le conteneur :

```
$box->bind('one.string', 'DiBox has all of a great one !');
$box->bind('one.integer', 2023);
$box->bind('one.array', [1, 2, 3]);

echo $box->get('one.string'));  // Affiche "DiBox has ...')
echo $box->get('one.integer')); // Affiche "2023"
echo $box->get('one.array'));   // Attention piège, ça affiche quoi ?

```

#### Mode "ArrayAccess"

[](#mode-arrayaccess)

Le conteneur implémente l'interface `ArrayAccess` :

```
$box['make.b']   = function ($box, $args) { return new B(new A()); };
$box['integer']  = 4046;
$box['list']     = ['a', 'b', 'c'];
$box['class.a']  = A::class;

$b        = $box['make.b'];  // instance de B
$iInteger = $box['integer']; // 4096
$aList    = $box['list'];    // cf. 5 lignes au dessus
$a        = $box['class.a']; // bon, vous maîtrisez normalement
```

Du coup, vous pouvez faire usage de `isset()` et `unset()` :

```
unset($box['class.a']);
isset($box['class.a']); // >> false
```

#### Dépendances partagées (singletons)

[](#dépendances-partagées-singletons)

Vous pouvez, si besoin, partager des dépendances : le mode "singleton" (mais en mieux, car, comme vous le savez [faire des vrais singletons n'est pas toujours une bonne pratique même si c'est pratique](https://doc.nette.org/fr/dependency-injection/global-state)) :

```
class Counter
{
    protected $count = 0;

    public function increment(): int
    {
        return $this->count++;
    }
}

$box->singleton(Counter::class);

echo $box->get(Counter::class)->increment(); // 0
echo $box->get(Counter::class)->increment(); // 1
echo $box->get(Counter::class)->increment(); //	2
```

### Autres méthodes

[](#autres-méthodes)

Ci-après, à connaître :

```
$box->has('MyBar');    // pour vérifier la présense d'une dépendance
$box->remove('MyBar'); // pour retirer cette dépendance que vous ne voulez plus voir
$box->empty();         // pour vider le conteneur
```

Fournisseurs de dépendances
---------------------------

[](#fournisseurs-de-dépendances)

Vous êtes encore là ? C'est bien beau, on peut déclarer plein de dépendances et alimenter comme on veut le conteneur mais vous êtes probablement en train de développer une application qui ne connaît peut être pas encore toutes les dépendances qu'elle aura à gérer, ou, vous voulez simplement organiser tout ça dans vos différents namespaces / packages.

Vous avez donc besoin de créer des fournisseurs, qui viendront injecter les dépendances dont ils ont la responsabilité dans l'un de vos conteneurs.

Il est donc temps d'implémenter le contrat `wlib\Di\DiBoxProvider` :

```
// Exemple (classique ?) d'un fournisseur des services HTTP d'une application
class HttpProvider implements DiBoxProvider
{
	public function provide(DiBox $box)
	{
		$box->bind('http.request', function($box, $args)
		{
			return MyApp\Http\Request();
		});

		$box->bind('http.response', function($box, $args)
		{
			return MyApp\Http\Response($box['http.request']);
		});
	}
}

// Et pour le fournir au conteneur, rien de plus simple :
$box->register(HttpProvider::class);

$response = $box->get('http.response'); // Et vous avez une réponse HTTP prête à servir vos applications / API
```

Voilà, vous maîtrisez ! À vous de jouer.

Exceptions
----------

[](#exceptions)

Il est possible, en cas de malfonction, volontaire ou fortuite, que `DiBox` lève les exceptions suivantes :

- `wlib\Di\DiException` : levée au moindre truc qui chagrine le conteneur,
- `wlib\Di\DiNotFoundException` : conforme à **PSR-11**, levée si vous tentez d'accèder à une dépendance qui n'existe pas.

Tests unitaires
---------------

[](#tests-unitaires)

N'hésitez pas à prendre connaissance du fichier `/tests/Unit/DiBoxTest.php` qui vous donnera quelques détails techniques supplémentaires sur l'utilisation de `DiBox`.

Les tests unitaires font usage de la libraire [Pest](https://pestphp.com/).

###  Health Score

30

—

LowBetter than 64% of packages

Maintenance49

Moderate activity, may be stable

Popularity7

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity48

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

Every ~125 days

Recently: every ~135 days

Total

6

Last Release

412d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/e6e3b6cbcc3109815e57326009b00cbf41ed1c31b95b74eb58330c535092383d?d=identicon)[SamRay1024](/maintainers/SamRay1024)

---

Top Contributors

[![SamRay1024](https://avatars.githubusercontent.com/u/4489805?v=4)](https://github.com/SamRay1024 "SamRay1024 (2 commits)")

---

Tags

containerdependencyinjectiondipsr11wlib

###  Code Quality

TestsPest

### Embed Badge

![Health badge](/badges/wlib-dibox/health.svg)

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

###  Alternatives

[league/container

A fast and intuitive dependency injection container.

86387.8M343](/packages/league-container)[capsule/di

A PSR-11 compliant autowiring dependency injection container.

2857.5k2](/packages/capsule-di)[miladrahimi/phpcontainer

Dependency injection (IoC) container for PHP projects

1322.7k2](/packages/miladrahimi-phpcontainer)

PHPackages © 2026

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