© Vladimir D Ivanovic, 123RF.com

Eigentlich sollte Flow3 nur der Unterbau einer neuen Typo3-Version werden. Nach mehrjähriger Entwicklung kam Ende Oktober 2011 jedoch ein modernes PHP-Framework heraus, in dessen Kielwasser Enterprise-Webanwendungen rasch Fahrt aufnehmen.

Im Jahr 2007 wardas Contentmanagement-System Typo3 in die Jahre gekommen. Zwar erfreute sich die Open-Source-Software anhaltender Beliebtheit, ihr gewachsener Unterbau hatte jedoch eine Generalüberholung nötig. Die dazu erforderlichen umfangreichen Umbauarbeiten hätten allerdings die Stabilität des kompletten Systems gefährdet. Also entschlossen sich die Typo3-Entwickler, die Version 5 (Codename Phoenix) komplett neu zu schreiben.

Im ersten Schritt sollte dazu ein moderner Unterbau her, der aktuellen Entwicklungs- und Programmierkonzepten folgt. An diese Aufgabe wagten sich Robert Lemke und Karsten Dambekalns sowie zahlreiche freiwillige Helfer aus der Typo3-Gemeinde. Fünf Jahre später können die Entwickler ein interessantes Framework vorweisen, das sich auch unabhängig von Typo3 zum Schreiben großer Webanwendungen eignet. Die erste stabile Version des Flow3 [1] getauften Systems erschien Ende Oktober 2011. Vorausgegangen waren zahlreiche Vorab- und Testversionen, die Entwickler bauten Flow3 im Laufe der Zeit sogar mehrfach komplett um.

Das hielt jedoch ein großes Unternehmen in Deutschland nicht davon ab, bereits auf den Vorabversionen seine Kundendatenbank aufzubauen [2]. Welches Unternehmen das ist, mochten die Entwickler bislang nicht verraten. Flow3 erscheint jedenfalls so attraktiv, dass sich eine genauere Inspektion lohnt.

Buzzword-Bingo

Im Kern ist Flow3 eine Sammlung von PHP-Klassen, mit denen man schnell eine eigene Webanwendung stricken kann. So muss sich der Anwendungsentwickler beispielsweise nicht mehr selbst darum kümmern, einzelne PHP-Objekte irgendwie in eine relationale Datenbank zu pressen. Flow3 soll vor allem mittlere und große Webanwendungen antreiben. Deren Entwicklung erfordert eine gute und geordnete Planung. Daher setzt Flow3 auf Entwurfsmuster und moderne Programmiertechniken. Dazu zählen in erster Linie Model-View-Controller (MVC), Dependency Injection, Domain-Driven-Design und aspektorientierte Programmierung. Hinzu kommt eine exzessive Nutzung der in PHP 5.3 eingeführten Namensräume (Namespaces) sowie der eigentlich von PHP gar nicht unterstützten Annotationen.

Wem jetzt ob der vielen Begriffe der Kopf schwirrt, der sei beruhigt: Wer in Flow3 einsteigen möchte, muss lediglich mit der objektorientierten Programmierung und dem Model-View-Controller-Konzept vertraut sein.

Model, View und Controller

Jede Flow3-Anwendung besteht aus mehreren Teilen (Abbildung 1): Wann immer der Benutzer eine Aktion auslöst, aktiviert Flow3 einen so genannten Controller. Der übernimmt die Kontrolle und leitet alle weiteren Maßnahmen ein. Benötigt er Informationen aus der Datenbank, befragt er ein Repository. Dies zapft die Datenbank an und verpackt das zurückgelieferte Ergebnis in ein handliches PHP-Objekt, das so genannte Model. Das Repository spricht übrigens nicht direkt mit der Datenbank, es greift im Hintergrund auf das in Flow3 integrierte Framework Doctrine 2 zurück [3].

Letzter Helfer im Bunde ist die View. Sie bastelt aus den Informationen im Model und einer Layout-Vorlage die fertige Webseite. Dabei zur Hand geht ihr die eigens für Flow3 entwickelte Template-Engine namens Fluid. Dies ermöglicht es dem Framework zugleich, Inhalte und Optik geschickt zu trennen.

Das alles klingt ziemlich aufwändig. Für eine komplette Adressen-Anwendung oder eine kleine Filmdatenbank benötigt man jedoch lediglich drei eigene PHP-Klassen und eine mit Fluid-Befehlen angereicherte HTML-Datei. Und selbst diese vier generiert Flow3 auf Wunsch halbautomatisch.

