Che cos'è il contenitore DI?
****************************

.[perex]
Il dependency injection container (DIC) è una classe che può istanziare e configurare oggetti.

Può sorprendere, ma in molti casi non è necessario un contenitore per l'iniezione di dipendenza (dependency injection container) per trarre vantaggio dall'iniezione di dipendenza (DI in breve). Dopo tutto, anche nel [capitolo precedente |introduction] abbiamo mostrato esempi specifici di DI e non è stato necessario alcun contenitore.

Tuttavia, se è necessario gestire un gran numero di oggetti diversi con molte dipendenze, un contenitore di dependency injection sarà davvero utile. Questo è forse il caso delle applicazioni web costruite su un framework.

Nel capitolo precedente, abbiamo introdotto le classi `Article` e `UserController`. Entrambe hanno alcune dipendenze, ovvero il database e il factory `ArticleFactory`. Per queste classi, ora creeremo un contenitore. Naturalmente, per un esempio così semplice, non ha senso avere un contenitore. Ma ne creeremo uno per mostrare l'aspetto e il funzionamento.

Ecco un semplice contenitore codificato per l'esempio precedente:

```php
class Container
{
	public function createDatabase(): Nette\Database\Connection
	{
		return new Nette\Database\Connection('mysql:', 'root', '***');
	}

	public function createArticleFactory(): ArticleFactory
	{
		return new ArticleFactory($this->createDatabase());
	}

	public function createUserController(): UserController
	{
		return new UserController($this->createArticleFactory());
	}
}
```

L'uso sarebbe simile a questo:

```php
$container = new Container;
$controller = $container->createUserController();
```

Basta chiedere al contenitore l'oggetto e non è più necessario sapere come crearlo o quali sono le sue dipendenze; il contenitore sa tutto. Le dipendenze vengono iniettate automaticamente dal contenitore. Questo è il suo potere.

Finora, il contenitore ha tutto codificato. Quindi facciamo il passo successivo e aggiungiamo dei parametri per rendere il contenitore davvero utile:

```php
class Container
{
	public function __construct(
		private array $parameters,
	) {
	}

	public function createDatabase(): Nette\Database\Connection
	{
		return new Nette\Database\Connection(
			$this->parameters['db.dsn'],
			$this->parameters['db.user'],
			$this->parameters['db.password'],
		);
	}

	// ...
}

$container = new Container([
	'db.dsn' => 'mysql:',
	'db.user' => 'root',
	'db.password' => '***',
]);
```

I lettori più attenti avranno notato un problema. Ogni volta che ottengo un oggetto `UserController`, viene creata anche una nuova istanza `ArticleFactory` e un database. Questo non lo vogliamo assolutamente.

Aggiungiamo quindi un metodo `getService()` che restituirà sempre le stesse istanze:

```php
class Container
{
	private array $services = [];

	public function __construct(
		private array $parameters,
	) {
	}

	public function getService(string $name): object
	{
		if (!isset($this->services[$name])) {
			// getService('Database') chiama createDatabase()
			$method = 'create' . $name;
			$this->services[$name] = $this->$method();
		}
		return $this->services[$name];
	}

	// ...
}
```

La prima chiamata ad esempio a `$container->getService('Database')` farà sì che `createDatabase()` crei un oggetto database, che memorizzerà nell'array `$services` e lo restituirà direttamente alla chiamata successiva.

Modifichiamo anche il resto del contenitore per usare `getService()`:

```php
class Container
{
	// ...

	public function createArticleFactory(): ArticleFactory
	{
		return new ArticleFactory($this->getService('Database'));
	}

	public function createUserController(): UserController
	{
		return new UserController($this->getService('ArticleFactory'));
	}
}
```

A proposito, il termine servizio si riferisce a qualsiasi oggetto gestito dal contenitore. Da qui il nome del metodo `getService()`.

Fatto. Abbiamo un contenitore DI completamente funzionante! E possiamo usarlo:

```php
$container = new Container([
	'db.dsn' => 'mysql:',
	'db.user' => 'root',
	'db.password' => '***',
]);

$controller = $container->getService('UserController');
$database = $container->getService('Database');
```

Come si può vedere, non è difficile scrivere un DI. È da notare che gli oggetti stessi non sanno che un contenitore li sta creando. Pertanto, è possibile creare qualsiasi oggetto in PHP in questo modo, senza modificare il codice sorgente.

Creare e mantenere manualmente una classe contenitore può diventare un incubo piuttosto rapidamente. Pertanto, nel prossimo capitolo parleremo di [Nette DI Container |nette-container], che può generare e aggiornare se stesso in modo quasi automatico.