Für die Implementierung von Domain-Objekten in ihrer Grundform benötigt man nur eines. PHP 5. Alle Domain-Objekte sind einfach nur gute, alte PHP-Objekte ohne Besonderheiten. Ich weiß, das ist enttäuschend! Das Model sollte komplex sein, unmöglich zu verstehen, man sollte einen Doktor-Titel dafür brauchen. Stattdessen haben wir es in ein System von Objekten eingedampft, die für sich genommen nicht besonders kompliziert sind.

Bevor unser Model gespeichert werden kann, muss sichergestellt sein, dass die Daten des Models die von uns definierten Randbedingungen erfüllen und Regeln befolgen, dass sie also valide sind und alle Werte gefiltert wurden, wie es eben nötig ist. Wir könnten Validatoren in Form von Zend_Validate und Filter in Form von Zend_Filter verwenden, aber unsere Formulare für das Model würden dieses Regeln duplizieren. Vervielfältigung ist schlecht, und daher werden wir in logischer Folge Zend_Form-Instanzen als Basis verwenden, um diese Regeln zu implementieren.

Der Einsatz von Zend_Form an dieser Stelle kommt nicht ohne Fragen aus. Da die Klasse ein Formular repräsentiert, werden wir sie doch eindeutig häufig in unserer View verwenden. Vermischen wir damit nicht Model und View, verwenden die Klasse also in unangebrachter Weise? Das ist die eine Sichtweise. Die andere ist, dass Zend_Form-Instanzen eine Doppelrolle als Element der Präsentation und als Container für vom Model abgeleitete Validierungs- und Filterregeln wahrnehmen können. Das mag zwar nicht immer der Fall sein, und bei komplexen Models kann es sogar vorkommen, dass Formulare nur zu einem kleinen Teil den in einem Model vorgehaltenen Daten entsprechen. Doch unser Blog ist ziemlich simpel, also brauchen wir uns darüber kaum Gedanken zu machen. Von einem technischen Standpunkt aus wäre die ideale thereotische Lösung eine Formular-Klasse, die zwei unabhängige Teile enthält: einen Daten-Container mit Validatoren und Filtern (sehr nahe an einem Domain-Objekt) und einen Satz an Renderern, welche die Container in das Formular einer View transformieren können. Doch lassen wir das Wunschdenken beiseite (selbst die theoretisch perfekten Lösungen in diesem Gebiet sind mindestens so komplex wie Zend_Form, wenn nicht schlimmer), geben wir uns mit dem zufrieden was wir haben und passen wir es an unsere Bedürfnisse an.

Wir werden uns Zend_Form in einem späteren Kapitel ansehen und uns damit beschäftigen, wie es implementiert wird.

Da es sich hier um ein Zend-Framework-Buch handelt, werden wir natürlich Zend_Db verwenden. Genau genommen Zend_Db_Table_Abstract, welches das Table-Data-Gateway-Pattern aus Martin Fowlers POEAA implementiert. Dieses Gateway-Pattern kann definiert werden als eine Klasse, die den Zugriff auf eine Tabelle in einer Datenbank ermöglicht und es uns erlaubt, Inserts, Selects, Updates und Deletes auf jede Zeile oder auf Gruppen von Zeilen dieser Tabelle auszuführen. Fowler definiert dieses Pattern wie folgt::

Zend_Db bietet zudem eine Implementierung des Row-Data-Gateway-Pattern in Form von Zend_Db_Table_Row an. Das Pattern ist dem Table-Data-Gateway ähnlich mit der Ausnahme, dass es sich mit einer einzelnen Zeile einer Datenbanktabelle auseinandersetzt. In beiden Fällen bietet Zend_Db über seine öffentliche API einen abstrahierten Zugriff. Sie können SQL-Abfragen konstruieren, indem Sie Objekt-Methoden hintereinander aufrufen. Das wird bei beiden Pattern-Implementierungen so gemacht.

Wir werden für unser Model Data-Mapper stellen, die auf die Datenbank mittels Zend_Db_Table zugreifen (also die Option Table-Data-Gateway). Das stimmt mit dem Konzept eines Data-Mappers überein, der von vielen Domain-Objekten verwendet werden kann, aber von ihnen unabhängig bleibt, das heißt: er ist nicht mit einem spezifischen Domain-Objekt verbunden, kann aber spezifische, konkrete Subklassen für jedes Domain-Objekt anbieten, um eine für dieses Domain-Objekt spezifische Mapping-Logik umzusetzen.

Wichtig: unsere Domain-Objekte oder Mapper werden nie Zend_Db_Table erweitern, wie es im Referenzhandbuch vorgeschlagen wird. Dadurch würde unser Model auf eine Implementierung mit Datenbankzugriff festgenagelt. Dadurch müsste unser Model auch Kenntnis vom Speicher-Backend, also dem Objekt zur Persistenzhaltung der Daten, erlangen. Dadurch würden Entwickler ermuntert, Datenbank und Nicht-Datenbank-Code überall miteinander zu vermischen. Solange es nicht unser Ziel ist, wirklich nur Datenbankabstraktion zu verwenden, handelt es sich dabei nur um schlechtes objektorientiertes Design. Die Quintessenz daraus ist, dass wir Wert auf die Regel "composition over inheritance" legen, "Komposition vor Vererbung", eine fundamentale "Best Practice" in der objektorientierten Programmierung. All unsere Domain-Objekte werden eine "has-a" oder "has-many"-Beziehung mit anderen Klassen eingehen, ausgenommen vielleicht abstrakte Elternklassen oder Interfaces, mittels derer wir sichergehen können, dass alle Domain-Objekte in ihrer API zumindest einen ähnlichen Ansatz verfolgen.

Die Tests für unser Model werden in /tests/ZFExt/Model gespeichert. Ein Test für unser Entry-Domain-Objekt zum Beispiel wird in der Datei /tests/ZFExt/Model/EntryTest.php abgelegt. Damit der Test ausgeführt wird, müssen wir in demselben Verzeichnis eine Datei AllTests.php mit folgendem Inhalt hinzufügen:

• <?php
• if (!defined('PHPUnit_MAIN_METHOD')) {
• define('PHPUnit_MAIN_METHOD', 'ZFExt_Model_AllTests::main');
• }
• require_once 'TestHelper.php';
• require_once 'ZFExt/Model/EntryTest.php';
• class ZFExt_Model_AllTests
• {
• public static function main()
• {
• PHPUnit_TextUI_TestRunner::run(self::suite());
• }
• public static function suite()
• {
• $suite = new PHPUnit_Framework_TestSuite('ZFSTDE Blog Suite: Models');
• $suite->addTestSuite('ZFExt_Model_EntryTest');
• return $suite;
• }
• }
• if (PHPUnit_MAIN_METHOD == 'ZFExt_Model_AllTests::main') {
• ZFExt_Model_AllTests::main();
• }