Für eine Flow3-Installation sind zunächst ein Webserver und PHP ab Version 5.3.2 erforderlich. Diese im Vergleich zu anderen Contentmanagement-Systemen recht hohe PHP-Version ist unter anderem den verwendeten Namespaces geschuldet. Als Webserver empfehlen die Flow3-Entwickler Apache 2 mit aktiviertem »mod_rewrite« -Modul.

Wer Daten speichern möchte, braucht noch eine Datenbank. Flow3 kommt mit allen zurecht, für die ein PDO-Treiber existiert, darunter natürlich die beliebte MySQL [4]. Eine passende Laufzeitumgebung stellt beispielsweise XAMPP [5] dar, unter Ubuntu 11.10 installiert man alternativ die Pakete »apache2« , »mysql-server« , »php5« , »php5-cli« und »php5-mysql« .

Sind alle Voraussetzungen erfüllt, lädt der Anwender das Flow3-Archiv herunter und entpackt es im »DocumentRoot« -Verzeichnis – unter Ubuntu wäre dies »/var/www« , bei XAMPP »/opt/lampp/htdocs« . Dabei entsteht der Ordner »FLOW3-1.0.0« mit den Unterverzeichnissen aus Tabelle 1. Das »Web« -Verzeichnis beziehungsweise die darin liegende Datei »index.php« ist der zentrale Einsprungspunkt der neuen Webanwendung – sie steuert der Benutzer mit seinem Browser an. Flow3 selbst steckt vollständig in »Packages/Framework« , bei einem Update ist folglich nur diesen Ordner zu aktualisieren.

Rechtsschutz

Während des Betriebs schreibt Flow3 immer wieder in einige seiner Verzeichnisse. Folglich muss der Admin dem Benutzer, unter dem der Webserver läuft, entsprechende Schreibrechte einräumen. Das allein reicht aber noch nicht aus: Über ein Hilfsskript lässt sich Flow3 auch über die Kommandozeile starten. Der Anwendungsentwickler benötigt somit ebenfalls Schreibrechte. Um all dies sicherzustellen, wechselt man im Terminal ins Unterverzeichnis »FLOW3-1.0.0« und startet das dort lagernde Skript »flow3« :

sudo ./flow3 core:setfilepermissionstim www-data www-data

Dabei ist das erste »www-data« jener Benutzer, unter dem der Webserver läuft, das hinterste »www-data« dessen Gruppe und »tim« schließlich der Benutzername des Anwendungsentwicklers. Der obige Befehl ist für Ubuntu gedacht (Abbildung 2), XAMPP-Nutzer verwenden:

sudo /opt/lampp/bin/php flow3 core:setfilepermissions tim nobody nogroup

Dieser Befehl setzt aber nur die Dateirechte. Es ist zudem sicherzustellen, dass der Anwendungsentwickler auch in der Benutzergruppe des Webservers steht.

Kickstart

Nun lässt sich mit dem Browser die URL »http://localhost/FLOW3-1.0.0/Web« ansteuern. Es dauert ein paar Sekunden, bis Flow3 seinen Initialisierungsvorgang abgeschlossen hat. Zumindest während der Entwicklung sollte allen PHP-Skripten mindestens 250 MByte Hauptspeicher zur Verfügung stehen. Gegebenenfalls muss man dazu das »memory_limit« in der »php.ini« heraufsetzen. Hat die Initialisierung geklappt, erscheint die Seite aus Abbildung 3.

Wer Apache 2 mit aktiviertem »mod_rewrite« einsetzt, bekommt sie jedoch sehr wahrscheinlich nicht zu Gesicht – das ist etwa in einer XAMPP-Umgebung der Fall. Abhilfe schafft ein virtueller Host, der zur Flow3-Installation führt. Unter XAMPP fügt der Benutzer dazu der Konfigurationsdatei »/opt/lampp/etc/httpd.conf« die Zeilen aus Listing 1 hinzu: Die Datei »/etc/hosts« erhält zusätzlich folgende Zeile:

01 NameVirtualHost *:80
02
03 <VirtualHost *:80>
04     DocumentRoot /opt/lampp/htdocs/FLOW3-1.0.0/Web/
05     ServerName beispiel.local
06 </VirtualHost>

127.0.0.1 beispiel.local

Danach ist ein Neustart des Webservers erforderlich, bevor unter »http://beispiel.local« die gewünschte Seite zu sehen ist. Erscheint die Seite aus Abbildung 3, ist Flow3 einsatzbereit.

