Als das TYPO3-Entwickler-Team ankündigte, mit TYPO3 Flow (damals noch FLOW3) ein eigenes PHP-Applikations-Framework zu entwickeln, sorgte das für helle Aufregung in der PHP-Gemeinde. Mittlerweile hat sich Flow zu einem eigenständigen Produkt gemausert – auch wenn es ursprünglich nur als Nebenprodukt der CMS-Neuentwicklung TYPO3 Neos entstanden ist.

TYPO3 Flow unterstützt neben Domain-Driven Design moderne Entwurfsprinzipien und Architekturmuster wie die MVC-Architektur oder die aspektorientierte Programmierung. Viele dieser Konzepte stammen – ungewöhnlich für ein PHP-Framework – aus der Java-Welt, vor allem von dem Spring-Framework. Der Artikel zeigt die Entwicklung einer mit Flow realisierten t3n-Autorenverwaltung inklusive Autoren (Author) und Ausgaben (Issue), an denen die jeweiligen Autoren mitgewirkt haben.

Ein möglicher Architekturentwurf für eine einfache Autorenverwaltung.

Da TYPO3 Flow wie Symfony2 und Zend Framework das Paketmanagement-Tool Composer nutzen, lässt sich ein neues TYPO3 Flow-Projekt vergleichsweise einfach aufsetzen. Seit TYPO3 Flow 2.3 wird jedoch PHP in Version 5.5 oder höher vorausgesetzt.

$ curl -s https://getcomposer.org/installer | php
sudo mv composer.phar /usr/bin/composer
$ ./composer.phar create-project typo3/flow-base-distribution t3ntest
$ ./flow help

Nach Eingabe des letzten Befehls sollte der Entwickler die Hilfe-Seite des Flow-Kommandozeilen-Tools angezeigt bekommen – das neue Flow-Projekt wurde somit erfolgreich eingerichtet.

Alle Quelltexte sind in Flow in Paketen organisiert – also sowohl das Framework, das aus mehreren einzelnen Paketen besteht, als auch der eigene Code. Framework-Pakete werden standardmäßig im Verzeichnis Packages/Framework erwartet, eigene Pakete im Verzeichnis Packages/Application.

Eigene Pakete kann man über den mitgelieferten Kickstarter erstellen, der sich über die Kommandozeile bedienen lässt. Das folgende Listing legt zunächst ein neues, leeres Paket mit dem Namen T3n.Authors an und erstellt dann eine Model-Klasse zur Modellierung eines Autors.

$ ./flow package:create T3n.Authors
$ ./flow kickstart:model T3n.Authors Author "name:string"

Die erste Zeile erzeugt ein neues Flow-Paket im Verzeichnis Packages/Application/T3n.Authors. Die zweite Zeile legt eine neue PHP-Klasse mit dem Namen \T3n\Authors\Domain\Model\Author an und speichert sie im Paket unter Classes/T3n/Authors/Domain/Model/Author.php.

Das Beispiel zeigt auch, welchen Konventionen Flow bei der Benennung von Klassen und Dateien folgt: So muss der PHP-Namensraum immer mit dem Paketnamen beginnen. Alle Klassen eines Pakets liegen im Verzeichnis „Classes“ und die Verzeichnisstruktur im Classes-Verzeichnis stimmt mit dem PHP-Namensraum überein. Darüber hinaus liegen Model-Klassen per Konvention immer im Namensraum Domain\Model. Ein Blick in die gerade erstellte PHP-Klasse zeigt den Aufbau der Model-Klassen:

<?php 
namespace T3n\Authors\Domain\Model; 

use TYPO3\Flow\Annotations as Flow; 

/** 
 * @Flow\Entity 
 */ 
class Author {
	/**
	 * @var string
	 */
	protected $name;
	
	// [...] weitere Attribute
	
	/**
	 * @return string
	 */
	public function getName() {
		return $this->name;
	}

	// [...] weitere Getter- und Setter-Methoden	

}