Während wir unser Model implementieren, werden Sie weitere Tests in dieser Datei hinzufügen müssen, damit sie ausgeführt werden. Sie können hinzugefügt werden, indem Sie dem Muster für die Suite ZFExt_Model_EntryTest folgen. Da es sich hierbei nicht um die Datei AllTests.php im obersten Verzeichnis handelt, sollten Sie dies in die "root"-Testdatei /tests/AllTests.php einfügen:

• <?php
• if (!defined('PHPUnit_MAIN_METHOD')) {
• define('PHPUnit_MAIN_METHOD', 'AllTests::main');
• }
• require_once 'TestHelper.php';
• require_once 'ZFExt/Model/AllTests.php';
• class AllTests
• {
• public static function main()
• {
• PHPUnit_TextUI_TestRunner::run(self::suite());
• }
• public static function suite()
• {
• $suite = new PHPUnit_Framework_TestSuite('ZFSTDE Blog Suite');
• $suite->addTest(ZFExt_Model_AllTests::suite());
• return $suite;
• }
• }
• if (PHPUnit_MAIN_METHOD == 'AllTests::main') {
• AllTests::main();
• }

Wie im Anhang beschrieben werden Tests gestartet, in dem Sie in der Konsole zu /tests/ZFExt/Model navigieren (oder /tests, um jeden einzelnen Test der gesamtem Anwendung ablaufen zu lassen) und folgenden Befehl aufrufen:

phpunit AllTests.php

Da es sich bei unserem Entry-Domainobjekt nur um ein gewöhnliches Objekt handelt, können wir es zu Beginn als einen simplen Datencontainer behandeln. Wir sollten unsere Klassen immer mit einem Namespace versehen (nach der alten Art des Namespacings vor PHP 5.3). Daher werden wir den NamespaceZFExt_Model für alle Model-bezogenen Klassen verwenden. Das gilt auch für die Test-Dateien. Vorerst speichern wir alles im Verzeichnis /library. Lassen Sie uns mit ersten Tests beginnen, die überprüfen, ob wir Eigenschaften des Domain-Objekts setzen und eine Instanz eines Entry-Domain-Objekts mit einem Array von Daten erstellen können. Dies ist zu Beginn der Inhalt von /tests/ZFExt/Model/EntryTest.php:

• <?php
• require_once 'ZFExt/Model/Entry.php';
• class ZFExt_Model_EntryTest extends PHPUnit_Framework_TestCase
• {
• public function testSetsAllowedDomainObjectProperty()
• {
• $entry = new ZFExt_Model_Entry;
• $entry->title = 'My Title';
• $this->assertEquals('My Title', $entry->title);
• }
• public function testConstructorInjectionOfProperties()
• {
• $data = array(
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author' => new ZFExt_Model_Author
• );
• $entry = new ZFExt_Model_Entry($data);
• $expected = $data;
• $expected['id'] = null;
• $this->assertEquals($expected, $entry->toArray());
• }
• }

Das können wir nun in /library/ZFExt/Model/Entry.php implementieren (die Tests schlagen auf jeden Fall fehl, wenn die Klasse nicht geschrieben wurde!):

• <?php
• class ZFExt_Model_Entry
• {
• protected $_data = array(
• 'id' => null,
• 'title' => '',
• 'content' => '',
• 'published_date' => '',
• 'author' => null
• );
• public function __construct(array $data = null)
• {
• if (!is_null($data)) {
• foreach ($data as $name => $value) {
• $this->{$name} = $value;
• }
• }
• }
• public function toArray()
• {
• return $this->_data;
• }
• public function __set($name, $value)
• {
• $this->_data[$name] = $value;
• }
• public function __get($name)
• {
• if (array_key_exists($name, $this->_data)) {
• return $this->_data[$name];
• }
• }
• }

Sie wundern sich vielleicht, warum nicht alle Eigenschaften als public deklariert wurden. Wenn man ein Array mit der Sichtbarkeit "protected" und PHPs magische Methoden (wie __set()) für den Datenzugriff verwendet, hat man den Vorteil, dass man beim Zugriff immer ein Gateway passiert. Dadurch können wir beim Setzen eines Wertes nach Belieben Überprüfungen ablaufen lassen und Ausnahmen werfen, falls Fehler auftreten.

Unser neues Objekt ist noch sehr einfach gehalten. Lassen Sie uns den Rest der magischen Standardmethoden hinzufügen, damit wir kontrollieren können, ob die Eigenschaften im geschützten Array gesetzt werden und ob sie zurückgesetzt werden, falls wir das benötigen. Unten werden nur die neuen Tests gezeigt.

• <?php
• require_once 'ZFExt/Model/Entry.php';
• class ZFExt_Model_EntryTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testReturnsIssetStatusOfProperties()
• {
• $entry = new ZFExt_Model_Entry;
• $entry->title = 'My Title';
• $this->assertTrue(isset($entry->title));
• }
• public function testCanUnsetAnyProperties()
• {
• $entry = new ZFExt_Model_Entry;
• $entry->title = 'My Title';
• unset($entry->title);
• $this->assertFalse(isset($entry->title));
• }
• }

• <?php
• class ZFExt_Model_Entry
• {
• protected $_data = array(
• 'id' => null,
• 'title' => '',
• 'content' => '',
• 'published_date' => '',
• 'author' => null
• );
• public function __construct(array $data = null)
• {
• if (!is_null($data)) {
• foreach ($data as $name => $value) {
• $this->{$name} = $value;
• }
• }
• }
• public function toArray()
• {
• return $this->_data;
• }
• public function __set($name, $value)
• {
• $this->_data[$name] = $value;
• }
• public function __get($name)
• {
• if (array_key_exists($name, $this->_data)) {
• return $this->_data[$name];
• }
• }
• public function __isset($name)
• {
• return isset($this->_data[$name]);
• }
• public function __unset($name)
• {
• if (isset($this->_data[$name])) {
• unset($this->_data[$name]);
• }
• }
• }

Unser Domain-Objekt ist nun besser definiert. Momentan kann man ohne Einschränkung Eigenschaften setzen, aber unser Domain-Objekt benötigt nur die Eigenschaften, die im anfänglichen Datenarray als Schlüssel gesetzt sind. Wir können verhindern, dass nicht benötigte Eigenschaften gesetzt werden, und eine Ausnahme werfen, falls das passiert, indem wir wie folgt eine zusätzliche Kontrolle in die Methode __set()einbauen.

• <?php
• require_once 'ZFExt/Model/Entry.php';
• class ZFExt_Model_EntryTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testCannotSetNewPropertiesUnlessDefinedForDomainObject()
• {
• $entry = new ZFExt_Model_Entry;
• try {
• $entry->notdefined = 1;
• $this->fail('Setting new property not defined in class should'
• . ' have raised an Exception');
• } catch (ZFExt_Model_Exception $e) {
• }
• }
• }