Packstation

Alle PHP-Dateien und Ressourcen einer Anwendung fasst Flow3 in Paketen (Packages) zusammen. Jedes Paket erhält einen eindeutigen Namen, den so genannten Package Key. Er setzt sich aus dem Firmennamen des Entwicklers und einem frei wählbaren Paketnamen zusammen. Möchte beispielsweise die Roxy GmbH eine Verwaltung für Kinofilme erstellen, könnte sie alle dazu gehörenden PHP-Dateien in ein Paket namens »Roxy.Filme« stecken.

Die Dateien und Ressourcen eines Pakets lagern unter »Packages/Application« in jeweils einem eigenen Verzeichnis, das wiederum den Namen des Pakets trägt. Die Dateien der Roxy GmbH finden ihren Platz folglich unter »FLOW3-1.0.0/Packages/Application/Roxy.Filme« .

Darin liegt der PHP-Code aber nicht einfach lose herum, er hat einer festen Verzeichnisstruktur zu folgen. Die könnte der Anwender mühsam per Hand anlegen – oder er überlässt die Arbeit einfach wieder dem »flow3« -Skript. Der folgende Befehl erzeugt das »Roxy.Filme« -Paket:

./flow3 kickstart:package Roxy.Filme

In »Packages/Application/Roxy.Filme« befinden sich jetzt die Unterverzeichnisse aus Tabelle 2. Darüber hinaus hat Flow3 bereits einen einfachen Controller namens »Standard« angelegt, der bei seinem Aufruf einen Nonsens-Text ausspuckt. Er lässt sich im Browser über die URL »http://localhost/FLOW3-1.0.0/Web/index.php/Roxy.Filme/Standard« aufrufen (mit virtuellem Host unter »http://beispiel.local/Roxy.Filme/Standard« ). Das Ergebnis zeigt Abbildung 4. Anhand der URL erkennt Flow3 also, welchen Controller in welchem Package es aufrufen muss.

Lagerhalle

Die Roxy GmbH möchte allerdings keinen Dummytext ausgeben, sondern eine Liste mit Filmen verwalten. Alle Streifen sollen dabei in einer Datenbank aufgehoben sein. In welcher Datenbank genau, muss der Anwender über eine entsprechende Konfigurationsdatei Flow3 mitteilen. Im Fall einer MySQL-Datenbank erstellt er im Verzeichnis »/FLOW3-1.0.0/Configuration« die neue Datei »Settings.yaml« und füllt sie wie in Listing 2.

01 TYPO3:
02   FLOW3:
03     persistence:
04      backendOptions:
05       driver: 'pdo_mysql'
06       dbname: 'filme' # Name der Datenbank
07       user: 'root'        # Benutzer der Datenbank
08       password: 'geheim'  # Passwort der Datenbank
09       host: '127.0.0.1'   # Datenbank-Host

Den Datenbanknamen (»dbname« ), den Benutzernamen (»user« ) und das Passwort muss er an die eigenen Gegebenheiten anpassen. Unter Ubuntu und XAMPP heißt der Benutzer »root« , das Passwort ist bei XAMPP leer. Konfigurationsdateien erwartet Flow3 immer im Yaml-Format [6]. In dieser Auszeichnungssprache spielen die Einrückungen eine wichtige Rolle: Pro Ebene sind dabei jeweils zwei Leerzeichen zu verwenden. Eine kommentierte Vorlage für »Settings.yaml« gibt es unter »/FLOW3-1.0.0/Configuration/Settings.yaml.example« .

Die Datenbank – im Beispiel heißt sie »filme« – legt Flow3 im Gegensatz zu anderen CMS nicht selbst an. Der Anwender muss das per Kommandozeile tun:

mysql -u root
CREATE DATABASE filme;
exit

Unter XAMPP steckt »mysql« im Unterverzeichnis »/opt/lampp/bin« . Sobald die Datenbank existiert, erzeugt

./flow3 doctrine:migrate

darin alle von Flow3 benötigten Datenbanktabellen.

Model-Bau

Als Nächstes teilt der Anwendungsentwickler Flow3 mit, welche Daten es in der Datenbank unterbringen soll. Dazu legt er ein passendes Model an. In Flow3 sind Models nichts anderes als einfache PHP-Objekte. Die Filmverwaltung braucht also nur eine Klasse, die die Daten eines Films kapselt. Der Einfachheit halber sollen das hier nur der Filmname und eine Kurzbeschreibung sein.