Als Schnittstelle zwischen Model und Datenbank benötigt man in TYPO3 Flow Repositorys. Bei einem Repository handelt es sich um ein Entwurfsmuster, das dazu dient, den Zugriff auf Domänen-Objekte von einer konkreten Persistenzschicht aus zu abstrahieren – so bleibt man auch dann flexibel, wenn zum Beispiel zu einem späteren Zeitpunkt der Wechsel auf eine andere Datenbank nötig ist. Mit folgendem Kommando kann man nun ein Repository für die Model-Klasse erstellen.

$ ./flow kickstart:repository T3n.Authors Author

Das Repository trägt den Klassennamen \T3n\Authors\Domain\Repositoy\AuthorRepository. Die Klasse enthält noch keine eigenen Methoden. Die wichtigsten Methoden, die man braucht, um Objekte dieser Klasse aus der Datenbank zu laden und zu speichern, werden jedoch geerbt.

Fehlt nur noch der Controller, der die Schnittstelle zwischen Geschäftslogik und Nutzereingabe bildet. Mit der folgenden Zeile kann man einen Controller zur Verwaltung von Autoren sowie die dazugehörigen Views erstellen.

$ ./flow kickstart:actioncontroller --generate-actions --generate-templates T3n.Authors Author

Dieser Befehl erstellt einen neuen Controller mit dem Dateinamen Classes/Controller/AuthorController.php sowie diverse Views im Verzeichnis Resources/Private/Templates/Author. Die Controller-Klasse zeigt den grundlegenden Aufbau eines Controllers:

<?php
namespace T3n\Authors\Controller;

use TYPO3\Flow\Annotations as Flow;
use TYPO3\Flow\Mvc\Controller\ActionController; 
use T3n\Authors\Domain\Model\Author;

/** 
 * @Flow\Scope("singleton") 
 */ 
class AuthorController extends ActionController { 

	/**
	 * @Flow\Inject 
	 * @var \T3n\Authors\Domain\Repository\AuthorRepository 
	 */
	protected $authorRepository; 
	
	public function indexAction() {
		$this->view->assign('authors', $this->authorRepository->findAll()); 
	}

	public function showAction(Author $author) { 
		$this->view->assign('author', $author); 
	}

	// Weitere action-Methoden...
}

Der Controller enthält für jede mögliche Benutzerinteraktion eine Action-Methode. Für jede Action existiert im Verzeichnis Resources/Private/Template/<Controller> eine Fluid-Vorlage. Für die Index-Action liegt sie beispielsweise unter Resources/Private/Template/Author/Index.html. Über das Kommando „$this->view->assign“ kann man der View Variablen zuweisen, die sich dort wieder auswerten lassen – doch dazu später mehr.

Interessant ist weiterhin die Annotation @Flow\Inject. Sie sorgt dafür, dass dem Attribut $authorRepository automatisch eine Instanz der angegebenen Klasse zugewiesen wird. Dieses Entwurfsmuster wird auch als Dependency Injection bezeichnet. Um die Erstellung und Zuweisung der Instanzen aller benötigten Klassen kümmert sich das Framework von alleine. Der Entwickler muss an dieser Stelle einfach die @Flow\Inject-Annotation setzen.

An der showAction-Methode lässt sich auch erkennen, dass Flow Benutzereingaben – zum Beispiel in Form von GET- und POST-Parametern – automatisch auf die Methodenparameter abbildet. Wird die show-Action also mit dem Parameter &author=1 aufgerufen, sorgt Flow automatisch dafür, den Autor mit der entsprechenden ID aus der Datenbank zu laden. Diesen Vorgang bezeichnet man als Property Mapping.

Die in diesem Tutorial dargestellte Autorenverwaltung lässt sich mit einer Default-Installation von TYPO3 Flow
im Browser unter http://localhost/t3n.authors/author aufrufen. Die
Abbildung von URLs auf Controller-Actions kann man übrigens über die
Datei „Routes.yaml“ im Order „Configuration“ von TYPO3 Flow frei konfigurieren.

Flow bildet sämtliche Model-Klassen (hier die Author-Klasse) standardmäßig auf Tabellen in einer relationalen Datenbank ab. Genauer gesagt übernimmt das ORM-Framework Doctrine in Flow diese Aufgabe der objektrelationalen Abbildung. Zur Abbildung der Tabellenstruktur – und vor allem der Änderungen daran – arbeitet Doctrine mit so genannten „Migrations“.

