Zend Framework 2 - Amazon Simple Storage Service · Inhalt 6 3 Das Zend Framework einrichten 53 3.1...
63
Ralf Eggert Zend Framework 2 Das Praxisbuch
Transcript of Zend Framework 2 - Amazon Simple Storage Service · Inhalt 6 3 Das Zend Framework einrichten 53 3.1...
Ralf Eggert
Zend Framework 2Das 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.8echo $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.85echo $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 stockSave orderSend order confirmationBake the pizzaUpdate 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, '<h5>Zähler</h5>');Debug::dump($basket->order, '<h5>Warenkorb</h5>');
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:luigifrancesca:Luigis Pizza-Service:francescaalessandro:Luigis Pizza-Service:alessandrovalentina: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:6b150f7dc4cdc0fe1b16315482544685francesca:Luigis Pizza-Service:d23e77cb95c9129102cd8452a9e10390alessandro:Luigis Pizza-Service:b03fd2ec130d394f1af3960e3bb37017valentina: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('<br />', $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 '<div class="alert ' . $alertClass . '">'
. $showMessage . '</div>';}
$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