Eine passende PHP-Klasse erzeugt das »flow3« -Skript:

./flow3 kickstart:model Roxy.Filme Filmtitel:string beschreibung:string

Demnach soll das Framework eine Klasse »Film« anlegen, die zum Paket »Roxy.Filme« gehört. Sie kapselt zwei Member-Variablen namens »titel« und »beschreibung« , die Zeichenketten aufnehmen (»string« ). Die Klasse »Film« liegt in der Datei »/FLOW3-1.0.0/Packages/Application/Roxy.Filme/Classes/Domain/Model/Film.php« . Wie Listing 3 zeigt, besteht sie nur aus den zwei Variablen nebst Getter- und Setter-Methoden.

01 <?php
02 namespace Roxy\Filme\Domain\Model;
03 use TYPO3\FLOW3\Annotations as FLOW3;
04
05 /**
06  * @FLOW3\Scope("prototype")
07  * @FLOW3\Entity
08  */
09 class Film {
10
11         /**
12          * @var string
13          */
14         protected $titel;
15
16         /**
17          * @var string
18          */
19         protected $beschreibung;
20
21         /**
22          * @return string The Film's titel
23          */
24         public function getTitel() {
25                 return $this->titel;
26         }
27
28         // ...
29 }
30 ?>

Normalerweise würde ein PHP-Entwickler jetzt Datenbanktabellen einrichten und sich dann überlegen, wie er die Informationen aus den Variablen dort hineinprügelt. Um all das kümmert sich netterweise Flow3 – vorausgesetzt man greift dem System ein wenig unter die Arme. Dies geschieht durch so genannte Annotationen, die in Kommentaren versteckt sind. Sie geben Flow3 Informationen über eine Klasse, eine Methode oder ein Attribut.

Da PHP von Haus aus keine Annotationen beherrscht, verwendet Flow3 seine eigene Syntax. Gemäß dieser beginnen Annotationen immer mit einem »@« . Das »@var string« in Listing 3 etwa weist darauf hin, dass die Variable »$titel« einen String aufnimmt. Diese Information hilft dem Framework später, eine passende Datenbanktabelle zu erstellen.

Als Nächstes benötigt die Webanwendung ein Repository, das ein Film-Objekt entgegennimmt und in die Datenbank steckt beziehungsweise dort herausholt. Flow3 verlangt, dass für jedes zu speichernde Model ein eigenes Repository existiert. Um eines anzulegen, muss man einfach eine neue Klasse von »Repository« ableiten. Auch diese Aufgabe übernimmt auf Wunsch das »flow3« -Skript. Ein zum »Film« passendes Repository erzeugt:

./flow3 kickstart:repository Roxy.Filme Film

Die generierte Datei »/FLOW3-1.0.0/Packages/Application/Roxy.Filme/Classes/Domain/Repository/FilmRepository.php« zeigt Listing 4. Da die Basisklasse »Repository« schon zahlreiche nützliche Standardmethoden mitbringt, ist außer der Ableitung nichts weiter notwendig. Wer sich über die merkwürdige Backslash-Notation vor »Repository« wundert: Sie gehört zum Namensraum-Konzept von PHP [7]. Die Annotation »@FLOW3\Scope(“singleton”)« stellt zudem sicher, dass es immer nur ein einziges Film-Repository gibt – mit Hilfe des Entwurfsmusters Singleton.

01 <?php
02 namespace Roxy\Filme\Domain\Repository;
03
04 use TYPO3f\FLOW3\Annotations as FLOW3;
05
06 /**
07  * @FLOW3\Scope("singleton")
08  */
09 class FilmRepository extends \TYPO3\FLOW3\Persistence\Repository {
10 }
11 ?>

Immer wenn der Entwickler ein Model oder Repository neu geschaffen oder verändert hat, bringt er mit »./flow3 doctrine:update« anschließend die Datenbanktabellen auf den aktuellen Stand.

Kontrolleur

In der Filmverwaltung soll ein Benutzer später Filme anlegen, löschen, bearbeiten und natürlich auch ansehen können. Diese Aktionen steuert und koordiniert ein Controller, dessen Klasse »flow3« ruck, zuck generiert ist:

./flow3 kickstart:actioncontroller--generate-actions Roxy.Filme Film

Der Controller heißt im Beispiel »Film« . Der Parameter »–generate-actions« verpasst dessen Klasse automatisch Methoden, die ein neues »Film« -Objekt anlegen, bearbeiten und löschen.

