documentation/manual/de/tutorials/quickstart-create-model.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <!-- EN-Revision: 21740 -->
   3 <!-- Reviewed: no -->
   4 <sect1 id="learning.quickstart.create-model">
   5     <title>Ein Modell und eine Datenbank Tabelle erstellen</title>
   6
   7     <para>
   8         Bevor wir anfangen nehmen wie etwas an: Wo werden diese Klassen leben, und wie werden wir
   9         Sie finden? Das Standardprojekt welches wir erstellt haben instanziert einen Autoloader. Wir
  10         können Ihm andere Autoloader anhängen damit er weiss wo andere Klassen zu finden sind.
  11         Typischerweise wollen wir das unsere verschiedenen MVC Klassen im selben Baum gruppiert sind
  12         -- in diesem Fall <filename>application/</filename> -- und meistens einen gemeinsamen Präfix
  13         verwenden.
  14     </para>
  15
  16     <para>
  17         <classname>Zend_Controller_Front</classname> hat den Begriff von "Modulen", welche
  18         individuelle Mini-Anwendungen sind. Module mimen die Verzeichnisstruktur welche das
  19         <command>zf</command> Tool unter <filename>application/</filename> einrichtet, und von allen
  20         Klassen in Ihm wird angenommen das Sie mit einen gemeinsamen Präfix beginnen, dem Namen des
  21         Moduls. <filename>application/</filename> selbst ist ein Modul -- das "default" oder
  22         "application" Modul. Als solches richten wir das Autoloading für Ressourcen in diesem
  23         Verzeichnis ein.
  24     </para>
  25
  26     <para>
  27         <classname>Zend_Application_Module_Autoloader</classname> bietet die Funktionalität welche
  28         benötigt wird um die verschiedenen Ressourcen unter einem Modul mit den richtigen
  29         Verzeichnissen zu verbinden, und auch einen standardmäßigen Namensmechanismus. Standardmäßig
  30         wird eine Instanz der Klasse wärend der Initialisierung des Bootstrap Objekts erstellt;
  31         unser Application Bootstrap verwendet standardmäßig das Modulpräfix "Application". Daher
  32         beginnen alle unsere Modelle, Formulare, und Tabellenklassen mit dem Klassenpräfix
  33         "Application_".
  34     </para>
  35
  36     <para>
  37         Nehmen wir jetzt also an was ein Guestbook ausmacht. Typischerweise sind Sie einfach eine
  38         Liste ein Einträgen mit einem <emphasis>Kommentar</emphasis> (comment), einem
  39         <emphasis>Zeitpunkt</emphasis> (timestamp) und oft einer <emphasis>Email Adresse</emphasis>.
  40         Angenommen wir speichern diese in einer Datenbank, dann wollen wir auch einen
  41         <emphasis>eindeutigen Identifikator</emphasis> für jeden Eintrag. Wir wollen in der Lage
  42         sein einen Eintrag zu speichern, individuelle Einträge zu holen, und alle Einträge zu
  43         empfangen. Als solches könnte das Modell einer einfachen Guestbook API wie folgt aussehen:
  44     </para>
  45
  46     <programlisting language="php"><![CDATA[
  47 // application/models/Guestbook.php
  48
  49 class Application_Model_Guestbook
  50 {
  51     protected $_comment;
  52     protected $_created;
  53     protected $_email;
  54     protected $_id;
  55
  56     public function __set($name, $value);
  57     public function __get($name);
  58
  59     public function setComment($text);
  60     public function getComment();
  61
  62     public function setEmail($email);
  63     public function getEmail();
  64
  65     public function setCreated($ts);
  66     public function getCreated();
  67
  68     public function setId($id);
  69     public function getId();
  70 }
  71
  72 class Application_Model_GuestbookMapper
  73 {
  74     public function save(Application_Model_Guestbook $guestbook);
  75     public function find($id);
  76     public function fetchAll();
  77 }
  78 ]]></programlisting>
  79
  80     <para>
  81         <methodname>__get()</methodname> und <methodname>__set()</methodname> bieten uns bequeme
  82         Mechanismen an um auf individuelle Eigenschaften von Einträgen zuzugreifen und auf andere
  83         Getter und Setter zu verweisen. Sie stellen auch sicher das nur Eigenschaften im Objekt
  84         vorhanden sind die wir freigegeben haben.
  85     </para>
  86
  87     <para>
  88         <methodname>find()</methodname> und <methodname>fetchAll()</methodname> bieten die Fähigkeit
  89         einen einzelnen Eintrag oder alle Einträge zu holen, wärend <methodname>save()</methodname>
  90         das Speichern der Einträge im Datenspeicher übernimmt.
  91     </para>
  92
  93     <para>
  94         Von hier an können wir über die Einrichtung unserer Datenbank nachdenken.
  95     </para>
  96
  97     <para>
  98         Zuerst muss unsere <classname>Db</classname> Ressource initialisiert werden. Wie bei der
  99         <classname>Layout</classname> und <classname>View</classname> kann die Konfiguration für die
 100         <classname>Db</classname> Ressource angegeben werden. Dies kann mit dem Befehl
 101         <command>zf configure db-adapter</command> getan werden:
 102     </para>
 103
 104     <programlisting language="shell"><![CDATA[\r
 105 % zf configure db-adapter \\r
 106 > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook.db"' \\r
 107 > production\r
 108 A db configuration for the production has been written to the application config file.\r
 109 \r
 110 % zf configure db-adapter \\r
 111 > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook-testing.db"' \\r
 112 > testing\r
 113 A db configuration for the production has been written to the application config file.\r
 114 \r
 115 % zf configure db-adapter \\r
 116 > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook-dev.db"' \\r
 117 > development\r
 118 A db configuration for the production has been written to the application config file.\r
 119 ]]></programlisting>\r
 120 \r
 121     <para>
 122         Jetzt muss die Datei <filename>application/configs/application.ini</filename> bearbeitet
 123         werden, und man kann sehen das die folgenden Zeilen in den betreffenden Abschnitten
 124         hinzugefügt wurden.
 125     </para>\r
 126
 127     <programlisting language="ini"><![CDATA[
 128 ; application/configs/application.ini
 129
 130 [production]
 131 ; ...
 132 resources.db.adapter       = "PDO_SQLITE"
 133 resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"
 134
 135 [testing : production]
 136 ; ...\r
 137 resources.db.adapter = "PDO_SQLITE"
 138 resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"
 139
 140 [development : production]
 141 ; ...\r
 142 resources.db.adapter = "PDO_SQLITE"
 143 resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"
 144 ]]></programlisting>
 145
 146     <para>
 147         Die endgültige Konfigurationsdatei sollte wie folgt aussehen:
 148     </para>
 149
 150     <programlisting language="ini"><![CDATA[
 151 ; application/configs/application.ini
 152
 153 [production]
 154 phpSettings.display_startup_errors = 0
 155 phpSettings.display_errors = 0
 156 bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
 157 bootstrap.class = "Bootstrap"
 158 appnamespace = "Application"
 159 resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
 160 resources.frontController.params.displayExceptions = 0
 161 resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"
 162 resources.view[] =
 163 resources.db.adapter = "PDO_SQLITE"
 164 resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"
 165
 166 [staging : production]
 167
 168 [testing : production]
 169 phpSettings.display_startup_errors = 1
 170 phpSettings.display_errors = 1
 171 resources.db.adapter = "PDO_SQLITE"
 172 resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"
 173
 174 [development : production]
 175 phpSettings.display_startup_errors = 1
 176 phpSettings.display_errors = 1
 177 resources.db.adapter = "PDO_SQLITE"
 178 resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"
 179 ]]></programlisting>
 180
 181     <para>
 182         Es ist zu beachten das die Datenbank(en) unter <filename>data/db/</filename> gespeichert
 183         wird. Diese Verzeichnisse sind zu erstellen und weltweit-schreibbar zu machen. Auf
 184         Unix-artigen Systemen kann man das wie folgt durchführen:
 185     </para>
 186
 187     <programlisting language="shell"><![CDATA[
 188 % mkdir -p data/db; chmod -R a+rwX data
 189 ]]></programlisting>
 190
 191     <para>
 192         Unter Windows muss man die Verzeichnisse im Explorer erstellen und die Zugriffsrechte so zu
 193         setzen das jeder in das Verzeichnis schreiben darf.
 194     </para>
 195
 196     <para>
 197         Ab diesem Punkt haben wir eine Verbindung zu einer Datenbank; in unserem Fall ist es eine
 198         verbindung zu einer Sqlite Datenbank die in unserem <filename>application/data/</filename>
 199         Verzeichnis ist. Designen wir also eine einfache Tabelle die unsere Guestbook Einträge
 200         enthalten wird.
 201     </para>
 202
 203     <programlisting language="sql"><![CDATA[
 204 -- scripts/schema.sqlite.sql
 205 --
 206 -- Man muss das Datenbank Schema mit diesem SQL laden.
 207
 208 CREATE TABLE guestbook (
 209     id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
 210     email VARCHAR(32) NOT NULL DEFAULT 'noemail@test.com',
 211     comment TEXT NULL,
 212     created DATETIME NOT NULL
 213 );
 214
 215 CREATE INDEX "id" ON "guestbook" ("id");
 216 ]]></programlisting>
 217
 218     <para>
 219         Und damit wir gleich einige Arbeitsdaten haben, erstellen wir ein paar Zeilen an Information
 220         um unsere Anwendung interessant zu machen.
 221     </para>
 222
 223     <programlisting language="sql"><![CDATA[
 224 -- scripts/data.sqlite.sql
 225 --
 226 -- Man kann damit beginnen die Datenbank zu befüllen indem die folgenden SQL
 227 -- Anweisungen ausgeführt werden.
 228
 229 INSERT INTO guestbook (email, comment, created) VALUES
 230     ('ralph.schindler@zend.com',
 231     'Hallo! Hoffentlich geniesst Ihr dieses Beispiel einer ZF Anwendung!
 232     DATETIME('NOW'));
 233 INSERT INTO guestbook (email, comment, created) VALUES
 234     ('foo@bar.com',
 235     'Baz baz baz, baz baz Baz baz baz - baz baz baz.',
 236     DATETIME('NOW'));
 237 ]]></programlisting>
 238
 239     <para>
 240         Jetzt haben wir sowohl das Schema als auch einige Daten definiert. Schreiben wir also ein
 241         Skript das wir jetzt ausführen können um diese Datenbank zu erstellen. Natürlich wird das
 242         nicht in der Produktion benötigt, aber dieses Skriupt hilft Entwicklern die Notwendigkeiten
 243         der Datenbank lokal zu erstellen damit Sie eine voll funktionsfähige Anwendung haben. Das
 244         Skript ist als <filename>scripts/load.sqlite.php</filename> mit dem folgenden Inhalt zu
 245         erstellen:
 246     </para>
 247
 248     <programlisting language="php"><![CDATA[
 249 // scripts/load.sqlite.php
 250
 251 /**
 252  * Skript für das erstellen und Laden der Datenbank
 253  */
 254
 255 // Initialisiert den Pfad und das Autoloading der Anwendung
 256 defined('APPLICATION_PATH')
 257     || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));
 258 set_include_path(implode(PATH_SEPARATOR, array(
 259     APPLICATION_PATH . '/../library',
 260     get_include_path(),
 261 )));
 262 require_once 'Zend/Loader/Autoloader.php';
 263 Zend_Loader_Autoloader::getInstance();
 264
 265 // Definiert einige CLI Optionen
 266 $getopt = new Zend_Console_Getopt(array(
 267     'withdata|w' => 'Datenbank mit einigen Daten laden',
 268     'env|e-s'    => "Anwendungsumgebung für welche die Datenbank "
 269                   . "erstellt wird (Standard ist Development)",
 270     'help|h'     => 'Hilfe -- Verwendung',
 271 ));
 272 try {
 273     $getopt->parse();
 274 } catch (Zend_Console_Getopt_Exception $e) {
 275     // Schlechte Option übergeben: Verwendung ausgeben
 276     echo $e->getUsageMessage();
 277     return false;
 278 }
 279
 280 // Wenn Hilfe angefragt wurde, Verwendung ausgeben
 281 if ($getopt->getOption('h')) {
 282     echo $getopt->getUsageMessage();
 283     return true;
 284 }
 285
 286 // Werte basierend auf Ihrer Anwesenheit oder Abwesenheit von CLI Optionen initialisieren
 287 $withData = $getopt->getOption('w');
 288 $env      = $getopt->getOption('e');
 289 defined('APPLICATION_ENV')
 290     || define('APPLICATION_ENV', (null === $env) ? 'development' : $env);
 291
 292 // Zend_Application initialisieren
 293 $application = new Zend_Application(
 294     APPLICATION_ENV,
 295     APPLICATION_PATH . '/configs/application.ini'
 296 );
 297
 298 // Die DB Ressource initialisieren und empfangen
 299 $bootstrap = $application->getBootstrap();
 300 $bootstrap->bootstrap('db');
 301 $dbAdapter = $bootstrap->getResource('db');
 302
 303 // Den Benutzer informieren was abgeht
 304 // (wir erstellen hier aktuell eine Datenbank)
 305 if ('testing' != APPLICATION_ENV) {
 306     echo 'Schreiben in die Guestbook Datenbank (control-c um abzubrechen): ' . PHP_EOL;
 307     for ($x = 5; $x > 0; $x--) {
 308         echo $x . "\r"; sleep(1);
 309     }
 310 }
 311
 312 // Prüfen um zu sehen ob wie bereits eine Datenbankdatei haben
 313 $options = $bootstrap->getOption('resources');
 314 $dbFile  = $options['db']['params']['dbname'];
 315 if (file_exists($dbFile)) {
 316     unlink($dbFile);
 317 }
 318
 319 // Dieser Block führt die aktuellen Statements aus welche von der Schemadatei
 320 // geladen werden.
 321 try {
 322     $schemaSql = file_get_contents(dirname(__FILE__) . '/schema.sqlite.sql');
 323     // Die Verbindung direkt verwenden um SQL im Block zu laden
 324     $dbAdapter->getConnection()->exec($schemaSql);
 325     chmod($dbFile, 0666);
 326
 327     if ('testing' != APPLICATION_ENV) {
 328         echo PHP_EOL;
 329         echo 'Datenbank erstellt';
 330         echo PHP_EOL;
 331     }
 332
 333     if ($withData) {
 334         $dataSql = file_get_contents(dirname(__FILE__) . '/data.sqlite.sql');
 335         // Die Verbindung direkt verwenden um SQL in Blöcken zu laden
 336         $dbAdapter->getConnection()->exec($dataSql);
 337         if ('testing' != APPLICATION_ENV) {
 338             echo 'Daten geladen.';
 339             echo PHP_EOL;
 340         }
 341     }
 342
 343 } catch (Exception $e) {
 344     echo 'EIN FEHLER IST AUFGETRETEN:' . PHP_EOL;
 345     echo $e->getMessage() . PHP_EOL;
 346     return false;
 347 }
 348
 349 // Generell gesprochen wird dieses Skript von der Kommandozeile aus aufgerufen
 350 return true;
 351 ]]></programlisting>
 352
 353     <para>
 354         Jetzt führen wir dieses Skript aus. Von einem Terminal oder der DOS Kommandozeile ist das
 355         folgende zu tun:
 356     </para>
 357
 358     <programlisting language="shell"><![CDATA[
 359 % php scripts/load.sqlite.php --withdata
 360 ]]></programlisting>
 361
 362     <para>
 363         Man sollte eine ähnliche Ausgabe wie folgt sehen:
 364     </para>
 365
 366     <programlisting language="text"><![CDATA[
 367 path/to/ZendFrameworkQuickstart/scripts$ php load.sqlite.php --withdata
 368 Schreiben in die Guestbook Datenbank (control-c um abzubrechen):
 369 1
 370 Datenbank erstellt
 371 Daten geladen.
 372 ]]></programlisting>
 373
 374     <para>
 375         Jetzt haben wir eine voll funktionsfähige Datenbank und eine Tabelle für unsere Guestbook
 376         Anwendung. Unsere nächsten paar Schritte sind die Ausarbeitung unseres Anwendungscodes. Das
 377         inkludiert das Bauen einer Datenquelle (in unserem Fall verwenden wir
 378         <classname>Zend_Db_Table</classname>), und einen Daten Mapper um diese Datenquelle mit
 379         unserem Domain Modell zu verbinden. Letztendlich erstellen wir den Controller der mit diesem
 380         Modell interagiert damit sowohl existierende Einträge angezeigt als auch neue Einträge
 381         bearbeitet werden.
 382     </para>
 383
 384     <para>
 385         Wir verwenden ein <ulink
 386             url="http://martinfowler.com/eaaCatalog/tableDataGateway.html">Table Data
 387             Gateway</ulink> um uns mit unserer Datenquelle zu verbinden;
 388         <classname>Zend_Db_Table</classname> bietet diese Funktionalität. Um anzufangen erstellen
 389         wir eine <classname>Zend_Db_Table</classname>-basierende Tabellenklasse. Wie wir es für
 390         Layouts und den Datenbank Adapter getan haben, können wir das <command>zf</command> Tool
 391         verwenden um uns zu assistieren indem der Befehl <command>create db-table</command>
 392         verwendet wird. Dieser nimmt mindestens zwei Argumente, den Namen mit dem man auf die Klasse
 393         referenzieren will, und die Datenbanktabelle auf die Sie zeigt.
 394     </para>
 395
 396     <programlisting language="shell"><![CDATA[\r
 397 % zf create db-table Guestbook guestbook\r
 398 Creating a DbTable at application/models/DbTable/Guestbook.php\r
 399 Updating project profile 'zfproject.xml'\r
 400 ]]></programlisting>\r
 401 \r
 402     <para>
 403         Wenn man in der Verzeichnisbaum sieht, dann wird man jetzt sehen das ein neues Verzeichnis
 404         <filename>application/models/DbTable/</filename> zusammen mit der Datei
 405         <filename>Guestbook.php</filename> erstellt wurde. Wenn man die Datei öffnet wird man den
 406         folgenden Inhalt sehen:\r
 407     </para>\r
 408
 409     <programlisting language="php"><![CDATA[
 410 // application/models/DbTable/Guestbook.php
 411
 412 /**
 413  * Das ist die DbTable Klasse für die Guestbook Tabelle.
 414  */
 415 class Application_Model_DbTable_Guestbook extends Zend_Db_Table_Abstract
 416 {
 417     /** Tabellenname */
 418     protected $_name    = 'guestbook';
 419 }
 420 ]]></programlisting>
 421
 422     <para>
 423         Der Klassenpräfix ist zu beachten: <classname>Application_Model_DbTable</classname>. Der
 424         Klassenpräfix für unser Modul "Application" ist das erste Segment, und dann haben wir die
 425         Komponente "Model_DbTable"; die letztere verweist auf das Verzeichnis
 426         <filename>models/DbTable/</filename> des Moduls.
 427     </para>
 428
 429     <para>
 430         Alles das ist wirklich notwendig wenn <classname>Zend_Db_Table</classname> erweitert wird
 431         um einen Tabellennamen anzubieten und optional den primären Schlüssel (wenn es nicht die
 432         "id" ist).
 433     </para>
 434
 435     <para>
 436         Jetzt erstellen wir einen <ulink
 437             url="http://martinfowler.com/eaaCatalog/dataMapper.html">Daten Mapper</ulink>. Ein
 438         <emphasis>Daten Mapper</emphasis> bildet ein Domain Objekt in der Datenbank ab. In unserem
 439         Fall bildet es unser Modell <classname>Application_Model_Guestbook</classname> auf unsere
 440         Datenquelle, <classname>Application_Model_DbTable_Guestbook</classname>, ab. Eine typische
 441         API für einen Daten Mapper ist wie folgt:
 442     </para>
 443
 444     <programlisting language="php"><![CDATA[
 445 // application/models/GuestbookMapper.php
 446
 447 class Application_Model_GuestbookMapper
 448 {
 449     public function save($model);
 450     public function find($id, $model);
 451     public function fetchAll();
 452 }
 453 ]]></programlisting>
 454
 455     <para>
 456         Zusätzlich zu diesen Methoden, fügen wir Methoden für das Setzen und Holen des Table Data
 457         Gateways hinzu. Um die initiale Klasse zu erstellen kann das <command>zf</command> CLI
 458         Tool verwendet werden:
 459     </para>
 460
 461     <programlisting language="shell"><![CDATA[\r
 462 % zf create model GuestbookMapper\r
 463 Creating a model at application/models/GuestbookMapper.php\r
 464 Updating project profile '.zfproject.xml'\r
 465 ]]></programlisting>\r
 466 \r
 467     <para>
 468         Jetzt muss die Klasse <classname>Application_Model_GuestbookMapper</classname> welche in
 469         <filename>application/models/GuestbookMapper.php</filename> gefunden werden kann so
 470         geändert werden dass Sie wie folgt zu lesen ist:\r
 471     </para>\r
 472
 473     <programlisting language="php"><![CDATA[
 474 // application/models/GuestbookMapper.php
 475
 476 class Application_Model_GuestbookMapper
 477 {
 478     protected $_dbTable;
 479
 480     public function setDbTable($dbTable)
 481     {
 482         if (is_string($dbTable)) {
 483             $dbTable = new $dbTable();
 484         }
 485         if (!$dbTable instanceof Zend_Db_Table_Abstract) {
 486             throw new Exception('Ungültiges Table Data Gateway angegeben');
 487         }
 488         $this->_dbTable = $dbTable;
 489         return $this;
 490     }
 491
 492     public function getDbTable()
 493     {
 494         if (null === $this->_dbTable) {
 495             $this->setDbTable('Application_Model_DbTable_Guestbook');
 496         }
 497         return $this->_dbTable;
 498     }
 499
 500     public function save(Application_Model_Guestbook $guestbook)
 501     {
 502         $data = array(
 503             'email'   => $guestbook->getEmail(),
 504             'comment' => $guestbook->getComment(),
 505             'created' => date('Y-m-d H:i:s'),
 506         );
 507
 508         if (null === ($id = $guestbook->getId())) {
 509             unset($data['id']);
 510             $this->getDbTable()->insert($data);
 511         } else {
 512             $this->getDbTable()->update($data, array('id = ?' => $id));
 513         }
 514     }
 515
 516     public function find($id, Application_Model_Guestbook $guestbook)
 517     {
 518         $result = $this->getDbTable()->find($id);
 519         if (0 == count($result)) {
 520             return;
 521         }
 522         $row = $result->current();
 523         $guestbook->setId($row->id)
 524                   ->setEmail($row->email)
 525                   ->setComment($row->comment)
 526                   ->setCreated($row->created);
 527     }
 528
 529     public function fetchAll()
 530     {
 531         $resultSet = $this->getDbTable()->fetchAll();
 532         $entries   = array();
 533         foreach ($resultSet as $row) {
 534             $entry = new Application_Model_Guestbook();
 535             $entry->setId($row->id)
 536                   ->setEmail($row->email)
 537                   ->setComment($row->comment)
 538                   ->setCreated($row->created);
 539             $entries[] = $entry;
 540         }
 541         return $entries;
 542     }
 543 }
 544 ]]></programlisting>
 545
 546     <para>
 547         Jetzt ist es Zeit unsere Modellklasse zu erstellen. Wir machen dies indem wieder das
 548         Kommando <command>zf create model</command> verwendet wird:
 549     </para>
 550
 551     <programlisting language="shell"><![CDATA[\r
 552 % zf create model Guestbook\r
 553 Creating a model at application/models/Guestbook.php\r
 554 Updating project profile '.zfproject.xml'\r
 555 ]]></programlisting>\r
 556 \r
 557    <para>
 558         Wir verändern diese leere <acronym>PHP</acronym> Klasse um es einfach zu machen das Modell
 559         bekanntzugeben indem ein Array an Daten entweder an den Constructor oder an die
 560         <methodname>setOptions()</methodname> Methode übergeben wird. Das endgültige Modell, welches
 561         in <filename>application/models/Guestbook.php</filename> ist, sollte wie folgt aussehen:
 562     </para>
 563
 564     <programlisting language="php"><![CDATA[
 565 // application/models/Guestbook.php
 566
 567 class Application_Model_Guestbook
 568 {
 569     protected $_comment;
 570     protected $_created;
 571     protected $_email;
 572     protected $_id;
 573
 574     public function __construct(array $options = null)
 575     {
 576         if (is_array($options)) {
 577             $this->setOptions($options);
 578         }
 579     }
 580
 581     public function __set($name, $value)
 582     {
 583         $method = 'set' . $name;
 584         if (('mapper' == $name) || !method_exists($this, $method)) {
 585             throw new Exception('Ungültige Guestbook Eigenschaft');
 586         }
 587         $this->$method($value);
 588     }
 589
 590     public function __get($name)
 591     {
 592         $method = 'get' . $name;
 593         if (('mapper' == $name) || !method_exists($this, $method)) {
 594             throw new Exception('Ungültige Guestbook Eigenschaft');
 595         }
 596         return $this->$method();
 597     }
 598
 599     public function setOptions(array $options)
 600     {
 601         $methods = get_class_methods($this);
 602         foreach ($options as $key => $value) {
 603             $method = 'set' . ucfirst($key);
 604             if (in_array($method, $methods)) {
 605                 $this->$method($value);
 606             }
 607         }
 608         return $this;
 609     }
 610
 611     public function setComment($text)
 612     {
 613         $this->_comment = (string) $text;
 614         return $this;
 615     }
 616
 617     public function getComment()
 618     {
 619         return $this->_comment;
 620     }
 621
 622     public function setEmail($email)
 623     {
 624         $this->_email = (string) $email;
 625         return $this;
 626     }
 627
 628     public function getEmail()
 629     {
 630         return $this->_email;
 631     }
 632
 633     public function setCreated($ts)
 634     {
 635         $this->_created = $ts;
 636         return $this;
 637     }
 638
 639     public function getCreated()
 640     {
 641         return $this->_created;
 642     }
 643
 644     public function setId($id)
 645     {
 646         $this->_id = (int) $id;
 647         return $this;
 648     }
 649
 650     public function getId()
 651     {
 652         return $this->_id;
 653     }
 654 }
 655 ]]></programlisting>
 656
 657     <para>
 658         Letztendlich, um diese Elemente alle zusammen zu verbinden, erstellen wir einen Guestbook
 659         Controller der die Einträge auflistet welche aktuell in der Datenbank sind.
 660     </para>
 661
 662     <para>
 663         Um einen neuen Controller zu erstellen muss das Kommando
 664         <command>zf create controller</command> verwendet werden:
 665     </para>
 666
 667     <programlisting language="shell"><![CDATA[
 668 % zf create controller Guestbook\r
 669 Creating a controller at\r
 670     application/controllers/GuestbookController.php\r
 671 Creating an index action method in controller Guestbook\r
 672 Creating a view script for the index action method at\r
 673     application/views/scripts/guestbook/index.phtml\r
 674 Creating a controller test file at\r
 675     tests/application/controllers/GuestbookControllerTest.php\r
 676 Updating project profile '.zfproject.xml'
 677 ]]></programlisting>
 678
 679     <para>
 680         Das erstellt einen neuen Controller, <classname>GuestbookController</classname>, in
 681         <filename>application/controllers/GuestbookController.php</filename> mit einer einzelnen
 682         Aktions Methode, <methodname>indexAction()</methodname>. Er erstellt auch ein View Skript
 683         Verzeichnis für den Controller, <filename>application/views/scripts/guestbook/</filename>,
 684         mit einem View Skript für die Index Aktion.
 685     </para>
 686
 687     <para>
 688         Wir verwenden die "index" Aktion als Landeseite um alle Guestbook Einträge anzusehen.
 689     </para>
 690
 691     <para>
 692         Jetzt betrachten wir die grundsätzliche Anwendungslogik. Bei einem Treffer auf
 693         <methodname>indexAction()</methodname> zeigen wir alle Guestbook Einträge an. Das würde wie
 694         folgt aussehen:
 695     </para>
 696
 697     <programlisting language="php"><![CDATA[
 698 // application/controllers/GuestbookController.php
 699
 700 class GuestbookController extends Zend_Controller_Action
 701 {
 702     public function indexAction()
 703     {
 704         $guestbook = new Application_Model_GuestbookMapper();
 705         $this->view->entries = $guestbook->fetchAll();
 706     }
 707 }
 708 ]]></programlisting>
 709
 710     <para>
 711         Und natürlich benötigen wir ein View Skript um damit weiterzumachen.
 712         <filename>application/views/scripts/guestbook/index.phtml</filename> ist zu bearbeiten damit
 713         Sie wie folgt aussieht:
 714     </para>
 715
 716     <programlisting language="php"><![CDATA[
 717 <!-- application/views/scripts/guestbook/index.phtml -->
 718
 719 <p><a href="<?php echo $this->url(
 720     array(
 721         'controller' => 'guestbook',
 722         'action'     => 'sign'
 723     ),
 724     'default',
 725     true) ?>">Im Guestbook eintragen</a></p>
 726
 727 Guestbook Einträge: <br />
 728 <dl>
 729     <?php foreach ($this->entries as $entry): ?>
 730     <dt><?php echo $this->escape($entry->email) ?></dt>
 731     <dd><?php echo $this->escape($entry->comment) ?></dd>
 732     <?php endforeach ?>
 733 </dl>
 734 ]]></programlisting>
 735
 736     <note>
 737         <title>Checkpoint</title>
 738
 739         <para>
 740             Jetzt gehen wir auf "http://localhost/guestbook". Man sollte das folgende im Browser
 741             sehen:
 742         </para>
 743
 744         <para>
 745             <inlinegraphic width="525" scale="100" align="center" valign="middle"
 746                 fileref="figures/learning.quickstart.create-model.png" format="PNG" />
 747         </para>
 748     </note>
 749
 750     <note>
 751         <title>Das Datenlade Skript verwenden</title>
 752
 753         <para>
 754             Das Datenlade Skript welches in diesem Kapitel beschrieben wird
 755             (<filename>scripts/load.sqlite.php</filename>) kann verwendet werden um die Datenbank,
 756             für jede Umgebung die man definiert hat, zu erstellen sowie Sie mit Beispieldaten zu
 757             laden. Intern verwendet es <classname>Zend_Console_Getopt</classname>, was es erlaubt
 758             eine Anzahl von Kommandozeilen Schalter anzubieten. Wenn man den "-h" oder "--help"
 759             Schalter übergibt, werden die folgenden Optionen angegeben:
 760         </para>
 761
 762         <programlisting language="php"><![CDATA[
 763 Usage: load.sqlite.php [ options ]
 764 --withdata|-w         Datenbank mit einigen Daten laden
 765 --env|-e [  ]         Anwendungsumgebung für welche die Datenbank erstellt wird
 766                       (Standard ist Development)
 767 --help|-h             Hilfe -- Verwendung)]]
 768 ]]></programlisting>
 769
 770         <para>
 771             Der "-e" Schalter erlaubt es den Wert zu spezifizieren der für die Konstante
 772             <constant>APPLICATION_ENV</constant> verwendet wird -- welcher es erlaubt eine SQLite
 773             Datenbank für jede Umgebung zu erstellen die man definiert. Man sollte sicherstellen
 774             dass das Skript für die Umgebung gestartet wird welche man für die eigene Anwendung
 775             ausgewählt hat wenn man in Betrieb geht.
 776         </para>
 777     </note>
 778 </sect1>