Generierte Fabriken

*******************

.[perex]

Nette DI kann automatisch Code für Fabriken basierend auf Schnittstellen generieren, was Ihnen das Schreiben von Code erspart.

Eine Fabrik ist eine Klasse, die Objekte herstellt und konfiguriert. Sie übergibt ihnen also auch ihre Abhängigkeiten. Bitte verwechseln Sie dies nicht mit dem Entwurfsmuster *Factory Method*, das eine spezifische Art der Verwendung von Fabriken beschreibt und mit diesem Thema nichts zu tun hat.

Wie eine solche Fabrik aussieht, haben wir im [Einführungskapitel |introduction#Fabrik] gezeigt:

```php

class ArticleFactory

{

public function __construct(

private Nette\Database\Connection $db,

) {

}

public function create(): Article

{

return new Article($this->db);

}

}

```

Nette DI kann den Code von Fabriken automatisch generieren. Alles, was Sie tun müssen, ist, eine Schnittstelle zu erstellen, und Nette DI generiert die Implementierung. Die Schnittstelle muss genau eine Methode namens `create` haben und einen Rückgabetyp deklarieren:

```php

interface ArticleFactory

{

function create(): Article;

}

```

Die Fabrik `ArticleFactory` hat also eine Methode `create`, die `Article`-Objekte erstellt. Die Klasse `Article` könnte beispielsweise so aussehen:

```php

class Article

{

public function __construct(

private Nette\Database\Connection $db,

) {

}

}

```

Wir fügen die Fabrik zur Konfigurationsdatei hinzu:

```neon

services:

- ArticleFactory

```

Nette DI generiert die entsprechende Implementierung der Fabrik.

Im Code, der die Fabrik verwendet, fordern wir das Objekt über die Schnittstelle an, und Nette DI verwendet die generierte Implementierung:

```php

class UserController

{

public function __construct(

private ArticleFactory $articleFactory,

) {

}

public function foo()

{

// lassen wir die Fabrik das Objekt erstellen

$article = $this->articleFactory->create();

}

}

```

Parametrisierte Fabrik

======================

Die Fabrikmethode `create` kann Parameter annehmen, die sie dann an den Konstruktor weitergibt. Ergänzen wir beispielsweise die Klasse `Article` um die ID des Artikelautors:

```php

class Article

{

public function __construct(

private Nette\Database\Connection $db,

private int $authorId,

) {

}

}

```

Wir fügen den Parameter auch zur Fabrik hinzu:

```php

interface ArticleFactory

{

function create(int $authorId): Article;

}

```

Da der Parameter im Konstruktor und der Parameter in der Fabrik denselben Namen haben, übergibt Nette DI sie vollautomatisch.

Erweiterte Definition

=====================

Die Definition kann auch in mehrzeiliger Form unter Verwendung des Schlüssels `implement` geschrieben werden:

```neon

services:

articleFactory:

implement: ArticleFactory

```

Bei dieser längeren Schreibweise können zusätzliche Argumente für den Konstruktor im Schlüssel `arguments` und zusätzliche Konfigurationen mittels `setup` angegeben werden, genau wie bei regulären Diensten.

Beispiel: Wenn die Methode `create()` den Parameter `$authorId` nicht akzeptieren würde, könnten wir einen festen Wert in der Konfiguration angeben, der an den Konstruktor von `Article` übergeben würde:

```neon

services:

articleFactory:

implement: ArticleFactory

arguments:

authorId: 123

```

Oder umgekehrt, wenn `create()` den Parameter `$authorId` akzeptieren würde, aber er nicht Teil des Konstruktors wäre und über die Methode `Article::setAuthorId()` übergeben würde, würden wir im Abschnitt `setup` darauf verweisen:

```neon

services:

articleFactory:

implement: ArticleFactory

setup:

- setAuthorId($authorId)

```

Accessor

========

Nette kann neben Fabriken auch sogenannte Accessoren generieren. Dies sind Objekte mit einer `get()`-Methode, die einen bestimmten Dienst aus dem DI-Container zurückgibt. Wiederholte Aufrufe von `get()` geben immer dieselbe Instanz zurück.

Accessoren ermöglichen Lazy-Loading für Abhängigkeiten. Nehmen wir an, wir haben eine Klasse, die Fehler in eine spezielle Datenbank schreibt. Wenn diese Klasse die Datenbankverbindung als Abhängigkeit im Konstruktor übergeben bekäme, müsste die Verbindung immer erstellt werden, obwohl in der Praxis ein Fehler nur selten auftritt und die Verbindung daher meist ungenutzt bliebe. Stattdessen übergibt sich die Klasse einen Accessor, und erst wenn dessen `get()` aufgerufen wird, wird das Datenbankobjekt erstellt:

Wie erstellt man einen Accessor? Schreiben Sie einfach eine Schnittstelle, und Nette DI generiert die Implementierung. Die Schnittstelle muss genau eine Methode namens `get` haben und einen Rückgabetyp deklarieren:

```php

interface PDOAccessor

{

function get(): PDO;

}

```

Wir fügen den Accessor zur Konfigurationsdatei hinzu, wo auch die Definition des Dienstes steht, den er zurückgeben wird:

```neon

services:

- PDOAccessor

- PDO(%dsn%, %user%, %password%)

```

Da der Accessor einen Dienst vom Typ `PDO` zurückgibt und in der Konfiguration nur ein solcher Dienst vorhanden ist, wird er genau diesen zurückgeben. Wenn es mehrere Dienste dieses Typs gäbe, würden wir den zurückgegebenen Dienst anhand seines Namens bestimmen, z. B. `- PDOAccessor(@db1)`.

Mehrfachfabrik/-accessor

========================

Unsere Fabriken und Accessoren konnten bisher immer nur ein Objekt herstellen oder zurückgeben. Es ist jedoch sehr einfach, auch Mehrfachfabriken in Kombination mit Accessoren zu erstellen. Die Schnittstelle einer solchen Klasse enthält eine beliebige Anzahl von Methoden mit den Namen `create<name>()` und `get<name>()`, z. B.:

```php

interface MultiFactory

{

function createArticle(): Article;

function getDb(): PDO;

}

```

Anstatt also mehrere generierte Fabriken und Accessoren zu übergeben, übergeben wir eine komplexere Fabrik, die mehr kann.

Alternativ kann anstelle mehrerer Methoden `get()` mit einem Parameter verwendet werden:

```php

interface MultiFactoryAlt

{

function get($name): PDO;

}

```

Dann gilt, dass `MultiFactory::getArticle()` dasselbe tut wie `MultiFactoryAlt::get('article')`. Die alternative Schreibweise hat jedoch den Nachteil, dass nicht ersichtlich ist, welche Werte für `$name` unterstützt werden, und logischerweise können in der Schnittstelle auch keine unterschiedlichen Rückgabewerte für verschiedene `$name` unterschieden werden.

Definition durch Liste

----------------------

Auf diese Weise kann eine Mehrfachfabrik in der Konfiguration definiert werden: .{data-version:3.2.0}

```neon

services:

- MultiFactory(

article: Article # definiert createArticle()

db: PDO(%dsn%, %user%, %password%) # definiert getDb()

)

```

Oder wir können uns in der Fabrikdefinition mittels Referenz auf bestehende Dienste beziehen:

```neon

services:

article: Article

- PDO(%dsn%, %user%, %password%)

- MultiFactory(

article: @article # definiert createArticle()

db: @\PDO # definiert getDb()

)

```

Definition mittels Tags

-----------------------

Die zweite Möglichkeit ist, zur Definition [Tags |services#Tags] zu verwenden:

```neon

services:

- App\Core\RouterFactory::createRouter

- App\Model\DatabaseAccessor(

db1: @database.db1.explorer

)

```