• <?php
• class ZFExt_Model_Entry
• {
• protected $_data = array(
• 'id' => null,
• 'title' => '',
• 'content' => '',
• 'published_date' => '',
• 'author' => null
• );
• public function __construct(array $data = null)
• {
• if (!is_null($data)) {
• foreach ($data as $name => $value) {
• $this->{$name} = $value;
• }
• }
• }
• public function toArray()
• {
• return $this->_data;
• }
• public function __set($name, $value)
• {
• if (!array_key_exists($name, $this->_data)) {
• throw new ZFExt_Model_Exception('You cannot set new properties'
• . 'on this object');
• }
• $this->_data[$name] = $value;
• }
• public function __get($name)
• {
• if (array_key_exists($name, $this->_data)) {
• return $this->_data[$name];
• }
• }
• public function __isset($name)
• {
• return isset($this->_data[$name]);
• }
• public function __unset($name)
• {
• if (isset($this->_data[$name])) {
• unset($this->_data[$name]);
• }
• }
• }

Als nächstes soll unser Entry-Domain-Objekt ein Autoren-Objekt enthalten. Da jedes weitere Domain-Objekt unseren bisher in ZFExt_Model_Entry geschriebenen Code vermutlich duplizieren würde, sollten wir unsere Klasse refaktorisieren, damit sie alle möglicherweise wiederverwendbaren Methoden von einer Parent-Klasse erbt. Wir fügen daher nun eine neue Parent-Klasse hinzu namens ZFExt_Model_Entity hinzu, die diese Rolle übernimmt.

• <?php
• class ZFExt_Model_Entity
• {
• public function __construct(array $data = null)
• {
• if (!is_null($data)) {
• foreach ($data as $name => $value) {
• $this->{$name} = $value;
• }
• }
• }
• public function toArray()
• {
• return $this->_data;
• }
• public function __set($name, $value)
• {
• if (!array_key_exists($name, $this->_data)) {
• throw new ZFExt_Model_Exception('You cannot set new properties'
• . ' on this object');
• }
• $this->_data[$name] = $value;
• }
• public function __get($name)
• {
• if (array_key_exists($name, $this->_data)) {
• return $this->_data[$name];
• }
• }
• public function __isset($name)
• {
• return isset($this->_data[$name]);
• }
• public function __unset($name)
• {
• if (isset($this->_data[$name])) {
• unset($this->_data[$name]);
• }
• }
• }

• <?php
• class ZFExt_Model_Entry extends ZFExt_Model_Entity
• {
• protected $_data = array(
• 'id' => null,
• 'title' => '',
• 'content' => '',
• 'published_date' => '',
• 'author' => null
• );
• }

Ein weiterer Lauf unserer Tests wird bestätigen, dass die Refaktorierung erfolgreich war.

Nun wollen wir eine ähnliche Klasse für Autoren hinzufügen. Um den neuen Test anzupassen, bearbeiten Sie die Datei /tests/ZFExt/Model/AllTests.php und fügen einen neuen Test unter /tests/ZFExt/Model/AuthorTest.php hinzu. Die Tests und die Klassen, die diese enthalten, werden denen des Entry-Domain-Objekts sehr ähnlich sein. Hier sind die ersten Tests, die jenen des Entry-Objekts entsprechen, aber die Eigenschaften des Autoren-Objekts berücksichtigen.

• <?php
• class ZFExt_Model_AuthorTest extends PHPUnit_Framework_TestCase
• {
• public function testSetsAllowedDomainObjectProperty()
• {
• $author = new ZFExt_Model_Author;
• $author->fullname = 'Joe';
• $this->assertEquals('Joe', $author->fullname);
• }
• public function testConstructorInjectionOfProperties()
• {
• $data = array(
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• );
• $author = new ZFExt_Model_Author($data);
• $expected = $data;
• $expected['id'] = null;
• $this->assertEquals($expected, $author->toArray());
• }
• public function testReturnsIssetStatusOfProperties()
• {
• $author = new ZFExt_Model_Author;
• $author->fullname = 'Joe Bloggs';
• $this->assertTrue(isset($author->fullname));
• }
• public function testCanUnsetAnyProperties()
• {
• $author = new ZFExt_Model_Author;
• $author->fullname = 'Joe Bloggs';
• unset($author->fullname);
• $this->assertFalse(isset($author->fullname));
• }
• public function testCannotSetNewPropertiesUnlessDefinedInClass()
• {
• $author = new ZFExt_Model_Author;
• try {
• $author->notdefinedinclass = 1;
• $this->fail('Setting new property not defined in class should'
• . ' have raised an Exception');
• } catch (ZFExt_Model_Exception $e) {
• }
• }
• }

Hier ist die Implementierung, die alle neuen Tests erfüllt.

• <?php
• class ZFExt_Model_Author extends ZFExt_Model_Entity
• {
• protected $_data = array(
• 'id' => null,
• 'username' => '',
• 'fullname' => '',
• 'email' => '',
• 'url' => ''
• );
• }

Um uns endgültig abzusichern, dass unser Interface an die Verwendung dieser Domain-Objekte gebunden ist, kontrollieren wir, dass ZFExt_Model_Entry nur ein ZFExt_Model_Author-Objekt akzeptiert, wenn die Eigenschaft author gesetzt wird. Wie üblich schreiben wir zuerst den Test und dann den Code, mittels dem dieser Test bestanden wird.

• <?php
• class ZFExt_Model_EntryTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testThrowsExceptionIfAuthorNotAnAuthorEntityObject()
• {
• $entry = new ZFExt_Model_Entry;
• try {
• $entry->author = 1;
• $this->fail('Setting author should have raised an Exception'
• . ' since value was not an instance of ZFExt_Model_Author');
• } catch (ZFExt_Model_Exception $e) {
• }
• }
• }

• <?php
• class ZFExt_Model_Entry extends ZFExt_Model_Entity
• {
• protected $_data = array(
• 'id' => null,
• 'title' => '',
• 'content' => '',
• 'published_date' => '',
• 'author' => null
• );
• public function __set($name, $value)
• {
• if ($name == 'author' && !$value instanceof ZFExt_Model_Author) {
• throw new ZFExt_Model_Exception('Author can only be set using'
• . ' an instance of ZFExt_Model_Author');
• }
• parent::__set($name, $value);
• }
• }

Alles was wir hier getan haben ist, die Methode __set() der Elternklasse zu überschreiben, um eine neue Kontrolle hinzuzufügen, die dafür sorgt, dass unser Objekt als Wert für author nur ein Objekt des Typs ZFExt_Model_Author enthält. Wird nicht der Autor gesetzt, übergeben wir der Elternklasse die Kontrolle, um die Eigenschaft zu setzen.

Wir sind fürs Erste fertig! Wenden wir unsere Aufmerksamkeit nun unserer Implementierung des Data-Mappers zu, damit wir diese Objekte in einer Datenbank abspeichern oder sie von dort beziehen können.