Diese kleinen PHP-Skripte werden bei der Installation oder dem Update eines Flow-Pakets ausgeführt und nehmen Änderungen an der Datenbankstruktur vor. Um Doctrine verwenden zu können, muss man Flow zunächst eine Datenbankanbindung vorgeben. Die erfolgt in der Datei Configuration/Development/Settings.yaml.

TYPO3: 
	Flow: 
		persistence:
			backendOptions: 
        		host: '127.0.0.1'
        		dbname: 'quickstart'
        		user: ''
        		password: ''

Für die in Kickstarter erstellten, neuen Model-Klassen benötigt man eine Doctrine-Migration, die die dazugehörige Datenbank-Tabelle erstellt. Dies kann über folgende Kommandozeilenbefehle erfolgen.

$ ./flow doctrine:migrate
$ ./flow doctrine:migrationgenerate

Der letzte Befehl legt eine Migrations-Datei mit den generierten SQL-Befehlen im Verzeichnis Data/DoctrineMigrations an, die man noch mal überprüfen und bennen sollte, um sie danach in das Verzeichnis Migrations/Mysql im eigenen Paket zu verschieben. Anschließend lässt sich die neue Migration mit einem weiteren ./flow doctrine:migrate ausführen und somit zum Beispiel ein Live-System auf das neueste Datenbank-Schema aktualisieren, nachdem eine neue Version eines Projekts live geschaltet wurde.

Die eigens für Flow entwickelte Template-Engine Fluid wertet die Views aus, die zuvor mit dem Kickstarter im Verzeichnis Resources/Private/Templates/Author erstellt wurden. Interessant ist zunächst die Datei Resources/Private/Layouts/Default.html. Sie dient als Grundgerüst für alle späteren Views und enthält spezielle „Sections“, die sich in den einzelnen Views mit Inhalt füllen lassen. Die Index-View sieht zum Beispiel vereinfacht dargestellt wie folgt aus:

<f:layout name="Default" /> 
<f:section name="Title">List of authors</f:section> 
<f:section name="Content"> 
	<ul>
		<f:for each="{authors}" as="author">
		<li>
		<f:link.action action="show" arguments="{author: author}">{author.name}</f:link.action> 
		<f:link.action action="edit" arguments="{author: author}">Edit</f:link.action> 
		<f:link.action action="delete" arguments="{author: author}">Delete</f:link.action> 
		</li> 
		</f:for>
	</ul>
	<p><f:link.action action="new">Create a new author</f:link.action></p> 
</f:section>

Zur Erinnerung: Unter dem Namen „authors“ erhielt die View im Controller in der index-Action eine Liste aller in der Datenbank verfügbaren Autoren. In der Fluid-View lässt sich diese nun iterieren und wird als eine Liste aller Autoren in HTML ausgegeben. Die Template-Sprache Fluid ermöglicht dabei Kontrollstrukturen wie Bedingungen und Schleifen (wie zum Beispiel die f:for-Schleife im obigen Beispiel). Das Ausführen von PHP-Code oder erweiterter Programmlogik ist in Fluid explizit nicht erlaubt. Wer über die Grundfunktionen von Fluid hinaus den Sprachumfang erweitern möchte (z.B. mit einem Gravatar-Helper), kann dies durch eigene View-Helper tun.

TYPO3 Flow bringt mit seiner aus der Java-Welt inspirierten Ansätzen frischen Wind in die PHP-Framework-Szene – ohne es dem Anwender unnötig kompliziert zu machen. Man muss kein Experte sein, um die ersten Gehversuche mit dem Framework erfolgreich zu bestehen, Anwendungen damit umzusetzen und die Stärken kennen zu lernen.

Die Performance des Frameworks – in den frühen Versionen noch einer der größten Kritikpunkte – hat sich mit den letzten veröffentlichten Versionen aufgrund zahlreicher Optimierungen massiv verbessert. Somit besteht aller Grund zur Hoffnung, dass sich TYPO3 Flow auf lange Sicht erfolgeich neben den etablierten Frameworks wie Symfony oder dem Zend Framework 2 wird behaupten können.