galileocomputing_zendframework2

  • Published on
    18-Oct-2015

  • View
    64

  • Download
    0

Transcript

  • Ralf Eggert Zend Framework 2 Das Praxisbuch
  • Auf einen Blick Auf einen Blick TEIL I Die Grundlagen 1 Einführung in das Zend Framework 2 ............................................................. 27 2 Neuerungen im Zend Framework 2 ................................................................. 33 3 Das Zend Framework einrichten ...................................................................... 53 TEIL II Die Komponenten 4 Basis-Komponenten ............................................................................................. 87 5 Der Event-Manager ............................................................................................... 117 6 Service Location & Dependency Injection ..................................................... 127 7 Der Modul-Manager ............................................................................................. 151 8 MVC-Komponenten .............................................................................................. 183 9 View-Komponenten .............................................................................................. 237 10 Datenbank-Komponenten .................................................................................. 257 11 Ausgabe-Komponenten ...................................................................................... 289 12 Formularverarbeitung .......................................................................................... 315 13 Benutzermanagement ......................................................................................... 351 14 Sonstige Komponenten ....................................................................................... 369 TEIL III Die Module 15 Das Anwendungsmodul ...................................................................................... 383 16 Das Blog-Modul ...................................................................................................... 411 17 Das Benutzer-Modul ............................................................................................. 453 18 Das Pizza-Modul ..................................................................................................... 483 19 Das Kommentar-Modul ....................................................................................... 505 20 Das Spamabwehr-Modul .................................................................................... 525 21 Das CMS-Modul ...................................................................................................... 549 22 Das Shop-Modul ..................................................................................................... 565
  • Inhalt 5 Inhalt Geleitwort .............................................................................................................................................. 19 Vorwort .................................................................................................................................................. 21 Vorwort des Autors zur Vorauflage .............................................................................................. 23 TEIL I Die Grundlagen 1 Einführung in das Zend Framework 2 27 1.1 Abgrenzung zu anderen PHP-Frameworks ........................................................ 27 1.2 Die Zielgruppe des Buches .................................................................................... 28 1.3 Wegweiser ................................................................................................................ 28 1.4 Überblick über die Komponenten ........................................................................ 29 1.5 Listings, Projektdateien, Programmierrichtlinien ............................................ 31 1.6 Der Zend Framework 2-Kosmos ........................................................................... 31 1.7 Links zum Buch ........................................................................................................ 32 2 Neuerungen im Zend Framework 2 33 2.1 Begrifflichkeiten ...................................................................................................... 33 2.2 PHP-Version .............................................................................................................. 34 2.2.1 PHP-Namespaces ....................................................................................... 34 2.2.2 Closures ....................................................................................................... 36 2.2.3 Late Static Binding ..................................................................................... 38 2.3 Git und GitHub ......................................................................................................... 39 2.4 Neue Konzepte ........................................................................................................ 40 2.4.1 Verbesserte Modularität ........................................................................... 40 2.4.2 Dependency Injection ................................................................................ 41 2.4.3 Service-Locator ........................................................................................... 43 2.4.4 Ereignisgesteuerte Architektur ................................................................ 45 2.5 Komponentenvergleich ......................................................................................... 48 2.6 Vor- und Nachteile des ZF2 ................................................................................... 50
  • Inhalt 6 3 Das Zend Framework einrichten 53 3.1 Voraussetzungen .................................................................................................... 53 3.1.1 PHP-Version ................................................................................................ 53 3.1.2 PHP-Extensions .......................................................................................... 54 3.1.3 Apache 2-Konfiguration ............................................................................ 57 3.1.4 Virtual Host einrichten unter Linux ......................................................... 57 3.1.5 Virtual Host einrichten unter Windows .................................................. 59 3.1.6 Weitere Informationen ............................................................................. 60 3.2 Zend Framework 2 installieren ............................................................................. 61 3.2.1 Installation aus einem ZIP-Paket .............................................................. 61 3.2.2 Installation mit Pyrus ................................................................................ 62 3.2.3 Installation mit Composer ........................................................................ 65 3.3 SkeletonApplication installieren ......................................................................... 68 3.3.1 Installation aus einem ZIP-Paket .............................................................. 69 3.3.2 Installation mit Git ..................................................................................... 69 3.3.3 Einrichtung mit Composer ........................................................................ 70 3.4 Struktur einer Zend Framework 2-Anwendung ................................................ 71 3.4.1 Hauptverzeichnis ....................................................................................... 71 3.4.2 Das Konfigurationsverzeichnis ................................................................. 73 3.4.3 Das Public-Verzeichnis .............................................................................. 74 3.4.4 Vendor-Verzeichnis .................................................................................... 76 3.4.5 Das Modulverzeichnis ............................................................................... 77 3.4.6 Kaskadierendes Laden der Konfigurationsdaten ................................... 82 3.4.7 Autoloading mit Composer ...................................................................... 83 TEIL II Die Komponenten 4 Basis-Komponenten 87 4.1 Zend\Loader ............................................................................................................. 87 4.1.1 StandardAutoloader .................................................................................. 88 4.1.2 ClassMapAutoloader ................................................................................. 88 4.1.3 AutoloaderFactory ..................................................................................... 89 4.1.4 Eigenen Autoloader erstellen ................................................................... 90 4.2 Zend\Config ............................................................................................................. 90 4.2.1 Konfigurationsdateien lesen .................................................................... 90 4.2.2 Konfigurationsdateien schreiben ............................................................ 91
  • Inhalt 7 4.3 Zend\Cache .............................................................................................................. 92 4.3.1 Cache-Storages .......................................................................................... 92 4.3.2 Storage-Plugins und Capabilities ............................................................. 94 4.3.3 Cache-Patterns ........................................................................................... 95 4.4 Zend\Log ................................................................................................................... 96 4.4.1 Zusammenspiel der Teilkomponenten ................................................... 97 4.4.2 Writer .......................................................................................................... 98 4.4.3 Formatter .................................................................................................... 98 4.4.4 Filter ............................................................................................................. 98 4.5 Zend\Mail und Zend\Mime .................................................................................. 99 4.5.1 Eine E-Mail-Nachricht erstellen ................................................................ 100 4.5.2 Eine E-Mail-Nachricht versenden ............................................................. 100 4.5.3 MIME-Nachricht erstellen ......................................................................... 101 4.5.4 E-Mail-Nachrichten abrufen ..................................................................... 102 4.6 Zend\Filter ................................................................................................................ 103 4.6.1 Standardfilter ............................................................................................. 104 4.6.2 Statische Filter ............................................................................................ 106 4.6.3 Filterketten ................................................................................................. 107 4.6.4 Eigenen Filter erstellen .............................................................................. 107 4.7 Zend\Validator ........................................................................................................ 108 4.7.1 Standardvalidatoren .................................................................................. 109 4.7.2 Statische Validatoren ................................................................................ 111 4.7.3 Validatorketten .......................................................................................... 112 4.7.4 Eigenen Validator erstellen ....................................................................... 113 4.7.5 Validator-Fehlermeldungen anpassen .................................................... 115 5 Der Event-Manager 117 5.1 Einführung ................................................................................................................ 117 5.2 EventManagerAwareInterface ............................................................................. 118 5.3 Listener mit Closures umsetzen ........................................................................... 119 5.4 Listener mit Aggregaten umsetzen ..................................................................... 121 5.5 Übergabe von Parametern an Listener ............................................................... 124 5.6 SharedEventManager ............................................................................................. 124
  • Inhalt 8 6 Service Location & Dependency Injection 127 6.1 Zend\ServiceManager ............................................................................................ 127 6.1.1 Beispielklassen ........................................................................................... 128 6.1.2 Unterstützte Instanziierungsarten .......................................................... 130 6.1.3 Den Service-Manager konfigurieren ........................................................ 131 6.1.4 Konfigurationsklasse ................................................................................. 132 6.1.5 Konfigurationsdatei ................................................................................... 133 6.1.6 Initializer einrichten .................................................................................. 135 6.1.7 Abstrakte Fabrik verwenden ..................................................................... 137 6.1.8 Den Service-Manager richtig nutzen ....................................................... 140 6.2 Zend\Di ..................................................................................................................... 141 6.2.1 Automatische Erkennung mit »RuntimeDefinition« ............................. 141 6.2.2 Definition kompilieren mit »CompilerDefinition« ................................. 144 6.2.3 Abhängigkeiten konfigurieren ................................................................. 147 6.2.4 Zend\Di richtig nutzen .............................................................................. 150 7 Der Modul-Manager 151 7.1 Einführung ................................................................................................................ 151 7.2 Aufbau eines Moduls .............................................................................................. 152 7.2.1 Die Modul-Klasse ....................................................................................... 153 7.2.2 Das Konfigurationsverzeichnis ................................................................. 155 7.2.3 Assets im Public-Verzeichnis .................................................................... 155 7.2.4 Das Source-Verzeichnis ............................................................................. 156 7.2.5 Tests ............................................................................................................ 156 7.2.6 Das View-Verzeichnis ................................................................................ 157 7.3 Modulkonfiguration ............................................................................................... 157 7.3.1 Autoloading konfigurieren ....................................................................... 157 7.3.2 Konfigurationsdaten bereitstellen .......................................................... 158 7.3.3 Services konfigurieren ............................................................................... 161 7.3.4 Controller konfigurieren ........................................................................... 164 7.3.5 Controller-Plugins konfigurieren ............................................................. 166 7.3.6 View-Helper konfigurieren ....................................................................... 167 7.3.7 Weitere Konfigurationen .......................................................................... 169 7.4 Ein Anwendungsmodul entwickeln .................................................................... 169 7.4.1 Die Modul-Klasse ....................................................................................... 170 7.4.2 Modulkonfiguration .................................................................................. 171
  • Inhalt 9 7.4.3 Controller und View-Script einrichten ..................................................... 173 7.4.4 Request-Parameter verwenden ............................................................... 175 7.5 Library-Modul erstellen ......................................................................................... 177 7.6 Fremdmodule installieren ..................................................................................... 179 7.6.1 Die ZendDeveloperTools mit Composer installieren ............................. 179 7.6.2 ZfcUser und ZfcBase mit Git klonen ........................................................ 181 8 MVC-Komponenten 183 8.1 Einführung ................................................................................................................ 183 8.2 Application ............................................................................................................... 184 8.2.1 Initialisierungsprozess ............................................................................... 184 8.2.2 Bootstrapping ............................................................................................. 186 8.2.3 Der Verarbeitungsprozess ......................................................................... 188 8.3 Services ...................................................................................................................... 189 8.4 Routing ...................................................................................................................... 192 8.4.1 Route-Typen ............................................................................................... 192 8.4.2 Der Route-Typ »Hostname« ...................................................................... 193 8.4.3 Der Route-Typ »Literal« ............................................................................. 194 8.4.4 Der Route-Typ »Regex« ............................................................................. 195 8.4.5 Der Route-Typ »Segment« ........................................................................ 196 8.4.6 SimpleRouteStack ...................................................................................... 197 8.4.7 TreeRouteStack .......................................................................................... 198 8.4.8 Routing konfigurieren ............................................................................... 201 8.4.9 Routing-Tipps ............................................................................................. 203 8.5 Events ........................................................................................................................ 205 8.5.1 Das »route«-Event für die Sprachfestlegung nutzen ............................. 205 8.5.2 Das »dispatch.error«-Event für das Logging nutzen .............................. 206 8.5.3 Das »finish«-Event für die Zeitmessung nutzen .................................... 209 8.6 Controller .................................................................................................................. 211 8.6.1 Einführung .................................................................................................. 211 8.6.2 Action-Controller ....................................................................................... 212 8.6.3 Zugriff auf Objekte .................................................................................... 214 8.6.4 Services injizieren ....................................................................................... 215 8.6.5 RESTful-Controller ...................................................................................... 218 8.7 Controller-Plugins ................................................................................................... 224 8.7.1 Zugriff auf Plugins ..................................................................................... 224
  • Inhalt 10 8.7.2 Das »Layout«-Plugin .................................................................................. 225 8.7.3 Das »Url«-Plugin ........................................................................................ 225 8.7.4 Das »Redirect«-Plugin ................................................................................ 227 8.7.5 Das »Forward«-Plugin ............................................................................... 227 8.7.6 Das »Params«-Plugin ................................................................................. 229 8.7.7 Das »PostRedirectGet«-Plugin .................................................................. 229 8.7.8 Das »FilePostRedirectGet«-Plugin ............................................................ 231 8.7.9 Das »FlashMessenger«-Plugin .................................................................. 233 8.7.10 Ein eigenes Plugin erstellen ...................................................................... 234 9 View-Komponenten 237 9.1 Einführung in Zend\View ...................................................................................... 237 9.1.1 Bestandteile ................................................................................................ 237 9.1.2 Teilkomponenten ....................................................................................... 238 9.1.3 Konfiguration ............................................................................................. 240 9.2 ViewModels .............................................................................................................. 241 9.2.1 ViewModels verschachteln ....................................................................... 242 9.2.2 Weitere View-Models ................................................................................ 243 9.3 Resolver, Renderer und Strategies ...................................................................... 244 9.3.1 Resolver ....................................................................................................... 244 9.3.2 Renderer ...................................................................................................... 245 9.3.3 Strategies .................................................................................................... 245 9.4 View-Scripts .............................................................................................................. 247 9.5 View-Helper .............................................................................................................. 248 9.5.1 View-Helper für HTML-Kopfdaten ........................................................... 249 9.5.2 View-Helper für URLs ................................................................................. 250 9.5.3 View-Helper für das Escaping ................................................................... 250 9.5.4 Weitere View-Helper ................................................................................. 251 9.5.5 Einen eigenen View-Helper erstellen ...................................................... 253 9.6 Template-Engines ................................................................................................... 256 10 Datenbank-Komponenten 257 10.1 Das Datenbankmodell ............................................................................................ 257 10.2 Datenbankadapter .................................................................................................. 258
  • Inhalt 11 10.2.1 Konfiguration eines Adapters ................................................................... 258 10.2.2 Ausführen von lesenden Abfragen .......................................................... 260 10.2.3 Ausführen von schreibenden Abfragen .................................................. 261 10.2.4 ResultSet für Adapter konfigurieren ........................................................ 262 10.3 SQL-Abfragen generieren ...................................................................................... 265 10.3.1 Lesende Abfragen generieren ................................................................... 265 10.3.2 Schreibende Abfragen generieren ........................................................... 268 10.3.3 Abfragen mit DDL generieren ................................................................... 270 10.4 Gateway-Klassen ..................................................................................................... 271 10.4.1 Zend\Db\TableGateway ........................................................................... 271 10.4.2 TableGateway-Features ............................................................................ 274 10.4.3 Zend\Db\RowGateway ............................................................................. 278 10.5 Doctrine 2 .................................................................................................................. 281 10.5.1 Installation und Konfiguration ................................................................. 281 10.5.2 Modul und Entitäten vorbereiten ............................................................ 282 10.5.3 Doctrine 2 einsetzen .................................................................................. 286 11 Ausgabe-Komponenten 289 11.1 Zend\I18n .................................................................................................................. 289 11.1.1 Translator .................................................................................................... 289 11.1.2 View-Helper ................................................................................................ 292 11.1.3 Fehlermeldungen für Zend\Validator übersetzen ................................. 294 11.2 Zend\Navigation ..................................................................................................... 295 11.2.1 Container und Seiten anlegen .................................................................. 295 11.2.2 Navigation konfigurieren .......................................................................... 297 11.2.3 Navigation ausgeben ................................................................................ 299 11.2.4 Navigation und ACL ................................................................................... 301 11.3 Zend\Paginator ....................................................................................................... 302 11.3.1 Adapter für Zend\Paginator ..................................................................... 303 11.3.2 Seitennavigation ........................................................................................ 305 11.4 Zend\Feed ................................................................................................................. 309 11.4.1 Feeds lesen .................................................................................................. 309 11.4.2 Feeds schreiben .......................................................................................... 310 11.4.3 Feeds mit Zend\Mvc und Zend\View ...................................................... 311 11.5 Weitere Hilfskomponenten .................................................................................. 312 11.5.1 Zend\Escaper .............................................................................................. 312
  • Inhalt 12 11.5.2 Zend\Json ................................................................................................... 312 11.5.3 Zend\Tag ..................................................................................................... 313 11.5.4 Zend\Barcode ............................................................................................. 314 12 Formularverarbeitung 315 12.1 Zend\InputFilter ...................................................................................................... 315 12.1.1 Ein InputFilter-Objekt erstellen ................................................................ 315 12.1.2 Factory mit Konfigurationsdaten nutzen ................................................ 317 12.1.3 InputFilter als eigenständige Klassen ...................................................... 318 12.1.4 Hierarchische InputFilter .......................................................................... 320 12.1.5 InputFilter im MVC .................................................................................... 322 12.2 Zend\Form ................................................................................................................ 322 12.2.1 Einführung .................................................................................................. 323 12.2.2 Ein Form-Objekt erstellen ......................................................................... 323 12.2.3 Fieldsets ...................................................................................................... 325 12.2.4 Collections .................................................................................................. 328 12.2.5 Elemente ..................................................................................................... 331 12.2.6 Ausgabe mit View-Helpern ....................................................................... 333 12.2.7 Validierung von Formularen ..................................................................... 337 12.2.8 Objekte anbinden ...................................................................................... 340 12.2.9 Annotationen ............................................................................................. 343 12.2.10 Datei-Uploads ............................................................................................ 346 13 Benutzermanagement 351 13.1 Zend\Session ............................................................................................................ 351 13.1.1 Mit Session-Containern arbeiten ............................................................. 351 13.1.2 Session-Manager verwenden ................................................................... 352 13.1.3 Sessions in der Datenbank speichern ...................................................... 353 13.2 Zend\Permissions\Acl ............................................................................................ 355 13.2.1 Begrifflichkeiten ......................................................................................... 355 13.2.2 ACL definieren ............................................................................................ 355 13.2.3 ACL abfragen .............................................................................................. 357 13.2.4 ACL cachen .................................................................................................. 357 13.3 Zend\Permissions\Rbac ........................................................................................ 358 13.3.1 Begrifflichkeiten ......................................................................................... 358
  • Inhalt 13 13.3.2 RBAC definieren ......................................................................................... 359 13.3.3 RBAC abfragen ............................................................................................ 360 13.4 Zend\Authentication ............................................................................................. 361 13.4.1 Per HTTP authentifizieren ......................................................................... 361 13.4.2 Gegen eine Datenbanktabelle authentifizieren ..................................... 363 13.4.3 Authentifizierungsservice ......................................................................... 365 13.5 Zend\Ldap ................................................................................................................. 368 14 Sonstige Komponenten 369 14.1 Zend\Http ................................................................................................................. 369 14.1.1 HTTP-Anfrage senden und verarbeiten ................................................... 369 14.1.2 Verbindungsadapter .................................................................................. 370 14.1.3 Fortgeschrittener Einsatz .......................................................................... 370 14.2 Zend\Soap ................................................................................................................ 371 14.2.1 SOAP-Server bereitstellen ......................................................................... 371 14.2.2 SOAP-Client einsetzen ............................................................................... 373 14.3 Zend\XmlRpc ........................................................................................................... 374 14.3.1 XML-RPC-Server bereitstellen ................................................................... 374 14.3.2 XML-RPC-Client einsetzen ......................................................................... 375 14.4 Zend\Crypt ............................................................................................................... 376 14.5 Zend\Stdlib ............................................................................................................... 377 TEIL III Die Module 15 Das Anwendungsmodul 383 15.1 Anforderungen ........................................................................................................ 383 15.2 Anwendungsmodul konfigurieren ...................................................................... 384 15.3 Eigene View-Helper ................................................................................................ 388 15.3.1 Der View-Helper »PageTitle« .................................................................... 388 15.3.2 Der View-Helper »ShowMessages« ......................................................... 389 15.3.3 Der View-Helper »ShowForm« ................................................................. 391 15.3.4 Der View-Helper »Date« ............................................................................ 393
  • Inhalt 14 15.4 Mehrstufiges Seitenlayout .................................................................................. 395 15.5 Menü im Seitenkopf einrichten ......................................................................... 399 15.6 Controller und View-Scripts ................................................................................ 401 15.7 Meldungen der Validatoren übersetzen .......................................................... 402 15.8 Pagination ............................................................................................................... 403 15.9 Eigene Filter ............................................................................................................ 404 15.9.1 Der »StringToUrl«-Filter .......................................................................... 404 15.9.2 Der »StringHtmlPurifier«-Filter .............................................................. 406 15.9.3 Konfiguration für beide Filter ................................................................. 407 15.10 CKEditor ................................................................................................................... 409 16 Das Blog-Modul 411 16.1 Anforderungen ........................................................................................................ 411 16.2 Das Blog-Modul einrichten ................................................................................... 412 16.3 Modelinfrastruktur ................................................................................................. 419 16.3.1 Datenbank einrichten ................................................................................ 419 16.3.2 Klassen erstellen ........................................................................................ 421 16.4 Filter und Formulare ............................................................................................... 425 16.4.1 Filter und Validierung ................................................................................ 426 16.4.2 Formularklasse ........................................................................................... 427 16.4.3 Factories ...................................................................................................... 429 16.5 Den Blog-Service einrichten .................................................................................. 431 16.5.1 Formular-Objekte injizieren ...................................................................... 432 16.5.2 Der Blog-Service – Überblick ..................................................................... 433 16.6 Öffentlicher Bereich ................................................................................................ 440 16.6.1 Action-Controller einrichten ..................................................................... 440 16.6.2 View-Scripts einrichten ............................................................................. 443 16.7 Administrationsbereich ......................................................................................... 444 16.7.1 Action-Controller einrichten ..................................................................... 445 16.7.2 View-Scripts einrichten ............................................................................. 447 16.8 Optimierungen ........................................................................................................ 451
  • Inhalt 15 17 Das Benutzer-Modul 453 17.1 Anforderungen ........................................................................................................ 453 17.2 Vorbereitungen ....................................................................................................... 454 17.3 Authentifizierung und Autorisierung ................................................................. 455 17.3.1 Authentifizierungsadapter ....................................................................... 456 17.3.2 Authentifizierungsservice ......................................................................... 460 17.3.3 Autorisierungsservice ................................................................................ 461 17.3.4 Konfiguration der Benutzerrechte ........................................................... 464 17.4 User-Service einrichten .......................................................................................... 466 17.5 View-Helper einrichten .......................................................................................... 470 17.5.1 Der View-Helper »UserIsAllowed« ........................................................... 470 17.5.2 Der View-Helper »UserShowWidget« ..................................................... 471 17.6 UserListener einrichten .......................................................................................... 475 17.7 Öffentlicher Bereich ................................................................................................ 478 17.7.1 Den Action-Controller einrichten ............................................................. 478 17.7.2 View-Scripts einrichten ............................................................................. 481 18 Das Pizza-Modul 483 18.1 Anforderungen ........................................................................................................ 483 18.2 Vorbereitungen ....................................................................................................... 484 18.3 Modelinfrastruktur ................................................................................................. 485 18.4 Pizza-Service einrichten ......................................................................................... 490 18.5 Formulare einrichten .............................................................................................. 494 18.6 Bild-Upload einrichten ........................................................................................... 498 18.7 Administrationsbereich ......................................................................................... 501 18.8 Ein Pizza-Karussell einrichten ............................................................................... 502 19 Das Kommentar-Modul 505 19.1 Anforderungen ........................................................................................................ 505 19.2 Vorbereitungen ....................................................................................................... 506
  • Inhalt 16 19.3 Modul-Konfiguration ............................................................................................. 508 19.4 View-Helper einrichten .......................................................................................... 511 19.4.1 Der View-Helper »CommentShowLinks« ................................................ 511 19.4.2 Der View-Helper »CommentShowComments« ..................................... 513 19.4.3 Einsatz der View-Helper ............................................................................ 516 19.5 Kommentare anlegen ............................................................................................ 519 19.6 Kommentar-Service erweitern ............................................................................. 521 20 Das Spamabwehr-Modul 525 20.1 Anforderungen ........................................................................................................ 525 20.2 Vorbereitungen ....................................................................................................... 526 20.3 Modul-Konfiguration ............................................................................................. 527 20.4 Autoloading .............................................................................................................. 529 20.5 Spamabwehr-Service .............................................................................................. 530 20.6 Controller-Plugin ..................................................................................................... 532 20.7 Der View-Helper »SpamCheck« ........................................................................... 534 20.8 Spamabwehr im Kommentar-Modul nutzen .................................................... 535 20.8.1 Konfiguration anpassen ............................................................................ 536 20.8.2 Entität anpassen ........................................................................................ 537 20.8.3 Den Kommentar-Service anpassen .......................................................... 537 20.8.4 Action-Controller anpassen ...................................................................... 539 20.8.5 View-Scripts anpassen .............................................................................. 542 20.9 Das Spamabwehr-Modul im Einsatz ................................................................... 545 21 Das CMS-Modul 549 21.1 Anforderungen ........................................................................................................ 549 21.2 Vorbereitungen ....................................................................................................... 550 21.2.1 Konfiguration ............................................................................................. 551 21.2.2 CMS-Service ................................................................................................ 552 21.2.3 Textblöcke ................................................................................................... 553 21.2.4 View-Helper zur Ausgabe von Textblöcken ............................................ 553
  • Inhalt 17 21.3 Ein Formular einrichten ......................................................................................... 555 21.4 CMS-Service erweitern ......................................................................................... 556 21.5 View-Helper für das Bearbeiten erweitern ...................................................... 558 21.6 JavaScript-Funktionen .......................................................................................... 560 21.7 Controller einrichten ............................................................................................ 562 22 Das Shop-Modul 565 22.1 Anforderungen ...................................................................................................... 565 22.2 Vorbereitungen ..................................................................................................... 566 22.3 Modelinfrastruktur ............................................................................................... 567 22.4 Bestellservice .......................................................................................................... 573 22.5 Warenkorb-Service ............................................................................................... 576 22.6 Controller-Plugin ................................................................................................... 580 22.7 View-Helper ............................................................................................................ 581 22.7.1 Der View-Helper »ShowBasket« ............................................................. 581 22.7.2 Der View-Helper »GetOrder« .................................................................. 586 22.8 Der Warenkorb-Controller .................................................................................. 587 22.9 Warenkorb-View-Scripts ..................................................................................... 589 22.10 Den Warenkorb im Pizza-Modul einsetzen ..................................................... 593 22.11 Das Warenkorb-Modul im Einsatz ..................................................................... 594 Anhang 599 A Installation der Projektdateien ............................................................................ 601 A.1 ZIP-Pakete downloaden ......................................................................... 601 A.2 Dateien von GitHub klonen ................................................................... 602 A.3 Installation ohne Composer .................................................................. 602 A.4 Virtual Host anpassen ............................................................................. 603 B Weitere Komponenten .......................................................................................... 605 C Performance-Tipps .................................................................................................. 607 C.1 Autoloader ClassMap .............................................................................. 607
  • Inhalt 18 C.2 TemplateMap ............................................................................................ 607 C.3 Die Modul-Konfiguration cachen ......................................................... 608 C.4 Weitere Caches ......................................................................................... 608 Index ........................................................................................................................................................ 611
  • 33 2 Kapitel 2 Neuerungen im Zend Framework 2 Viele Umsteiger vom Zend Framework 1 sind besonders an den Neuerungen interes- siert, die das Zend Framework 2 mit sich bringt. Für Umsteiger hat sich im ZF2 einiges geändert, sodass sie sich auf einen erneuten Lernaufwand einstellen müssen. Diese Hürde sollte jedoch niemanden abschrecken. Wer sich einmal in die neuen Konzepte und Komponenten eingearbeitet hat, der wird sie zukünftig nicht mehr missen wol- len. Die größten Probleme treten am ehesten auf, wenn eine viel genutzte ZF1-Kom- ponente im ZF2 nicht mehr zum Framework-Kern gehört. In solch einem Fall können Sie bei Bedarf zumindest übergangsweise immer noch die ZF1-Komponenten ver- wenden. Dieses Kapitel fasst die wesentlichen Änderungen beim Umstieg vom ZF1 auf das ZF2 zusammen. Wenn Sie sich bereits mit dem ZF1 auskennen, sollten Sie sich dieses Kapitel aufmerksam durchlesen. Einsteiger ins Zend Framework 2 sollten die Abschnitte über PHP 5.3, Git und GitHub sowie die neuen Konzepte genauer in Augenschein nehmen. Alle Listings aus diesem Kapitel finden Sie auf der buchbegleitenden Bonus-Seite. Details zur Installation finden Sie in Anhang A, »Installation der Projektdateien«. 2.1 Begrifflichkeiten Einige Begriffe werden in diesem Buch von Beginn an sehr häufig gebraucht, auch wenn diese im ZF1 für den Anwender nicht ganz so allgegenwärtig waren, wie sie es im ZF2 sind. Interfaces wurden bereits im ZF1 an vielen Stellen eingesetzt. Wenn Sie das ZF2 ein- setzen, kommen Sie damit häufiger in Berührung. Ein Interface gibt vor, welche Methoden mit welchen Parametern in einer Klasse vorhanden sein müssen, wenn diese Klasse das Interface implementiert. Für Klassen, die von anderen Klassen ver- wendet werden, wird empfohlen, ein Interface als Basis zu erschaffen und dieses auch in den Methodensignaturen zu verwenden. Es heißt also nicht: function bakePizza(Pizza $pizza) sondern:
  • 2 Neuerungen im Zend Framework 2 34 function bakePizza(PizzaInterface $pizza) Die Aufgabe von Factories ist es, ein Objekt zu erstellen. Dabei wird nicht einfach der Konstruktor dieser Klasse aufgerufen. Sondern es wird die Factory aufgerufen, die verschiedene Vorbereitungen trifft, um dann den Konstruktor aufzurufen. Diese Vorbereitungen sind in der Regel die Bereitstellung von anderen Objekten, die der Konstruktor bei der Initialisierung benötigt. Factories können als Klassen, Methoden oder Closures implementiert sein. In einer Modelinfrastruktur kann es verschiedene Bestandteile geben. Eine Entität stellt dabei ein einfaches Objekt, wie z. B. eine Pizza, ein Buch oder einen Blogbeitrag dar. Eine Datenquelle ist dafür zuständig, die Daten für eine Entität aus einer Daten- bank oder einer anderen Datenquelle zu lesen. Um die Daten aus einer Datenquelle an eine Entität zu übergeben, bedarf es eines Mappers. Ein Hydrator ist ebenfalls eine Art Mapper, der Daten eines Arrays an ein Objekt übergeben kann und umgekehrt. Ein Model-Service hält alles zusammen. Er kommuniziert mit Datenquellen und Mappern, verarbeitet Entitäten, setzt Hydratoren ein und stellt eine Schnittstelle bereit, damit Controller auf die Modelinfrastruktur zugreifen können. 2.2 PHP-Version Die augenscheinlichste Neuerung ist der Wechsel auf PHP 5.3 als Mindestanforde- rung für das Zend Framework 2. Setzte das Zend Framework 1 noch PHP 5.2 voraus, so konnten durch den Umstieg auf PHP 5.3 eine Vielzahl neuer Funktionen genutzt wer- den. Der Zend Framework 2-Nutzer kommt am ehesten mit dem Einsatz von Namensräumen und der Verwendung von Closures in Berührung. Das Zend Frame- work 2 macht aber auch regen Gebrauch vom Late Static Binding. Trotz allem sollten Sie neue Projekte am besten gleich auf PHP 5.4 aufsetzen, da auch PHP 5.3 langsam in die Jahre gekommen ist. 2.2.1 PHP-Namespaces In PHP 5.2 wurden keine Namensräume unterstützt. Deshalb wurden im Zend Frame- work 1 künstliche Namensräume geschaffen, um die Klassen auf die Dateiebene abbilden zu können. Ein Beispiel: Die Klasse Zend_Loader_Autoloader ist im Zend Framework 1 in der Datei /library/Zend/Loader/Autoloader.php abgelegt. Durch diese künstlichen Namensräume wird sichergestellt, dass es nicht zu Namenskollisi- onen mit anderen Autoloader-Klassen aus anderen Bibliotheken kommt. PHP 5.3 bietet echte Namensräume, sodass im Zend Framework 2 das Abbilden von Klassen auf Dateiebene vereinfacht wird. Die neue Klasse StandardAutoloader gehört
  • 2.2 PHP-Version 35 2 zum Namensraum Zend\Loader und befindet sich somit in der Datei /library/Zend/ Loader/StandardAutoloader.php. Ein anderes Beispiel soll eine weitere Neuerung verdeutlichen: Im Zend Framework 1 befindet sich die Klasse Zend_Config in der Datei /library/Zend/Config.php. Im Zend Framework 2 dürfen im /library/Zend/-Verzeichnis keine Dateien liegen. Die äquiva- lente Klasse Config gehört somit zum Namensraum Zend\Config und befindet sich in der Datei /library/Zend/Config/Config.php. In Listing 2.1 ist auszugsweise die besagte Klasse Config zu sehen. Oben wird mit dem Schlüsselwort namespace der Namensraum definiert, zu dem die Klasse gehört. Mit- hilfe des Schlüsselwortes use werden andere Namensräume importiert, damit Klas- sen und Interfaces aus diesen Namensräumen in unserer Klasse verwendet werden können. Bei den Namensräumen ArrayAccess, Countable und Iterator handelt es sich übrigens um Namensräume, die von PHP 5.3 direkt bereitgestellt werden. namespace Zend\Config; use ArrayAccess; use Countable; use Iterator; class Config implements Countable, Iterator, ArrayAccess { // do whatever } Listing 2.1 Namensraum-Deklaration für die Config-Klasse Die Verwendung der Namensräume ist jedoch nicht auf die Zend Framework 2-Biblio- thek beschränkt. Auch in den Klassen und Anwendungsmodulen können und sollten Entwickler Namensräume definieren (zum Thema Modularität siehe Abschnitt 2.4.1, »Verbesserte Modularität«). In Listing 2.2 ist ein Action-Controller aus einem Application-Modul zu sehen. Dieser Klasse wurde der Namensraum Application\Controller zugewiesen. Die Klasse importiert vier Namensräume, von denen zwei zur Zend Framework 2-Bibliothek gehören und die beiden anderen zu einem Blog-Modul. Mithilfe des Schlüsselworts as kann einem Namensraum auch ein Alias gegeben werden. Dies ist erforderlich, da es ansonsten zwischen den beiden Klassen Blog\Service\Blog und Blog\Options\ Blog zu Namenskollisionen kommen könnte. namespace Application\Controller; use Zend\Mvc\Controller\AbstractActionController;
  • 2 Neuerungen im Zend Framework 2 36 use Zend\View\Model\ViewModel; use Blog\Service\Blog as BlogService; use Blog\Options\Blog as BlogOptions; class IndexController extends AbstractActionController {} Listing 2.2 Namensraum-Deklaration für einen Action-Controller ZF1-Umsteiger und ZF2-Einsteiger werden gleichermaßen die Vorteile der Namens- räume schnell zu schätzen wissen und ihre Anwendung darauf aufbauen wollen. 2.2.2 Closures Eine Closure ist eine anonyme Funktion, die z. B. einer Variable zugeordnet werden kann. Sie wird als anonym bezeichnet, da diese Funktion keinen Namen hat, durch den sie aufgerufen werden könnte. Listing 2.3 zeigt ein einfaches Beispiel. Der Variablen $pizzaPrice wird eine Closure zugewiesen. Diese Funktion nimmt die Anzahl der Zutaten entgegen und ermittelt damit den Preis einer Pizza, indem zu einem Grundpreis nochmals der Preis pro Zutat hinzuaddiert wird. Der Aufruf dieser Closure erfolgt dann direkt über die Vari- able $pizzaPrice, die als Funktion verwendet werden kann. $pizzaPrice = function($items) { return 3.95 + $items * 0.95; }; echo $pizzaPrice(3); // output 6.8 echo $pizzaPrice(7); // output 10.6 Listing 2.3 Beispiel für eine einfache Closure-Definition Eine Closure kann aber beim Aufruf nicht nur variable Parameter übergeben bekom- men. Es ist auch möglich, bei der Definition Variablen mithilfe des Schlüsselwortes use zu übergeben, die dann als fixe Werte verwendet werden können. Listing 2.4 zeigt das geänderte Beispiel, bei dem die Werte für den Grundpreis und den Preis pro Zutat bei der Definition der Funktion übergeben werden: $basePrice = 3.95; $itemPrice = 0.95; $pizzaPrice = function($items) use ($basePrice, $itemPrice) { return $basePrice + $items * $itemPrice;
  • 2.2 PHP-Version 37 2 }; echo $pizzaPrice(2); // output 5.85 echo $pizzaPrice(6); // output 9.65 Listing 2.4 Beispiel für eine Closure-Definition mit übergebenen Variablen Closures können aber nicht nur an Variablen übergeben werden, sondern auch als Parameter an andere Funktionen oder Klassenmethoden übergeben werden. In Lis- ting 2.5 werden zuerst einige Pizza-Klassen definiert sowie eine Sammlung von Pizza- Objekten erstellt. Um nur die Salami-Pizzen auszufiltern, wird das Objekt $pizzaList an die array_filter()-Methode übergeben. Zudem wird eine Closure als Callback- Funktion übergeben, die true zurückgibt, wenn der Wert eine Instanz von Pizza- Salami ist, und andernfalls false. Bei der Ausgabe werden nur die beiden Instanzen von PizzaSalami ausgegeben, und die anderen Pizzen werden ausgefiltert. class PizzaSalami {} class PizzaHawaii {} class PizzaMelon {} $pizzaList = array( new PizzaSalami(), new PizzaHawaii(), new PizzaMelon(), new PizzaSalami() ); $pizzaSalamiOnly = array_filter($pizzaList, function($val) { return ($val instanceof PizzaSalami); }); var_dump($pizzaSalamiOnly); Listing 2.5 Beispiel für eine Closure-Definition als Parameter einer Funktion Somit können wir Closures auch für alle PHP-Funktionen verwenden, die eine Call- back-Funktion als Parameter erwarten. Neben der verwendeten array_filter()- Funktion wären das z. B. auch call_user_func() oder usort(). Zend Framework 2-Nutzer verwenden Closures am ehesten bei der Definition von Factories für den Service-Manager (siehe Abschnitt 6.1, »Zend\ServiceManager«).
  • 2 Neuerungen im Zend Framework 2 38 2.2.3 Late Static Binding Die Methodik das Late Static Binding (»späte statische Bindung«) löst ein Problem bei erweiterten Klassen mit statischen Methoden und Eigenschaften, das in Listing 2.6 demonstriert wird. Die Klasse PizzaSalami definiert drei Methoden. Die Methode getNameSelf() greift über das Schlüsselwort self auf die Methode name() zu, während die Methode getNameStatic() das Schlüsselwort static verwendet. Die Klasse Pizza- SalamiPeperoni erweitert die Klasse PizzaSalami und überschreibt die Methode name(). Der Unterschied in der Funktionsweise tritt beim Aufruf der Methode Pizza- SalamiPeperoni::getNameStatic() am Ende des Listings auf. Dort wird nämlich der richtige Name der PizzaSalamiPeperoni ausgegeben. Dieses Verhalten war in PHP 5.2 nicht möglich und hat vielen Entwicklern einiges Kopfzerbrechen bereitet. class PizzaSalami { public static function getNameSelf() { return self::name(); } public static function getNameStatic() { return static::name(); } public static function name() { return 'Pizza mit Salami'; } } class PizzaSalamiPeperoni extends PizzaSalami { public static function name() { return 'Pizza mit Salami und Peperoni'; } } echo PizzaSalami::getNameSelf(); echo PizzaSalami::getNameStatic(); echo PizzaSalamiPeperoni::getNameSelf(); echo PizzaSalamiPeperoni::getNameStatic(); Listing 2.6 Beispiel für Late Static Binding Die Methodik des Late Static Binding wird in der Zend Framework 2-Bibliothek recht häufig verwendet. Als Nutzer des Zend Framework 2 kommen Sie damit nur in Berührung, wenn Sie es in ihren eigenen Klassen verwenden möchten.
  • 2.3 Git und GitHub 39 2 2.3 Git und GitHub Eine technische Umstellung, die vorwiegend die Zend Framework 2-Entwickler betrifft, ist der Wechsel von Subversion (SVN) zu Git. Bei SVN und Git handelt es sich um Software für die Versionsverwaltung von Dateien. Das Zend Framework 1 hat von Beginn an auf SVN gesetzt. Für das Zend Framework 2 wurde frühzeitig entschieden, sich die Vorteile von Git für die Entwicklung des ZF2 zunutze zu machen. Doch wieso kam es dazu? Das Zend-Framework-Team versprach sich von dem Wechsel eine verbesserte Pro- duktivität, sodass Patches und Verbesserungsvorschläge der Framework-Anwender schneller eingepflegt werden können. Die Erfahrung der letzten Jahre in der Entwick- lung vom Zend Framework 2 hat diese Hoffnung mehr als bestätigt. Mittlerweile ist auch der Issue Tracker, in dem Anwender Bugs und Feature Requests einstellen kön- nen, auch zu GitHub gewechselt. Somit liegen die wichtigsten Entwicklungstools nun auf einer Plattform und sind nicht über mehrere Tools verteilt. Git gibt es für alle wichtigen Betriebssysteme wie Linux, Windows und Mac OS X (http://git-scm.com/). Wenn Sie eine Anwendung mit dem Zend Framework erstel- len möchten, müssen Sie für Ihre Versionsverwaltung nicht unbedingt auch zu Git wechseln. Es ist aber dennoch hilfreich, wenn auf Ihrem Entwicklungsrechner auch Git zur Verfügung steht, da dies die Installationen der SkeletonApplication (siehe Abschnitt 3.3, »SkeletonApplication installieren«) sowie von Fremdmodulen verein- fachen kann. Bei GitHub handelt es sich um einen webbasierten Hosting-Dienst für Softwarepro- jekte (https://github.com/). Dort kann jeder Entwickler eigene öffentliche Reposito- ries für seine Softwareprojekte anlegen und pflegen oder bestehende kopieren, um sie an eigene Bedürfnisse anzupassen. Nicht nur das Zend Framework 2 wird in einem Repository auf GitHub gepflegt (siehe https://github.com/zendframework/). Auch viele ZF2-Fremdmodule sind dort zu fin- den; als Beispiel seien die Module der ZF-Commons-Initiative genannt (siehe https:// github.com/ZF-Commons). Wer sich mit Git und GitHub noch nicht auskennt, der braucht keine Angst zu haben, außer mit dem neuen Zend Framework 2 auch noch Stunden mit dem Lernen von Git und GitHub verbringen zu müssen. Mit folgenden Links gelingt der Einstieg auch Anfängern: � http://try.github.com/ Ein schön gemachtes, interaktives Tutorial für den allgemeinen Einstieg in Git und GitHub
  • 2 Neuerungen im Zend Framework 2 40 � http://framework.zend.com/wiki/x/vYFZAQ Im Zend Framework 2-Wiki gibt es einen Git Guide, mit dem sich der Entwickler mit den wichtigsten Befehlen und Funktionen von Git und GitHub vertraut machen kann. � http://de.gitready.com/ Die Website bietet viele Tipps und Tricks auf Deutsch zum Lernen von Git – auch für fortgeschrittene Themen. Im weiteren Verlauf des Buches werden wir bei der Installation der SkeletonApplica- tion und bei Fremdmodulen sowie beim Einrichten eigener Repositories auf die grundlegenden Befehle und Funktionen von Git näher eingehen. 2.4 Neue Konzepte Im Zend Framework 2 wurde eine Vielzahl neuer Konzepte implementiert, die im Zend Framework 1 noch nicht oder nur teilweise umgesetzt waren. Diese Konzepte wurden nicht von den Zend Framework 2-Entwicklern erfunden, sondern werden schon länger in der Softwareentwicklung eingesetzt. Neu ist der Einsatz im ZF2. Mithilfe dieser Konzepte wurde die Entwicklung von Zend Framework 2-Anwendun- gen noch einmal um ein Vielfaches vereinfacht. Einsteiger und Umsteiger müssen diese Lernkurve jedoch erst einmal erklimmen. Sobald Sie aber die Konzepte verstan- den und verinnerlicht haben, werden Sie diese in Zukunft nicht mehr missen wollen. Die Konzepte werden in diesem Abschnitt unabhängig vom Zend Framework 2 erläu- tert. Auf die konkreten Zend Framework 2-Implementierungen wird entsprechend verwiesen. 2.4.1 Verbesserte Modularität Im Zend Framework 1 gab es bereits Module. Doch diese waren eher Bürger zweiter Klasse (»second-class citizens«). Die Konfiguration der Module war mühsam, und ein Austausch von Modulen zwischen mehreren Anwendungen war aufgrund von Abhängigkeiten nicht ohne Weiteres möglich. Im Wesentlichen waren Module im ZF1 nur Container für Action-Controller, View-Scripts und für weitere Klassen des Moduls. Im Zend Framework 2 sind die Module nun Bürger erster Klasse. Das bedeutet, dass im Prinzip alles ein Modul ist. Selbst die Zend Framework 2-Bibliothek kann als Modul betrachtet werden. Somit braucht jede Zend Framework 2-Anwendung immer mindestens ein Anwendungsmodul, das aber vom Entwickler vollkommen frei kon- figuriert werden kann. Dies bringt viele Freiheiten, bedeutet aber auch einen gewis- sen Aufwand bei der Einrichtung einer neuen Zend Framework 2-Anwendung.
  • 2.4 Neue Konzepte 41 2 Somit kann eine Zend Framework 2-Anwendung verschiedene Anwendungsmodule wie ein Blog, einen Shop oder ein Kommentarmodul einsetzen. Und Sie können diese Module in der Regel mit vertretbarem Aufwand in anderen Zend Framework 2- Anwendungen ebenfalls einsetzen. Zusätzlich gibt es eine Vielzahl an ZF2-Fremdmodulen, die Sie in Ihre Projekte inte- grieren können. Diese Module bieten Benutzermanagement, Doctrine 2-Integration, Twitter Bootstrap-Unterstützung, Asset-Management und vieles mehr. In Kapitel 7, »Der Modul-Manager«, wird die Implementation der neuen Modularität detailliert erläutert. Auch die Entwicklung von Anwendungsmodulen und die Instal- lation von Fremdmodulen werden anhand praktischer Beispiele beleuchtet. 2.4.2 Dependency Injection Der Begriff der Dependency Injection definiert ein Entwurfsmuster, das die Steue- rung der Abhängigkeiten zwischen Objekten löst. Ohne Dependency Injection wer- den Abhängigkeiten von Objekten meistens hart codiert in den Code aufgenommen. Listing 2.7 demonstriert ein Beispiel mit festen Abhängigkeiten. Diese Pizza Salami wird mit den drei festen Belägen Salami, Käse und Tomatenpampe belegt, und der Pizzaboden ist aus Weizenmehl gemacht. Möchte ein Kunde nun doppelt Käse, Elch- salami oder einen Pizzaboden aus Dinkelmehl, kann Luigi diese Wünsche nicht im System abbilden. class PizzaSalami { public function __construct() { $this->crust = new CrustWheatFlour(); $this->toppings = array( new ToppingSalami(), new ToppingCheese(), new ToppingTomatoStodge(), ); } } $pizzaSalami = new PizzaSalami(); var_dump($pizzaSalami); Listing 2.7 Klasse für eine Pizza Salami mit festen Belägen und Pizzaboden
  • 2 Neuerungen im Zend Framework 2 42 Die Lösung für das Problem der hart codierten Abhängigkeiten ist in Listing 2.8 zu sehen. Der Konstruktor nimmt einen Parameter entgegen, der das CrustInterface implementiert. Wenn unsere Klassen CrustWheatFlour und CrustSpeltFlour dieses Interface implementieren, sind wir flexibel beim Austausch des Pizzabodens. Anstatt die Beläge in einem Array an den Konstruktor zu übergeben, wurde eine eigene Methode addTopping() implementiert. Diese Methode nimmt einen Parameter ent- gegen, der das ToppingInterface implementieren muss. Somit können wir nicht nur die Beläge selber, sondern auch die Anzahl der Beläge bequem variieren. Am Ende des Listings wird unsere Pizza Salami instanziiert. Dabei wird unser Pizzaboden aus Weizenmehl übergeben, und danach werden die Beläge hinzugefügt. Auch die Spezi- alpizza mit Elchsalami, doppelt Käse und einem Pizzaboden aus Dinkelmehl ist nun kein Problem mehr. class Pizza { public function __construct(CrustInterface $crust) { $this->crust = $crust; } public function addTopping(ToppingInterface $topping) { $this->toppings[] = $topping; } } $pizzaSalami = new Pizza(new CrustWheatFlour()); $pizzaSalami->addTopping(new ToppingSalami()); $pizzaSalami->addTopping(new ToppingCheese()); $pizzaSalami->addTopping(new ToppingTomatoStodge()); $pizzaSpeciale = new Pizza(new CrustSpeltFlour()); $pizzaSpeciale->addTopping(new ToppingElkSalami()); $pizzaSpeciale->addTopping(new ToppingCheese()); $pizzaSpeciale->addTopping(new ToppingCheese()); $pizzaSpeciale->addTopping(new ToppingTomatoStodge()); Listing 2.8 Klasse für Pizza mit variablen Belägen und variablem Pizzaboden Diese Vorgehensweise ist nicht nur beim Belegen von Pizzen hilfreich. Auch das Tes- ten der Anwendung wird dadurch stark vereinfacht. Denn solange unsere Beläge das Interface ToppingInterface implementieren, können wir diese Klasse auch mit Mock- Objekten (Dummy-Objekten oder Attrappen) befüllen. Solange Luigi am Ende keine
  • 2.4 Neue Konzepte 43 2 Pizza mit Gel-Schinken und Kunst-Käse ausliefert, kann das Mocken der Beläge beim Testen durchaus akzeptabel und sinnvoll sein. In Abschnitt 6.2, »Zend\Di«, wird die Zend Framework 2-Implementation des Ent- wurfsmusters Dependency Injection ausführlich dargestellt. 2.4.3 Service-Locator Wer im Zend Framework 1 gerne und viel mit der Zend_Registry gearbeitet hat, der wird überrascht sein. Im Zend Framework 2 gibt es keine zentrale Registry mehr, in der Sie nach Lust und Laune ihre Objekte und Daten ablegen können. Das Zend Framework 2 stellt aber etwas viel Besseres bereit: den Service-Locator. Beim Service- Locator handelt es sich auch um ein Entwurfsmuster für eine zentrale Registrierung von Objekten zur späteren Nutzung. Es funktioniert ähnlich wie die Registry, nur dass sich der Service-Locator auch um die Instanziierung der Objekte kümmert. In Listing 2.9 wird das Prinzip des Service-Locators mit einer eigenen Implementa- tion dargestellt. Die Klasse ServiceLocator verfügt über drei Methoden zum Initiali- sieren, Hinzufügen und Holen von Services. Die Methode set() nimmt einen Bezeichner und den Namen der Klasse entgegen, instanziiert die Klasse und legt sie für den späteren Zugriff ab. Die Methode get() gibt mithilfe des Bezeichners die Instanz zurück. Unter der Klassendeklaration wird der ServiceLocator zuerst mit den notwendigen Services gefüttert. Am Ende des Listings wird unsere Salamipizza mit Pizzaboden und Belägen erstellt, die aus dem Service-Locator geholt und nicht direkt instanziiert werden. class ServiceLocator { protected $services = array(); public function set($id, $className) { $this->services[$id] = new $className(); } public function get($id) { return $this->services[$id]; } } $sl = new ServiceLocator(); $sl->set('wheat-crust', 'CrustWheatFlour'); $sl->set('salami', 'ToppingSalami');
  • 2 Neuerungen im Zend Framework 2 44 $sl->set('cheese', 'ToppingCheese'); $sl->set('tomato-stodge', 'ToppingTomatoStodge'); $pizzaSalami = new Pizza($sl->get('wheat-crust')); $pizzaSalami->addTopping($sl->get('salami')); $pizzaSalami->addTopping($sl->get('cheese')); $pizzaSalami->addTopping($sl->get('tomato-stodge')); Listing 2.9 Einfache Implementierung eines Service-Locators Wie oben erwähnt wurde, ist dieses Beispiel funktional stark reduziert, und der Mehr- aufwand mag auf den ersten Blick zu viel des Guten sein. Dies liegt vor allem daran, dass die Services, die wir ablegen, nur einfache Objekte ohne Methoden sind. Denken Sie statt an Käse und Salami einmal an komplexere Services für Authentifizierung, Mailversand oder Logging. Diese Objekte werden wiederum andere Objekte für die Instanziierung benötigen, die wiederum andere Objekte benötigen. Statt eines einfa- chen Klassennamens kann ein Service-Locator (wie im nächsten Beispiel zu sehen) auch eine Closure übergeben bekommen, die sich um die Instanziierung der Objekte kümmert. Listing 2.10 zeigt den geänderten Service-Locator, an dem nur die set()-Methode ver- ändert wurde. Statt eines Strings nimmt sie nun eine Instanz des Closure-Objekts entgegen. Der Service wird angelegt, indem die Closure ausgeführt wird. Weiter unten wird die Closure-Methode definiert und an die Variable $factoryClosure über- geben. In der Funktion wird unsere Pizza auf dem klassischen Weg instanziiert und belegt. Diese Closure-Funktion wird nun an das ServiceLocator-Objekt übergeben und dabei ausgeführt. Zum Abschluss wird die Instanz vom Service-Locator angefor- dert und ausgegeben. Wir erhalten dabei eine Instanz von Pizza mit Salami, Käse und Tomatenpampe zurück. class ServiceLocator { public function __construct() { $this->services = array(); } public function set($id, Closure $closure) { $this->services[$id] = $closure(); } public function get($id) { return $this->services[$id]; }
  • 2.4 Neue Konzepte 45 2 } $factoryClosure = function() { $pizzaSalami = new Pizza(new CrustWheatFlour()); $pizzaSalami->addTopping(new ToppingSalami()); $pizzaSalami->addTopping(new ToppingCheese()); $pizzaSalami->addTopping(new ToppingTomatoStodge()); return $pizzaSalami; }; $sl = new ServiceLocator(); $sl->set('pizza-salami', $factoryClosure); var_dump($sl->get('pizza-salami')); Listing 2.10 Implementation eines Service-Locators mit Closures Ein Service-Locator könnte neben Klassennamen und Closures auch andere Parame- ter für die Instanziierung der Objekte verarbeiten, was die Flexbilität und die Testbar- keit erhöhen würde. So wären Factory-Klassen denkbar, deren Aufgabe es ist, ein Objekt einer Klasse zu instanziieren und zurückzuliefern. In Abschnitt 6.1, »Zend\ServiceManager«, wird die Zend Framework 2-Implementa- tion des Service-Locator-Entwurfsmusters und deren Konfiguration mit Beispielen erläutert. 2.4.4 Ereignisgesteuerte Architektur Bei der ereignisgesteuerten Architektur (event-driven architecture) handelt es sich um ein weiteres Entwurfsmuster, das im Zend Framework 2 neu implementiert wurde. Bei diesem Prinzip wird die Interaktion von lose gekoppelten Komponenten durch Ereignisse (Events) gesteuert. Für eine beispielhafte Implementation benötigen wir einen Event-Manager, der auch als Event-Dispatcher bezeichnet wird. Dessen Aufgabe ist es, eine Reihe von Event- Listenern zu verwalten. Diese Listener warten darauf, dass ein Ereignis angestoßen wird (to trigger an event). Wird das Ereignis angestoßen, so können die Aufgaben ausgeführt werden. Für unser nächstes Beispiel stellen wir uns den Eingang einer Pizzabestellung vor. Sobald die neue Bestellung gespeichert wird, muss eine Reihe von Aufgaben erledigt werden. Diese Aufgaben könnten der Versand einer Bestellbestätigung, die Aktuali- sierung des Warenbestands und das Backen der Pizza sein. Vor dem Speichern der Bestellung könnte zudem der Warenbestand geprüft werden.
  • 2 Neuerungen im Zend Framework 2 46 Listing 2.11 zeigt ein kompaktes Beispiel für einen Event-Manager. Zuerst wird das Interface EventListener definiert, das von einer Reihe von Klassen implementiert wird. Die Klassen SendConfirmation, UpdateStock und BakePizza implementieren die Methode postOrder(). Die Klasse CheckStock implementiert die Methode preOrder(). Zusätzlich benötigen wir noch eine Klasse für die Bestellung der Pizza. Den Kern stellt die Klasse EventManager dar. Mithilfe der Methode attach() können die definierten Listener für ein entsprechendes Ereignis hinzugefügt werden. Zudem steht die Methode trigger() bereit, um die Ereignisse bei den registrierten Listenern ausfüh- ren zu lassen. interface EventListener {} class SendConfirmation implements EventListener { public function postOrder() { echo "Send order confirmation"; } } class UpdateStock implements EventListener { public function postOrder() { echo "Update stock"; } } class BakePizza implements EventListener { public function postOrder() { echo "Bake the pizza"; } } class CheckStock implements EventListener { public function preOrder() { echo "Check stock"; } } class PizzaOrder { public function __construct() { echo "Save order"; }
  • 2.4 Neue Konzepte 47 2 } class EventManager { protected $listeners = array(); public function attach($event, EventListener $listener) { $this->listeners[$event][] = $listener; } public function trigger($event) { foreach ($this->listeners[$event] as $listener) { $listener->$event(); } } } $em = new EventManager(); $em->attach('postOrder', new SendConfirmation()); $em->attach('postOrder', new BakePizza()); $em->attach('postOrder', new UpdateStock()); $em->attach('preOrder', new CheckStock()); $em->trigger('preOrder'); $pizzaOrder = new PizzaOrder(); $em->trigger('postOrder'); Listing 2.11 Beispiel für einen Event-Manager Danach wird der Event-Manager instanziiert, und die Listener werden für die Ereig- nisse hinzugefügt. Entscheidend für die Ausführung eines Listeners ist die Reihen- folge, in der die Listener hinzugefügt wurden. Danach kann es endlich losgehen. Zuerst wird das Ereignis preOrder ausgelöst, danach wird die Bestellung erstellt und zum Schluss das Ereignis postOrder ausgelöst. Die Ausgabe erfolgt in dieser Reihen- folge: Check stock Save order Send order confirmation Bake the pizza Update stock
  • 2 Neuerungen im Zend Framework 2 48 Natürlich ist dieser Event-Manager recht primitiv. Listener müssten auch entfernt werden können. Zudem wäre eine frei definierbare Reihenfolge für die Ausführung der Listener beim Auslösen eines Ereignisses sinnvoll. Wir könnten weitere Inter- faces erstellen, die das Vorhandensein von preOrder()- und postOrder()-Methoden vorschreiben. Außerdem sollte nach einer fehlerhaften Prüfung des Bestandes durch eine Exception der gesamte Prozess beendet werden, damit die Bestellung nicht gespeichert wird. In Kapitel 5, »Der Event-Manager«, wird die Zend Framework 2-Implementation des Event-Managers ausführlich dargelegt und mit Beispielen versehen. Übrigens wurde der Event-Manager mittlerweile auch in das Zend Framework 1.12 zurückportiert. 2.5 Komponentenvergleich Der Großteil der Komponenten, die es bereits im Zend Framework 1 gegeben hat, fin- det sich auch weiterhin im Zend Framework 2 wieder. Manche Komponenten wur- den nur leicht überarbeitet, andere wiederum von Grund auf neu entwickelt; wieder andere fielen ganz weg oder gehören nicht mehr zum Kern des Zend Framework 2. Tabelle 2.1 zeigt alle ZF2-Komponenten, die es bereits im Zend Framework 1 gegeben hat. Zend_Auth ist in Zend\Authentication umbenannt worden, und aus Zend_Con- troller wurde Zend\Mvc. Die Komponente Zend_Acl wurde nach Zend\Permissions\ Acl verschoben. Wenn Sie bisher diese Komponenten reichlich genutzt haben, kön- nen Sie auch weiterhin darauf bauen, auch wenn sich die Benutzung dieser Kompo- nenten zum Teil gravierend geändert hat. Zend\Authentication Zend\Http Zend\Progressbar Zend\Barcode Zend\InputFilter Zend\Serializer Zend\Cache Zend\Json Zend\Server Zend\Captcha Zend\Ldap Zend\Session Zend\Console Zend\Loader Zend\Soap Zend\Code Zend\Log Zend\Tag Zend\Config Zend\Mail Zend\Text Zend\Db Zend\Memory Zend\Uri Zend\Debug Zend\Mime Zend\Validator Tabelle 2.1 Alte ZF1-Komponenten im neuen Gewand (Stand: ZF 2.2.0)
  • 2.5 Komponentenvergleich 49 2 In Tabelle 2.2 sind alle diejenigen Komponenten aufgelistet, die im Zend Framework 2 komplett neu hinzugekommen sind. Dabei stellt Zend\I18n eine Besonderheit dar. Im Zend Framework 1 gab es mit Zend_Date, Zend_Locale, Zend_Translate und anderen einen bunten Strauß an Komponenten für die Internationalisierung (»i18n«) und Lokalisierung (»l10n«) von Webanwendungen. Da PHP 5.3 jedoch eigene Funktiona- litäten für die Internationalisierung und Lokalisierung bietet, konnten diese Kompo- nenten stark reduziert werden. Das Ergebnis ist die Komponente Zend\I18n, die weiterhin einen Translator sowie Filter und Validatoren für die Internationalisierung und Lokalisierung bereitstellt. Tabelle 2.3 listet alle Komponenten auf, die es nicht mehr in den Kern des Zend Framework geschafft haben. Alle mit einem »(I18n)« markierten Komponenten wurden wie oben erwähnt in der neuen Komponente Zend\I18n zusammengefasst. Für die Komponenten mit einem »(GH)« wurden auf GitHub eigene Repositories eingerichtet (https://github.com/zendframework). Die ZF-Community ist dazu auf- gerufen, sich dieser Komponenten anzunehmen und sie zukünftig weiterzuentwi- ckeln. Das Zend Framework-Kernteam kann diese Arbeit zukünftig nicht mehr über- nehmen. Zend\Dom Zend\Mvc Zend\Version Zend\Feed Zend\Navigation Zend\View Zend\Filter Zend\Paginator Zend\XmlRpc Zend\Form Zend\Permissions\Acl Zend\Crypt Zend\EventManager Zend\ModuleManager Zend\Di Zend\I18n Zend\ServiceManager Zend\Escaper Zend\Math Zend\Stdlib Tabelle 2.2 Neue ZF2-Komponenten mit neuem Glanz (Stand: ZF 2.2.0) Zend_Amf (GH) Zend_Markup (GH) Zend_Search_Lucene (GH) Zend_Cloud (GH) Zend_Measure (I18n) Zend_Service (GH) Zend_Currency (I18n) Zend_OAuth (GH) Zend_Test Tabelle 2.3 Der traurige Rest: vergessen, verraten und verkauft (Stand: ZF 2.2.0) Tabelle 2.1 Alte ZF1-Komponenten im neuen Gewand (Stand: ZF 2.2.0) (Forts.)
  • 2 Neuerungen im Zend Framework 2 50 Diese Liste ist interessant, da Komponenten wie Zend_Search_Lucene und Zend_Pdf in der Anfangszeit großes Interesse in der PHP-Community hervorgerufen haben und so manchen Entwickler erst zum Zend Framework 1 gebracht haben. Die Zeit hat jedoch bei beiden Komponenten schnell gezeigt, dass sie aus Performance-Gründen oder wegen fehlender Funktionen in der Praxis nur schwer einsetzbar waren. Andere Komponenten, wie Zend_Amf, Zend_Gdata oder Zend_InfoCard, sind so speziell, dass sie nicht mehr zum Framework-Kern gehören. Auch die Webservice-Kompo- nenten aus Zend_Service gehören nicht mehr zum Kern vom ZF2. Das gleiche Schicksal teilen die beiden Komponenten Zend_Dojo und ZendX_JQuery, die Unterstützung für JavaScript-Bibliotheken geboten haben (wobei speziell ZendX_ JQuery nie zum Kern des Zend Framework 1 gezählt hat). Wer Unterstützung für Dojo und jQuery sucht, wird zukünftig auf spezielle Fremdmodule hoffen müssen. Die Fokussierung auf weniger Kernkomponenten ist ein großes Plus für das Zend Framework 2. Dadurch werden die Kapazitäten besser auf die wesentlichen Kompo- nenten konzentriert und das Problem mit Komponenten, die nicht oder nur kaum gepflegt werden, hat sich damit auch gelöst. 2.6 Vor- und Nachteile des ZF2 Wer vom Zend Framework 1 auf das Zend Framework 2 umsteigt, kommt in den Genuss einiger wesentlicher Vorteile: � Ein wichtiges Feature des Zend Framework 2 ist die neue Modularität, die den Aus- tausch von Modulen zwischen Anwendungen sowie die Konfiguration der Module stark vereinfacht. Zudem gibt es bereits ein großes Angebot an wiederver- wendbaren Fremdmodulen, und nahezu täglich kommen mehr dazu. Diese frem- den Module lassen sich in der Regel leicht installieren und bei Bedarf auch anpassen. Zend_Date (I18n) Zend_OpenId (GH) Zend_TimeSync (GH) Zend_Dojo Zend_Pdf (GH) Zend_Tool (GH) Zend\File Zend_Queue (GH) Zend_Translate (I18n) Zend_Gdata (GH) Zend_Reflection Zend_Wildfire Zend_InfoCard Zend_Registry Zend_Locale (I18n) Zend_Rest (GH) Tabelle 2.3 Der traurige Rest: vergessen, verraten und verkauft (Stand: ZF 2.2.0) (Forts.)
  • 2.6 Vor- und Nachteile des ZF2 51 2 � Das Zend Framework 1 bot ein hohes Maß an Flexibilität. Mit dem Zend Frame- work 2 konnten diese Freiheiten nochmals erweitert werden. Gab es im ZF1 festge- legte Konventionen, an die Sie sich halten mussten, damit Ihre Anwendung problemlos lief, so können Sie im ZF2 viele Funktionalitäten selber konfigurieren. Es gibt zwar immer noch Empfehlungen, an die Sie sich halten sollten. Aber Sie haben auch mehr Freiheiten. � Waren im Zend Framework 1 noch viele Komponenten eng miteinander verzahnt, so wurde die lose Kopplung der Komponenten mit dem Zend Framework 2 stark vorangetrieben. Einige Komponenten wie Zend\Form und Zend\View, die im ZF1 eine Vielzahl an Aufgaben übernommen hatten, wurden stark entkoppelt. Selbst das Zusammenspiel der Zend\Mvc-Komponenten lässt sich so weit aufbohren, dass Sie den gesamten Prozess der Model-View-Controller-Verarbeitung umgestalten können. � Die neuen Konzepte Dependency Injection, Service-Locator und Event-Manager entfalten ihr großes Potenzial, sobald Sie diese verinnerlicht haben und täglich anwenden. Wenn Sie die Lernkurve erst einmal erklommen haben, werden Sie ungern zum Zend Framework 1 zurückkehren wollen. � Neu beim ZF2 ist auch die Möglichkeit, nur die Komponenten zu installieren, die Sie brauchen. Sie sind nicht gezwungen, das gesamte Framework herunterzula- den. Für die Installation stehen zudem mehrere Wege (u.a. Composer, Pyrus) zur Auswahl. � Wie beim ZF1 sind Sie auch beim ZF2 nicht gezwungen, das gesamte Framework für Ihre Anwendung zu nutzen. Sie können das Zend Framework somit als Glue Framework einsetzen. Auf der anderen Seite können Sie das Zend Framework auch als Full-Stack Framework verwenden und damit komplette Projekte umsetzen. � Das gesamte Framework ist mit einer soliden Testbasis ausgestattet. Keine Kom- ponente wird für den Kern akzeptiert, wenn die Funktionalitäten nicht mit ausrei- chend und fehlerfreien Unit-Tests ausgestattet sind. � Wer sich beim ZF1 einbringen wollte, um neue Features beizusteuern, Bugs zu fixen oder die Dokumentation zu übersetzen, musste zwingend ein CLA (Contri- butor License Agreement) unterzeichnen und an die Firma Zend faxen. Diese Hürde fällt mit dem Zend Framework 2 weg. Es gibt auch einige Nachteile beim Einsatz des Zend Frameworks 2, die gerade zu Beginn und bei der Einarbeitung eine große Hürde darstellen. Diese sollen nicht ver- schwiegen werden, auch wenn sie mit wachsender Erfahrung keine Hindernisse mehr darstellen werden. � Die Konfigurationslastigkeit kann auf den ersten Blick abschrecken. Da es für viele Dinge keine festen Konventionen mehr gibt, müssen Sie diese selber konfigurie- ren. Die SkeletonApplication, die Sie in Abschnitt 3.3, »SkeletonApplication instal-
  • 2 Neuerungen im Zend Framework 2 52 lieren«, kennenlernen werden, nimmt Ihnen zwar einiges an Arbeit ab. Dennoch müssen Sie für Ihre Anwendungsmodule die Routen, die Controller, eigene View Helper und Plugins, das Autoloading und vieles mehr konfigurieren. � Die zusätzliche Flexibilität, die das Zend Framework 2 bietet, hat natürlich auch eine höhere Komplexität zu Folge. Wer seit einigen Jahren mit dem Zend Frame- work 1 gearbeitet hat, der kann damit neue Projekte im Schlaf einrichten. Mit dem Zend Framework 2 wird dies gerade zu Anfang vielleicht nicht so schnell von der Hand gehen. � Die neuen Konzepte erfordern neues Denken der Entwickler. Wenn Sie sich mit Themen wie Dependency Injection oder der ereignisgesteuerten Architektur aus- kennen, ist das ein großes Plus für den Einstieg ins ZF2. � Außer mit dem Zend Framework 2 an sich muss der Entwickler sich auch noch mit Tools wie Git, Pyrus und Composer auseinandersetzen.
  • 351 13 Kapitel 13 Benutzermanagement Eine moderne Webanwendung lebt von der Interaktion ihrer Nutzer. Doch selbst eine Website, die nicht mit dem Besucher interagieren möchte, muss von Redakteu- ren gepflegt werden. Für das Benutzermanagement stellt das ZF2 mehrere Kompo- nenten bereit. Dazu zählen die Sessionverarbeitung, die Autorisierung und die Authentifizierung. Alle Listings aus diesem Kapitel finden Sie auf der buchbegleitenden Bonus-Seite. Details zur Installation finden Sie in Anhang A, »Installation der Projektdateien«. 13.1 Zend\Session Zend\Session setzt auf dem PHP-internen Sessionhandling auf und stellt Container als einfachen Weg zum Speichern von Daten in Sessions bereit. Dazu gibt es Funktio- nen für die Sessionverarbeitung und die Möglichkeit, Sessions in einer Datenbank zu schreiben (siehe https://zf2.readthedocs.org/en/latest/modules/zend.session.intro- duction.html). 13.1.1 Mit Session-Containern arbeiten Um mit einem Container zu arbeiten, erstellen Sie eine Zend\Session\Container- Instanz und übergeben die zu speichernden Daten. Beim nächsten Seitenaufruf kön- nen Sie darauf zugreifen (siehe Listing 13.1). Bei der Instanziierung eines Container- Objekts übergeben Sie einen Bezeichner, um die gespeicherten Daten identifizieren zu können. Dem Objekt können Sie Daten zuweisen, indem Sie einen Bezeichner mit Werten belegen. Im ersten Beispiel wird bei jedem Seitenaufruf ein Zähler um 1 erhöht. use Zend\Debug\Debug; use Zend\Math\Rand; use Zend\Session\Container; $counter = new Container('counter'); $counter->number = $counter->number + 1;
  • 13 Benutzermanagement 352 $pizzaList = array('Pizza Salami', 'Pizza Mais', 'Pizza Melone'); $randomPizza = $pizzaList[array_rand($pizzaList)]; $randomCount = Rand::getInteger(1, 3); $basket = new Container('basket'); if (!$basket->offsetExists('order')) { $basketData = array('rows' => array(), 'sum' => 0); } else { $basketData = $basket->offsetGet('order'); } $basketData['rows'][] = $randomCount . 'x ' . $randomPizza; $basketData['sum' ] = $basketData['sum'] + $randomCount; $basket->offsetSet('order', $basketData); Debug::dump($counter->number, 'Zähler'); Debug::dump($basket->order, 'Warenkorb'); Listing 13.1 Einsatz von Zend\Session\Container Im zweiten Beispiel werden eine Pizza und ein Container-Objekt erstellt. Mit offset- Exists() prüfen Sie, ob ein Bezeichner mit einem Wert belegt ist. Mit offsetGet() holen Sie sich den aktuellen Wert aus der Session. Mit offsetSet() können Sie den Bezeichner mit einem Wert belegen. Die Werte für die beiden Bezeichner werden aus- gegeben; dabei wird hochgezählt, und der Warenkorb wird immer voller. Um die Speicherung der Daten in der Session müssen Sie sich nicht selber kümmern. Diese Aufgabe übernimmt Zend\Session\Container für Sie. 13.1.2 Session-Manager verwenden Mit dem Session-Manager können Sie die Konfiguration ändern, Sessions starten und beenden, die Cookie-Lebenszeit ändern, die Session-ID erneuern usw. Das Con- tainer-Objekt ermöglicht mit getManager() den Zugriff auf den Session-Manager: use Zend\Session\Container; $container = new Container('pizza'); $sessionManager = $container->getManager(); Sie können den Session-Manager auch direkt instanziieren: use Zend\Session\SessionManager; $sessionManager = new SessionManager();
  • 13.1 Zend\Session 353 13 Über den Session-Manager haben Sie Zugriff auf die Session-Konfiguration und kön- nen diese bei Bedarf anpassen: $sessionManager->getConfig()->setSavePath( LUIGI_ROOT . '/data/session' ); $sessionManager->getConfig->setName('luigi_session'); $sessionManager->getConfig->setCookieLifetime(3600); Session im Dateisystem speichern Wenn Sie die Sessions im Dateisystem speichern, sollten Sie mit setSavePath() den SavePath auf ein Verzeichnis im Projekt umleiten. Ansonsten gibt es Probleme, wenn mehrere Projekte auf dem Server ihre Sessions im selben Verzeichnis spei- chern. Wenn noch keine Session gestartet wurde, können Sie dies manuell machen. Sie kön- nen die Session wieder löschen, wobei Session-Daten und Session-Cookie auch gelöscht werden: $sessionManager->start(); [...] $sessionManager->destroy(); Außerdem können Sie eine Session-ID erstellen oder die Cookie-Laufzeit auf 0 setzen: $sessionManager->regenerateId(); $sessionManager->rememberMe(3600); $sessionManager->forgetMe(); 13.1.3 Sessions in der Datenbank speichern Standardmäßig werden Session-Daten durch den SaveHandler auf Dateiebene gespeichert, wobei Sie den Pfad zu dem Verzeichnis anpassen können. Möchten Sie Session-Daten in einer Datenbank speichern, müssen Sie den SaveHandler anpassen. Listing 13.2 zeigt den SQLite3-Dump für die Datenbanktabelle sessions zum Spei- chern der Session-Daten: DROP TABLE sessions; CREATE TABLE sessions ( id varchar(32) primary key, name varchar(32), data text,
  • 13 Benutzermanagement 354 modified integer, lifetime integer ); Listing 13.2 SQL-Dump für Datenbanktabelle »sessions« für SQLite3 Listing 13.3 zeigt die Konfiguration des Session-SaveHandlers DbTableGateway. Zuerst wird ein Datenbankadapter für die SQLite3-Datenbank initialisiert, ein TableGate- way-Objekt für die sessions-Tabelle instanziiert und ein Optionen-Objekt für den SaveHandler erstellt. Das TableGateway-Objekt und die Optionen werden wiederum für die Instanziierung des DbTableGateway-SaveHandler benötigt. Danach sind die Vorbereitungen abgeschlossen. use Zend\Db\Adapter\Adapter; use Zend\Db\TableGateway\TableGateway; use Zend\Debug\Debug; use Zend\Session\SessionManager; use Zend\Session\SaveHandler\DbTableGateway; use Zend\Session\SaveHandler\DbTableGatewayOptions; $db = new Adapter(array( 'driver' => 'Pdo_Sqlite', 'database' => LUIGI_ROOT . '/data/db/session.sqlite3.db', )); $tableGateway = new TableGateway('sessions', $db); $options = new DbTableGatewayOptions(); $saveHandler = new DbTableGateway($tableGateway, $options); $sessionManager = new SessionManager(); $sessionManager->setSaveHandler($saveHandler); $sessionManager->start(); $sessionManager->writeClose(); $rows = $tableGateway->select(); foreach ($rows as $row) { Debug::dump($row->getArrayCopy()); } Listing 13.3 Session-SaveHandler für das »DbTableGateway« ändern Als Nächstes wird dem Session-Manager der neue SaveHandler mitgeteilt. Danach wird die Session gestartet. Der Aufruf der Methode writeClose() ist normalerweise nicht notwendig, da sie am Ende der Verarbeitung einer Anfrage automatisch aufge-
  • 13.2 Zend\Permissions\Acl 355 13 rufen wird. Hier dient der Aufruf nur zu Demonstrationszwecken, damit bei der Abfrage der Daten über das TableGateway auch beim ersten Seitenaufruf etwas ausge- geben wird. Die Session-Daten werden in der Datenbank abgelegt und können wei- terverwendet werden. So könnte eine Verknüpfung zu einem bestimmten Benutzer abgelegt werden oder es könnte abgefragt werden, welche Sessions sich in den letz- ten 5 Minuten verändert haben, um die Anzahl der aktiven Nutzer zu schätzen. 13.2 Zend\Permissions\Acl Bei der Autorisierung legen Sie fest, welche Funktionen ein Benutzer in der Anwen- dung ausführen darf. Dafür stellt Zend\Permissions\Acl eine Zugriffskontrollliste (access control list, kurz ACL) bereit. Sie legt fest, wer auf die vorhandenen Ressour- cen welche Rechte anwenden darf oder nicht. Details finden Sie im Referenzhand- buch unter http://zf2.readthedocs.org/en/latest/index.html#zend-permissions-acl. 13.2.1 Begrifflichkeiten Eine ACL besteht aus mehreren Bestandteilen. Das erste Element sind die Benutzer- rollen. Beispiele hierfür sind Gäste, Kunden, Redakteure oder Administratoren. Die Rollen können mit Zend\Permissions\Acl verschachtelt werden, sodass ein Adminis- trator z. B. alle Rechte der Gäste, Kunden und Redakteure erben kann. Das zweite Element sind die Ressourcen. Dabei handelt es sich um die Objekte, auf die Rechte ausgeübt werden sollen. Dies können z. B. Produkte wie eine Pizza, Artikel aus dem CMS oder ein Profilbild sein. Oft werden auch die Action-Controller als Res- sourcen verwendet. Auch Ressourcen können voneinander erben. Das dritte Element sind die Privilegien. Dabei geht es darum, welche Aufgabe mit einer Ressource ausgeführt werden soll. Ein Produkt kann bestellt oder verändert werden, ein Artikel kann erstellt oder gelöscht werden, und ein Profilbild kann ver- kleinert oder ausgedruckt werden. Oft werden die Aktionsmethoden aus den Action- Controllern als Privilegien verwendet. Als viertes Element dienen Regeln. Diese besagen, dass eine Rolle auf eine Ressource ein Privileg anwenden darf oder nicht. Kunden dürfen Produkte bestellen, Redak- teure dürfen Artikel erstellen und Administratoren dürfen Profilbilder verkleinern. 13.2.2 ACL definieren In Listing 13.4 wird eine ACL für einen Pizza-Service definiert. Die Rollen guest, custo- mer, staff und admin werden definiert, wobei customer von guest und staff von
  • 13 Benutzermanagement 356 customer erben soll. Die beiden Ressourcen product und order werden definiert. Zum Schluss werden die Privilegien festgelegt. use Zend\Debug\Debug; use Zend\Permissions\Acl\Acl; $acl = new Acl(); $acl->addRole('guest'); $acl->addRole('customer', 'guest'); $acl->addRole('staff', 'customer'); $acl->addRole('admin'); $acl->addResource('product'); $acl->addResource('order'); $acl->allow('guest', 'product', array('show', 'list')); $acl->allow('customer', 'product', array('basket')); $acl->allow('staff', 'product', array('create', 'update')); $acl->deny('guest', 'order'); $acl->allow('customer', 'order', array('create', 'send')); $acl->allow('staff', 'order', array('update', 'list', 'finish')); $acl->allow('admin'); Debug::dump($acl->getRoles()); Debug::dump($acl->getResources()); Listing 13.4 ACL mit Zend\Permissions\Acl definieren Diese ACL beschreibt im Einzelnen folgende Benutzerrechte: � Gäste dürfen Produkte anzeigen und auflisten. � Kunden dürfen Produkte in den Warenkorb legen und alles tun, was Gäste dürfen. � Mitarbeiter dürfen Produkte anlegen und bearbeiten und alles tun, was Kunden und Gäste dürfen. � Gäste dürfen nichts mit Bestellungen machen. � Kunden dürfen Bestellungen anlegen und abschicken. � Mitarbeiter dürfen Bestellungen verändern, auflisten und abschließen. � Administratoren dürfen alles. Übrigens ist der Aufruf von deny() überflüssig, da alle Rollen für alle Ressourcen erst einmal nichts dürfen. Zudem können Sie auch globale Rechte vergeben und sperren, indem Sie keine Privilegien (und Ressourcen) beim Aufruf von allow() und deny() angeben.
  • 13.2 Zend\Permissions\Acl 357 13 13.2.3 ACL abfragen Eine ACL wird mit isAllowed() abgefragt, wobei die Rolle, die Ressource und das Pri- vileg oder Teile davon angegeben werden. Listing 13.5 zeigt die Abfrage der ACL von oben. Es wird true oder false zurückgegeben, abhängig von den vorhandenen Rech- ten der Rolle. use Zend\Debug\Debug; use Zend\Permissions\Acl\Acl; [...] Debug::dump($acl->isAllowed('guest', 'product', 'show')); Debug::dump($acl->isAllowed('guest', 'product', 'basket')); Debug::dump($acl->isAllowed('guest', 'order', 'create')); Debug::dump($acl->isAllowed('customer', 'product', 'basket')); Debug::dump($acl->isAllowed('customer', 'product', 'update')); Debug::dump($acl->isAllowed('customer', 'order', 'create')); Debug::dump($acl->isAllowed('staff', 'product', 'basket')); Debug::dump($acl->isAllowed('staff', 'product', 'create')); Debug::dump($acl->isAllowed('staff', 'product', 'delete')); Debug::dump($acl->isAllowed('admin', 'product', 'show')); Debug::dump($acl->isAllowed('admin', 'product', 'delete')); Debug::dump($acl->isAllowed('admin', 'order', 'finish')); Listing 13.5 Zend\Permissions\Acl abfragen Es ist denkbar, bei einer Abfrage kein Privileg abzugeben, wenn Sie prüfen wollen, ob eine Rolle mit einer Ressource überhaupt etwas machen darf. 13.2.4 ACL cachen Da der Aufbau einer ACL recht komplex sein kann, sollten Sie fertige Acl-Objekte mit Zend\Cache cachen (siehe Listing 13.6). Nach der Konfiguration des Cache-Storage wird geprüft, ob sich die ACL im Cache befindet. Falls nein, wird sie erstellt und gecacht. Eine Meldung gibt an, ob das Acl-Objekt aus dem Cache stammt oder nicht. use Zend\Cache\StorageFactory; use Zend\Debug\Debug; use Zend\Permissions\Acl\Acl; $cache = StorageFactory::factory(array( 'adapter' => array( 'name' => 'filesystem', 'options' => array(
  • 13 Benutzermanagement 358 'namespace' => 'acl', 'ttl' => 5, 'cache_dir' => LUIGI_ROOT . '/data/cache', ), ), 'plugins' => array('serializer'), )); $acl = $cache->getItem('acl'); if (!$acl) { $acl = new Acl(); [...] $cache->setItem('acl', $acl); Debug::dump('ACL in den Cache geschrieben'); } else { Debug::dump('ACL aus dem Cache gelesen'); } Listing 13.6 ACL mit Zend\Cache speichern Details zu Zend\Cache finden Sie in Abschnitt 4.3, »Zend\Cache«. 13.3 Zend\Permissions\Rbac Eine Alternative zur ACL ist Zend\Permissions\Rbac, mit der Sie eine rollenbasierte Zugriffskontrolle (role-based access control – RBAC) umsetzen können. Im Gegensatz zur ACL liegt der Fokus auf den Rollen und nicht auf den Ressourcen. Die Details fin- den Sie im Referenzhandbuch unter http://zf2.readthedocs.org/en/latest/index. html#zend-permissions-rbac. 13.3.1 Begrifflichkeiten Die RBAC basiert auf drei Bausteinen. Das erste Element ist die Identität, z. B. Luigi, Alessandro und Francesca. Jeder Benutzer hat genau eine Identität. Das zweite Element sind die Rollen. Eine Identität kann verschiedene Rollen anneh- men. Während Alessandro der einzige Administrator ist, sind Luigi, Alessandro und Francesca alle Mitarbeiter. Rollen können auch unterteilt sein.
  • 13.3 Zend\Permissions\Rbac 359 13 Das dritte Element sind die Berechtigungen. Eine Berechtigung kann verschiedenen Rollen zugeordnet sein, während eine Rolle verschiedene Berechtigungen haben kann. Während ein Administrator Bestellungen löschen kann, kann ein Mitarbeiter sie nur verändern. 13.3.2 RBAC definieren Bitte beachten Sie, dass Sie nicht wie bei der ACL globale Rechte vergeben können. Es ist nicht möglich, einem Administrator alle Berechtigungen in einem Rutsch zu geben. Sie müssen für jede Rolle alle Genehmigungen definieren oder mit Hierar- chien arbeiten. Um die RBAC zu definieren, müssen Sie Rollen, Berechtigungen und Beziehungen zu anderen Rollen festlegen. Danach können Sie das Role-Objekt einem Rbac-Objekt zuordnen. In Listing 13.7 werden vier Rollen und deren Berechtigungen definiert. Soll ein Role-Objekt die Berechtigungen eines anderen erben, können Sie mit addChild() die untergeordnete Rolle angeben, von der die Rechte geerbt werden sollen. Es kann beliebig viele untergeordnete Rollen geben. Mit addRole() ordnen Sie eine Rolle einem Rbac-Objekt zu. use Zend\Permissions\Rbac\Rbac; use Zend\Permissions\Rbac\Role; $roleGuest = new Role('guest'); $roleGuest->addPermission('pizza_list'); $roleGuest->addPermission('pizza_show'); $roleCustomer = new Role('customer'); $roleCustomer->addPermission('pizza_basket'); $roleCustomer->addPermission('order_create'); $roleCustomer->addPermission('order_send'); $roleCustomer->addChild($roleGuest); $roleStaff = new Role('staff'); $roleStaff->addPermission('pizza_create'); $roleStaff->addPermission('pizza_update'); $roleStaff->addPermission('order_update'); $roleStaff->addPermission('order_cancel'); $roleStaff->addPermission('order_finish'); $roleStaff->addChild($roleCustomer); $roleAdmin = new Role('admin'); $roleAdmin->addPermission('pizza_delete');
  • 13 Benutzermanagement 360 $roleAdmin->addPermission('order_delete'); $roleAdmin->addChild($roleStaff); $rbac = new Rbac(); $rbac->addRole($roleGuest); $rbac->addRole($roleCustomer); $rbac->addRole($roleStaff); $rbac->addRole($roleAdmin); Listing 13.7 Zend\Permissions\Rbac mit vier Rollen definieren Die Berechtigungen bestehen aus einem Präfix (wie 'pizza' oder 'order'), einem Unterstrich und dem eigentlichen Namen (wie 'list', 'basket' oder 'cancel'). Sie kön- nen diesen Vorschlag übernehmen, die Reihenfolge ändern, einen Punkt als Trenner verwenden oder mit Zahlen arbeiten. Zudem können Sie auch den Namen eines Con- trollers und einer Aktionsmethode verwenden. Wichtig ist nur dass jede Berechti- gung eindeutig ist. Das erstellte Rbac-Objekt lässt sich cachen. Die Vorgehensweise für das Cachen eines Acl-Objekts finden Sie in Listing 13.6. 13.3.3 RBAC abfragen Für die Abfrage der RBAC müssen Sie den Namen der Rolle sowie den Namen der Berechtigung an die Methode isGranted() übergeben. Sie erhalten als Ergebnis true oder false. In Listing 13.8 werden Prüfungen für die vorherige RBAC vorgenommen, wobei die ersten sieben Zeilen true und die letzten vier false ausgeben. Bei den feh- lerhaften Prüfungen sind die abgefragten Berechtigungen für die Rolle nicht vorhan- den. Bei der letzten Abfrage auf 'order_copy' ist diese Berechtigung in der RBAC gar nicht definiert. use Zend\Debug\Debug; use Zend\Permissions\Rbac\Rbac; use Zend\Permissions\Rbac\Role; [...] Debug::dump($rbac->isGranted('guest', 'pizza_list')); Debug::dump($rbac->isGranted('customer', 'pizza_basket')); Debug::dump($rbac->isGranted('customer', 'pizza_list')); Debug::dump($rbac->isGranted('staff', 'pizza_list')); Debug::dump($rbac->isGranted('staff', 'order_cancel')); Debug::dump($rbac->isGranted('admin', 'pizza_delete')); Debug::dump($rbac->isGranted('admin', 'order_create'));
  • 13.4 Zend\Authentication 361 13 Debug::dump($rbac->isGranted('guest', 'pizza_create')); Debug::dump($rbac->isGranted('customer', 'order_finish')); Debug::dump($rbac->isGranted('staff', 'order_delete')); Debug::dump($rbac->isGranted('admin', 'order_copy')); Listing 13.8 Zend\Permissions\Rbac abfragen 13.4 Zend\Authentication Zend\Authentication hilft ihnen, die Benutzer Ihrer Anwendung zu authentifizieren. Die Komponente bringt mehrere Adapter mit sich, die für die Authentifizierung zuständig sind. Außerdem stehen Storages zum Speichern des authentifizierten Benutzers sowie ein Authentifizierungsservice bereit. Weitere Details finden Sie im Referenzhandbuch unter http://zf2.readthedocs.org/en/latest/index.html#zend- authentication. Ein Beispiel für einen Authentifizierungsadapter, der für die Passwortverschlüsse- lung die Komponente Zend\Crypt\Password\Bcrypt einsetzt, finden Sie in Abschnitt 17.3.1, »Authentifizierungsadapter«. 13.4.1 Per HTTP authentifizieren Bei der Authentifizierung mit HTTP müssen Sie die Varianten Basic Authentication und Digest Authentication unterscheiden. Der Unterschied ist, dass die Passwörter bei der Digest Authentication nicht im Klartext übermittelt werden. Für die Basic Authentication wird die Passwortdatei /data/auth/basic.pw benötigt (siehe Listing 13.9). Der Zeilenaufbau ist Benutzername:Realm:Passwort, wobei die Passwörter unverschlüsselt sind. luigi:Luigis Pizza-Service:luigi francesca:Luigis Pizza-Service:francesca alessandro:Luigis Pizza-Service:alessandro valentina:Luigis Pizza-Service:valentina Listing 13.9 Die Passwortdatei basic.pw für eine Basic-HTTP-Authentication Das Beispiel läuft in Listing 13.10 im Kontext eines View-Scripts, wundern Sie sich also nicht über den Zugriff auf den Service-Manager über den HelperPluginManager. Aus dem Service-Manager werden die Request- und Response-Objekte geholt. Der Http-Adapter wird mit der Methode Basic Authentication und dem Realm »Luigis Pizza-Service« konfiguriert. Der FileResolver wird für die Passwortdatei konfiguriert und Resolver, Request und Response werden an den Adapter übergeben. Durch den
  • 13 Benutzermanagement 362 Aufruf von authenticate() erfolgt die Authentifizierung. Das Result-Objekt kann ausgewertet werden und ermöglicht bei Erfolg die Abfrage der angemeldeten Identi- tät. use Zend\Authentication\Adapter\Http; use Zend\Authentication\Adapter\Http\FileResolver; $sm = $this->getHelperPluginManager()->getServiceLocator(); $response = $sm->get('response'); $request = $sm->get('request'); $adapter = new Http(array( 'accept_schemes' => 'basic', 'realm' => 'Luigis Pizza-Service', 'digest_domains' => '/listing/listing1310', 'nonce_timeout' => 3600, )); $basicResolver = new FileResolver(); $basicResolver->setFile(LUIGI_ROOT . '/data/auth/basic.pw'); $adapter->setBasicResolver($basicResolver); $adapter->setRequest($request); $adapter->setResponse($response); $result = $adapter->authenticate(); if (!$result->isValid()) { echo 'Du kommst hier nicht rein!'; } else { $identity = $result->getIdentity(); echo 'Herzlich Willkommen ' . $identity['username'] . '!'; } Listing 13.10 Basic-HTTP-Authentication mit Http-Adapter Wenn Sie http://luigis-pizza.local/listing/listing1310 aufrufen, können Sie das Bei- spiel ausprobieren. Für die Digest Authentication ist die Passwortdatei unter /data/auth/digest.pw zu finden (siehe Listing 13.11). Der Aufbau ist derselbe wie bei der Basic Authentication,
  • 13.4 Zend\Authentication 363 13 nur ist das Passwort mit md5() verschlüsselt und der Hash wird z. B. aus der Kombina- tion luigi:Luigis Pizza-Service:luigi gebildet. luigi:Luigis Pizza-Service:6b150f7dc4cdc0fe1b16315482544685 francesca:Luigis Pizza-Service:d23e77cb95c9129102cd8452a9e10390 alessandro:Luigis Pizza-Service:b03fd2ec130d394f1af3960e3bb37017 valentina:Luigis Pizza-Service:8792865b2896655c5de293ef425a06c3 Listing 13.11 Die Passwortdatei digest.pw für eine Digest-HTTP-Authentication Der Ablauf der Digest Authentication ist in Listing 13.12 (gekürzt) zu sehen und unter- scheidet sich kaum von der Basic Authentication. Die Konfiguration des accept_ schemes ist anders, die Passwortdatei für die Digest Authentication wird verwendet, und der Resolver wird mit setDigestResolver() übergeben. Probieren Sie es mit http://luigis-pizza.local/listing/listing1312 aus. [...] $adapter = new Http(array( 'accept_schemes' => 'digest', 'realm' => 'Luigis Pizza-Service', 'digest_domains' => '/listing/listing1312', 'nonce_timeout' => 3600, )); $digestResolver = new FileResolver(); $digestResolver->setFile(LUIGI_ROOT . '/data/auth/digest.pw'); $adapter->setDigestResolver($digestResolver); [...] Listing 13.12 Digest-HTTP-Authentication mit Http-Adapter (gekürzt) 13.4.2 Gegen eine Datenbanktabelle authentifizieren Mit Zend\Authentication können Sie gegen eine Datenbanktabelle authentifizieren. Listing 13.13 zeigt einen SQLite3-Dump für die Tabelle users, die die Benutzerdaten enthält. Das Passwort für den Benutzer »luigi« lautet »luigi«. DROP TABLE users; CREATE TABLE users ( id integer primary key, name varchar(32),
  • 13 Benutzermanagement 364 pass varchar(32) ); INSERT INTO "users" VALUES (1,'luigi','ccebba93f54d6bf2b17f8350e7c12ec4'); Listing 13.13 SQL-Dump für die Datenbanktabelle »users« für SQLite3 Passwortverschlüsselung mit Bcrypt Der Einfachheit halber werden die Passwörter mit md5() verschlüsselt. Sicherer ist eine Verschlüsselung mit Bcrypt. In Abschnitt 17.3, »Authentifizierung und Autori- sierung«, finden Sie einen Authentifizierungsadapter, der zur Verschlüsselung Bcrypt verwendet. Zur Authentifizierung gegen eine Datenbanktabelle kommt der DbTable zum Einsatz. In Listing 13.14 werden Zugangsdaten notiert und wird der Authentifizierungsadap- ter mit dem Datenbankadapter und den Namen für die Tabelle, Benutzerspalte und Passwortspalte konfiguriert. use Zend\Authentication\Adapter\DbTable; use Zend\Db\Adapter\Adapter; use Zend\Debug\Debug; $credentials = array( array('name' => 'francesca', 'pass' => 'francesca'), array('name' => 'luigi', 'pass' => 'francesca'), array('name' => 'luigi', 'pass' => 'luigi'), ); [...] $authAdapter = new DbTable($db, 'users', 'name', 'pass'); foreach ($credentials as $row) { $authAdapter->setIdentity($row['name']); $authAdapter->setCredential(md5($row['pass'])); $result = $authAdapter->authenticate(); Debug::dump($result); if ($result->isValid()) {
  • 13.4 Zend\Authentication 365 13 Debug::dump($authAdapter->getResultRowObject(null, 'pass')); } } Listing 13.14 Authentifizierung mit dem DbTable-Adapter Für jede Zeile werden im Authentifizierungsadapter der Benutzername und das Pass- wort festgelegt und wird die Authentifizierung gestartet. War der Versuch erfolglos, wird das Result-Objekt ausgegeben. Dem Result-Objekt können Sie die genaue Feh- lermeldung entnehmen. War die Authentifizierung erfolgreich, wird zusätzlich der gefundene Datensatz mit getResultRowObject() ausgegeben. Durch die Angabe von 'pass' als zweiten Parameter wird der Inhalt der Passwortspalte nicht zurückge- geben. 13.4.3 Authentifizierungsservice Sie können Ihre Benutzerauthentifizierung direkt mit einem der bisher vorgestellten Adapter durchführen. Der Zend\Authentication\AuthenticationService erleichtert die Authentifizierung jedoch noch weiter. Um den Ablauf an einem praktischen Bei- spiel zu demonstrieren, benötigen Sie ein Formular zum Anmelden und Abmelden (siehe Listing 13.15). Weitere Details zu Zend\Form finden Sie in Kapitel 12, »Formular- verarbeitung«. namespace Pizza\Form; use Zend\Form\Element\Password; use Zend\Form\Element\Submit; use Zend\Form\Element\Text; use Zend\Form\Form; class LoginForm extends Form { public function __construct() { parent::__construct('login'); $nameElement = new Text('name'); $nameElement->setLabel('Benutzername'); $passElement = new Password('pass'); $passElement->setLabel('Passwort'); $submitElement = new Submit('login'); $submitElement->setValue('Anmelden'); $submitElement->setAttribute('class', 'btn');
  • 13 Benutzermanagement 366 $this->add($nameElement); $this->add($passElement); $this->add($submitElement); } } class LogoutForm extends Form { public function __construct() { parent::__construct('logout'); $submitElement = new Submit('logout'); $submitElement->setValue('Abmelden'); $submitElement->setAttribute('class', 'btn'); $this->add($submitElement); } } Listing 13.15 Formulare zum Anmelden und Abmelden mit Zend\Authentication Der AuthenticationService benötigt einen Authentifizierungsadapter (siehe Listing 13.16) Zu Beginn werden der AuthenticationService und das Request-Objekt initia- lisiert, und es wird geprüft, ob eine POST-Anfrage vorliegt. Wenn dies der Fall ist, wird überprüft, ob der Login-Button geklickt, aber kein Benutzername eingegeben wurde. In diesem Fall wird eine Fehlermeldung festgelegt. Die nächste Prüfung schaut nach dem Login-Button. In diesem Fall werden der Datenbankadapter und der Authenti- fizierungsadapter konfiguriert, wobei der Authentifizierungsadapter den Benutzer- namen und das Passwort übergeben bekommt. Danach wird die Authentifizierung durchgeführt. Mögliche Fehlermeldungen werden zwischengespeichert. Die letzte Prüfung schaut nach dem Logout-Button und zerstört bei Bedarf die aktuelle Identi- tät und meldet den Nutzer ab. Der Rest des Listings kümmert sich um die Ausgabe der Meldungen und des Formulars. use Pizza\Form\LoginForm; use Pizza\Form\LogoutForm; use Zend\Authentication\AuthenticationService; use Zend\Authentication\Adapter\DbTable; use Zend\Db\Adapter\Adapter; use Zend\Http\PhpEnvironment\Request;
  • 13.4 Zend\Authentication 367 13 $authService = new AuthenticationService(); $request = new Request(); if ($request->isPost()) { if ($request->getPost('login') && !$request->getPost('name')) { $showMessage = 'Es wurde kein Benutzername eingegeben'; } elseif ($request->getPost('login')) { $db = new Adapter(array( 'driver' => 'Pdo_Sqlite', 'database' => LUIGI_ROOT . '/data/db/session.sqlite3.db', )); $authAdapter = new DbTable($db, 'users', 'name', 'pass'); $authAdapter->setIdentity( strtolower($request->getPost('name')) ); $authAdapter->setCredential(md5($request->getPost('pass'))); $result = $authService->authenticate($authAdapter); if (!$result->isValid()) { $showMessage = implode('', $result->getMessages()); } } elseif ($request->getPost('logout')) { $authService->clearIdentity(); } } if ($authService->hasIdentity()) { $showMessage = '"' . $authService->getIdentity() . '" angemeldet!'; } $alertClass = $authService->hasIdentity() ? 'alert-success' : 'alert-error'; if ($showMessage) { echo '' . $showMessage . ''; } $form = $authService->hasIdentity()
  • 13 Benutzermanagement 368 ? new LogoutForm() : new LoginForm(); $form->setData($request->getPost()->toArray()); $form->prepare(); echo $this->form()->openTag($form); foreach ($form as $element) { echo $this->formRow($element); } echo $this->form()->closeTag(); Listing 13.16 »AuthenticationService« mit »DbTable« einsetzen Der AuthenticationService lässt sich mit allen Adaptern für die Authentifizierung kombinieren. Die Vorgehensweise ist dabei prinzipiell dieselbe, wobei nicht jedes Mal ein Formular benötigt wird. In Abschnitt 17.3, »Authentifizierung und Autorisie- rung«, finden Sie ein Modul, das die Authentifizierung mit der Autorisierung im MVC-Kontext verknüpft. 13.5 Zend\Ldap Die Zend\Ldap-Komponente ermöglicht die Kommunikation zwischen Ihrer Anwen- dung und einem LDAP-Verzeichnis. Sie können Zend\Ldap eigenständig und als Adapter mit Zend\Auth einsetzen. Weitere Details zu Zend\Ldap finden Sie im Refe- renzhandbuch unter http://zf2.readthedocs.org/en/latest/index.html#zend-ldap.
  • Index 611 Index A AggregateResolver ................................................. 244 Akismet ....................................................................... 526 Anwendungsmodul ............................................... 383 Controller ................................................................ 173 Konfiguration .............................................. 171, 384 Menü ....................................................................... 399 Modul-Klasse........................................................ 170 Request-Parameter ............................................. 175 Seitenlayout.......................................................... 395 View-Script ............................................................. 173 Apache 2........................................................................ 57 Konfiguration ........................................................ 57 Virtual Host Linux................................................ 57 Virtual Host Windows ........................................ 59 Aspektorientierte Programmierung ................ 117 AssetManager ............................................................ 155 Atom-Feeds............................................................... 309 B B8-Filter ....................................................................... 526 Barcodes ...................................................................... 314 Basket Controller-Plugin ..................................... 580 Bcrypt ........................................................................... 376 Benutzermanagement ........................................... 351 Authentifizierungsservice ............................... 365 Session-Manager ................................................ 352 Zend\Authentication ........................................ 361 Zend\Ldap ............................................................ 368 Zend\Permissions\Acl....................................... 355 Zend\Permissions\Rbac ................................... 358 Zend\Session ......................................................... 351 Benutzer-Modul....................................................... 453 Anforderungen .................................................... 453 Authentifizierungsadapter ............................ 456 Authentifizierungsservice .............................. 460 Autorisierungsservice ....................................... 461 Benutzerrechte.................................................... 464 Öffentlicher Bereich ........................................... 478 UserListener .......................................................... 475 User-Service ......................................................... 466 View-Helper ......................................................... 470 Vorbereitungen ................................................... 454 Blog-Modul ................................................................. 411 Administrationsbereich .................................. 444 Blog-Modul (Forts.) Anforderungen ..................................................... 411 Blog-Service ........................................................... 431 Einrichtung ............................................................ 412 Entität ...................................................................... 421 Filter......................................................................... 426 Formular ................................................................ 428 Formular-Factories............................................ 429 Modelinfrastruktur............................................ 419 Öffentlicher Bereich.......................................... 440 Routing .................................................................... 415 Screenshot ................................................... 443, 450 TableGateway...................................................... 423 C CKEditor............................................................ 409, 448 Inline Editing........................................................ 549 Closures ........................................................................ 36 CmsContentBlock-View-Helper ................ 553, 558 CMS-Modul................................................................ 549 Anforderungen .................................................... 549 CMS-Service .......................................................... 556 CMS-Service erweitern...................................... 556 Controller .............................................................. 562 Formular ................................................................. 555 Funktionsweise ................................................... 563 JavaScript-Funktionen .................................... 560 Textblöcke .............................................................. 553 View-Helper .................................................. 553, 558 Vorbereitungen ................................................... 550 CommentShowComments-View-Helper ....... 513 CommentShowLinks-View-Helper.................... 511 Composer ..................................................................... 65 Autoloading ........................................................... 83 Fremdmodul installieren ................................. 179 SkeletonApplication installieren ................... 70 Zend Framework 2 installieren ....................... 65 ConsoleRenderer..................................................... 245 Controller .................................................................... 211 Action-Controller ................................................ 212 Einführung ............................................................. 211 Objekt-Zugriff ....................................................... 214 RESTful-Controller .............................................. 218 Services injizieren ................................................ 215 Controller-Plugin Basket..................................................................... 580
  • Index 612 Controller-Plugin (Forts.) Eigenes Plugin erstellen ................................... 234 FilePostRedirectGet.................................. 231, 500 FlashMessenger ................................................... 233 Forward .................................................................. 227 Layout ..................................................................... 225 Params .................................................................... 229 PostRedirectGet................................................... 229 Redirect ................................................................... 227 SpamCheck............................................................ 532 Url ............................................................................. 225 Zugriff...................................................................... 224 CurrencyFormat-View-Helper .................. 293, 397 Cycle-View-Helper .................................................. 252 D DateFormat-View-Helper..................................... 293 Datei-Uploads .......................................................... 498 Datenbank .................................................................. 257 Datenbankadapter ............................................ 258 Datenbankmodell .............................................. 257 Datenbankzugriffe loggen.............................. 275 DDL.......................................................................... 270 Doctrine 2 .............................................................. 281 Microsoft SQL Server ......................................... 258 MySQL ............................................................ 257, 303 Paginierung ......................................................... 304 PostgreSQL ................................................... 257, 303 RowGateway ........................................................ 278 SQL-Abfragen ....................................................... 265 SQLite3 ........................................................... 257, 303 TableGateway ....................................................... 271 Zend\Db.................................................................. 257 Date-View-Helper.................................................... 393 DDL............................................................................... 270 Dependency Injection ..................................... 41, 127 Zend\Di .................................................................... 141 DluTwBootstrap ....................................................... 337 Doctrine 2 ................................................................... 281 Annotationen ....................................................... 283 DoctrineORMModule ........................................ 281 Dokumentation................................................... 287 Entitäten ................................................................ 283 Entity-Manager .................................................. 286 Installation............................................................ 281 Modul konfigurieren ......................................... 282 Relationen ............................................................. 285 Reverse Engineering ......................................... 286 Doctrine/Common ................................................. 343 DoctrineORMModule ............................................ 281 E Entwurfsmuster Beobachter ............................................................. 117 Dependency Injection........................................ 127 Ereignisgesteuerte Architektur ...................... 117 MVC .......................................................................... 183 Service-Locator..................................................... 127 Ereignisgesteuerte Architektur .................... 45, 117 Event-Manager .................................................... 117 EscapeCss-View-Helper ......................................... 251 EscapeHtmlAttr-View-Helper ............................. 251 EscapeHtml-View-Helper ..................................... 251 EscapeJs-View-Helper............................................. 251 EscapeUrl-View-Helper.......................................... 251 Escaping ............................................................ 248, 250 Zend\Escaper ........................................................ 312 Event-driven architecture ..................................... 45 EventFeature.............................................................. 275 ext/intl .......................................................................... 56 F FeedRenderer............................................................ 245 FeedStrategy ...................................................... 245, 311 FilePostRedirectGet Plugin ........................ 231, 500 FlashMessenger-Plugin ........................................ 233 FormElementErrors-View-Helper .................... 335 FormElement-View-Helper................................. 335 FormLabel-View-Helper ....................................... 335 FormRow-View-Helper ......................................... 334 Formularverarbeitung ........................................... 315 Ausgabe mit View-Helpern ............................ 333 Fieldset als Collection ....................................... 329 Formularelemente .............................................. 331 Objekte anbinden .............................................. 340 Validierung ........................................................... 337 Zend\Form ............................................................ 322 Zend\InputFilter .................................................. 315 Form-View-Helper .................................................. 334 Fortschrittsbalken ................................................. 606 Fremdmodule............................................................ 179 AssetManager....................................................... 155 DluTwBootstrap ................................................. 337 Doctrine/common ............................................. 343 doctrine/common.............................................. 343 DoctrineORMModule ........................................ 281 SmartyModule..................................................... 256 ZfcBase..................................................................... 181 ZfcTwitterBootstrap .......................................... 337
  • Index 613 Fremdmodule (Forts.) ZfcUser ..................................................................... 181 ZFTool....................................................................... 69 G GetOrder-View-Helper ......................................... 586 Git & GitHub ............................................................... 39 Einführung .............................................................. 39 Fremdmodul klonen ........................................... 181 SkeletonApplication installieren ................... 69 GlobalAdapterFeature ........................................... 275 Gravatar-View-Helper ........................................... 252 H HeadTitle-View-Helper ........................................ 388 HtmlFlash-View-Helper ........................................ 252 HtmlList-View-Helper ........................................... 252 HtmlObject-View-Helper ..................................... 252 HtmlPage-View-Helper ......................................... 252 HTMLPurifier ........................................................... 406 HtmlQuicktime-View-Helper............................. 252 Hydrator............................................. 263, 341, 377, 571 HydratorInterface .............................................. 341 ReflectionHydrator ........................................... 264 I include_path ............................................................... 61 InlineScript-View-Helper ..................................... 252 Installation SkeletonApplication........................ 68 Composer ................................................................. 70 Git .............................................................................. 69 ZIP-Paket ................................................................. 69 Installation Zend Framework ............................... 61 Composer ................................................................. 65 include_path .......................................................... 61 Pyrus .......................................................................... 62 ZIP-Paket .................................................................. 61 Internationalisierung ext/intl ...................................................................... 56 Sprache mittels Routing ................................. 205 Zend\I18n .............................................................. 289 J JSON Controller ............................................................... 247 JsonModel .............................................................. 243 JsonRenderer ........................................................ 245 JSON (Forts.) JsonStrategy ......................................................... 245 Zend\Json................................................................ 312 Json ................................................................................ 312 JsonRenderer ............................................................ 245 JsonStrategy .............................................................. 245 Json-View-Helper .................................................... 252 K Kommentar-Modul................................................ 505 Administrationsbereich................................... 507 Anforderungen .................................................... 505 Kommentare anlegen ....................................... 519 Kommentar-Service ........................................... 521 Konfiguration ..................................................... 508 Modelinfrastruktur........................................... 506 Spamabwehr ......................................................... 535 View-Helper ............................................................ 511 View-Helper einsetzen....................................... 516 Vorbereitungen .................................................. 506 Konzepte ...................................................................... 40 Dependency Injection.......................................... 41 Ereignisgesteuerte Architektur ....................... 45 Event-driven architecture ................................. 45 Modularität ............................................................ 40 Service-Locator...................................................... 43 L Late Static Binding.................................................... 38 Layout Listener ................................................................... 395 Layout-Plugin ........................................................... 225 Layout-View-Helper............................................... 252 Library-Modul ........................................................... 177 Listings ........................................................................... 31 M MasterSlaveFeature ................................................ 275 MetadataFeature ...................................................... 275 Microsoft SQL Server ............................................. 258 Modelinfrastruktur Blog-Modul ........................................................... 419 Model-View-Controller.......................................... 183 Modularität ................................................................. 40 Anwendungsmodul ........................................... 169 Fremdmodule ....................................................... 179 Library-Modul ...................................................... 177 Module.php.............................................................. 77
  • Index 614 Modularität (Forts.) Modul-Manager ................................................... 151 Verzeichnisstruktur ............................................. 77 Module Anwendungsmodul ........................................... 383 Benutzer-Modul .................................................. 453 Blog-Modul ............................................................ 411 CMS-Modul .......................................................... 549 Kommentar-Modul........................................... 505 Pizza-Modul ......................................................... 483 Shop-Modul .......................................................... 565 Spamabwehr-Modul.......................................... 525 Mvc Events ................................................................ 205 dispatch.error...................................................... 206 finish-Event .......................................................... 209 route-Event........................................................... 205 MySQL ........................................................ 257, 259, 303 N Navigation-View-Helper............................. 299, 302 NumberFormat-View-Helper ............................. 293 P PageTitle-View-Helper ......................................... 388 PaginationControl-View-Helper ...................... 305 PartialLoop-View-Helper...................................... 252 Partial-View-Helper ................................................ 252 Passwörter verschlüsseln..................................... 376 PHP 5.3........................................................................... 34 Buchtipps ................................................................ 60 Closures .................................................................... 36 Late Static Binding ............................................... 38 PHP-Namespaces ................................................. 34 PHP-Extensions ......................................................... 54 PHP-Frameworks....................................................... 27 PhpRenderer ............................................................. 245 PhpRendererStrategy ............................................ 245 PHP-Version ................................................................ 53 Pizza-Modul .............................................................. 483 Administrationsbereich ................................... 501 Anforderungen ................................................... 483 Bild-Upload .......................................................... 498 Entität .................................................................... 489 Modelinfrastruktur ............................................ 485 Pizza-Karussell ................................................... 502 Pizza-Service ........................................................ 490 TableGateway ..................................................... 486 Vorbereitungen .................................................. 484 Placeholder-View-Helper ..................................... 252 PostgreSQL........................................................ 257, 303 PostRedirectGet Plugin ........................................ 229 Pyrus .............................................................................. 62 R RenderChildModel-View-Helper ...................... 252 Renderer ..................................................................... 245 ConsoleRenderer................................................. 245 FeedRenderer ....................................................... 245 JsonRenderer ........................................................ 245 PhpRenderer ......................................................... 245 RenderToPlaceholder-View-Helper................. 252 Resolver ...................................................................... 244 AggregateResolver............................................. 244 TemplateMapResolver ..................................... 244 TemplatePathStack ........................................... 244 RESTful-Webservice ................................................ 218 Controller .............................................................. 219 Konfiguration ....................................................... 221 Model-Service ...................................................... 220 Testen mit Zend\Http\Client ......................... 223 Routing........................................................................ 192 Beispiel..................................................................... 415 Konfiguration ...................................................... 201 Route-Typ ............................ 193, 194, 195, 196, 199 Route-Typen ......................................................... 192 SimpleRouteStack ............................................... 197 Tipps ........................................................................ 203 TreeRouteStack ................................................... 198 Zend\Navigation ................................................ 296 RowGatewayFeature..................................... 275, 280 RSS-Feeds................................................................... 309 S ServerUrl-View-Helper ......................................... 223 Service-Locator .................................................. 43, 127 Zend\ServiceManager ....................................... 127 Shop Modul Administrationsbereich................................... 596 Einsatz in Modulen............................................ 593 Funktionsweise ................................................... 594 Shop-Modul............................................................... 565 Anforderungen .................................................... 565 Bestellservice ......................................................... 573 Controller-Plugin............................................... 580 Hydrator ................................................................. 571 Modelinfrastruktur............................................ 567 Positionen ............................................................. 569 Script ....................................................................... 589
  • Index 615 Shop-Modul (Forts.) Serialisierung ........................................................ 571 View-Helper .......................................................... 581 View-Script ........................................................... 589 Vorbereitungen .................................................. 566 Warenkorb............................................................. 567 Warenkorb-Controller ...................................... 587 Warenkorb-Service ............................................. 576 ShowBasket-View-Helper..................................... 581 ShowForm-View-Helper ....................................... 391 ShowMessages-View-Helper.............................. 389 SimpleRouteStack ................................................... 197 SkeletonApplication................................................. 68 Autoloading mit Composer.............................. 83 Hauptverzeichnis .................................................. 71 Installation aus ZIP-Paket ............................... 69 Installation mit Composer ............................... 70 Installation mit Git ............................................. 69 Konfiguration ........................................................ 82 Konfigurationsverzeichnis ............................... 73 Modulverzeichnis ................................................. 77 Public-Verzeichnis ................................................ 74 Vendor-Verzeichnis.............................................. 76 SOAP .............................................................................. 371 Spamabwehr-Modul .............................................. 525 Anforderungen .................................................... 525 Autoloading.......................................................... 529 B8-Filter .................................................................. 526 Controller-Plugin ................................................ 532 Kommentar-Modul anpassen ....................... 535 Konfiguration ...................................................... 527 Modelinfrastruktur ............................................ 527 Modul einsetzen .................................................. 545 Serviceklasse ........................................................ 530 View-Helper .......................................................... 534 Vorbereitungen ................................................... 526 SpamCheck-Controller-Plugin ........................... 532 SpamCheck-View-Helper ..................................... 534 Spamfilter ................................................................... 526 SQL-Abfragen ............................................................ 265 Delete...................................................................... 268 Insert ....................................................................... 268 Join........................................................................... 266 Select ........................................................................ 265 Update ................................................................... 268 SQLite3....................................................... 257, 259, 303 Strategies .................................................................... 245 FeedStrategy ................................................. 245, 311 JsonStrategy.......................................................... 245 PhpRendererStrategy ........................................ 245 StringHtmlPurifier-Filter........................... 406, 427 StringToUrl-Filter................................................... 404 T Tagwolke...................................................................... 313 Template-Engines ................................................... 256 TemplateMapResolver.......................................... 244 TemplatePathStack ................................................ 244 Translate-View-Helper .......................................... 292 Translator ................................................................... 289 Konfiguration ...................................................... 291 Translator-Service.............................................. 292 View-Helper .......................................................... 292 Zend\Validator-Fehlermeldungen .............. 294 TreeRouteStack ........................................................ 198 Twitter Bootstrap ..................................... 70, 337, 391 Alerts ....................................................................... 389 Carousel ................................................................. 502 Menüleiste............................................................ 400 U Url-Plugin ................................................................... 225 Url-View-Helper........................................................ 174 UserIsAllowed-View-Helper .............................. 470 UserShowWidget-View-Helper........................... 471 V View-Helper............................................................... 248 BasePath ................................................................ 249 CmsContentBlock....................................... 553, 558 CommentShowComments .............................. 513 CommentShowLinks ........................................... 511 CurrencyFormat ................................................. 397 Cycle ........................................................................ 252 Date ......................................................................... 393 Doctype .................................................................. 249 eigene View-Helper................................... 253, 388 EscapeCss................................................................ 251 EscapeHtml.................................................... 176, 251 EscapeHtmlAttr ................................................... 251 EscapeJs ................................................................... 251 EscapeUrl ................................................................ 251 Form ........................................................................ 334 FormElement........................................................ 335 FormRow ............................................................... 334 GetOrder ................................................................ 586 Gravatar ................................................................ 252 HeadLink ............................................................... 249
  • Index 616 View-Helper (Forts.) HeadMeta ............................................................. 249 HeadScript ............................................................ 249 HeadStyle.............................................................. 249 HeadTitle............................................................... 249 HtmlFlash .............................................................. 252 HtmlList.................................................................. 252 HtmlObject............................................................ 252 HtmlPage ............................................................... 252 HtmlQuicktime.................................................... 252 InlineScript ............................................................ 252 Json ........................................................................... 252 Layout ..................................................................... 252 Navigation .................................................. 299, 302 PageTitle ............................................................... 388 PaginationControl ............................................ 305 Partial...................................................................... 252 PartialLoop ........................................................... 252 Placeholder ........................................................... 252 RenderChildModel.............................................. 252 RenderToPlaceholder ........................................ 252 ServerUrl........................................................ 223, 250 ShowBasket ........................................................... 581 ShowForm.............................................................. 391 ShowMessages .................................................... 389 SpamCheck............................................................ 534 Translate ................................................................ 292 Url .................................................................... 174, 250 UserIsAllowed ..................................................... 470 UserShowWidget................................................. 471 ViewModel............................................................. 252 Widgets ................................................................... 253 ViewModel ................................................................. 241 Aktionsmethode.................................................. 241 ConsoleModel ...................................................... 243 FeedModel ..................................................... 243, 311 JsonModel .............................................................. 243 Listener ................................................................... 395 Verschachtelung ................................................. 242 ViewModel-View-Helper ...................................... 252 View-Scripts ............................................................... 247 Beispiel ........................................................... 174, 248 Escaping ....................................................... 248, 250 Templatevariablen............................................ 248 View-Helper ......................................................... 248 Virtual Host Linux .................................................... 57 Virtual Host Windows ............................................. 59 Voraussetzungen ...................................................... 53 Apache 2-Konfiguration .................................... 57 PHP-Extensions ..................................................... 54 Voraussetzungen (Forts.) Virtual Host Linux ................................................ 57 Virtual Host Windows ........................................ 59 W Wegweiser .................................................................... 28 X XML-RPC ..................................................................... 374 XSS ...................................................................... 248, 406 Z Zend Framework 1..................................................... 33 Komponentenvergleich ..................................... 48 Umsteiger ................................................................. 33 Zend Framework 2..................................................... 27 Anwendung einrichten ....................................... 53 Einführung ............................................................... 27 Installation .............................................................. 61 Komponentenvergleich ..................................... 48 Konzepte .................................................................. 40 Links............................................................................ 31 Nachteile ................................................................... 51 Neuerungen ............................................................. 33 Struktur ..................................................................... 71 Überblick über die Komponenten ................. 29 Versionsverwaltung ............................................ 39 Voraussetzungen .................................................. 53 Vorteile ..................................................................... 50 Zend Framework 2-Links ........................................ 31 Zend\Authentication ............................................. 361 Authentifizierungsprozess ............................. 366 Authentifizierungsservice..................... 365, 460 Basic Authentication ......................................... 361 Datenbank-Authentifizierung ...................... 363 DbCrypt-Authentifizierungsadapter .......... 456 Digest Authentication ...................................... 362 HTTP-Authentifizierung ................................... 361 Ldap ......................................................................... 368 Login-Formular ................................................... 365 Logout-Formular ................................................ 365 Zend\Barcode ............................................................ 314 Zend\Cache.................................................................. 92 Capabilities ............................................................. 94 Patterns .................................................................... 95 Plugins ...................................................................... 94 Storages ................................................................... 92 Zend\Code ................................................................ 605
  • Index 617 Zend\Config................................................................ 90 ACL cachen ............................................................ 357 Factory ...................................................................... 91 Kaskadierendes Laden........................................ 82 PHP-Array einlesen .............................................. 91 Reader ...................................................................... 90 Writer......................................................................... 91 YAML-Unterstützung installieren.................. 91 Zend\Console........................................................... 605 Zend\Crypt................................................................. 376 DbCrypt-Authentifizierungsadapter ......... 456 Zend\Db ...................................................................... 257 Datenbankadapter ............................................ 258 RowGateway ........................................................ 278 SQL-Abfragen ....................................................... 265 TableGateway ....................................................... 271 Zend\Db\Adapter .................................................... 258 Entität-Klasse ....................................................... 262 Hydrator................................................................. 263 Konfiguration ...................................................... 258 Lesende Abfragen .............................................. 260 Queries ................................................................... 260 ResultSet................................................................. 262 Schreibende Abfragen....................................... 261 Statements ............................................................ 261 Zend\Db\RowGateway.......................................... 278 Daten lesen............................................................ 279 Daten schreiben .................................................. 279 Entität-Klasse ...................................................... 280 RowGatewayFeature............................... 275, 280 Zend\Db\Sql .............................................................. 265 Alter Table ............................................................ 270 Create Table ......................................................... 270 Delete...................................................................... 268 Drop Table ............................................................ 270 Insert ....................................................................... 268 Join........................................................................... 266 Select ........................................................................ 265 Update ................................................................... 268 Zend\Db\Sql\Ddl .................................................... 270 Zend\Db\TableGateway ........................................ 271 Beispiel .................................................................... 423 Daten schreiben .................................................. 273 Datenbankzugriffe loggen.............................. 275 Entität-Klasse ....................................................... 272 EventFeature ........................................................ 275 Formular ............................................................... 494 GlobalAdapterFeature...................................... 275 MasterSlaveFeature........................................... 275 MetadataFeature................................................ 275 RowGatewayFeature............................... 275, 280 Zend\Db\TableGateway (Forts.) Verknüpfungstabelle ........................................ 488 Zend\Debug ............................................................. 605 Zend\Di ........................................................................ 141 Automatische Erkennung ................................ 141 Definition kompilieren..................................... 144 Konfiguration ....................................................... 147 Tipps ........................................................................ 150 Zend\Dom................................................................. 605 Zend\Escaper ............................................................. 312 Zend\EventManager............................................... 117 Einführung ............................................................. 117 EventManagerAwareInterface ...................... 118 Listener Closures.................................................. 119 Listener-Aggregate ............................................. 121 MvcEvent ............................................................... 205 Objekte injizieren ............................................... 432 Parameter übergeben........................................ 124 Zend\SharedEventManager............................ 124 Zend\Feed ................................................................. 309 FeedModel .............................................................. 311 Feeds lesen ........................................................... 309 Feeds schreiben ................................................... 310 FeedStrategy ......................................................... 311 Zend\Filter ................................................................. 103 Beispiel.................................................................... 426 Benutzereingaben filtern ................................ 427 Eigene Filter ................................................ 107, 404 Filterketten............................................................ 107 Parameter übergeben....................................... 105 Standardfilter ...................................................... 104 Statische Filter ..................................................... 106 Zend\Form................................................................. 322 Annotationen ...................................................... 343 Ausgabe mit View-Helpern ............................ 333 Beispiel.......................................................... 428, 494 Collections............................................................. 328 Datei-Uploads...................................................... 346 Einführung ............................................................ 323 Factory........................................................... 324, 326 Fieldset erweitern ............................................... 326 Fieldsets.................................................................. 325 Formularelemente .............................................. 331 HTML5-Elemente ................................................ 332 InputFilter ............................................................. 337 InputFilterProviderInterface ......................... 338 Konfiguration ...................................................... 324 Objekt erstellen ................................................... 323 Objekte anbinden .............................................. 340 spezielle View-Helper........................................ 334 Standardelemente .............................................. 331
  • Index 618 Zend\Form (Forts.) Twitter Bootstrap ............................................... 337 Upload durchführen ......................................... 348 Uploadformular .................................................. 347 Validierung ........................................................... 337 Validierungsgruppe ........................................... 338 Zend\Http\Client ................................................... 369 Authentifizierung ................................................ 371 Cookies................................................................... 370 HTTP-Anfrage versenden ............................... 369 RESTful-Webservice testen .............................. 223 Verbindungsadapter ........................................ 370 Zend\I18n .................................................................. 289 ext/intl ...................................................................... 56 Translator ............................................................. 289 Translator konfigurieren ................................. 291 Translator-Service .............................................. 292 View-Helper .......................................................... 292 Zend\Validator Fehlermeldungen ..... 294, 402 Zend\InputFilter ....................................................... 315 eigenständige Klasse......................................... 318 Factory ..................................................................... 317 InputFilterProviderInterface .......................... 338 Input-Objekte ........................................................ 315 Konfiguration ....................................................... 317 Objekt erstellen..................................................... 315 Zend\Json ................................................................... 312 Zend\Ldap ................................................................. 368 Zend\Loader ................................................................ 87 ClassMap generieren........................................... 89 ClassMapAutoloader .......................................... 88 eigenen Autoloader erstellen.......................... 90 StandardAutoloader ........................................... 88 Zend\Log ...................................................................... 96 Datenbankzugriffe loggen.............................. 275 Fehler loggen ....................................................... 206 Filter ........................................................................... 98 Formatter................................................................. 98 Logger....................................................................... 96 Writer......................................................................... 98 Zend\Mail .................................................................... 99 E-Mail-Nachricht erstellen ............................. 100 E-Mail-Nachricht versenden ......................... 100 E-Mail-Nachrichten abrufen .......................... 102 MIME-Nachrichten erstellen .......................... 101 Zend\Math ................................................................ 605 Zend\Memory ......................................................... 605 Zend\Mime ................................................................ 101 Zend\ModuleManager ........................................... 151 Anwendungsmodul entwickeln .................... 169 Assets ........................................................................ 155 Zend\ModuleManager (Forts.) Autoloading .......................................................... 157 Controller konfigurieren ................................. 164 Controller-Plugins konfigurieren................. 166 Einführung .............................................................. 151 Fremdmodule ....................................................... 179 Konfiguration ............................................... 155, 157 Konfigurationsdaten ......................................... 158 Konfigurationsschlüssel ................................... 159 Library-Modul ...................................................... 177 Modulaufbau ........................................................ 152 Modul-Klasse ........................................................ 153 Services konfigurieren ....................................... 161 Source-Verzeichnis ............................................. 156 Tests .......................................................................... 156 View-Helper konfigurieren .............................. 167 Views ........................................................................ 157 Weitere Konfigurationen ................................ 169 Zend\Mvc .................................................................... 183 Application ........................................................... 184 Controller ............................................................... 211 Controller, Beispiel............................................ 440 Einführung ............................................................. 183 Events ...................................................................... 205 Routing ................................................................... 192 Services ................................................................... 189 Zend\Mvc\Application ......................................... 184 Bootstrapping...................................................... 186 Initialisierungsprozess ..................................... 184 Verarbeitung ........................................................ 188 Zend\Navigation ..................................................... 295 Acl ............................................................................. 301 Beispiel..................................................................... 415 Container............................................................... 295 Konfiguration ...................................................... 297 Menü im Seitenkopf .......................................... 399 Menüs ausgeben................................................ 300 MVC-Seiten ........................................................... 296 NavigationFactory ............................................ 299 Routing ................................................................... 296 Seiten ....................................................................... 295 URI-Seiten.............................................................. 295 View-Helper .......................................................... 299 Zend\Paginator........................................................ 302 Adapter................................................................... 303 Paginierung .......................................................... 302 Seitennavigation ................................................ 305 Seitennavigation View-Script....................... 308 Seitennavigation View-Skript ...................... 403 View-Helper .......................................................... 305
  • Index 619 Zend\Permissions\Acl .......................................... 355 ACL abfragen ........................................................ 357 ACL cachen ............................................................ 357 ACL definieren...................................................... 355 Autorisierungsservice ....................................... 461 Benutzerrechte prüfen ..................................... 476 Privilegien .............................................................. 355 Regeln ...................................................................... 355 Ressourcen ............................................................ 355 Rollen....................................................................... 355 Zend\Navigation ................................................ 301 Zend\Permissions\Rbac ....................................... 358 Berechtigungen ................................................... 359 Identitäten............................................................. 358 RBAC abfragen.................................................... 360 RBAC definieren .................................................. 359 Rollen....................................................................... 358 Zend\ProgressBar.................................................. 606 Zend\Serializer ................................................ 571, 606 Zend\ServiceManager ............................................ 127 AbstractFactories ...................................... 130, 138 Aliases ..................................................................... 130 Factories ......................................................... 130, 131 Initializers ...................................................... 130, 135 Instanziierungsarten ........................................ 130 Invokables ............................................................. 130 Konfigurationsdatei ........................................... 133 Konfigurationsklasse ........................................ 132 ServiceLocatorAwareInterface....................... 137 Services ................................................................... 130 Shared ..................................................................... 130 Tipps........................................................................ 140 Zend\Session.............................................................. 351 Session-Container ............................................... 351 Session-Manager ................................................ 352 Sessions in der Datenbank speichern ......... 353 Zend\Soap ................................................................... 371 AutoDiscover ........................................................ 372 Client einsetzen ................................................... 373 Server bereitstellen.............................................. 371 Zend\Soap (Forts.) WSDL-Caching abschalten .............................. 371 Zend\Stdlib ................................................................. 377 Hydrator ................................................................. 377 Zend\Tag...................................................................... 313 Zend\Text.................................................................. 606 Zend\Uri .................................................................... 606 Zend\Validator......................................................... 108 eigenen Validator erstellen ............................. 113 Fehlermeldungen anpassen ............................. 115 Fehlermeldungen übersetzen .............. 294, 402 Parameter übergeben........................................ 110 Standardvalidatoren ........................................ 109 Statische Validatoren ......................................... 111 Validatorketten.................................................... 112 Zend\Version ........................................................... 606 Zend\View.................................................................. 237 Ablauf...................................................................... 238 Beispiel.................................................................... 239 Konfiguration ..................................................... 240 Layout ..................................................................... 395 Renderer ................................................................. 245 Resolver .................................................................. 244 Strategies ............................................................... 245 Teilkomponenten ............................................... 237 Template-Engines .............................................. 256 View-Helper .......................................................... 248 ViewModel ............................................................. 241 View-Scripts .......................................................... 247 View-Scripts, Beispiel ............................... 443, 447 Zend\XmlRpc............................................................ 374 Caching ................................................................... 375 Client einsetzen .................................................... 375 Server bereitstellen ............................................ 374 ZendDeveloperTools .............................................. 179 ZfcBase.......................................................................... 181 ZfcTwig ........................................................................ 256 ZfcTwitterBootstrap............................................... 337 ZfcUser ......................................................................... 181 ZFTool ............................................................................ 69 Zielgruppe .................................................................... 28 Galileo Computing Leseprobe Zend Framework 2 Ralf Eggert -------------------------------------------- Auf einen Blick Inhalt -------------------------------------------- Kapitel 2: Neuerungen im Zend Framework 2 2.1 Begrifflichkeiten 2.2 PHP-Version 2.2.1 PHP-Namespaces 2.2.2 Closures 2.2.3 Late Static Binding 2.3 Git und GitHub 2.4 Neue Konzepte 2.4.1 Verbesserte Modularität 2.4.2 Dependency Injection 2.4.3 Service-Locator 2.4.4 Ereignisgesteuerte Architektur 2.5 Komponentenvergleich 2.6 Vor- und Nachteile des ZF2 Kapitel 13: Benutzermanagement 13.1 Zend\Session 13.1.1 Mit Session-Containern arbeiten 13.1.2 Session-Manager verwenden 13.1.3 Sessions in der Datenbank speichern 13.2 Zend\Permissions\Acl 13.2.1 Begrifflichkeiten 13.2.2 ACL definieren 13.2.3 ACL abfragen 13.2.4 ACL cachen 13.3 Zend\Permissions\Rbac 13.3.1 Begrifflichkeiten 13.3.2 RBAC definieren 13.3.3 RBAC abfragen 13.4 Zend\Authentication 13.4.1 Per HTTP authentifizieren 13.4.2 Gegen eine Datenbanktabelle authentifizieren 13.4.3 Authentifizierungsservice 13.5 Zend\Ldap -------------------------------------------- Index -------------------------------------------- www.galileocomputing.de © Galileo Press GmbH 2013 /ColorImageDict > /JPEG2000ColorACSImageDict > /JPEG2000ColorImageDict > /AntiAliasGrayImages false /CropGrayImages false /GrayImageMinResolution 150 /GrayImageMinResolutionPolicy /OK /DownsampleGrayImages true /GrayImageDownsampleType /Average /GrayImageResolution 200 /GrayImageDepth -1 /GrayImageMinDownsampleDepth 2 /GrayImageDownsampleThreshold 1.50000 /EncodeGrayImages true /GrayImageFilter /DCTEncode /AutoFilterGrayImages true /GrayImageAutoFilterStrategy /JPEG /GrayACSImageDict > /GrayImageDict > /JPEG2000GrayACSImageDict > /JPEG2000GrayImageDict > /AntiAliasMonoImages false /CropMonoImages false /MonoImageMinResolution 300 /MonoImageMinResolutionPolicy /OK /DownsampleMonoImages true /MonoImageDownsampleType /Bicubic /MonoImageResolution 300 /MonoImageDepth -1 /MonoImageDownsampleThreshold 1.50000 /EncodeMonoImages true /MonoImageFilter /CCITTFaxEncode /MonoImageDict > /AllowPSXObjects true /CheckCompliance [ /None ] /PDFX1aCheck false /PDFX3Check false /PDFXCompliantPDFOnly false /PDFXNoTrimBoxError true /PDFXTrimBoxToMediaBoxOffset [ 0.00000 0.00000 0.00000 0.00000 ] /PDFXSetBleedBoxToMediaBox true /PDFXBleedBoxToTrimBoxOffset [ 0.00000 0.00000 0.00000 0.00000 ] /PDFXOutputIntentProfile (U.S. Web Coated \050SWOP\051 v2) /PDFXOutputConditionIdentifier (CGATS TR 001) /PDFXOutputCondition () /PDFXRegistryName (http://www.color.org) /PDFXTrapped /False /CreateJDFFile false /Description > /Namespace [ (Adobe) (Common) (1.0) ] /OtherNamespaces [ > /FormElements false /GenerateStructure false /IncludeBookmarks false /IncludeHyperlinks false /IncludeInteractive false /IncludeLayers false /IncludeProfiles false /MarksOffset 6 /MarksWeight 0.250000 /MultimediaHandling /UseObjectSettings /Namespace [ (Adobe) (CreativeSuite) (2.0) ] /PDFXOutputIntentProfileSelector /UseName /PageMarksFile /RomanDefault /PreserveEditing false /UntaggedCMYKHandling /UseDocumentProfile /UntaggedRGBHandling /LeaveUntagged /UseDocumentBleed false >> > ] >> setdistillerparams > setpagedevice