Unsere Data-Mapper werden im Hintergrund Zend_Db_Table verwenden, weswegen ihre Funktion in diesem Design ist, typische CRUD-Operationen auszuführen. Später werden wir sehen, dass sie ebenfalls Träger von Methoden mit speziellerem Verwendungszweck (z.B. Abfragen von Datensätzen, die bestimmte Bedingungen erfüllen) sein können. Für den Moment konzentrieren wir uns aber darauf, sie erst einmal aufzusetzen. Im ersten Test, den wir erstellen, wird eine Instanz unseres Data-Mappers erzeugt und eine konfigurierte Instanz von Zend_Db_Table_Abstract erstellt, mit der gearbeitet werden kann. Wie Sie sehen werden, verwende ich keine echte Datenbank. Obwohl man am Beginn einiges an Code schreiben muss, verwende ich statt einem echten Zend_Db_Table_Abstract-Objekt ein Mock-Object (quasi einen Doppelgänger für den Test). Dadurch kann ich genau kontrollieren, was dieses Objekt macht, welche Rückgabewerte erzeugt werden, ich kann Erwartungen festlegen, welche Methoden aufgerufen werden sollten, mit welchen Argumenten das geschehen sollte etc. Der Hauptgrund warum ich das tue ist, dass eine reale Datenbank hier nichts Neues bietet - unsere Tests brauchen keine Datenbank. Würden wir eine Datenbank verwenden, würde es auch funktionieren, aber dann würden wir zusätzlich zu allem anderen auch noch Zend_Db_Table_Abstract testen, da es ja schließlich von unserem Code in Anspruch genommen wird. Zend Framework hat aber bereits Tests für diese Komponente.

Fügen Sie wie zuvor die Datei und Klasse zu /tests/ZFExt/Model/AllTests.php hinzu, um den Test zu Ihrer Suite hinzuzufügen. Die Tests selbst werden in /tests/ZFExt/Model/EntryMapperTest.php geschrieben.

• <?php
• class ZFExt_Model_EntryMapperTest extends PHPUnit_Framework_TestCase
• {
• protected $_tableGateway = null;
• protected $_adapter = null;
• protected $_rowset = null;
• protected $_mapper = null;
• public function setup()
• {
• $this->_tableGateway = $this->_getCleanMock(
• 'Zend_Db_Table_Abstract'
• );
• $this->_adapter = $this->_getCleanMock(
• 'Zend_Db_Adapter_Abstract'
• );
• $this->_rowset = $this->_getCleanMock(
• 'Zend_Db_Table_Rowset_Abstract'
• );
• $this->_tableGateway->expects($this->any())->method('getAdapter')
• ->will($this->returnValue($this->_adapter));
• $this->_mapper = new ZFExt_Model_EntryMapper($this->_tableGateway);
• }
• protected function _getCleanMock($className) {
• $class = new ReflectionClass($className);
• $methods = $class->getMethods();
• $stubMethods = array();
• foreach ($methods as $method) {
• if ($method->isPublic() || ($method->isProtected()
• && $method->isAbstract())) {
• $stubMethods[] = $method->getName();
• }
• }
• $mocked = $this->getMock(
• $className,
• $stubMethods,
• array(),
• $className . '_EntryMapperTestMock_' . uniqid(),
• false
• );
• return $mocked;
• }
• }

Alle Data-Mapper-Tests verwenden ein Mock-Objekt, eine Imitation von Zend_Db_Table_Abstract - die Komponente ist bereits vom Zend-Framework-Team getestet worden, also wäre es sinnlos, ein Objekt zu verwenden, das tatsächlich mit einer Datenbank verbunden ist. Wenn wir die Klasse in der Anwendung verwenden, werden wir normalerweise nicht eine echte Instanz an den Konstruktor übergeben, sondern wir können uns stattdessen darauf verlassen, dass der Konstruktor eine passende Instanz erzeugen wird. Das obige Grundgerüst für den Test ist darauf ausgelegt, eine voll funktionsfähige Imitation von Zend_Db_Table_Abstract zu erzeugen.

Auch wenn man die Information im Handbuch zu PHPUnit nur schwer findet ohne in den Quelltext einzutauchen, ermöglicht es die geschützte Methode _getCleanMock() die ich verwende, ein komplett "jungfräuliches" Mock-Objekt zu erzeugen, bei der alle herkömmlichen Methoden durch Imitationen ersetzt wurden.Sie erzeugt für das Imitat bei jedem Aufruf einen einzigartigen Namen, um sicherzustellen, dass es zu keinem Konflikt bei den Namen der imitierten Klassen kommt. Momentan ist nur ein Schritt für uns notwendig: wir müssen darauf achten, dass alle Zend_Db_Table_Abstract-Mock-Objekte auch ein Adapter-Imitat zurückgeben. Ansich gibt es nur einen Grund, ein Mock-Objekt des Adapters zu erstellen, nämlich die häufig verwendete Methode quoteInto(), mit der Werte in einer SQL-Expression oder einer Bedingung maskier werden.

Hier ist unsere anfängliche (bis jetzt ungetestete) Implementierung, die zeigt, warum es nicht wert ist, sich die Mühe mit dem Testen der echten Instanz anzutun - die Implementierung ist extrem einfach, und um es noch einmal zu betonen, wir würden einfach nur Zend_Db_Table_Abstract testen.

• <?php
• class ZFExt_Model_EntryMapper
• {
• protected $_tableGateway = null;
• protected $_tableName = 'entries';
• public function __construct(Zend_Db_Table_Abstract $tableGateway)
• {
• if (is_null($tableGateway)) {
• $this->_tableGateway = new Zend_Db_Table($this->_tableName);
• } else {
• $this->_tableGateway = $tableGateway;
• }
• }
• protected function _getGateway()
• {
• return $this->_tableGateway;
• }
• }

Im obigen Code setzen wir eine Instanz von Zend_Db_Table auf, mit der wir auf die Datenbank zugreifen. Obwohl diese Klasse als Abstract bezeichnet wird, enthält sie eigentlich keine abstrakten Methoden. Als einzige Konfiguration, die wir vorerst benötigen, müssen wir dieser Instanz mitteilen, welche Datenbanktabelle verwendet werden soll. Wir müssen keine Einstellungen für eine Datenbankverbindung übergeben, da wir später einen Standarddatenbankadapter von unserer Bootstrap setzen können.

Lassen Sie uns nun einige nützliche Methoden hinzufügen. Wir beginnen mit einer Methode, um ein neues Domain-Objekt zu speichern. Da wir Zend_Db_Table_Abstract nachgeahmt haben, definieren wir fürs Erste keine Zusicherungen (assertions). Die Zusicherungen ergeben sich in Wirklichkeit daraus, das wir Erwartungen in den Mock-Objekten definieren und kontrollieren, dass unser Mapper die erwartete Methode insert() von Zend_Db_Table_Abstract mit dem korrekten Daten-Array aufruft.