Die komplette Anwendung ist damit bereits einsatzbereit: Es genügt, den Controller im Browser über »http://localhost/FLOW3-1.0.0/Web/index.php/Roxy.Filme/Film« beziehungsweise »http://beispiel.local/Roxy.Filme/Film« anzustupsen. Das Ergebnis ist die zwar noch etwas schmucklose, aber voll funktionsfähige Anwendung aus Abbildung 5.

Was dabei im Hintergrund passiert, verdeutlicht ein Blick in die Klasse des Film-Controllers, der in der Datei »FLOW3 -1.0.0/Packages/Application/Roxy.Filme/ Classes/Controller/FilmController.php« liegt. Ihren Anfang zeigt Listing 5. Veranlasst durch den Aufruf des Browsers aktiviert Flow3 zunächst den »FilmController« . Da keine bestimmte Aktion angegeben ist, führt dieser einfach seine Methode »indexAction()« aus. In ihr bittet er das Film-Repository via »filmRepository->findAll()« um alle gespeicherten Filme. Diese Methode gehört übrigens zum Standardrepertoire der »Repository« -Basisklasse.

01 <?php
02 namespace Roxy\Filme\Controller;
03 use TYPO3\FLOW3\Annotations as FLOW3;
04 use TYPO3\FLOW3\MVC\Controller\ActionController;
05 use \Roxy\Filme\Domain\Model\Film;
06
07 /**
08  * @FLOW3\Scope("singleton")
09  */
10 class FilmController extends ActionController {
11
12         /**
13          * @FLOW3\Inject
14          * @var \Roxy\Filme\Domain\Repository\FilmRepository
15          */
16         protected $filmRepository;
17
18         /**
19          * @return void
20          */
21         public function indexAction() {
22                 $this->view->assign('films', $this->filmRepository->findAll());
23         }
24
25         // ...

An das Repository-Objekt gelangt der Controller per Dependency Injection: Die Variable »$filmRepository« ist mit der Annotation »@FLOW3\Inject« versehen. Damit signalisiert der Controller: “Ich hätte gerne das Film-Repository in meiner Variablen »$filmRepository« “. Flow3 wertet dies aus und “injiziert” beim Anlegen des Controllers automatisch das Repository in die gewünschte Variable. Dank dieser Technik muss der PHP-Programmierer nicht umständlich Objekte umherschieben beziehungsweise an andere durchreichen.

Das Repository liefert eine Liste mit Filmen zurück, die der Controller mittels »assign()« sofort in eine Standard-View stopft. Die hat er netterweise schon vorab automatisch erzeugt und in der Variablen »$this->view« abgelegt. Gleichzeitig sorgt »assign()« zusätzlich dafür, dass die View die Filmliste ab sofort unter dem Namen »films« kennt. Unter dieser Bezeichnung kann der Webentwickler die Filme praktischerweise auch in den Layoutvorlagen ansprechen und weiterverwenden.

Die View ihrerseits wirft nun im Hintergrund die in Flow3 integrierte Template-Engine Fluid an, die aus den HTML-Dateien in den Verzeichnissen »Roxy.Filme/Resources/Private/Layouts/« und »Roxy.Filme/Resources/Private/Templates/« die fertige Webseite zusammenstellt. Eine eigene View-Klasse muss der Entwickler eigentlich nur dann schreiben und dem Controller unterschieben, wenn er die Seiten anders erzeugen möchte.

Im Beispiel widmet sich Fluid als Erstes der Vorlage unter »Roxy.Filme/Resources/Private/Layouts/Default.html« . Sie enthält den Grundaufbau einer jeden Webseite, das so genannte Layout. Darin könnte man beispielsweise ein Firmenlogo einbinden, das dann auf allen Seiten der Anwendung zu sehen sein würde. In diesem einfachen Beispiel besteht das Layout nur aus einer einfachen HTML-Seite (Listing 6).

01 <!DOCTYPE html>
02 <html>
03         <head>
04                 <meta charset="utf-8">
05                 <title><f:render section="Title" /></title>
06                 <f:base />
07         </head>
08         <body>
09                 <f:flashMessages class="flashmessages" />
10
11                 <h1><f:render section="Title" /></h1>
12                 <f:render section="Content" />
13         </body>
14 </html>

Flutschende Vorlagen

Die merkwürdigen, mit einem »<f:« beginnenden Tags sind Platzhalter. Fluid ersetzt sie gegen andere HTML-Schnipsel, die so genannten Sektionen. Im Beispiel-Layout gibt es zwei Sektionen, die eine heißt »Title« , die andere »Content« . Wie diese Sektionen aussehen, steht in einer weiteren Datei, dem so genannten Template, das in Listing 7 zu sehen ist. Im Beispiel liegt es unter »Roxy.Filme/Resources/Private/Templates/Film/Index.html« . Diese Datei enthält alle Sektionen für das Layout der Datei »Default.html« , worauf auch gleich die erste Zeile in Listing 7 hinweist.

01 <f:layout name="Default" />
02
03 <f:section name="Title">A list of films</f:section>
04
05 <f:section name="Content">
06   <f:if condition="{films}">
07     <f:then>
08       <ul>
09         <f:for each="{films}" as="film">
10           <li>
11             <f:link.action action="show" arguments="{film: film}">{film.name}</f:link.action>
12             <f:link.action action="edit" arguments="{film: film}">Edit</f:link.action>
13             <f:link.action action="delete" arguments="{film: film}">Delete</f:link.action>
14           </li>
15         </f:for>
16       </ul>
17     </f:then>
18     <f:else>
19       <p>No films created yet.</p>
20     </f:else>
21   </f:if>
22   <p><f:link.action action="new">Create a new film</f:link.action></p>
23 </f:section>

Die Sektion »Title« enthält nur den Text »A list of films« . Der Inhalt der Sektion »Content« (Zeile 5) ist etwas komplexer. Zunächst prüft Fluid aufgrund der für ihn bestimmten Anweisung »<f:if condition=”{films}”>« , ob der Controller überhaupt eine Liste mit Filmen übergeben hat. Die geschweiften Klammern greifen auf die vorhin per »assign()« in die View gepresste Variable zu. Sofern diese Variable leer ist, also noch kein Film existiert, landet nur der Hinweis »<p>No films created yet.</p>« auf dem Bildschirm (Zeile 19).

Andernfalls durchläuft die For-Each-Schleife ab Zeile 9 alle vorhandenen Filme und erstellt für jeden von ihnen die drei Links zum Anzeigen, Bearbeiten und Löschen (Zeilen 11 bis 13). Wenn der Benutzer später den Link anklickt, soll der Controller die in »action« angegebene Aktion ausführen. Der Controller startet dann beispielsweise die Funktion »editAction()« . Sie erhält als Argument (»arguments=”…”« ) den aktuellen Film übergeben.

Diese Automatik funktioniert aber zumindest in diesem Beispiel nicht ganz perfekt: Sobald der Benutzer einen Film angelegt hat, fehlt dessen Name in der Liste. Der Übeltäter versteckt sich in Zeile 11 des Template: Hier landet »{film.name}« in der Ausgabe. Das Attribut »name« gibt es im Film-Objekt jedoch nicht, korrekt wäre hier der »titel« :

<f:link.action action="show" arguments="{film: film}">{film.titel}</f:link.action>

Bis hierher ist übrigens keine einzige Zeile eigener Code fällig, Flow3 hat alle Klassen selbst generiert.

Flow3 zwingt den Entwickler dazu, moderne Programmierkonzepte konsequent anzuwenden. Was auf den ersten Blick wie Gängelung wirkt, vereinfacht gerade in größeren Projekten die Entwicklung, hilft Fehler vermeiden und macht die Produktpflege zum Kinderspiel.

Im Gegensatz zu anderen Komponenten-basierten PHP-Frameworks lassen sich allerdings keine einzelnen Teile aus Flow3 herauslösen und separat nutzen. Im Gegenzug versprechen die Entwickler jedoch, dass sich mit Flow3 entwickelte Anwendungen später recht einfach als Erweiterung an Typo3 Phoenix anflanschen lassen.

Ausblick

Dieser Artikel konnte nur einen kleinen Einblick in den Leistungsumfang von Flow3 geben. Wer mehr wissen will, sollte sich in die gelungene Dokumentation vertiefen, auch wenn sie an einigen Stellen noch Lücken aufweist [8]. Offene Fragen klären mehrere Mailinglisten und ein eigener Flow3-Kanal im IRC, in dem man auch die Entwickler trifft [9].

Für die kommenden Flow3-Versionen 1.1 und 1.2 steht die Agenda übrigens schon fest [2]: Das Framework soll sich vor allem agiler verhalten und ein Package-Repository erhalten. Letzteres dient dann ähnlich wie das Extensions Repository von Typo3 als eine Art Marktplatz für Extensions. (mhu)