• <?php
• class ZFExt_Model_EntryMapperTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testSavesNewEntryAndSetsEntryIdOnSave() {
• $author = new ZFExt_Model_Author(array(
• 'id' => 2,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• $entry = new ZFExt_Model_Entry(array(
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author' => $author
• ));
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::insert()
• $insertionData = array(
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author_id' => 2
• );
• $this->_tableGateway->expects($this->once())
• ->method('insert')
• ->with($this->equalTo($insertionData))
• ->will($this->returnValue(123));
• $this->_mapper->save($entry);
• $this->assertEquals(123, $entry->id);
• }
• // ...
• }

Hier ist die Implementierung, die diesen Test besteht.

• <?php
• class ZFExt_Model_EntryMapper
• {
• protected $_tableGateway = null;
• protected $_tableName = 'entries';
• public function __construct(Zend_Db_Table_Abstract $tableGateway)
• {
• if (is_null($tableGateway)) {
• $this->_tableGateway = new Zend_Db_Table($this->_tableName);
• } else {
• $this->_tableGateway = $tableGateway;
• }
• }
• protected function _getGateway()
• {
• return $this->_tableGateway;
• }
• public function save(ZFExt_Model_Entry $entry)
• {
• $data = array(
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $entry->id = $this->_getGateway()->insert($data);
• }
• }

Das Speichern eines neuen Eintrags in die Datenbank beinhaltet den Aufruf von Zend_Db_Table_Abstract::insert() mit einem Array der Spaltennamen und Werte, die in die Datenbanktabelle "entries" eingefügt werden sollen. Der Name der Tabelle wird im Konstruktor des Data-Mappers gesetzt. Die id wird weggelassen, da sie über den Rückgabewert von Zend_Db_Table_Abstract::insert() gesetzt wird.

Wie Sie sehen können, kennt unser Mapper das Datenbankschema - er bildet die Eigenschaft id des Autoren-Objekts auf eine Tabellenspalte namens author_id ab. Das Domainobjekt weiß nicht, dass diese Datenbankspalte existiert. Der Rest der Autorendaten wird ignoriert, da sie in einer anderen Tabelle gespeichert werden und nicht neu sind. Eigentlich ist es recht offensichtlich: Sie können einen Autor nicht so speichern, da Autoren-Objekte nur durch einen zukünftigen Autoren-Data-Mapper gespeichert werden können.

Wir werden Einträge auch aktualisieren wollen. Sie sollten leicht aufzuspüren sein, da sie bereits einen existierenden Wert für die Id haben. Lassen Sie uns einen Test und die Implementierung für das Verhalten bei einer Aktualisierung hinzufügen. Auch diesmal werden wir Erwartungen in einem Mock-Objekt anstelle von Zusicherungen verwenden. Denken Sie daran, dass Erwartungen des Mock-Objekts natürlich kontrolliert werden. Falls irgendwelche Anforderungen wie die Anzahl der Methodenaufrufe oder ähnliches von unserer Implementierung nicht erfüllt werden, wird der Test also fehlschlagen.

• <?php
• class ZFExt_Model_EntryMapperTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testUpdatesExistingEntry() {
• $author = new ZFExt_Model_Author(array(
• 'id' => 2,
• 'name' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• $entry = new ZFExt_Model_Entry(array(
• 'id' => 1,
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author' => $author
• ));
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::update()
• $updateData = array(
• 'id' => 1,
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author_id' => 2
• );
• // quoteInto() wird aufgerufen, um die Parameter des Adapters zu maskieren
• $this->_adapter->expects($this->once())
• ->method('quoteInto')
• ->will($this->returnValue('id = 1'));
• $this->_tableGateway->expects($this->once())
• ->method('update')
• ->with($this->equalTo($updateData), $this->equalTo('id = 1'));
• $this->_mapper->save($entry);
• }
• // ...
• }

• <?php
• class ZFExt_Model_EntryMapper
• {
• protected $_tableGateway = null;
• protected $_tableName = 'entries';
• public function __construct(Zend_Db_Table_Abstract $tableGateway)
• {
• if (is_null($tableGateway)) {
• $this->_tableGateway = new Zend_Db_Table($this->_tableName);
• } else {
• $this->_tableGateway = $tableGateway;
• }
• }
• protected function _getGateway()
• {
• return $this->_tableGateway;
• }
• public function save(ZFExt_Model_Entry $entry)
• {
• if (!$entry->id) {
• $data = array(
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $entry->id = $this->getGateway()->insert($data);
• } else {
• $data = array(
• 'id' => $entry->id,
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $where = $this->getGateway()->getAdapter()
• ->quoteInto('entry_id = ?', $entry->id);
• $this->getGateway()->update($data, $where);
• }
• }
• }

Fügen wir eine weitere Methode hinzu, bevor wir Schluss machen - wir werden während der Entwicklung unserer Blogging-Anwendung weitere Methoden hinzufügen. Wir werden nicht nur Einträge speichern und aktualisieren, sondern zumindest auch löschen und abfragen.

Das stellt uns vor zumindest ein Problem, denn Einträge enthalten Autoren. Damit der EntryMapper ein Autoren-Objekt beziehen kann, müssen wir zuerst einen Data-Mapper für Autoren hinzufügen. Hier ist der komplette Satz an Tests und eine Implementierung für die Klasse ZFExt_Model_AuthorMapper (die meisten Tests sind denen sehr ähnlich, die wir bisher geschrieben haben - und einige werden wir uns bald für den Entry-Data-Mapper genauer ansehen).

• <?php
• class ZFExt_Model_AuthorMapperTest extends PHPUnit_Framework_TestCase
• {
• protected $_tableGateway = null;
• protected $_adapter = null;
• protected $_rowset = null;
• protected $_mapper = null;
• public function setup()
• {
• $this->_tableGateway = $this->_getCleanMock(
• 'Zend_Db_Table_Abstract'
• );
• $this->_adapter = $this->_getCleanMock(
• 'Zend_Db_Adapter_Abstract'
• );
• $this->_rowset = $this->_getCleanMock(
• 'Zend_Db_Table_Rowset_Abstract'
• );
• $this->_tableGateway->expects($this->any())->method('getAdapter')
• ->will($this->returnValue($this->_adapter));
• $this->_mapper = new ZFExt_Model_AuthorMapper($this->_tableGateway);
• }
• public function testCreatesSuitableTableDataGatewayObjectWhenInstantiated()
• {
• $mapper = new ZFExt_Model_EntryMapper($this->_tableGateway);
• $this->assertTrue($mapper->getGateway()
• instanceof Zend_Db_Table_Abstract);
• }
• public function testSavesNewAuthorAndSetsAuthorIdOnSave() {
• $author = new ZFExt_Model_Author(array(
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::insert()
• $insertionData = array(
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• );
• $this->_tableGateway->expects($this->once())
• ->method('insert')
• ->with($this->equalTo($insertionData))
• ->will($this->returnValue(123));
• $this->_mapper->save($author);
• $this->assertEquals(123, $author->id);
• }
• public function testUpdatesExistingAuthor() {
• $author = new ZFExt_Model_Author(array(
• 'id' => 2,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::update()
• $updateData = array(
• 'id' => 2,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• );
• $this->_adapter->expects($this->once())
• ->method('quoteInto')
• ->will($this->returnValue('id = 2'));
• $this->_tableGateway->expects($this->once())
• ->method('update')
• ->with($this->equalTo($updateData), $this->equalTo('id = 2'));
• $this->_mapper->save($author);
• }
• public function testFindsRecordByIdAndReturnsDomainObject()
• {
• $author = new ZFExt_Model_Author(array(
• 'id' => 1,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• // Erwartetes Rowset-Ergebnis für den gefundenen Eintrag
• $dbData = new stdClass;
• $dbData->id = 1;
• $dbData->fullname = 'Joe Bloggs';
• $dbData->username = 'joe_bloggs';
• $dbData->email = '[email protected]';
• $dbData->url = 'http://www.example.com';
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::find()
• $this->_rowset->expects($this->once())
• ->method('current')
• ->will($this->returnValue($dbData));
• $this->_tableGateway->expects($this->once())
• ->method('find')
• ->with($this->equalTo(1))
• ->will($this->returnValue($this->_rowset));
• $entryResult = $this->_mapper->find(1);
• $this->assertEquals($author, $entryResult);
• }
• public function testDeletesAuthorUsingEntryId()
• {
• $this->_adapter->expects($this->once())
• ->method('quoteInto')
• ->with($this->equalTo('id = ?'), $this->equalTo(1))
• ->will($this->returnValue('author_id = 1'));
• $this->_tableGateway->expects($this->once())
• ->method('delete')
• ->with($this->equalTo('id = 1'));
• $this->_mapper->delete(1);
• }
• public function testDeletesAuthorUsingEntryObject()
• {
• $author = new ZFExt_Model_Author(array(
• 'id' => 1,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• $this->_adapter->expects($this->once())
• ->method('quoteInto')
• ->with($this->equalTo('id = ?'), $this->equalTo(1))
• ->will($this->returnValue('author_id = 1'));
• $this->_tableGateway->expects($this->once())
• ->method('delete')
• ->with($this->equalTo('id = 1'));
• $this->_mapper->delete($author);
• }
• protected function _getCleanMock($className) {
• $class = new ReflectionClass($className);
• $methods = $class->getMethods();
• $stubMethods = array();
• foreach ($methods as $method) {
• if ($method->isPublic() || ($method->isProtected()
• && $method->isAbstract())) {
• $stubMethods[] = $method->getName();
• }
• }
• $mocked = $this->getMock(
• $className,
• $stubMethods,
• array(),
• $className . '_AuthorMapperTestMock_' . uniqid(),
• false
• );
• return $mocked;
• }
• }

Die Implementierung dieser Klasse entspricht jener für den Entry-Mapper und fügt die Methoden find() und delete() hinzu.

• <?php
• class ZFExt_Model_AuthorMapper
• {
• protected $_tableGateway = null;
• protected $_tableName = 'authors';
• protected $_entityClass = 'ZFExt_Model_Author';
• public function __construct(Zend_Db_Table_Abstract $tableGateway)
• {
• if (is_null($tableGateway)) {
• $this->_tableGateway = new Zend_Db_Table($this->_tableName);
• } else {
• $this->_tableGateway = $tableGateway;
• }
• }
• protected function _getGateway()
• {
• return $this->_tableGateway;
• }
• public function save(ZFExt_Model_Author $author)
• {
• if (!$author->id) {
• $data = array(
• 'fullname' => $author->fullname,
• 'username' => $author->username,
• 'email' => $author->email,
• 'url' => $author->url
• );
• $author->id = $this->_getGateway()->insert($data);
• } else {
• $data = array(
• 'id' => $author->id,
• 'fullname' => $author->fullname,
• 'username' => $author->username,
• 'email' => $author->email,
• 'url' => $author->url
• );
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $author->id);
• $this->_getGateway()->update($data, $where);
• }
• }
• public function find($id)
• {
• $result = $this->_getGateway()->find($id)->current();
• $author = new $this->_entityClass(array(
• 'id' => $result->id,
• 'fullname' => $result->fullname,
• 'username' => $result->username,
• 'email' => $result->email,
• 'url' => $result->url
• ));
• return $author;
• }
• public function delete($author)
• {
• if ($author instanceof ZFExt_Model_Author) {
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $author->id);
• } else {
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $author);
• }
• $this->_getGateway()->delete($where);
• }
• }

Diesen neuen Autoren-Data-Mapper können wir in unserem Entry-Data-Mapper verwenden, um ein Autoren-Objekt zu holen und in das Entry-Objekt einzufügen, das von der neuen Methode find() zurückgegeben wird. Wir werden auch eine ähnliche Methode delete() einfügen.

Hier sind die Tests für das Finden eines Eintrags über die Eigenschaft id und für das Löschen eines Eintrags über die Id.

• <?php
• class ZFExt_Model_EntryMapperTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testFindsRecordByIdAndReturnsDomainObject()
• {
• $author = new ZFExt_Model_Author(array(
• 'id' => 1,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• $entry = new ZFExt_Model_Entry(array(
• 'id' => 1,
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author' => $author
• ));
• // Erwartetes Rowset-Ergebnis für den gefundenen Eintrag
• $dbData = new stdClass;
• $dbData->id = 1;
• $dbData->title = 'My Title';
• $dbData->content = 'My Content';
• $dbData->published_date = '2009-08-17T17:30:00Z';
• $dbData->author_id = 1;
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::find()
• $this->_rowset->expects($this->once())
• ->method('current')
• ->will($this->returnValue($dbData));
• $this->_tableGateway->expects($this->once())
• ->method('find')
• ->with($this->equalTo(1))
• ->will($this->returnValue($this->_rowset));
• // Erstelle ein Mock-Objekt von AuthorMapper - es hat eigene Tests
• $authorMapper = $this->_getCleanMock('ZFExt_Model_AuthorMapper');
• $authorMapper->expects($this->once())
• ->method('find')->with($this->equalTo(1))
• ->will($this->returnValue($author));
• $this->_mapper->setAuthorMapper($authorMapper);
• $entryResult = $this->_mapper->find(1);
• $this->assertEquals($entry, $entryResult);
• }
• public function testDeletesEntryUsingEntryId()
• {
• $this->_adapter->expects($this->once())
• ->method('quoteInto')
• ->with($this->equalTo('id = ?'), $this->equalTo(1))
• ->will($this->returnValue('entry_id = 1'));
• $this->_tableGateway->expects($this->once())
• ->method('delete')
• ->with($this->equalTo('id = 1'));
• $this->_mapper->delete(1);
• }
• public function testDeletesEntryUsingEntryObject()
• {
• $author = new ZFExt_Model_Author(array(
• 'id' => 2,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• $entry = new ZFExt_Model_Entry(array(
• 'id' => 1,
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z',
• 'author' => $author
• ));
• $this->_adapter->expects($this->once())
• ->method('quoteInto')
• ->with($this->equalTo('id = ?'), $this->equalTo(1))
• ->will($this->returnValue('entry_id = 1'));
• $this->_tableGateway->expects($this->once())
• ->method('delete')
• ->with($this->equalTo('id = 1'));
• $this->_mapper->delete($entry);
• }
• // ...
• }

Hier ist unsere Implementierung für diese zwei neuen Methoden. Wie die Tests es vorschreiben, können wir Einträge löschen, indem wir die Id als Integer-Wert oder das Domain-Objekt selbst übergeben.

• <?php
• class ZFExt_Model_EntryMapper
• {
• protected $_tableGateway = null;
• protected $_tableName = 'entries';
• protected $_entityClass = 'ZFExt_Model_Entry';
• protected $_authorMapperClass = 'ZFExt_Model_AuthorMapper';
• protected $_authorMapper = null;
• public function __construct(Zend_Db_Table_Abstract $tableGateway)
• {
• if (is_null($tableGateway)) {
• $this->_tableGateway = new Zend_Db_Table($this->_tableName);
• } else {
• $this->_tableGateway = $tableGateway;
• }
• }
• protected function _getGateway()
• {
• return $this->_tableGateway;
• }
• public function save(ZFExt_Model_Entry $entry)
• {
• if (!$entry->id) {
• $data = array(
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $entry->id = $this->_getGateway()->insert($data);
• } else {
• $data = array(
• 'id' => $entry->id,
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $entry->id);
• $this->_getGateway()->update($data, $where);
• }
• }
• public function find($id)
• {
• $result = $this->_getGateway()->find($id)->current();
• if (!$this->_authorMapper) {
• $this->_authorMapper = new $this->_authorMapperClass;
• }
• $author = $this->_authorMapper->find($result->author_id);
• $entry = new $this->_entityClass(array(
• 'id' => $result->id,
• 'title' => $result->title,
• 'content' => $result->content,
• 'published_date' => $result->published_date,
• 'author' => $author
• ));
• return $entry;
• }
• public function delete($entry)
• {
• if ($entry instanceof ZFExt_Model_Entry) {
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $entry->id);
• } else {
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $entry);
• }
• $this->_getGateway()->delete($where);
• }
• public function setAuthorMapper(ZFExt_Model_AuthorMapper $mapper)
• {
• $this->_authorMapper = $mapper;
• }
• }

Und endlich...wir haben eine funktionierende Implementierung des Data-Mappers! So sollte die finale Ausgabe von PHPUnit zur Testreihe aussehen.

PHPUnit 3.3.17 by Sebastian Bergmann.

.......................

Time: 0 seconds

OK (23 tests, 51 assertions)

Unsere Implementierung des Data-Mappers in ZFExt_Model_EntryMapper benötigt zwei SQL-Abfragen, um ein vollständiges Domain-Objekt zu erzeugen: eine Abfrage für den Eintrag selbst und eine weitere für den referenzierten Autor. Manchmal benötigen wir die Details zum Autor gar nicht; in diesem Fall ist die zusätzliche Abfrage überflüssig. Es wäre besser, den Data-Mapper so anzupassen, dass er die Autoren-Daten nur bei Bedarf lädt und uns so ab und zu den Weg zur Datenbank erspart (auch bekannt als "lazy loading").

Wir haben bereits gesehen, wie wir die Methode __set() überschreiben können, um einen Wert vor dem Setzen der Eigenschaft zu validieren. Wir können die Methode __get() verwenden, um eine ähnliche Funktionalität zu erreichen. Wir fangen den Versuch ab, auf das Autoren-Objekt in unserem Entry-Domain-Objekt zuzugreifen und starten eine Abfrage über ZFExt_Model_AuthorMapper, um das Objekt zu erhalten.

Da dadurch offensichtlich bereits getestetes Verhalten geändert wird, müssen wir zumindest einen Test für den Entry-Data-Mapper abändern. Wir müssen irgendwie die Id des Autors im Entry-Domain-Objekt speichern, damit wir etwas haben, was wir "lazy-loaden" können, und wir müssen sicher gehen, dass das nachträgliche Laden tatsächlich funktioniert. Hier sind die neuen, überarbeiteten Tests für den Entry-Mapper und das Entry-Domain-Objekt:

• <?php
• class ZFExt_Model_EntryMapperTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testFindsRecordByIdAndReturnsDomainObject()
• {
• $entry = new ZFExt_Model_Entry(array(
• 'id' => 1,
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z'
• ));
• // Erwartetes Rowset-Ergebnis für den gefundenen Eintrag
• $dbData = new stdClass;
• $dbData->id = 1;
• $dbData->title = 'My Title';
• $dbData->content = 'My Content';
• $dbData->published_date = '2009-08-17T17:30:00Z';
• $dbData->author_id = 1;
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::find()
• $this->_rowset->expects($this->once())
• ->method('current')
• ->will($this->returnValue($dbData));
• $this->_tableGateway->expects($this->once())
• ->method('find')
• ->with($this->equalTo(1))
• ->will($this->returnValue($this->_rowset));
• $entryResult = $this->_mapper->find(1);
• $this->assertEquals('My Title', $entryResult->title);
• }
• public function testFoundRecordCausesAuthorReferenceIdToBeSetOnEntryObject()
• {
• $entry = new ZFExt_Model_Entry(array(
• 'id' => 1,
• 'title' => 'My Title',
• 'content' => 'My Content',
• 'published_date' => '2009-08-17T17:30:00Z'
• ));
• // Erwartetes Rowset-Ergebnis für den gefundenen Eintrag
• $dbData = new stdClass;
• $dbData->id = 1;
• $dbData->title = 'My Title';
• $dbData->content = 'My Content';
• $dbData->published_date = '2009-08-17T17:30:00Z';
• $dbData->author_id = 5;
• // Setze Erwartungen für das Mock-Objekt beim Aufruf von Zend_Db_Table::find()
• $this->_rowset->expects($this->once())
• ->method('current')
• ->will($this->returnValue($dbData));
• $this->_tableGateway->expects($this->once())
• ->method('find')
• ->with($this->equalTo(1))
• ->will($this->returnValue($this->_rowset));
• $entryResult = $this->_mapper->find(1);
• $this->assertEquals(5, $entryResult->getReferenceId('author'));
• }
• // ...
• }

• <?php
• class ZFExt_Model_EntryTest extends PHPUnit_Framework_TestCase
• {
• // ...
• public function testAllowsAuthorIdToBeStoredAsAReference()
• {
• $entry = new ZFExt_Model_Entry;
• $entry->setReferenceId('author', 5);
• $this->assertEquals(5, $entry->getReferenceId('author'));
• }
• public function testLazyLoadingAuthorsRetrievesAuthorDomainObject()
• {
• $author = new ZFExt_Model_Author(array(
• 'id' => 5,
• 'username' => 'joe_bloggs',
• 'fullname' => 'Joe Bloggs',
• 'email' => '[email protected]',
• 'url' => 'http://www.example.com'
• ));
• $entry = new ZFExt_Model_Entry;
• $entry->setReferenceId('author', 5);
• $authorMapper = $this->_getCleanMock('ZFExt_Model_AuthorMapper');
• $authorMapper->expects($this->once())
• ->method('find')
• ->with($this->equalTo(5))
• ->will($this->returnValue($author));
• $entry->setAuthorMapper($authorMapper);
• $this->assertEquals('Joe Bloggs', $entry->author->fullname);
• }
• protected function _getCleanMock($className) {
• $class = new ReflectionClass($className);
• $methods = $class->getMethods();
• $stubMethods = array();
• foreach ($methods as $method) {
• if ($method->isPublic() || ($method->isProtected()
• && $method->isAbstract())) {
• $stubMethods[] = $method->getName();
• }
• }
• $mocked = $this->getMock(
• $className,
• $stubMethods,
• array(),
• $className . '_EntryTestMock_' . uniqid(),
• false
• );
• return $mocked;
• }
• // ...
• }

Als Ausgangslage für die Implementierung ändern wir die Klasse ZFExt_Model_Entry so ab, dass sie die Referenz-Id des Autors zur späteren Verwendung annimmt. Da das Lazy-Loading innerhalb dieses Objekts geschieht, müssen wir die Kenntnis von ZFExt_Model_AuthorMapper, die ursprünglich ZFExt_Model_EntryMapper besitzt, in das Domain-Objekt selbst transferieren. Technisch gesehen können Referenzen in jedem Domain-Objekt auftreten, das sie benötigt, weswegen wir dieses Feature der Elternklasse ZFExt_Model_Entity hinzufügen können. ZFExt_Model_Entry kann diese Methoden der Elternklasse verwenden, um Informationen zu den Referenzen zu setzen oder auszulesen.

• <?php
• class ZFExt_Model_Entity
• {
• protected $_references = array();
• // ...
• public function setReferenceId($name, $id)
• {
• $this->_references[$name] = $id;
• }
• public function getReferenceId($name)
• {
• if (isset($this->_references[$name])) {
• return $this->_references[$name];
• }
• }
• }

• <?php
• class ZFExt_Model_Entry extends ZFExt_Model_Entity
• {
• protected $_data = array(
• 'id' => null,
• 'title' => '',
• 'content' => '',
• 'published_date' => '',
• 'author' => null
• );
• protected $_authorMapperClass = 'ZFExt_Model_AuthorMapper';
• protected $_authorMapper = null;
• public function __set($name, $value)
• {
• if ($name == 'author' && !$value instanceof ZFExt_Model_Author ) {
• throw new ZFExt_Model_Exception('Author can only be set using'
• . ' an instance of ZFExt_Model_Author');
• }
• parent::__set($name, $value);
• }
• public function __get($name)
• {
• if ($name == 'author' && $this->getReferenceId('author')
• && !$this->_data['author'] instanceof ZFExt_Model_Author) {
• if (!$this->_authorMapper) {
• $this->_authorMapper = new $this->_authorMapperClass;
• }
• $this->_data['author'] = $this->_authorMapper
• ->find($this->getReferenceId('author'));
• }
• return parent::__get($name);
• }
• public function setAuthorMapper(ZFExt_Model_AuthorMapper $mapper)
• {
• $this->_authorMapper = $mapper;
• }
• }

Achten Sie auf die neue Methode __get(). Sie fängt alle Versuche ab, auf die Eigenschaft author des Domain-Objekts zuzugreifen. Falls das Objekt nicht bereits ein Autoren-Objekt enthält, versucht es eines aus der Datenbank zu laden, aber auch nur dann, wenn eine Referenz-Id (das heißt: eine Autoren-Id) gesetzt wurde, zum Beispiel als der Eintrag selbst geladen wurde. Anderenfalls wird der Wert null retourniert, was auch passieren sollte, wenn es sich um ein neues Objekt ohne einen Autor handelt.

Hier sehen Sie die überarbeitete Klasse ZFExt_Model_EntryMapper. Als einzige Änderung wurde das automatische Laden des Autoren-Objekts entfernt und durch das Setzen des Werts von author_id als Referenz im resultierenden Eintrag-Objekt ersetzt.

• <?php
• class ZFExt_Model_EntryMapper
• {
• protected $_tableGateway = null;
• protected $_tableName = 'entries';
• protected $_entityClass = 'ZFExt_Model_Entry';
• public function __construct(Zend_Db_Table_Abstract $tableGateway)
• {
• if (is_null($tableGateway)) {
• $this->_tableGateway = new Zend_Db_Table($this->_tableName);
• } else {
• $this->_tableGateway = $tableGateway;
• }
• }
• protected function _getGateway()
• {
• return $this->_tableGateway;
• }
• public function save(ZFExt_Model_Entry $entry)
• {
• if (!$entry->id) {
• $data = array(
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $entry->id = $this->_getGateway()->insert($data);
• } else {
• $data = array(
• 'id' => $entry->id,
• 'title' => $entry->title,
• 'content' => $entry->content,
• 'published_date' => $entry->published_date,
• 'author_id' => $entry->author->id
• );
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $entry->id);
• $this->_getGateway()->update($data, $where);
• }
• }
• public function find($id)
• {
• $result = $this->_getGateway()->find($id)->current();
• $entry = new $this->_entityClass(array(
• 'id' => $result->id,
• 'title' => $result->title,
• 'content' => $result->content,
• 'published_date' => $result->published_date
• ));
• $entry->setReferenceId('author', $result->author_id);
• return $entry;
• }
• public function delete($entry)
• {
• if ($entry instanceof ZFExt_Model_Entry) {
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $entry->id);
• } else {
• $where = $this->_getGateway()->getAdapter()
• ->quoteInto('id = ?', $entry);
• }
• $this->_getGateway()->delete($where);
• }
• }

Et voilá! Wir haben unseren Data-Mapper so modifiziert, dass er an geeigneten Stellen das Lazy-Loading von Objekten unterstützt. Ich gebe dazu, dass es sich hierbei eigentlich um einen Fall von frühzeitiger Optimierung handelt - wir haben keine Ahnung, ob diese Maßnahme die Leistung unserer Anwendung in irgendeiner Hinsicht steigern wird, da wir bisher keine Verbesserung messen können. Da ich das aber bereits bei früheren Gelegenheiten getan habe, kann ich davon ausgehen, dass es der Leistung unserer Anwendung zuträglich sein wird. Datenbankoperationen sind teuer, oft sogar die teuersten Operationen.