Vous êtes sur la page 1sur 1748

Guide de

référence du
programmeur

Zend Framework 1.10.x


Guide de référence du programmeur: Zend Framework 1.10.x
Date de publication 27/01/2010 by mikaelkael (SVN 20684)
Copyright © 2005-2010 Zend Technologies Inc. (http://www.zend.com)
Table des matières
I. Introduction au Zend Framework ................................................................................... 1
Présentation ............................................................................................................ 3
Installation ............................................................................................................... 4
II. Apprendre Zend Framework ......................................................................................... 5
Démarrez rapidement avec Zend Framework ............................................................ 8
1. Zend Framework & MVC Introduction ........................................................... 8
1.1. Zend Framework ............................................................................... 8
1.2. Model-View-Controller ....................................................................... 8
2. Create Your Project ................................................................................... 10
2.1. Install Zend Framework ................................................................... 10
2.2. Create Your Project ......................................................................... 10
2.3. The Bootstrap ................................................................................. 11
2.4. Configuration ................................................................................... 12
2.5. Action Controllers ............................................................................ 12
2.6. Views ............................................................................................. 13
2.7. Checkpoint ...................................................................................... 15
3. Create A Layout ........................................................................................ 15
4. Create a Model and Database Table ........................................................... 18
5. Create A Form ........................................................................................... 28
6. Congratulations! ......................................................................................... 31
Chargement automatique avec Zend Framework ..................................................... 33
1. Introduction ................................................................................................ 33
2. Architecture et buts .................................................................................... 33
2.1. Convention de noms des classes ..................................................... 33
2.2. Conventions et architecture d'Autoload ............................................. 33
3. Utilisation de base de l'autoloader ............................................................... 34
4. Auto-chargement de resources ................................................................... 36
5. Conclusion ................................................................................................. 37
Les plugins dans Zend Framework ......................................................................... 38
1. Introduction ................................................................................................ 38
2. Using Plugins ............................................................................................ 38
3. Conclusion ................................................................................................. 40
Bien démarrer avec Zend_Layout ........................................................................... 42
1. Introduction ................................................................................................ 42
2. Utiliser Zend_Layout .................................................................................. 42
2.1. Layout Configuration ....................................................................... 42
2.2. Créer un script de layout ................................................................. 43
2.3. Accéder à l'objet Layout .................................................................. 43
2.4. Autres opérations ............................................................................ 44
3. Zend_Layout: Conclusions .......................................................................... 45
Bien démarrer avec Zend_View .............................................................................. 46
1. Introduction ................................................................................................ 46
2. Basic Placeholder Usage ............................................................................ 46
3. Standard Placeholders ............................................................................... 49
3.1. Setting the DocType ........................................................................ 49
3.2. Specifying the Page Title ................................................................. 50
3.3. Specifying Stylesheets with HeadLink ............................................... 51
3.4. Aggregating Scripts Using HeadScript .............................................. 52
4. View Placeholders: Conclusion ................................................................... 54
Bien comprendre et utiliser les décorateurs Zend Form ............................................ 55
1. Introduction ................................................................................................ 55

iii
Guide de référence
du programmeur

2. Les bases des décorateurs ......................................................................... 55


2.1. Aperçu du pattern décorateur ........................................................... 55
2.2. Créer votre premier décorateur ........................................................ 57
3. Chainer les décorateurs ............................................................................. 58
4. Rendu individuel des décorateurs ............................................................... 62
5. Créer et rendre des éléments composites .................................................... 66
5.1. L'élément ........................................................................................ 66
5.2. Le décorateur ................................................................................. 68
5.3. Conclusion ...................................................................................... 71
6. Conclusion ................................................................................................. 71
Bien démarrer avec Zend_Session, Zend_Auth, et Zend_Acl .................................... 72
1. Fabrique une application Multi-Utilisateurs avec Zend Framework .................. 72
1.1. Zend Framework ............................................................................. 72
2. Gérer les sessions dans ZF ........................................................................ 72
2.1. Introduction aux sessions ................................................................ 72
2.2. Utilisation classique de Zend_Session .............................................. 73
2.3. Utilisation avancée de Zend_Session ............................................... 74
3. Authentification d'utilisateurs dans Zend Framework ..................................... 74
3.1. Introduction à l'authentification ......................................................... 74
3.2. Utilisation de base de Zend_Auth ..................................................... 74
4. Fabriquer un système de gestion d'autorisations avec Zend Framework ......... 76
4.1. Introduction à l'autorisation .............................................................. 76
4.2. Utilisation de base de Zend_Acl ....................................................... 76
Bien démarrer avec Zend_Search_Lucene .............................................................. 80
1. Introduction à Zend_Search_Lucene ........................................................... 80
2. Structure d'index Lucene ............................................................................ 81
3. Ouverture et création d'index ...................................................................... 82
4. Indexation .................................................................................................. 82
4.1. Politique d'indexation ....................................................................... 83
5. Recherche ................................................................................................. 83
6. Requêtes supportées ................................................................................. 84
7. Pagination de résultat de recherche ............................................................ 86
Bien démarrer avec Zend_Paginator ....................................................................... 88
1. Introduction ................................................................................................ 88
2. Simple Examples ....................................................................................... 88
3. Contrôles de la pagination et styles de défilement ........................................ 90
4. Putting it all Together ................................................................................. 91
III. Guide de référence Zend Framework ......................................................................... 93
Zend_Acl ............................................................................................................. 124
1. Introduction .............................................................................................. 124
1.1. A propos des ressources ............................................................... 124
1.2. A propos des rôles ........................................................................ 124
1.3. Créer la Liste de Contrôle d'Accès ................................................. 125
1.4. Registre des rôles ......................................................................... 126
1.5. Définir les Contrôles d'Accès .......................................................... 127
1.6. Interroger les ACL ......................................................................... 127
2. Affiner les Contrôles d'Accès .................................................................... 128
2.1. Mieux définir les Contrôles d'Accès ................................................ 128
2.2. Retirer les Contrôles d'Accès ......................................................... 130
3. Utilisation avancée ................................................................................... 130
3.1. Rendre les données ACL persistantes ............................................ 130
3.2. Écrire des règles ACL conditionnelles avec des assertions ............... 131
Zend_Amf ............................................................................................................ 132
1. Introduction .............................................................................................. 132

iv
Guide de référence
du programmeur

2. Zend_Amf_Server .................................................................................... 132


2.1. Connecting to the Server from Flex ................................................ 134
2.2. Error Handling ............................................................................... 136
2.3. AMF Responses ............................................................................ 136
2.4. Typed Objects ............................................................................... 136
2.5. Resources ..................................................................................... 138
2.6. Connecting to the Server from Flash ............................................... 138
2.7. Authentication ............................................................................... 140
Zend_Application .................................................................................................. 142
1. Introduction .............................................................................................. 142
2. Zend_Application démarrage rapide .......................................................... 142
2.1. Utiliser Zend_Tool ......................................................................... 142
2.2. Ajouter Zend_Application à votre existant ........................................ 144
2.3. Ajouter et créer des ressources ...................................................... 145
2.4. Aller plus loin avec Zend_Application .............................................. 147
3. Théorie générale ...................................................................................... 147
3.1. Bootstrapping ................................................................................ 148
3.2. Resource Plugins .......................................................................... 152
4. Exemples ................................................................................................. 153
5. Fonctionnalités principales ........................................................................ 156
5.1. Zend_Application ........................................................................... 156
5.2. Zend_Application_Bootstrap_Bootstrapper ...................................... 160
5.3. Zend_Application_Bootstrap_ResourceBootstrapper ........................ 161
5.4. Zend_Application_Bootstrap_BootstrapAbstract ............................... 162
5.5. Zend_Application_Bootstrap_Bootstrap ........................................... 165
5.6. Zend_Application_Resource_Resource ........................................... 166
5.7. Zend_Application_Resource_ResourceAbstract ............................... 166
6. Plugins de ressources disponibles ............................................................. 168
6.1. Zend_Application_Resource_Cachemanager ................................... 168
6.2. Zend_Application_Resource_Db ..................................................... 169
6.3. Zend_Application_Resource_Frontcontroller .................................... 170
6.4. Zend_Application_Resource_Layout ............................................... 171
6.5. Zend_Application_Resource_Locale ............................................... 171
6.6. Zend_Application_Resource_Log .................................................... 172
6.7. Zend_Application_Resource_Multidb ............................................... 173
6.8. Zend_Application_Resource_Mail ................................................... 174
6.9. Zend_Application_Resource_Modules ............................................. 174
6.10. Zend_Application_Resource_Navigation ........................................ 176
6.11. Zend_Application_Resource_Router ............................................. 176
6.12. Zend_Application_Resource_Session ............................................ 176
6.13. Zend_Application_Resource_View ................................................ 177
Zend_Auth ........................................................................................................... 178
1. Introduction .............................................................................................. 178
1.1. Adaptateurs ................................................................................... 178
1.2. Résultats ....................................................................................... 179
1.3. Persistance d'identité ..................................................................... 180
1.4. Utilisation de Zend_Auth ................................................................ 183
2. Authentification avec une table de base de données ................................... 184
2.1. Introduction ................................................................................... 184
2.2. Utilisation avancée : maintenir persistant l'objet de résultat DbTable
............................................................................................................. 186
2.3. Utilisation avancée par l'exemple .................................................... 186
3. Authentification "Digest" ............................................................................ 188
3.1. Introduction ................................................................................... 188

v
Guide de référence
du programmeur

3.2. Spécifications ................................................................................ 188


3.3. Identité .......................................................................................... 188
4. Adaptateur d'authentification HTTP ........................................................... 189
4.1. Introduction ................................................................................... 189
4.2. Fonctionnement ............................................................................. 189
4.3. Options de configuration ................................................................ 190
4.4. Résolveurs .................................................................................... 190
4.5. Usage général : ............................................................................. 191
5. LDAP Authentication ................................................................................ 192
5.1. Introduction ................................................................................... 192
5.2. Usage ........................................................................................... 192
5.3. The API ........................................................................................ 194
5.4. Server Options .............................................................................. 195
5.5. Collecting Debugging Messages ..................................................... 198
5.6. Common Options for Specific Servers ............................................. 199
6. Authentification OpenID ............................................................................ 201
6.1. Introduction ................................................................................... 201
6.2. Spécifications ................................................................................ 201
Zend_Barcode ..................................................................................................... 203
1. Introduction .............................................................................................. 203
2. Création de code-barres avec la classe Zend_Barcode ............................... 203
2.1. Utilisation de la fabrique Zend_Barcode::factory ............................... 203
2.2. Tracer un code-barres ................................................................... 204
2.3. Générer le rendu d'un code-barres ................................................. 204
3. Zend_Barcode Objects ............................................................................. 205
3.1. Common Options .......................................................................... 206
3.2. Common Additional Getters ........................................................... 208
3.3. Description of shipped barcodes ..................................................... 208
4. Zend_Barcode Renderers ......................................................................... 215
4.1. Common Options .......................................................................... 215
4.2. Zend_Barcode_Renderer_Image .................................................... 216
4.3. Zend_Barcode_Renderer_Pdf ........................................................ 217
Zend_Cache ........................................................................................................ 218
1. Introduction .............................................................................................. 218
2. Aspect théorique ...................................................................................... 220
2.1. La méthode de fabrique de Zend_Cache ........................................ 221
2.2. Baliser les enregistrements ............................................................ 222
2.3. Nettoyer le cache .......................................................................... 222
3. Les frontends Zend_Cache ....................................................................... 223
3.1. Zend_Cache_Core ......................................................................... 223
3.2. Zend_Cache_Frontend_Output ....................................................... 226
3.3. Zend_Cache_Frontend_Function .................................................... 227
3.4. Zend_Cache_Frontend_Class ........................................................ 228
3.5. Zend_Cache_Frontend_File ........................................................... 229
3.6. Zend_Cache_Frontend_Page ......................................................... 230
4. Les backends Zend_Cache ...................................................................... 235
4.1. Zend_Cache_Backend_File ............................................................ 235
4.2. Zend_Cache_Backend_Sqlite ......................................................... 237
4.3. Zend_Cache_Backend_Memcached ............................................... 237
4.4. Zend_Cache_Backend_Apc ........................................................... 238
4.5. Zend_Cache_Backend_Xcache ...................................................... 239
4.6. Zend_Cache_Backend_ZendPlatform ............................................. 239
4.7. Zend_Cache_Backend_TwoLevels ................................................. 239

vi
Guide de référence
du programmeur

4.8. Zend_Cache_Backend_ZendServer_Disk et
Zend_Cache_Backend_ZendServer_ShMem ........................................ 241
5. Le gestionnaire de Cache ......................................................................... 241
Zend_Captcha ..................................................................................................... 245
1. Introduction .............................................................................................. 245
2. Opération Captcha ................................................................................... 245
3. Adaptateurs CAPTCHA ............................................................................ 246
3.1. Zend_Captcha_Word ..................................................................... 246
3.2. Zend_Captcha_Dumb .................................................................... 247
3.3. Zend_Captcha_Figlet ..................................................................... 247
3.4. Zend_Captcha_Image .................................................................... 247
3.5. Zend_Captcha_ReCaptcha ............................................................ 248
Zend_CodeGenerator ........................................................................................... 249
1. Introduction .............................................................................................. 249
1.1. Théorie ......................................................................................... 249
2. Exemples Zend_CodeGenerator ............................................................... 251
3. Zend_CodeGenerator Réference ............................................................... 255
3.1. Classes abstraites et interfaces ...................................................... 255
3.2. Classes CodeGenerator concrêtes ................................................. 256
Zend_Config ........................................................................................................ 262
1. Introduction .............................................................................................. 262
2. Aspect théorique ...................................................................................... 263
3. Zend_Config_Ini ....................................................................................... 264
4. Zend_Config_Xml ..................................................................................... 266
Zend_Config_Writer .............................................................................................. 271
1. Zend_Config_Writer .................................................................................. 271
Zend_Console_Getopt .......................................................................................... 274
1. Introduction .............................................................................................. 274
2. Déclarer les règles Getopt ........................................................................ 275
2.1. Déclarer des options avec la syntaxe courte .................................... 275
2.2. Déclarer des options avec la syntaxe longue ................................... 275
3. Extraire les options et les arguments ......................................................... 276
3.1. Manipuler les exceptions Getopt ..................................................... 276
3.2. Extraire les options par nom .......................................................... 277
3.3. Extraire les options ........................................................................ 277
3.4. Extraction des arguments sans option ............................................. 278
4. Configurer Zend_Console_Getopt ............................................................. 278
4.1. Ajouter des règles d'options ........................................................... 278
4.2. Ajouter des messages d'aide ......................................................... 279
4.3. Ajouter des alias aux options ......................................................... 279
4.4. Ajouter des listes d'arguments ........................................................ 279
4.5. Ajouter une configuration ............................................................... 280
Zend_Controller ................................................................................................... 282
1. Zend_Controller - Démarrage rapide ......................................................... 282
1.1. Introduction ................................................................................... 282
1.2. Démarrage rapide ......................................................................... 282
2. Fondations de Zend_Controller ................................................................. 286
3. Le contrôleur frontal (Front Controller) ....................................................... 289
3.1. Présentation générale .................................................................... 289
3.2. Méthodes principales ..................................................................... 290
3.3. Méthodes d'accès à l'environnement ............................................... 292
3.4. Paramètres du contrôleur frontal .................................................... 293
3.5. Étendre le contrôleur frontal ........................................................... 294
4. L'objet Requête ........................................................................................ 294

vii
Guide de référence
du programmeur

4.1. Introduction ................................................................................... 294


4.2. Les requêtes HTTP ....................................................................... 295
4.3. Sous-classer l'objet Requête .......................................................... 298
5. Routeur Standard ..................................................................................... 299
5.1. Introduction ................................................................................... 299
5.2. Utilisation d'un routeur ................................................................... 301
5.3. Utilisation basique du routeur de réécriture ...................................... 301
5.4. Routes par défaut .......................................................................... 302
5.5. Base URL et sous dossiers ............................................................ 303
5.6. Paramètres globaux ....................................................................... 304
5.7. Types de route .............................................................................. 304
5.8. Utiliser Zend_Config avec le RewriteRouter ..................................... 315
5.9. Dérivation de l'objet Router ............................................................ 316
6. Le distributeur .......................................................................................... 316
6.1. Vue d'ensemble ............................................................................. 316
6.2. Sous-classer le distributeur ............................................................ 318
7. Contrôleurs d'action .................................................................................. 321
7.1. Introduction ................................................................................... 321
7.2. Initialisation d'objet ........................................................................ 322
7.3. Détournement Pre et Post-Dispatch (Hook) ..................................... 323
7.4. Accesseurs ................................................................................... 323
7.5. Intégration des Vues ...................................................................... 324
7.6. Méthodes utiles ............................................................................. 326
7.7. Sous-classer le contrôleur d'action .................................................. 326
8. Aides d'action (Helper) ............................................................................. 328
8.1. Introduction ................................................................................... 328
8.2. Initialisation des aides .................................................................... 328
8.3. Le gestionnaire d'aide (Broker) ....................................................... 329
8.4. Aides d'action intégrées ................................................................. 330
8.5. Écrire vos propres aides ................................................................ 358
9. Objet de réponse ..................................................................................... 359
9.1. Utilisation ...................................................................................... 359
9.2. Manipulation des en-têtes .............................................................. 361
9.3. Segments nommés ........................................................................ 361
9.4. Manipulation des exceptions dans l'objet de réponse ....................... 363
9.5. Dériver l'objet de réponse .............................................................. 363
10. Plugins .................................................................................................. 363
10.1. Introduction ................................................................................. 363
10.2. Écrire des plugins ........................................................................ 364
10.3. Utilisation des plugins .................................................................. 364
10.4. Récupération et manipulations des plugins .................................... 366
10.5. Plugins inclus dans Zend Framework ............................................ 366
11. Utilisation de conventions de dossiers modulaires .................................... 371
11.1. Introduction ................................................................................. 371
11.2. Spécification des dossiers de modules .......................................... 372
11.3. Routage des modules .................................................................. 373
11.4. Module ou contrôleur Default global .............................................. 373
12. Exceptions avec MVC ............................................................................ 373
12.1. Introduction ................................................................................. 373
12.2. Gestion des exceptions ................................................................ 373
12.3. Différents types d'exceptions que vous pouvez rencontrer ............... 375
Zend_Currency .................................................................................................... 378
1. Introduction à Zend_Currency ................................................................... 378
1.1. Pourquoi devriez-vous utiliser Zend_Currency ? .............................. 378

viii
Guide de référence
du programmeur

2. Utiliser Zend_Currency ............................................................................. 378


2.1. Utilisation de base ......................................................................... 378
2.2. Créer une monnaie basée sur une locale ........................................ 379
3. Options des monnaies .............................................................................. 379
4. Qu'est ce qui définit une monnaie? ........................................................... 380
5. Où est le symbole monnétaire? ................................................................ 382
6. A quoi ressemble une monnaie? ............................................................... 383
7. Travailler avec les valeurs des monnaies (les montants) ............................. 384
7.1. Travailler avec les valeurs des monnaies ........................................ 384
7.2. Utiliser la précision des monnaies .................................................. 385
8. Calculs avec les monnaies ....................................................................... 386
9. Echanger (convertir) des monnaies ........................................................... 387
10. Informations complémentaires pour Zend_Currency .................................. 388
10.1. Informations sur les monnaies ...................................................... 388
10.2. Optimisation des performances des monnaies ............................... 389
Zend_Date ........................................................................................................... 390
1. Introduction .............................................................................................. 390
1.1. Définissez toujours un fuseau horaire par défaut .............................. 390
1.2. Pourquoi utiliser Zend_Date ? ........................................................ 390
2. Aspect théorique ...................................................................................... 391
2.1. Fonctionnement interne ................................................................. 391
3. Méthodes de base ................................................................................... 392
3.1. La date courante ........................................................................... 392
3.2. Zend_Date : exemples ................................................................... 392
4. Zend_Date API Overview ......................................................................... 394
4.1. Zend_Date Options ....................................................................... 394
4.2. Working with Date Values .............................................................. 395
4.3. Basic Zend_Date Operations Common to Many Date Parts .............. 396
4.4. Comparing Dates .......................................................................... 399
4.5. Getting Dates and Date Parts ........................................................ 401
4.6. Working with Fractions of Seconds ................................................. 402
4.7. Sunrise / Sunset ............................................................................ 402
5. Créer des dates ....................................................................................... 403
5.1. Créer la date actuelle .................................................................... 403
5.2. Créer une date depuis une base de données .................................. 403
5.3. Créer des dates depuis un tableau ................................................. 404
6. Constants for General Date Functions ....................................................... 404
6.1. Using Constants ............................................................................ 404
6.2. List of All Constants ...................................................................... 405
6.3. Self-Defined OUTPUT Formats with ISO ......................................... 409
6.4. Self-Defined OUTPUT Formats Using PHP's date() Format
Specifiers ............................................................................................. 412
7. Exemples concrets ................................................................................... 415
7.1. Vérifier des dates .......................................................................... 415
7.2. Levé et couché du soleil ................................................................ 416
7.3. Fuseaux horaires (Timezones) ....................................................... 418
Zend_Db .............................................................................................................. 420
1. Zend_Db_Adapter .................................................................................... 420
1.1. Se connecter à un SGBD en utilisant un adaptateur ......................... 420
1.2. La base de données d'exemple ...................................................... 425
1.3. Lecture de résultats de requête ...................................................... 426
1.4. Effectuer des changements dans la base de données ...................... 429
1.5. Échapper des valeurs ou des identifiants ........................................ 433
1.6. Gérer les transactions dans une base de données ........................... 435

ix
Guide de référence
du programmeur

1.7. Lister et décrire les tables .............................................................. 436


1.8. Fermer une connexion ................................................................... 437
1.9. Exécuter des requêtes sur le driver directement .............................. 438
1.10. Récupérer la version du serveur SGBD ......................................... 439
1.11. Notes sur des adaptateur spécifiques ........................................... 439
2. Zend_Db_Statement ................................................................................. 443
2.1. Créer un statement ........................................................................ 443
2.2. Exécuter un statement ................................................................... 443
2.3. Récupérer des résultats depuis un statement SELECT ..................... 444
3. Zend_Db_Profiler ..................................................................................... 446
3.1. Introduction ................................................................................... 446
3.2. Utiliser le profileur ......................................................................... 447
3.3. Utilisation avancée du profileur ....................................................... 449
3.4. Profileurs spécialisés ..................................................................... 450
4. Zend_Db_Select ....................................................................................... 451
4.1. Introduction ................................................................................... 451
4.2. Créer un objet Select ..................................................................... 452
4.3. Construction de requêtes Select ..................................................... 452
4.4. Exécuter des requêtes Select ......................................................... 465
4.5. Autres méthodes ........................................................................... 466
5. Zend_Db_Table ....................................................................................... 468
5.1. Introduction ................................................................................... 468
5.2. Définir une classe de Table ........................................................... 468
5.3. Créer une instance de la classe de Table ....................................... 471
5.4. Insérer des enregistrement dans une table ...................................... 472
5.5. Mettre à jour des enregistrements dans une table ............................ 474
5.6. Supprimer des enregistrements d'une Table .................................... 475
5.7. Récupérer des enregistrements par clé primaire .............................. 475
5.8. Requêter pour plusieurs enregistrements ........................................ 477
5.9. Récupérer un seul enregistrement .................................................. 480
5.10. Récupérer les méta données d'une Table ..................................... 480
5.11. Cacher les méta données de la table ............................................ 481
5.12. Personnaliser et étendre une classe de Table ................................ 484
6. Zend_Db_Table_Row ............................................................................... 487
6.1. Introduction ................................................................................... 487
6.2. Récupérer un résultat (un "Row") ................................................... 487
6.3. Sauvegarde un Row en base de données ....................................... 489
6.4. Sérialisation et désérialisation d'un Row .......................................... 490
6.5. Étendre la classe Row ................................................................... 492
7. Zend_Db_Table_Rowset ........................................................................... 494
7.1. Introduction ................................................................................... 494
7.2. Récupérer un Rowset .................................................................... 494
7.3. Atteindre les Rows depuis un Rowset ............................................. 495
7.4. Récupérer un Rowset en tant que tableau (Array) ............................ 497
7.5. Sérialisation et Désérialisation d'un Rowset ..................................... 497
7.6. Étendre la classe Rowset .............................................................. 498
8. Relations Zend_Db_Table ......................................................................... 499
8.1. Introduction ................................................................................... 499
8.2. Définir ses relations ....................................................................... 500
8.3. Récupérer des enregistrements dépendants (enfants) ...................... 502
8.4. Récupérer l'enregistrement parent .................................................. 503
8.5. Récupérer des enregistrements dans une relation N-N (plusieurs-à-
plusieurs ou "many-to-many") .............................................................. 505
8.6. Opérations d'écritures en cascade .................................................. 507

x
Guide de référence
du programmeur

9. Zend_Db_Table_Definition ........................................................................ 509


9.1. Introduction ................................................................................... 509
9.2. Utilisation de base ......................................................................... 509
9.3. Utilisation avancée ........................................................................ 511
Zend_Debug ........................................................................................................ 513
1. Afficher des informations .......................................................................... 513
Zend_Dojo ........................................................................................................... 514
1. Introduction .............................................................................................. 514
2. Zend_Dojo_Data: dojo.data Envelopes ...................................................... 514
2.1. Zend_Dojo_Data Usage ................................................................. 514
2.2. Adding metadata to your containers ................................................ 516
2.3. Advanced Use Cases .................................................................... 516
3. Les aides de vues Dojo ............................................................................ 518
3.1. dojo() View Helper ......................................................................... 518
3.2. Dijit-Specific View Helpers ............................................................. 523
4. Les éléments de formulaire et les décorateurs Dojo .................................... 536
4.1. Dijit-Specific Form Decorators ........................................................ 537
4.2. Dijit-Specific Form Elements ........................................................... 539
4.3. Dojo Form Examples ..................................................................... 556
5. Zend_Dojo build layer support .................................................................. 557
5.1. Introduction ................................................................................... 557
5.2. Generating Custom Module Layers with Zend_Dojo_BuildLayer ........ 558
5.3. Generating Build Profiles with Zend_Dojo_BuildLayer ...................... 560
Zend_Dom ........................................................................................................... 563
1. Introduction .............................................................................................. 563
2. Zend_Dom_Query .................................................................................... 563
2.1. Aspect théorique ........................................................................... 563
2.2. Méthodes disponibles .................................................................... 564
Zend_Exception ................................................................................................... 566
1. Utiliser les exceptions ............................................................................... 566
2. Utilisation classique .................................................................................. 566
3. Exceptions précédentes ............................................................................ 567
Zend_Feed .......................................................................................................... 568
1. Introduction .............................................................................................. 568
2. Importer des flux ...................................................................................... 569
2.1. Flux personnalisés ......................................................................... 570
3. Obtenir des flux à partir de pages Web ..................................................... 574
4. Consommer un flux RSS .......................................................................... 574
5. Consommer un flux Atom ......................................................................... 576
6. Consommer une entrée Atom particulière .................................................. 577
7. Modifier la structure du flux ou des entrées ................................................ 577
8. Classes personnalisées pour les flux et entrées ......................................... 578
9. Zend_Feed_Reader .................................................................................. 580
9.1. Introduction ................................................................................... 580
9.2. Importing Feeds ............................................................................ 580
9.3. Retrieving Underlying Feed and Entry Sources ................................ 581
9.4. Cache Support and Intelligent Requests ......................................... 582
9.5. Locating Feed URIs from Websites ................................................. 583
9.6. Attribute Collections ....................................................................... 584
9.7. Retrieving Feed Information ........................................................... 585
9.8. Retrieving Entry/Item Information .................................................... 588
9.9. Extending Feed and Entry APIs ...................................................... 591
10. Zend_Feed_Writer .................................................................................. 595
10.1. Introduction ................................................................................. 595

xi
Guide de référence
du programmeur

10.2. Architecture ................................................................................. 595


10.3. Getting Started ............................................................................ 596
10.4. Setting Feed Data Points ............................................................. 597
10.5. Setting Entry Data Points ............................................................. 599
11. Zend_Feed_Pubsubhubbub .................................................................... 601
11.1. What is Pubsubhubbub? .............................................................. 601
11.2. Architecture ................................................................................. 602
11.3. Zend_Feed_Pubsubhubbub_Publisher .......................................... 602
11.4. Zend_Feed_Pubsubhubbub_Subscriber ........................................ 603
Zend_File ............................................................................................................ 611
1. Zend_File_Transfer .................................................................................. 611
1.1. Adaptateurs supportés par Zend_File_Transfer ................................ 612
1.2. Options de Zend_File_Transfer ...................................................... 612
1.3. Vérification des fichiers .................................................................. 613
1.4. Informations complémentaires sur les fichiers .................................. 613
1.5. Progress for file uploads ................................................................ 615
2. Validateurs pour Zend_File_Transfer ......................................................... 617
2.1. Utiliser les validateurs avec Zend_File_Transfer .............................. 618
2.2. Validateur Count ........................................................................... 620
2.3. Validateur Crc32 ........................................................................... 621
2.4. Validateur ExcludeExtension .......................................................... 621
2.5. Validateur ExcludeMimeType ......................................................... 622
2.6. Validateur Exists ........................................................................... 623
2.7. Validateur Extension ...................................................................... 623
2.8. Validateur FilesSize ....................................................................... 624
2.9. Validateur ImageSize ..................................................................... 625
2.10. Validateur IsCompressed ............................................................. 626
2.11. Validateur IsImage ....................................................................... 626
2.12. Validateur Hash ........................................................................... 626
2.13. Validateur Md5 ............................................................................ 627
2.14. Validateur MimeType ................................................................... 627
2.15. Validateur NotExists ..................................................................... 629
2.16. Validateur Sha1 ........................................................................... 629
2.17. Validateur Size ............................................................................ 629
2.18. Validateur WordCount .................................................................. 630
3. Filtres pour Zend_File_Transfer ................................................................ 631
3.1. Utiliser les filtres avec Zend_File_Transfer ...................................... 631
3.2. Filtre Decrypt ................................................................................ 632
3.3. Filtre Encrypt ................................................................................. 633
3.4. Filtre LowerCase ........................................................................... 633
3.5. Filtre Rename ............................................................................... 634
3.6. Filtre UpperCase ........................................................................... 635
Zend_Filter .......................................................................................................... 636
1. Introduction .............................................................................................. 636
1.1. Qu'est-ce qu'un filtre ? ................................................................... 636
1.2. Utilisation basique des filtres .......................................................... 636
1.3. Utilisation de la méthode statique staticFilter() ................................. 636
2. Classes de filtre standards ....................................................................... 637
2.1. Alnum ........................................................................................... 637
2.2. Alpha ............................................................................................ 637
2.3. BaseName .................................................................................... 637
2.4. Boolean ........................................................................................ 637
2.5. Callback ........................................................................................ 640
2.6. Compression et décompression ...................................................... 641

xii
Guide de référence
du programmeur

2.7. Decrypt ......................................................................................... 646


2.8. Digits ............................................................................................ 648
2.9. Dir ................................................................................................ 648
2.10. Encrypt ....................................................................................... 648
2.11. HtmlEntities ................................................................................. 651
2.12. Int ............................................................................................... 651
2.13. LocalizedToNormalized ................................................................ 651
2.14. NormalizedToLocalized ................................................................ 653
2.15. Null ............................................................................................. 654
2.16. PregReplace ............................................................................... 655
2.17. RealPath ..................................................................................... 656
2.18. StringToLower ............................................................................. 656
2.19. StringToUpper ............................................................................. 657
2.20. StringTrim ................................................................................... 657
2.21. Int ............................................................................................... 657
2.22. StripTags .................................................................................... 657
3. Chaînes de filtrage ................................................................................... 658
3.1. Changing filter chain order ............................................................. 658
4. Écriture de filtres ...................................................................................... 658
5. Zend_Filter_Input ..................................................................................... 659
5.1. Déclarer des règles de filtre et de validateur .................................... 660
5.2. Créer le processeur de filtres et validateurs ..................................... 661
5.3. Récupérer les champs validés/filtré, et les éventuels rapports ........... 661
5.4. Utiliser des méta commandes pour contrôler les règles des filtres et
validateurs ........................................................................................... 664
5.5. Ajouter des espaces de noms comme noms de classes ................... 669
6. Zend_Filter_Inflector ................................................................................. 670
6.1. Opération ...................................................................................... 671
6.2. Créer des chemins vers des filtres alternatifs ................................... 671
6.3. Paramétrer la cible de l'inflecteur .................................................... 671
6.4. Règles d'inflexion .......................................................................... 672
6.5. Autres méthodes utilitaires ............................................................. 674
6.6. Zend_Config avec Zend_Filter_Inflector .......................................... 675
Zend_Form .......................................................................................................... 676
1. Zend_Form .............................................................................................. 676
2. Zend_Form démarrage rapide ................................................................... 676
2.1. Créer un objet de formulaire .......................................................... 676
2.2. Ajouter des éléments au formulaire ................................................. 676
2.3. Rendre (visuellement) un formulaire ............................................... 678
2.4. Vérifier qu'un formulaire est valide .................................................. 680
2.5. Les statuts d'erreur ........................................................................ 680
2.6. Assembler le tout ensemble ........................................................... 681
2.7. Utiliser un objet Zend_Config ...................................................... 682
2.8. Conclusion .................................................................................... 683
3. Creating Form Elements Using Zend_Form_Element .................................. 683
3.1. Plugin Loaders .............................................................................. 683
3.2. Filters ........................................................................................... 686
3.3. Validators ...................................................................................... 687
3.4. Decorators .................................................................................... 692
3.5. Metadata and Attributes ................................................................. 694
3.6. Standard Elements ........................................................................ 695
3.7. Zend_Form_Element Methods ........................................................ 695
3.8. Configuration ................................................................................. 697
3.9. Custom Elements .......................................................................... 698

xiii
Guide de référence
du programmeur

4. Creating Forms Using Zend_Form ............................................................ 699


4.1. Plugin Loaders .............................................................................. 700
4.2. Elements ....................................................................................... 701
4.3. Display Groups ............................................................................. 705
4.4. Sub Forms .................................................................................... 709
4.5. Metadata and Attributes ................................................................. 710
4.6. Decorators .................................................................................... 711
4.7. Validation ...................................................................................... 713
4.8. Methods ........................................................................................ 715
4.9. Configuration ................................................................................. 718
4.10. Custom forms .............................................................................. 719
5. Créer un visuel personnalisé en utilisant Zend_Form_Decorator .................. 721
5.1. Configuration ................................................................................. 721
5.2. Décorateurs standards ................................................................... 722
5.3. Décorateurs personnalisés ............................................................. 722
5.4. Rendre des décorateurs individuellement ........................................ 725
6. Standard Form Elements Shipped With Zend Framework ............................ 725
6.1. Zend_Form_Element_Button .......................................................... 725
6.2. Zend_Form_Element_Captcha ....................................................... 726
6.3. Zend_Form_Element_Checkbox ..................................................... 727
6.4. Zend_Form_Element_File .............................................................. 727
6.5. Zend_Form_Element_Hidden ......................................................... 730
6.6. Zend_Form_Element_Hash ............................................................ 731
6.7. Zend_Form_Element_Image .......................................................... 731
6.8. Zend_Form_Element_MultiCheckbox .............................................. 731
6.9. Zend_Form_Element_Multiselect .................................................... 732
6.10. Zend_Form_Element_Password ................................................... 732
6.11. Zend_Form_Element_Radio ......................................................... 733
6.12. Zend_Form_Element_Reset ......................................................... 733
6.13. Zend_Form_Element_Select ......................................................... 733
6.14. Zend_Form_Element_Submit ........................................................ 734
6.15. Zend_Form_Element_Text ........................................................... 734
6.16. Zend_Form_Element_Textarea ..................................................... 734
7. Décorateurs standards fournis avec Zend Framework ................................. 734
7.1. Zend_Form_Decorator_Callback ............................................. 734
7.2. Zend_Form_Decorator_Captcha ............................................... 735
7.3. Zend_Form_Decorator_Description ....................................... 735
7.4. Zend_Form_Decorator_DtDdWrapper ....................................... 735
7.5. Zend_Form_Decorator_Errors ................................................. 736
7.6. Zend_Form_Decorator_Fieldset ............................................. 736
7.7. Zend_Form_Decorator_File ..................................................... 736
7.8. Zend_Form_Decorator_Form ..................................................... 736
7.9. Zend_Form_Decorator_FormElements ..................................... 736
7.10. Zend_Form_Decorator_FormErrors ....................................... 736
7.11. Zend_Form_Decorator_HtmlTag ............................................. 737
7.12. Zend_Form_Decorator_Image ................................................. 737
7.13. Zend_Form_Decorator_Label ................................................. 737
7.14. Zend_Form_Decorator_PrepareElements ............................. 738
7.15. Zend_Form_Decorator_ViewHelper ....................................... 738
7.16. Zend_Form_Decorator_ViewScript ....................................... 738
8. Internationaliser un formulaire Zend_Form ................................................. 740
8.1. Initialiser l'i18n dans les formulaires ................................................ 740
8.2. Cibles gérées par l'I18n ................................................................. 741
9. Advanced Zend_Form Usage .................................................................... 741

xiv
Guide de référence
du programmeur

9.1. Array Notation ............................................................................... 741


9.2. Multi-Page Forms .......................................................................... 744
Zend_Gdata ......................................................................................................... 746
1. Introduction .............................................................................................. 746
1.1. Structure of Zend_Gdata ................................................................ 746
1.2. Interacting with Google Services .................................................... 747
1.3. Obtaining instances of Zend_Gdata classes .................................... 747
1.4. Google Data Client Authentication .................................................. 748
1.5. Dependencies ............................................................................... 748
1.6. Creating a new Gdata client ........................................................... 748
1.7. Common Query Parameters ........................................................... 749
1.8. Fetching a Feed ............................................................................ 750
1.9. Working with Multi-page Feeds ...................................................... 750
1.10. Working with Data in Feeds and Entries ........................................ 751
1.11. Updating Entries .......................................................................... 751
1.12. Posting Entries to Google Servers ................................................ 751
1.13. Deleting Entries on Google Servers .............................................. 752
2. Authentification par procédé AuthSub ........................................................ 752
2.1. Création d'un client HTTP authentifié avec AuthSub ......................... 753
2.2. Destruction de l'authentification AuthSub ......................................... 754
3. Using the Book Search Data API .............................................................. 754
3.1. Authenticating to the Book Search service ...................................... 754
3.2. Searching for books ...................................................................... 755
3.3. Using community features .............................................................. 756
3.4. Book collections and My Library ..................................................... 758
4. Authentification avec ClientLogin ............................................................... 759
4.1. Création d'un client HTTP "ClientLogin" authentifié .......................... 760
4.2. Fermer un client HTTP authentifié par ClientLogin ........................... 760
5. Using Google Calendar ............................................................................ 760
5.1. Connecting To The Calendar Service ............................................. 761
5.2. Retrieving A Calendar List ............................................................. 763
5.3. Retrieving Events .......................................................................... 764
5.4. Creating Events ............................................................................. 766
5.5. Modifying Events ........................................................................... 769
5.6. Deleting Events ............................................................................. 769
5.7. Accessing Event Comments ........................................................... 770
6. Using Google Documents List Data API .................................................... 770
6.1. Get a List of Documents ................................................................ 770
6.2. Upload a Document ....................................................................... 771
6.3. Searching the documents feed ....................................................... 772
7. Using Google Health ................................................................................ 772
7.1. Connect To The Health Service ...................................................... 773
7.2. Profile Feed .................................................................................. 775
7.3. Profile List Feed ............................................................................ 777
7.4. Sending Notices to the Register Feed ............................................. 777
8. Using Google Spreadsheets ..................................................................... 778
8.1. Create a Spreadsheet .................................................................... 778
8.2. Get a List of Spreadsheets ............................................................ 778
8.3. Get a List of Worksheets ............................................................... 779
8.4. Interacting With List-based Feeds ................................................... 779
8.5. Interacting With Cell-based Feeds .................................................. 781
9. Using Google Apps Provisioning ............................................................... 782
9.1. Setting the current domain ............................................................. 783
9.2. Interacting with users ..................................................................... 783

xv
Guide de référence
du programmeur

9.3. Interacting with nicknames ............................................................. 786


9.4. Interacting with email lists .............................................................. 788
9.5. Interacting with email list recipients ................................................. 789
9.6. Handling errors ............................................................................. 790
10. Using Google Base ................................................................................ 791
10.1. Connect To The Base Service ...................................................... 791
10.2. Retrieve Items ............................................................................. 794
10.3. Insert, Update, and Delete Customer Items ................................... 795
11. Utilisation des albums Web Picasa .......................................................... 797
11.1. Se connecter au service .............................................................. 797
11.2. Comprendre et construire des requêtes ......................................... 800
11.3. Récupérer des flux et des éléments .............................................. 801
11.4. Créer des ressources .................................................................. 804
11.5. Supprimer des éléments .............................................................. 806
12. Using the YouTube Data API .................................................................. 807
12.1. Authentication .............................................................................. 808
12.2. Developer Keys and Client ID ...................................................... 808
12.3. Retrieving public video feeds ........................................................ 808
12.4. Retrieving video comments .......................................................... 810
12.5. Retrieving playlist feeds ............................................................... 810
12.6. Retrieving a list of a user's subscriptions ....................................... 811
12.7. Retrieving a user's profile ............................................................. 811
12.8. Uploading Videos to YouTube ...................................................... 812
12.9. Browser-based upload ................................................................. 813
12.10. Checking upload status .............................................................. 814
12.11. Other Functions ......................................................................... 815
13. Attraper les exceptions Gdata ................................................................. 815
Zend_Http ............................................................................................................ 817
1. Introduction .............................................................................................. 817
1.1. Utilisation de Zend_Http_Client ....................................................... 817
1.2. Les paramètres de configuration .................................................... 817
1.3. Utilisation basique ......................................................................... 818
1.4. Ajouts de paramètres GET et POST ............................................... 819
1.5. Accéder à la dernière requête, ou réponse ...................................... 820
2. Zend_Http_Client - Utilisation avancée ...................................................... 820
2.1. Redirections HTTP ........................................................................ 820
2.2. Ajout de cookies et gestion de leur persistance ............................... 820
2.3. Définir des en-têtes personnalisés .................................................. 821
2.4. Envoi de fichiers ............................................................................ 822
2.5. Envoyer des données brutes via POST ........................................... 823
2.6. Authentification HTTP .................................................................... 824
2.7. Envoyer plusieurs requêtes avec le même client .............................. 824
2.8. Data Streaming ............................................................................. 825
3. Zend_Http_Client - Adaptateurs de connexion ............................................ 826
3.1. Présentation globale ...................................................................... 826
3.2. Adaptateur Socket ......................................................................... 827
3.3. Adaptateur Proxy ........................................................................... 829
3.4. The cURL Adapter ........................................................................ 830
3.5. Adaptateur Test ............................................................................. 831
3.6. Créer vos propres adaptateurs de connexion ................................... 834
4. Zend_Http_Cookie and Zend_Http_CookieJar ............................................ 836
4.1. Introduction ................................................................................... 836
4.2. Instancier des objets Zend_Http_Cookie ......................................... 836
4.3. Zend_Http_Cookie méthodes getter ................................................ 837

xvi
Guide de référence
du programmeur

4.4. Zend_Http_Cookie: Correspondance de scénario ............................ 838


4.5. Classe Zend_Http_CookieJar : Instanciation .................................... 839
4.6. Ajouter des cookies à un objet Zend_Http_CookieJar ....................... 840
4.7. Récupérer les cookies présents dans un objet Zend_Http_CookieJar
............................................................................................................. 840
5. Zend_Http_Response ............................................................................... 841
5.1. Introduction ................................................................................... 841
5.2. Méthodes de tests booléennes ....................................................... 842
5.3. Méthodes accesseurs .................................................................... 842
5.4. Analyseurs statiques de réponse HTTP .......................................... 843
Zend_InfoCard ..................................................................................................... 845
1. Introduction .............................................................................................. 845
1.1. Basic Theory of Usage .................................................................. 845
1.2. Using as part of Zend_Auth ........................................................... 845
1.3. Using the Zend_InfoCard component standalone ............................. 847
1.4. Working with a Claims object ......................................................... 847
1.5. Attaching Information Cards to existing accounts ............................. 848
1.6. Creating Zend_InfoCard Adapters ................................................... 849
Zend_Json ........................................................................................................... 851
1. Introduction .............................................................................................. 851
2. Utilisation de base ................................................................................... 851
2.1. Pretty-printing JSON ...................................................................... 851
3. Utilisation avancée de Zend_Json ............................................................. 852
3.1. Objets JSON ................................................................................. 852
3.2. Encoding PHP objects ................................................................... 852
3.3. Internal Encoder/Decoder ............................................................... 852
3.4. JSON Expressions ........................................................................ 852
4. XML to JSON conversion ......................................................................... 853
5. Zend_Json_Server - JSON-RPC server ..................................................... 855
5.1. Advanced Details .......................................................................... 857
Zend_Layout ........................................................................................................ 863
1. Introduction .............................................................................................. 863
2. Zend_Layout - Démarrage rapide .............................................................. 863
2.1. Scripts de layout ........................................................................... 863
2.2. Utilisation de Zend_Layout avec le système MVC de Zend
Framework ........................................................................................... 864
2.3. Utilisation de Zend_Layout en composant indépendant .................... 865
2.4. Layout d'exemple .......................................................................... 866
3. Zend_Layout options de configuration ....................................................... 868
3.1. Exemples ...................................................................................... 868
4. Zend_Layout, utilisation avancée .............................................................. 870
4.1. Objets de vue personnalisés .......................................................... 870
4.2. Plugin de contrôleur frontal personnalisé ......................................... 871
4.3. Aide d'action personnalisée ............................................................ 871
4.4. Résolution de chemin de script personnalisé (inflecteur) ................... 871
Zend_Ldap .......................................................................................................... 873
1. Introduction .............................................................................................. 873
1.1. Theory of operation ....................................................................... 873
2. API overview ........................................................................................... 876
2.1. Configuration / options ................................................................... 876
2.2. API Reference ............................................................................... 878
3. Usage Scenarios ...................................................................................... 903
3.1. Authentication scenarios ................................................................ 903
3.2. Basic CRUD operations ................................................................. 904

xvii
Guide de référence
du programmeur

3.3. Extended operations ...................................................................... 905


4. Tools ....................................................................................................... 906
4.1. Creation and modification of DN strings .......................................... 906
4.2. Using the filter API to create search filters ....................................... 906
4.3. Modify LDAP entries using the Attribute API .................................... 906
5. Object oriented access to the LDAP tree using Zend_Ldap_Node ................ 906
5.1. Basic CRUD operations ................................................................. 906
5.2. Extended operations ...................................................................... 907
5.3. Tree traversal ................................................................................ 907
6. Getting information from the LDAP server .................................................. 907
6.1. RootDSE ....................................................................................... 907
6.2. Schema Browsing ......................................................................... 907
7. Serializing LDAP data to and from LDIF .................................................... 908
7.1. Serialize a LDAP entry to LDIF ...................................................... 908
7.2. Deserialize a LDIF string into a LDAP entry ..................................... 909
Zend_Loader ....................................................................................................... 911
1. Charger les fichiers et les classes dynamiquement ..................................... 911
1.1. Charger des fichiers ...................................................................... 911
1.2. Charger des classes ...................................................................... 911
1.3. Tester si un fichier est lisible .......................................................... 912
1.4. Utiliser l'autoloader ........................................................................ 913
2. L'autoloader ............................................................................................. 914
2.1. Utiliser le chargeur automatique (autoloader) ................................... 914
2.2. Selecting a Zend Framework version .............................................. 915
2.3. L'interface de l'autoloader .............................................................. 917
2.4. Référence de l'autoloader .............................................................. 917
3. Autoloaders de ressources ....................................................................... 920
3.1. Utilisation de l'autoloader de ressources ......................................... 920
3.2. L'autoloader de ressource Module .................................................. 922
3.3. Utiliser les autoloaders de ressources comme fabriques d'objets ....... 922
3.4. Référence de l'autoloader de ressources ......................................... 922
4. Chargeur de Plugins ................................................................................ 922
4.1. Utilisation basique ......................................................................... 923
4.2. Manipulation des chemins des Plugins ............................................ 924
4.3. Test des Plugins et récupération des noms de classe ...................... 924
4.4. Obtenir de meilleures performances avec les Plugins ....................... 924
Zend_Locale ........................................................................................................ 926
1. Introduction .............................................................................................. 926
1.1. What is Localization ...................................................................... 926
1.2. What is a Locale? ......................................................................... 927
1.3. How are Locales Represented? ...................................................... 927
1.4. Selecting the Right Locale ............................................................. 928
1.5. Usage of automatic Locales ........................................................... 928
1.6. Using a default Locale ................................................................... 929
1.7. ZF Locale-Aware Classes .............................................................. 930
1.8. Application wide locale .................................................................. 930
1.9. Zend_Locale_Format::setOptions(array $options) ............................ 931
1.10. Speed up Zend_Locale and its subclasses .................................... 931
2. Using Zend_Locale .................................................................................. 932
2.1. Copying, Cloning, and Serializing Locale Objects ............................. 932
2.2. Equality ......................................................................................... 932
2.3. Default locales .............................................................................. 933
2.4. Set a new locale ........................................................................... 933
2.5. Getting the language and region .................................................... 933

xviii
Guide de référence
du programmeur

2.6. Obtaining localized strings ............................................................. 934


2.7. Obtaining translations for "yes" and "no" ......................................... 948
2.8. Get a list of all known locales ........................................................ 949
2.9. Detecting locales ........................................................................... 949
3. Normalization and Localization .................................................................. 951
3.1. Number normalization: getNumber($input, Array $options) ................ 951
3.2. Number localization ....................................................................... 952
3.3. Number testing .............................................................................. 954
3.4. Float value normalization ............................................................... 954
3.5. Floating point value localization ...................................................... 954
3.6. Floating point value testing ............................................................ 954
3.7. Integer value normalization ............................................................ 955
3.8. Integer point value localization ....................................................... 955
3.9. Integer value testing ...................................................................... 955
3.10. Numeral System Conversion ........................................................ 955
4. Working with Dates and Times ................................................................. 957
4.1. Normalizing Dates and Times ........................................................ 957
4.2. Testing Dates ................................................................................ 960
4.3. Normalizing a Time ....................................................................... 961
4.4. Testing Times ............................................................................... 961
5. Supported locales .................................................................................... 961
Zend_Log ............................................................................................................ 973
1. Présentation ............................................................................................. 973
1.1. Créer un log .................................................................................. 973
1.2. Messages de logs ......................................................................... 973
1.3. Détruire un log .............................................................................. 974
1.4. Utiliser les priorités intégrées ......................................................... 974
1.5. Ajouter ses propres priorités .......................................................... 974
1.6. Comprendre les événements de logs .............................................. 975
2. Rédacteurs (Writers) ................................................................................ 975
2.1. Écrire vers un flux (stream) ............................................................ 975
2.2. Écrire dans des bases de données ................................................. 976
2.3. Écrire vers Firebug ........................................................................ 976
2.4. Écrire vers un émail ...................................................................... 979
2.5. Ecrire dans lee journal du système ................................................. 981
2.6. Ecrire vers le moniteur Zend Server ............................................... 982
2.7. Déraciner les rédacteurs ................................................................ 986
2.8. Tester avec un simulacre ............................................................... 986
2.9. Additionner les rédacteurs .............................................................. 986
3. Formateurs (mise en forme) ..................................................................... 987
3.1. Formatage simple .......................................................................... 987
3.2. Formater vers le XML .................................................................... 987
4. Filtres ...................................................................................................... 988
4.1. Filtrer pour tous les rédacteurs (Writers) ......................................... 988
4.2. Filtrer pour une seule instance de rédacteur .................................... 989
5. Utiliser la fabrique pour créer des logs ...................................................... 989
5.1. Options pour les objets d'écriture ................................................... 990
5.2. Options des filtres ......................................................................... 991
5.3. Créer des objets d'écriture et des filtres configurés .......................... 991
Zend_Mail ............................................................................................................ 994
1. Introduction .............................................................................................. 994
1.1. Pour commencer ........................................................................... 994
1.2. Configurer le transport sendmail par défaut ..................................... 994
2. Envoyer des émail en utilisant SMTP ........................................................ 995

xix
Guide de référence
du programmeur

3. Envoyer plusieurs émail par connexion SMTP ............................................ 996


4. Utiliser différents transports ...................................................................... 997
5. Émail HTML ............................................................................................. 997
6. Fichiers joints ........................................................................................... 998
7. Ajouter des destinataires .......................................................................... 999
8. Contrôler les limites MIME ........................................................................ 999
9. En-têtes additionnels ................................................................................ 999
10. Jeux de caractères ............................................................................... 1000
11. Encodage ............................................................................................. 1000
12. Authentification SMTP ........................................................................... 1001
13. Sécuriser les transports SMTP .............................................................. 1001
14. Lire des émail ...................................................................................... 1002
14.1. Exemple simple avec Pop3 ........................................................ 1002
14.2. Ouvrir un stockage local ............................................................. 1002
14.3. Ouvrir un stockage distant .......................................................... 1003
14.4. Extraire des messages et autres méthodes simples ...................... 1004
14.5. Travailler avec les messages ...................................................... 1004
14.6. Vérifier les drapeaux ("flags") ..................................................... 1006
14.7. Utiliser les dossiers .................................................................... 1007
14.8. Utilisation avancée ..................................................................... 1009
Zend_Markup ..................................................................................................... 1013
1. Introduction ............................................................................................ 1013
2. Guide de démarrage avec Zend_Markup ................................................. 1013
3. Analyseurs Zend_Markup (parsers) ......................................................... 1014
3.1. Theorie de l'analyse ..................................................................... 1014
3.2. L'analyseur BBCode .................................................................... 1015
3.3. L'analyseur Textile ....................................................................... 1015
4. Moteurs de rendu Zend_Markup ............................................................. 1016
4.1. Ajouter vos propres tags .............................................................. 1016
4.2. Liste de tags ............................................................................... 1017
Zend_Measure ................................................................................................... 1019
1. Introduction ............................................................................................ 1019
2. Création d'une mesure ........................................................................... 1019
2.1. Créer des mesures à partir de nombres entiers et décimaux ........... 1020
2.2. Créer des mesures à partir de chaînes de caractères ..................... 1020
2.3. Mesures à partir de chaînes localisées .......................................... 1020
3. Récupérer des mesures .......................................................................... 1021
3.1. Récupération automatique ............................................................ 1021
3.2. Récupération des valeurs ............................................................. 1022
3.3. Récupération de l'unité de mesure ................................................ 1022
3.4. Récupération en tant que chaîne régionale .................................... 1022
4. Manipuler des mesures .......................................................................... 1022
4.1. Convertir ..................................................................................... 1023
4.2. Ajouter et soustraire .................................................................... 1023
4.3. Vérifier l'égalité des mesures ........................................................ 1024
4.4. Comparer les mesures ................................................................. 1024
4.5. Changer manuellement des valeurs .............................................. 1025
4.6. Changer manuellement de type .................................................... 1025
5. Types de mesures ................................................................................. 1025
5.1. Conseils pour Zend_Measure_Binary ............................................ 1028
5.2. Conseils pour Zend_Measure_Number ......................................... 1028
5.3. Chiffres romains .......................................................................... 1029
Zend_Memory .................................................................................................... 1030
1. Présentation ........................................................................................... 1030

xx
Guide de référence
du programmeur

1.1. Introduction ................................................................................. 1030


1.2. Aspect théorique ......................................................................... 1030
2. Manager de mémoire ............................................................................. 1031
2.1. Créer un manager de mémoire ..................................................... 1031
2.2. Manager les objets mémoire ........................................................ 1032
2.3. Régler le manager de mémoire .................................................... 1033
3. Objet mémoire ....................................................................................... 1034
3.1. Mobile ......................................................................................... 1034
3.2. Verrouillé ..................................................................................... 1034
3.3. Propriété "value" du manager de mémoire ..................................... 1034
3.4. Interface du conteneur de mémoire ............................................... 1035
Zend_Mime ........................................................................................................ 1037
1. Zend_Mime ............................................................................................ 1037
1.1. Introduction ................................................................................. 1037
1.2. Méthodes statiques et constantes ................................................. 1037
1.3. Instancier Zend_Mime .................................................................. 1038
2. Zend_Mime_Message ............................................................................. 1038
2.1. Introduction ................................................................................. 1038
2.2. Instancier Zend_Mime_Message ................................................... 1038
2.3. Ajouter des parties MIME ............................................................. 1038
2.4. Gérer les frontières ...................................................................... 1038
2.5. Parser une chaîne de caractère pour créer un objet
Zend_Mime_Message (expérimental) .................................................. 1039
3. Zend_Mime_Part .................................................................................... 1039
3.1. Introduction ................................................................................. 1039
3.2. Instanciation ................................................................................ 1039
3.3. Méthodes pour retourner la partie du message en une chaîne de
caractères .......................................................................................... 1039
Zend_Navigation ................................................................................................ 1041
1. Introduction ............................................................................................ 1041
1.1. Pages et Conteneurs ................................................................... 1041
1.2. Séparation des données (modèle) et du rendu (vue) ...................... 1041
2. Pages .................................................................................................... 1041
2.1. Caractéristiques communes aux pages ......................................... 1042
2.2. Zend_Navigation_Page_Mvc ........................................................ 1044
2.3. Zend_Navigation_Page_Uri .......................................................... 1048
2.4. Créer des pages de type personnalisé .......................................... 1049
2.5. Créer des pages avec la fabrique ................................................. 1050
3. Containers ............................................................................................. 1052
3.1. Creating containers ...................................................................... 1052
3.2. Adding pages .............................................................................. 1055
3.3. Removing pages ......................................................................... 1055
3.4. Finding pages ............................................................................. 1056
3.5. Iterating containers ...................................................................... 1058
3.6. Other operations .......................................................................... 1058
Zend_Oauth ....................................................................................................... 1061
1. Introduction to OAuth ............................................................................. 1061
1.1. Protocol Workflow ........................................................................ 1061
1.2. Security Architecture .................................................................... 1062
1.3. Getting Started ............................................................................ 1063
Zend_OpenId ..................................................................................................... 1067
1. Introduction ............................................................................................ 1067
1.1. Qu'est ce qu'OpenID ? ................................................................. 1067
1.2. Comment cela fonctionne-t-il ? ..................................................... 1067

xxi
Guide de référence
du programmeur

1.3. Zend_OpenId Structure ................................................................ 1068


1.4. Standards OpenID supportés ....................................................... 1068
2. Zend_OpenId_Consumer Basics ............................................................. 1068
2.1. OpenID Authentication ................................................................. 1068
2.2. Combining all Steps in One Page ................................................. 1070
2.3. Consumer Realm ......................................................................... 1070
2.4. Immediate Check ......................................................................... 1071
2.5. Zend_OpenId_Consumer_Storage ................................................ 1071
2.6. Simple Registration Extension ...................................................... 1074
2.7. Integration with Zend_Auth ........................................................... 1075
2.8. Integration with Zend_Controller ................................................... 1077
3. Zend_OpenId_Provider ........................................................................... 1077
3.1. Quick Start .................................................................................. 1077
3.2. Combined Provide Scripts ............................................................ 1080
3.3. Simple Registration Extension ...................................................... 1081
3.4. Anything Else? ............................................................................ 1083
Zend_Paginator .................................................................................................. 1084
1. Introduction ............................................................................................ 1084
2. Utilisation ............................................................................................... 1084
2.1. Paginer des collections de données .............................................. 1084
2.2. The DbSelect and DbTableSelect adapter ..................................... 1085
2.3. Rendre des pages avec les scripts de vue .................................... 1086
3. Configuration .......................................................................................... 1090
4. Utilisation avancée ................................................................................. 1091
4.1. Adaptateurs de source de données personnalisée ......................... 1091
4.2. Styles de défilement personnalisés ............................................... 1091
4.3. Fonctionnalité de mise en cache .................................................. 1092
4.4. Zend_Paginator_AdapterAggregate Interface ................................. 1093
Zend_Pdf ........................................................................................................... 1094
1. Introduction ............................................................................................ 1094
2. Créer et charger des documents PDF ..................................................... 1094
3. Sauvegarder les changement dans un document PDF .............................. 1095
4. Les pages d'un document ....................................................................... 1095
4.1. Création de page ......................................................................... 1095
4.2. Clonage de page ......................................................................... 1096
5. Dessiner ................................................................................................ 1097
5.1. Géométrie ................................................................................... 1097
5.2. Couleurs ..................................................................................... 1097
5.3. Dessiner des formes .................................................................... 1098
5.4. Dessiner du texte ........................................................................ 1100
5.5. Utiliser des polices de caractères ................................................. 1101
5.6. Limitations des polices standard PDF ........................................... 1103
5.7. Extraction des polices .................................................................. 1104
5.8. Insertion d'images ........................................................................ 1106
5.9. Style de lignes ............................................................................ 1106
5.10. Style de remplissage .................................................................. 1107
5.11. Transformations linéaires ........................................................... 1108
5.12. Sauvegarder et restaurer l'état graphique .................................... 1109
5.13. Zone de dessin .......................................................................... 1109
5.14. Styles ........................................................................................ 1110
5.15. Transparence ............................................................................ 1113
6. Interactive Features ................................................................................ 1113
6.1. Destinations ................................................................................ 1113
6.2. Actions ........................................................................................ 1118

xxii
Guide de référence
du programmeur

6.3. Document Outline (bookmarks) ..................................................... 1120


6.4. Annotations ................................................................................. 1122
7. Informations du document et métadonnées .............................................. 1123
8. Exemple d'utilisation du module Zend_Pdf ............................................... 1125
Zend_ProgressBar .............................................................................................. 1127
1. Zend_ProgressBar .................................................................................. 1127
1.1. Introduction ................................................................................. 1127
1.2. Utilisation basique de Zend_Progressbar ....................................... 1127
1.3. Adaptateurs standard ................................................................... 1127
Zend_Queue ...................................................................................................... 1132
1. Introduction ............................................................................................ 1132
2. Example usage ...................................................................................... 1132
3. Framework ............................................................................................. 1133
3.1. Introduction ................................................................................. 1134
3.2. Commonality among adapters ...................................................... 1134
4. Adapters ................................................................................................ 1134
4.1. Specific Adapters - Configuration settings ...................................... 1135
4.2. Notes for Specific Adapters .......................................................... 1137
5. Customizing Zend_Queue ....................................................................... 1139
5.1. Creating your own adapter ........................................................... 1139
5.2. Creating your own message class ................................................ 1140
5.3. Creating your own message iterator class ..................................... 1141
5.4. Creating your own queue class ................................................... 1141
6. Stomp .................................................................................................... 1141
6.1. Stomp - Supporting classes .......................................................... 1141
Zend_Reflection ................................................................................................. 1142
1. Introduction ............................................................................................ 1142
2. Zend_Reflection Exemples ...................................................................... 1142
3. Réference de Zend_Reflection ................................................................ 1143
3.1. Zend_Reflection_Docblock ........................................................... 1144
3.2. Zend_Reflection_Docblock_Tag .................................................... 1144
3.3. Zend_Reflection_Docblock_Tag_Param ........................................ 1144
3.4. Zend_Reflection_Docblock_Tag_Return ........................................ 1145
3.5. Zend_Reflection_File ................................................................... 1145
3.6. Zend_Reflection_Class ................................................................ 1145
3.7. Zend_Reflection_Extension .......................................................... 1146
3.8. Zend_Reflection_Function ............................................................ 1146
3.9. Zend_Reflection_Method .............................................................. 1146
3.10. Zend_Reflection_Parameter ........................................................ 1146
3.11. Zend_Reflection_Property .......................................................... 1147
Zend_Registry .................................................................................................... 1148
1. Utiliser le registre ................................................................................... 1148
1.1. Mettre des valeurs dans le registre ............................................... 1148
1.2. Lire des valeurs du registre .......................................................... 1148
1.3. Construire un objet registre .......................................................... 1148
1.4. Accéder au registre comme à un tableau ...................................... 1149
1.5. Accéder au registre comme à un objet .......................................... 1149
1.6. Vérifier si un index existe ............................................................. 1150
1.7. Étendre le registre ....................................................................... 1150
1.8. Décharger le registre statique ....................................................... 1151
Zend_Rest ......................................................................................................... 1152
1. Introduction ............................................................................................ 1152
2. Zend_Rest_Client ................................................................................... 1152
2.1. Introduction ................................................................................. 1152

xxiii
Guide de référence
du programmeur

2.2. Réponses .................................................................................... 1153


2.3. Arguments de requêtes ................................................................ 1154
3. Zend_Rest_Server .................................................................................. 1155
3.1. Introduction ................................................................................. 1155
3.2. Utilisation d'un serveur REST ....................................................... 1155
3.3. Appelé un service Zend_Rest_Server ........................................... 1156
3.4. Envoyer un statut personnalisé ..................................................... 1156
3.5. Renvoyer une réponse XML personnalisée .................................... 1157
Zend_Search_Lucene ......................................................................................... 1158
1. Vue d'ensemble ..................................................................................... 1158
1.1. Introduction ................................................................................. 1158
1.2. Objet "Document" et "Field" .......................................................... 1158
1.3. Comprendre les types de champs ................................................. 1160
1.4. Documents HTML ........................................................................ 1160
1.5. Documents Word 2007 ................................................................ 1161
1.6. Document Powerpoint 2007 ......................................................... 1163
1.7. Documents Excel 2007 ................................................................ 1164
2. Créer des index ..................................................................................... 1165
2.1. Créer un nouvel index ................................................................. 1165
2.2. Mettre à jour un index .................................................................. 1165
2.3. Mise à jour de Documents ........................................................... 1165
2.4. Récupération de la taille de l'index ................................................ 1166
2.5. Optimisation d'index ..................................................................... 1166
2.6. Permissions ................................................................................. 1168
2.7. Limitations ................................................................................... 1168
3. Searching an Index ................................................................................ 1168
3.1. Building Queries .......................................................................... 1168
3.2. Search Results ............................................................................ 1170
3.3. Limiting the Result Set ................................................................. 1171
3.4. Results Scoring ........................................................................... 1171
3.5. Search Result Sorting .................................................................. 1172
3.6. Search Results Highlighting .......................................................... 1172
4. Langage de requêtes ............................................................................. 1174
4.1. Termes ....................................................................................... 1174
4.2. Champs ...................................................................................... 1175
4.3. Jokers (Wildcards) ....................................................................... 1175
4.4. Term Modifiers ............................................................................ 1176
4.5. Range Searches .......................................................................... 1176
4.6. Fuzzy Searches ........................................................................... 1177
4.7. Matched terms limitation .............................................................. 1177
4.8. Proximity Searches ...................................................................... 1177
4.9. Boosting a Term .......................................................................... 1177
4.10. Boolean Operators ..................................................................... 1178
4.11. Grouping ................................................................................... 1179
4.12. Field Grouping ........................................................................... 1179
4.13. Escaping Special Characters ...................................................... 1180
5. API de construction de requêtes ............................................................. 1180
5.1. Les Exceptions du parseur de requêtes ........................................ 1180
5.2. Requête sur un terme .................................................................. 1181
5.3. Requête multi-termes ................................................................... 1181
5.4. Requête booléene ....................................................................... 1182
5.5. Requête Joker (wildcard) ............................................................. 1184
5.6. Requête floue (fuzzy query) ......................................................... 1184
5.7. Requête de phrase ...................................................................... 1185

xxiv
Guide de référence
du programmeur

5.8. Requête d'intervalle ..................................................................... 1187


6. Jeu de caractères .................................................................................. 1188
6.1. Support UTF-8 et caractères sur un octet ...................................... 1188
6.2. Analyseur de texte par défaut ....................................................... 1188
6.3. Analyseurs de texte compatibles UTF-8 ........................................ 1188
7. Extensibilité ............................................................................................ 1190
7.1. Analyse de texte .......................................................................... 1190
7.2. Filtrage des segments .................................................................. 1192
7.3. Algorithme de score ..................................................................... 1193
7.4. Conteneur de stockage ................................................................ 1194
8. Agir avec Lucene Java ........................................................................... 1196
8.1. Formats de fichier ........................................................................ 1196
8.2. Répertoire Index .......................................................................... 1196
8.3. Code source Java ....................................................................... 1196
9. Avancé .................................................................................................. 1197
9.1. Depuis Zend Framework 1.6, gestion des transformations de format
d'index ............................................................................................... 1197
9.2. Utiliser les propriétés statiques de l'index ...................................... 1198
10. Bonnes pratiques ................................................................................. 1199
10.1. Nommage des champs .............................................................. 1199
10.2. Performance de l'indexation ........................................................ 1200
10.3. Indexation à l'arrêt du programme ............................................... 1202
10.4. Récupération de documents par leur id unique ............................. 1202
10.5. Utilisation de la mémoire ............................................................ 1203
10.6. Encodage .................................................................................. 1204
10.7. Maintenance de l'index ............................................................... 1205
Zend_Serializer .................................................................................................. 1206
1. Introduction ............................................................................................ 1206
1.1. Utiliser l'interface statique de Zend_Serializer ................................ 1206
2. Zend_Serializer_Adapter ......................................................................... 1207
2.1. Zend_Serializer_Adapter_PhpSerialize .......................................... 1207
2.2. Zend_Serializer_Adapter_Igbinary ................................................. 1207
2.3. Zend_Serializer_Adapter_Wddx .................................................... 1207
2.4. Zend_Serializer_Adapter_Json ..................................................... 1208
2.5. Zend_Serializer_Adapter_Amf 0 et 3 ............................................. 1208
2.6. Zend_Serializer_Adapter_PythonPickle ......................................... 1208
2.7. Zend_Serializer_Adapter_PhpCode ............................................... 1209
Zend_Server ...................................................................................................... 1210
1. Introduction ............................................................................................ 1210
2. Zend_Server_Reflection .......................................................................... 1210
2.1. Introduction ................................................................................. 1210
2.2. Utilisation .................................................................................... 1210
Zend_Service ..................................................................................................... 1212
1. Introduction ............................................................................................ 1212
2. Zend_Service_Akismet ........................................................................... 1212
2.1. Introduction ................................................................................. 1212
2.2. Verify an API key ........................................................................ 1213
2.3. Check for spam ........................................................................... 1213
2.4. Submitting known spam ............................................................... 1214
2.5. Submitting false positives (ham) ................................................... 1214
2.6. Zend-specific Methods ................................................................. 1215
3. Zend_Service_Amazon ........................................................................... 1215
3.1. Introduction ................................................................................. 1215
3.2. Codes de pays ............................................................................ 1216

xxv
Guide de référence
du programmeur

3.3. Rechercher un produit Amazon spécifique avec son ASIN .............. 1217
3.4. Lancer des recherches de produits sur Amazon ............................. 1217
3.5. Utiliser l'API alternative de requêtes .............................................. 1218
3.6. Classes Zend_Service_Amazon ................................................... 1218
4. Zend_Service_Amazon_Ec2 ................................................................... 1224
4.1. Introduction ................................................................................. 1224
4.2. What is Amazon Ec2? ................................................................. 1224
4.3. Static Methods ............................................................................ 1224
5. Zend_Service_Amazon_Ec2: Instances ................................................... 1224
5.1. Instance Types ............................................................................ 1224
5.2. Running Amazon EC2 Instances .................................................. 1226
5.3. Amazon Instance Utilities ............................................................. 1227
6. Zend_Service_Amazon_Ec2: Windows Instances ..................................... 1229
6.1. Windows Instances Usage ........................................................... 1230
7. Zend_Service_Amazon_Ec2: Reserved Instances .................................... 1231
7.1. How Reserved Instances are Applied ............................................ 1231
7.2. Reserved Instances Usage ........................................................... 1231
8. Zend_Service_Amazon_Ec2: CloudWatch Monitoring ............................... 1232
8.1. CloudWatch Usage ...................................................................... 1232
9. Zend_Service_Amazon_Ec2: Amazon Machine Images (AMI) ................... 1234
9.1. AMI Information Utilities ............................................................... 1234
9.2. AMI Attribute Utilities ................................................................... 1235
10. Zend_Service_Amazon_Ec2: Elastic Block Stroage (EBS) ....................... 1236
10.1. Create EBS Volumes and Snapshots .......................................... 1237
10.2. Describing EBS Volumes and Snapshots .................................... 1237
10.3. Attach and Detaching Volumes from Instances ............................ 1238
10.4. Deleting EBS Volumes and Snapshots ........................................ 1239
11. Zend_Service_Amazon_Ec2: Elastic IP Addresses ................................. 1239
12. Zend_Service_Amazon_Ec2: Keypairs ................................................... 1240
13. Zend_Service_Amazon_Ec2: Regions and Availability Zones ................... 1241
13.1. Amazon EC2 Regions ................................................................ 1241
13.2. Amazon EC2 Availability Zones .................................................. 1242
14. Zend_Service_Amazon_Ec2: Security Groups ........................................ 1242
14.1. Security Group Maintenance ....................................................... 1242
14.2. Authorizing Access .................................................................... 1243
14.3. Revoking Access ....................................................................... 1244
15. Zend_Service_Amazon_S3 ................................................................... 1245
15.1. Introduction ............................................................................... 1245
15.2. Registering with Amazon S3 ....................................................... 1245
15.3. API Documentation .................................................................... 1245
15.4. Features .................................................................................... 1245
15.5. Getting Started .......................................................................... 1245
15.6. Bucket operations ...................................................................... 1246
15.7. Object operations ....................................................................... 1247
15.8. Data Streaming ......................................................................... 1249
15.9. Stream wrapper ......................................................................... 1249
16. Zend_Service_Amazon_Sqs .................................................................. 1250
16.1. Introduction ............................................................................... 1250
16.2. Registering with Amazon SQS .................................................... 1250
16.3. API Documentation .................................................................... 1250
16.4. Features .................................................................................... 1250
16.5. Getting Started .......................................................................... 1250
16.6. Queue operations ...................................................................... 1251
16.7. Message operations ................................................................... 1252

xxvi
Guide de référence
du programmeur

17. Zend_Service_Audioscrobbler ............................................................... 1252


17.1. Introduction ............................................................................... 1252
17.2. Users ........................................................................................ 1253
17.3. Artists ........................................................................................ 1254
17.4. Tracks ....................................................................................... 1255
17.5. Tags ......................................................................................... 1255
17.6. Groups ...................................................................................... 1255
17.7. Forums ...................................................................................... 1256
18. Zend_Service_Delicious ........................................................................ 1256
18.1. Introduction ............................................................................... 1256
18.2. Récupérer vos entrées ............................................................... 1256
18.3. Zend_Service_Delicious_PostList ................................................ 1257
18.4. Édition des entrées .................................................................... 1258
18.5. Supprimer des entrées ............................................................... 1259
18.6. Ajout d'entrées .......................................................................... 1259
18.7. Les étiquettes ("tags") ................................................................ 1260
18.8. Les groupes d'étiquettes ............................................................ 1260
18.9. Données publiques .................................................................... 1260
18.10. Client HTTP ............................................................................. 1261
19. Zend_Service_DeveloperGarden ........................................................... 1262
19.1. Introduction to DeveloperGarden ................................................. 1262
19.2. BaseUserService ....................................................................... 1263
19.3. IP Location ................................................................................ 1264
19.4. Local Search ............................................................................. 1264
19.5. Send SMS ................................................................................. 1265
19.6. SMS Validation .......................................................................... 1265
19.7. Voice Call ................................................................................. 1266
19.8. ConferenceCall .......................................................................... 1267
19.9. Performance and Caching .......................................................... 1268
20. Zend_Service_Flickr ............................................................................. 1269
20.1. Introduction ............................................................................... 1269
20.2. Trouver les photos et les informations des utilisateurs Flickr .......... 1269
20.3. Trouver des photos dans le pool d'un groupe ............................... 1270
20.4. Récupérer les détails d'une image .............................................. 1270
20.5. Classes de résultats Zend_Service_Flickr .................................... 1270
21. Zend_Service_LiveDocx ........................................................................ 1272
21.1. Introduction to LiveDocx ............................................................. 1272
21.2. Zend_Service_LiveDocx_MailMerge ............................................ 1274
22. Zend_Service_Nirvanix ......................................................................... 1286
22.1. Introduction ............................................................................... 1286
22.2. Registering with Nirvanix ............................................................ 1286
22.3. API Documentation .................................................................... 1286
22.4. Features .................................................................................... 1287
22.5. Getting Started .......................................................................... 1287
22.6. Understanding the Proxy ............................................................ 1288
22.7. Examining Results ..................................................................... 1288
22.8. Handling Errors ......................................................................... 1289
23. Zend_Service_ReCaptcha ..................................................................... 1290
23.1. Introduction ............................................................................... 1290
23.2. Utilisation la plus simple ............................................................. 1290
23.3. Hiding email addresses .............................................................. 1291
24. Zend_Service_Simpy ............................................................................ 1292
24.1. Introduction ............................................................................... 1292
24.2. Liens ......................................................................................... 1292

xxvii
Guide de référence
du programmeur

24.3. Mots-clés ................................................................................... 1294


24.4. Notes ........................................................................................ 1295
24.5. Listes de surveillance ................................................................. 1296
25. Introduction .......................................................................................... 1297
25.1. Démarrage avec Zend_Service_SlideShare .......................... 1297
25.2. L'objet SlideShow ...................................................................... 1298
25.3. Récupérer un diaporama simplement .......................................... 1300
25.4. Récupérer des groupes de diaporamas ....................................... 1300
25.5. Politique de cache de Zend_Service_SlideShare ................... 1301
25.6. Changer le comportement du client HTTP ................................... 1302
26. Zend_Service_StrikeIron ....................................................................... 1302
26.1. Overview ................................................................................... 1302
26.2. Registering with StrikeIron .......................................................... 1303
26.3. Getting Started .......................................................................... 1303
26.4. Making Your First Query ............................................................ 1303
26.5. Examining Results ..................................................................... 1304
26.6. Handling Errors ......................................................................... 1305
26.7. Checking Your Subscription ........................................................ 1305
27. Zend_Service_StrikeIron: Bundled Services ........................................... 1306
27.1. ZIP Code Information ................................................................. 1306
27.2. U.S. Address Verification ............................................................ 1307
27.3. Sales & Use Tax Basic .............................................................. 1308
28. Zend_Service_StrikeIron: Advanced Uses .............................................. 1308
28.1. Using Services by WSDL ........................................................... 1308
28.2. Viewing SOAP Transactions ....................................................... 1309
29. Zend_Service_Technorati ...................................................................... 1309
29.1. Introduction ............................................................................... 1309
29.2. Getting Started .......................................................................... 1310
29.3. Making Your First Query ............................................................ 1310
29.4. Consuming Results .................................................................... 1311
29.5. Handling Errors ......................................................................... 1312
29.6. Checking Your API Key Daily Usage ........................................... 1312
29.7. Available Technorati Queries ...................................................... 1313
29.8. Zend_Service_Technorati Classes .............................................. 1316
30. Zend_Service_Twitter ........................................................................... 1319
30.1. Introduction ............................................................................... 1319
30.2. Authentication ............................................................................ 1320
30.3. Account Methods ....................................................................... 1320
30.4. Status Methods ......................................................................... 1321
30.5. User Methods ............................................................................ 1323
30.6. Direct Message Methods ............................................................ 1323
30.7. Friendship Methods ................................................................... 1324
30.8. Favorite Methods ....................................................................... 1325
30.9. Block Methods ........................................................................... 1325
30.10. Zend_Service_Twitter_Search ................................................... 1326
31. Zend_Service_WindowsAzure ............................................................... 1328
31.1. Introduction ............................................................................... 1328
31.2. Installing the Windows Azure SDK .............................................. 1328
31.3. API Documentation .................................................................... 1328
31.4. Features .................................................................................... 1328
31.5. Architecture ............................................................................... 1328
31.6. Zend_Service_WindowsAzure_Storage_Blob ............................... 1328
31.7. Zend_Service_WindowsAzure_Storage_Table ............................. 1333
31.8. Zend_Service_WindowsAzure_Storage_Queue ............................ 1340

xxviii
Guide de référence
du programmeur

32. Zend_Service_Yahoo ............................................................................ 1342


32.1. Introduction ............................................................................... 1342
32.2. Rechercher sur le Web avec Yahoo! ........................................... 1342
32.3. Trouver des images avec Yahoo! ................................................ 1343
32.4. Trouver des vidéos avec Yahoo! ................................................. 1343
32.5. Trouver des entreprises et des services locaux avec Yahoo! ......... 1343
32.6. Rechercher dans Yahoo! News ................................................... 1343
32.7. Rechercher avec Yahoo! Site Explorer Inbound Links ................... 1344
32.8. Rechercher avec Yahoo! Site Explorer's PageData ...................... 1344
32.9. Classes Zend_Service_Yahoo .................................................... 1344
Zend_Session .................................................................................................... 1351
1. Introduction ............................................................................................ 1351
2. Usage basique ....................................................................................... 1351
2.1. Tutoriel d'exemples ...................................................................... 1352
2.2. Énumérer les espaces de noms de session ................................... 1353
2.3. Accesseurs pour les espaces de noms de session ......................... 1353
3. Utilisation avancée ................................................................................. 1354
3.1. Démarrer une session .................................................................. 1354
3.2. Verrouiller les espaces de noms de session .................................. 1355
3.3. Expiration d'un espace de noms ................................................... 1355
3.4. Encapsulation de session et Contrôleurs ....................................... 1356
3.5. Limiter les instances multiples par espace de noms ....................... 1357
3.6. Travailler avec les tableaux .......................................................... 1357
3.7. Utiliser les sessions avec des objets ............................................. 1358
3.8. Utiliser les sessions avec les tests unitaires ................................... 1359
4. Gestion générale de la session ............................................................... 1360
4.1. Options de configuration .............................................................. 1361
4.2. L'erreur: "Headers Already Sent" .................................................. 1364
4.3. Identifiants de session ................................................................. 1364
4.4. rememberMe(integer $seconds) ........................................... 1365
4.5. forgetMe() ............................................................................... 1366
4.6. sessionExists() ..................................................................... 1366
4.7. destroy(bool $remove_cookie = true, bool $readonly
= true) ........................................................................................... 1366
4.8. stop() ....................................................................................... 1366
4.9. writeClose($readonly = true) .......................................... 1366
4.10. expireSessionCookie() ....................................................... 1367
4.11. setSaveHandler(Zend_Session_SaveHandler_Interface
$interface) .................................................................................... 1367
4.12. namespaceIsset($namespace) ............................................. 1367
4.13. namespaceUnset($namespace) ............................................. 1367
4.14. namespaceGet($namespace) ................................................. 1367
4.15. getIterator() ....................................................................... 1367
5. Zend_Session_SaveHandler_DbTable ..................................................... 1368
Zend_Soap ........................................................................................................ 1370
1. Zend_Soap_Server ................................................................................. 1370
1.1. Constructeur de Zend_Soap_Server .......................................... 1370
1.2. Méthodes de définitions de l'API du service ................................... 1371
1.3. Gestion des objets de requête et de réponse ................................. 1372
2. Zend_Soap_Client .................................................................................. 1374
2.1. Constructeur de Zend_Soap_Client .......................................... 1374
2.2. Effectuer des requêtes SOAP ....................................................... 1375
3. WSDL .................................................................................................... 1376
3.1. Constructeur Zend_Soap_Wsdl .................................................... 1376

xxix
Guide de référence
du programmeur

3.2. addMessage() ............................................................................. 1376


3.3. addPortType() ......................................................................... 1377
3.4. addPortOperation() ............................................................... 1377
3.5. addBinding() ........................................................................... 1378
3.6. addBindingOperation() ......................................................... 1378
3.7. addSoapBinding() ................................................................... 1378
3.8. addSoapOperation() ............................................................... 1378
3.9. addService() ........................................................................... 1379
3.10. Correspondance de type ............................................................ 1379
3.11. addDocumentation() ............................................................. 1381
3.12. Récupérer un document WSDL finalisé ....................................... 1381
4. Auto découverte ..................................................................................... 1381
4.1. Introduction à l'auto découverte .................................................... 1381
4.2. Auto découverte de classe ........................................................... 1383
4.3. Auto découverte des fonctions ...................................................... 1383
4.4. Types de donnée auto découverts ................................................ 1384
4.5. Styles de liaisons WSDL .............................................................. 1385
Zend_Tag .......................................................................................................... 1386
1. Introduction ............................................................................................ 1386
2. Zend_Tag_Cloud .................................................................................... 1386
2.1. Decorateurs ................................................................................. 1387
Zend_Test .......................................................................................................... 1389
1. Introduction ............................................................................................ 1389
2. Zend_Test_PHPUnit ............................................................................... 1389
2.1. Amorcer votre TestCase .............................................................. 1391
2.2. Tester vos contrôleurs et vos applications MVC ............................. 1392
2.3. Assertions ................................................................................... 1394
2.4. Exemples .................................................................................... 1396
3. Zend_Test_PHPUnit_Db ......................................................................... 1398
3.1. Quickstart .................................................................................... 1398
3.2. Utilisation, API et possibilités d'extension ...................................... 1402
3.3. Utiliser l'adaptateur de tests ......................................................... 1404
Zend_Text .......................................................................................................... 1406
1. Zend_Text_Figlet .................................................................................... 1406
2. Zend_Text_Table ................................................................................... 1407
Zend_TimeSync ................................................................................................. 1410
1. Introduction ............................................................................................ 1410
1.1. Pourquoi Zend_TimeSync ? ........................................................ 1410
1.2. Qu'est ce que NTP ? ................................................................... 1411
1.3. Qu'est ce que SNTP? .................................................................. 1411
1.4. Problèmes courants d'utilisation .................................................... 1411
1.5. Décider quel serveur de temps utiliser .......................................... 1411
2. Utiliser Zend_TimeSync .......................................................................... 1412
2.1. Requêter un serveur de temps public ............................................ 1412
2.2. Serveurs de temps multiples ........................................................ 1412
2.3. Les protocoles des serveurs de temps .......................................... 1413
2.4. Utiliser les ports pour les serveurs de temps .................................. 1413
2.5. Options pour les serveurs de temps .............................................. 1413
2.6. Utiliser des serveurs de temps différents ....................................... 1414
2.7. Informations sur les serveurs de temps ......................................... 1414
2.8. Gérer les exceptions .................................................................... 1414
Zend_Tool .......................................................................................................... 1416
1. Using Zend_Tool On The Command Line ................................................ 1416
1.1. Installation ................................................................................... 1416

xxx
Guide de référence
du programmeur

1.2. General Purpose Commands ....................................................... 1417


1.3. Project Specific Commands .......................................................... 1417
1.4. Environment Customization .......................................................... 1420
2. Extending Zend_Tool .............................................................................. 1421
2.1. Overview of Zend_Tool ................................................................ 1421
2.2. Zend_Tool_Framework Extensions ............................................... 1422
2.3. Zend_Tool_Project Extensions ..................................................... 1430
Zend_Tool_Framework ....................................................................................... 1432
1. Introduction ............................................................................................ 1432
2. Using the CLI Tool ................................................................................. 1432
2.1. Setting up the CLI tool ................................................................. 1433
2.2. Setting up the CLI tool on Unix-like Systems ................................. 1433
2.3. Setting up the CLI tool on Windows .............................................. 1435
2.4. Other Setup Considerations ......................................................... 1436
2.5. Where To Go Next? .................................................................... 1436
3. Architecture ............................................................................................ 1437
3.1. Registry ...................................................................................... 1437
3.2. Providers ..................................................................................... 1438
3.3. Loaders ....................................................................................... 1439
3.4. Manifests .................................................................................... 1440
3.5. Clients ........................................................................................ 1442
4. Creating Providers to use with Zend_Tool_Framework .............................. 1442
4.1. How Zend Tool finds your Providers ............................................. 1443
4.2. Basic Instructions for Creating Providers ....................................... 1443
4.3. The response object .................................................................... 1444
4.4. Advanced Development Information .............................................. 1444
5. Shipped System Providers ...................................................................... 1447
5.1. The Version Provider ................................................................... 1447
5.2. The Manifest Provider .................................................................. 1447
6. Extending and Configuring Zend_Tool_Framework ................................... 1447
6.1. Customizing Zend_Tool Console Client ......................................... 1447
Zend_Tool_Project ............................................................................................. 1450
1. Introduction ............................................................................................ 1450
2. Créer un projet ....................................................................................... 1450
3. Fournisseurs de Zend_Tool_Project ........................................................ 1451
4. Rouages internes de Zend_Tool_Project .................................................. 1451
4.1. Structure xml interne de Zend_Tool_Project .................................. 1451
4.2. Etendre les rouages de Zend_Tool_Project ................................... 1451
Zend_Translate .................................................................................................. 1452
1. Introduction ............................................................................................ 1452
1.1. Démarrer avec le multi-linguisme .................................................. 1452
2. Adaptateurs pour Zend_Translate ............................................................ 1453
2.1. Comment décider quel adaptateur de traduction utiliser ? ............... 1454
2.2. Intégrer ses propres adaptateurs .................................................. 1456
2.3. Améliorer les performances de tous les adaptateurs ....................... 1456
3. Utiliser les adaptateurs de traduction ....................................................... 1457
3.1. Structures des sources de traduction ............................................ 1458
3.2. Créer des fichiers sources de type tableau .................................... 1460
3.3. Créer des fichiers sources Gettext ................................................ 1461
3.4. Créer des fichiers source TMX ..................................................... 1462
3.5. Créer des fichiers source CSV ..................................................... 1462
3.6. Créer des fichiers sources INI ...................................................... 1463
3.7. Options pour les adaptateurs ........................................................ 1464
3.8. Gérer les langues ........................................................................ 1466

xxxi
Guide de référence
du programmeur

3.9. Détéction automatique de la source .............................................. 1468


3.10. Vérifier les traductions ................................................................ 1471
3.11. How to log not found translations ................................................ 1472
3.12. Access to the source data .......................................................... 1473
4. Creating source files ............................................................................... 1474
4.1. Creating Array source files ........................................................... 1474
4.2. Creating Gettext source files ........................................................ 1474
4.3. Creating TMX source files ............................................................ 1475
4.4. Creating CSV source files ............................................................ 1476
4.5. Creating INI source files ............................................................... 1476
5. Additional features for translation ............................................................ 1477
5.1. Options for adapters .................................................................... 1477
5.2. Handling languages ..................................................................... 1480
5.3. Automatic source detection .......................................................... 1482
5.4. Checking for translations .............................................................. 1484
5.5. How to log not found translations .................................................. 1485
5.6. Accessing source data ................................................................. 1486
6. Notation des pluriels pour Translation ...................................................... 1487
6.1. Méthode traditionnelle .................................................................. 1487
6.2. Méthode moderne de traduction du pluriel ..................................... 1487
6.3. Fichiers sources de pluriels .......................................................... 1488
6.4. Custom plural rules ...................................................................... 1489
Zend_Uri ............................................................................................................ 1491
1. Zend_Uri ................................................................................................ 1491
1.1. Aperçu ........................................................................................ 1491
1.2. Créer un nouvel URI .................................................................... 1491
1.3. Manipuler un URI existant ............................................................ 1491
1.4. Validation d'URI ........................................................................... 1492
1.5. Méthodes communes ................................................................... 1492
Zend_Validate .................................................................................................... 1494
1. Introduction ............................................................................................ 1494
1.1. Qu'est-ce qu'un validateur ? ......................................................... 1494
1.2. Utilisation basique des validateurs ................................................ 1494
1.3. Messages personnalisés .............................................................. 1495
1.4. Utilisation de la méthode statique is() ........................................ 1496
1.5. Translating messages .................................................................. 1497
2. Classes de validation standard ................................................................ 1498
2.1. Alnum ......................................................................................... 1498
2.2. Alpha .......................................................................................... 1498
2.3. Barcode ...................................................................................... 1498
2.4. Between ...................................................................................... 1498
2.5. Ccnum ........................................................................................ 1499
2.6. Date ............................................................................................ 1499
2.7. Db_RecordExists et Db_NoRecordExists ....................................... 1499
2.8. Digits .......................................................................................... 1501
2.9. EmailAddress .............................................................................. 1501
2.10. Float ......................................................................................... 1503
2.11. GreaterThan .............................................................................. 1503
2.12. Hex ........................................................................................... 1503
2.13. Hostname .................................................................................. 1503
2.14. Iban .......................................................................................... 1505
2.15. InArray ...................................................................................... 1506
2.16. Int ............................................................................................. 1506
2.17. Ip .............................................................................................. 1506

xxxii
Guide de référence
du programmeur

2.18. LessThan .................................................................................. 1506


2.19. NotEmpty .................................................................................. 1506
2.20. Regex ....................................................................................... 1506
2.21. Validateurs de Sitemap .............................................................. 1506
2.22. StringLength .............................................................................. 1507
3. Chaînes de validation ............................................................................. 1507
4. Écrire des validateurs ............................................................................. 1508
5. Messages de validation .......................................................................... 1512
5.1. Limiter la taille d'un message de validation .................................... 1517
Zend_Version ..................................................................................................... 1519
1. Lire la version de Zend Framework ......................................................... 1519
Zend_View ......................................................................................................... 1520
1. Introduction ............................................................................................ 1520
1.1. Script du Contrôleur ..................................................................... 1520
1.2. Script de vue ............................................................................... 1520
1.3. Options ....................................................................................... 1521
1.4. Balises courtes dans les scripts de vue ......................................... 1521
1.5. Accesseurs utiles ......................................................................... 1522
2. Scripts de contrôleur .............................................................................. 1523
2.1. Assigner des variables ................................................................. 1523
2.2. Effectuer le rendu d'un script de vue ............................................. 1524
2.3. Chemin des scripts de vue ........................................................... 1524
3. Scripts de vue ........................................................................................ 1525
3.1. Échapper la sortie ....................................................................... 1525
3.2. Utiliser des systèmes de gabarit (template) alternatifs ..................... 1526
4. Aides de vue ......................................................................................... 1532
4.1. Aides initiales .............................................................................. 1532
4.2. Chemin des aides ........................................................................ 1584
4.3. Écrire des aides personnalisées ................................................... 1585
4.4. Registering Concrete Helpers ....................................................... 1586
5. Zend_View_Abstract ............................................................................... 1587
Zend_Wildfire ..................................................................................................... 1588
1. Zend_Wildfire ......................................................................................... 1588
Zend_XmlRpc .................................................................................................... 1589
1. Introduction ............................................................................................ 1589
2. Zend_XmlRpc_Client .............................................................................. 1589
2.1. Introduction ................................................................................. 1589
2.2. Appels de méthodes .................................................................... 1589
2.3. Types et conversions ................................................................... 1590
2.4. Objet proxy du serveur ................................................................ 1592
2.5. Gestion des erreurs ..................................................................... 1592
2.6. Introspection du serveur ............................................................... 1593
2.7. De la requête à la réponse ........................................................... 1594
2.8. Client HTTP et tests .................................................................... 1594
3. Zend_XmlRpc_Server ............................................................................. 1594
3.1. Introduction ................................................................................. 1594
3.2. Usage de base ............................................................................ 1594
3.3. Structures du serveur .................................................................. 1595
3.4. Conventions ................................................................................ 1595
3.5. Utiliser des espaces de noms (Namespaces) ................................. 1596
3.6. Requêtes personnalisées ............................................................. 1596
3.7. Réponses personnalisées ............................................................ 1596
3.8. Gérer les exceptions grâce aux erreurs (Faults) ............................. 1597
3.9. Cacher la définition du serveur entre les requêtes .......................... 1597

xxxiii
Guide de référence
du programmeur

3.10. Exemples d'utilisation ................................................................. 1598


ZendX_Console_Process_Unix ........................................................................... 1602
1. ZendX_Console_Process_Unix ............................................................... 1602
1.1. Introduction ................................................................................. 1602
1.2. Basic usage of ZendX_Console_Process_Unix .............................. 1602
ZendX_JQuery ................................................................................................... 1604
1. Introduction ............................................................................................ 1604
2. ZendX_JQuery View Helpers .................................................................. 1604
2.1. jQuery() View Helper ................................................................... 1604
2.2. JQuery Helpers ........................................................................... 1610
3. ZendX_JQuery Form Elements and Decorators ........................................ 1616
3.1. General Elements and Decorator Usage ....................................... 1616
3.2. Form Elements ............................................................................ 1617
3.3. Form Decorators ......................................................................... 1617
A. Configuration système requise par Zend Framework ................................................ 1620
A.1. Introduction ................................................................................................. 1620
A.1.1. Version de PHP requise ................................................................... 1620
A.1.2. Extensions PHP ............................................................................... 1620
A.1.3. Les composants de Zend Framework ................................................ 1624
A.1.4. Dépendances internes de Zend Framework ....................................... 1628
B. Notes de migration de Zend Framework .................................................................. 1649
B.1. Zend Framework 1.10 ................................................................................. 1649
B.1.1. Zend_Feed_Reader .......................................................................... 1650
B.1.2. Zend_File_Transfer ........................................................................... 1650
B.1.3. Zend_Filter_HtmlEntities ................................................................... 1651
B.1.4. Zend_Filter_StripTags ....................................................................... 1651
B.1.5. Zend_Translate ................................................................................ 1651
B.1.6. Zend_Validate .................................................................................. 1652
B.2. Zend Framework 1.9 ................................................................................... 1653
B.2.1. Zend_File_Transfer ........................................................................... 1653
B.2.2. Zend_Filter ....................................................................................... 1653
B.2.3. Zend_Http_Client .............................................................................. 1653
B.2.4. Zend_Locale .................................................................................... 1654
B.2.5. Zend_View_Helper_Navigation .......................................................... 1655
B.2.6. Security fixes as with 1.9.7 ............................................................... 1656
B.3. Zend Framework 1.8 ................................................................................... 1657
B.3.1. Zend_Controller ................................................................................ 1657
B.3.2. Zend_Locale .................................................................................... 1657
B.4. Zend Framework 1.7 ................................................................................... 1657
B.4.1. Zend_Controller ................................................................................ 1657
B.4.2. Zend_File_Transfer ........................................................................... 1657
B.4.3. Zend_Locale .................................................................................... 1661
B.4.4. Zend_Translate ................................................................................ 1663
B.4.5. Zend_View ....................................................................................... 1664
B.5. Zend Framework 1.6 ................................................................................... 1664
B.5.1. Zend_Controller ................................................................................ 1665
B.5.2. Zend_File_Transfer ........................................................................... 1665
B.6. Zend Framework 1.5 ................................................................................... 1665
B.6.1. Zend_Controller ................................................................................ 1665
B.7. Zend Framework 1.0 ................................................................................... 1667
B.7.1. Zend_Controller ................................................................................ 1667
B.7.2. Zend_Currency ................................................................................. 1669
B.8. Zend Framework 0.9 ................................................................................... 1669
B.8.1. Zend_Controller ................................................................................ 1669

xxxiv
Guide de référence
du programmeur

B.9. Zend Framework 0.8 ................................................................................... 1670


B.9.1. Zend_Controller ................................................................................ 1670
B.10. Zend Framework 0.6 ................................................................................. 1671
B.10.1. Zend_Controller .............................................................................. 1671
C. Convention de codage PHP de Zend Framework .................................................... 1674
C.1. Vue d'ensemble .......................................................................................... 1674
C.1.1. Portée ............................................................................................. 1674
C.1.2. Buts ................................................................................................. 1675
C.2. Formatage des fichiers PHP ........................................................................ 1675
C.2.1. Général ........................................................................................... 1675
C.2.2. Indentation ....................................................................................... 1675
C.2.3. Longueur maximum d'une ligne ......................................................... 1675
C.2.4. Terminaison de lignes ...................................................................... 1675
C.3. Conventions de nommage ........................................................................... 1675
C.3.1. Classes ........................................................................................... 1675
C.3.2. Abstract Classes .............................................................................. 1676
C.3.3. Interfaces ......................................................................................... 1676
C.3.4. Noms de fichiers .............................................................................. 1676
C.3.5. Fonctions et méthodes ..................................................................... 1677
C.3.6. Variables ......................................................................................... 1677
C.3.7. Constantes ....................................................................................... 1678
C.4. Style de codage .......................................................................................... 1678
C.4.1. Démarcation du code PHP ............................................................... 1678
C.4.2. Chaînes de caractères ...................................................................... 1678
C.4.3. Tableaux .......................................................................................... 1679
C.4.4. Classes ........................................................................................... 1680
C.4.5. Fonctions et méthodes ..................................................................... 1681
C.4.6. Structure de contrôle ........................................................................ 1684
C.4.7. Documentation intégrée .................................................................... 1685
D. Zend Framework Documentation Standard .............................................................. 1687
D.1. Overview .................................................................................................... 1687
D.1.1. Scope .............................................................................................. 1687
D.2. Documentation File Formatting .................................................................... 1687
D.2.1. XML Tags ........................................................................................ 1687
D.2.2. Maximum Line Length ...................................................................... 1688
D.2.3. Indentation ....................................................................................... 1688
D.2.4. Line Termination .............................................................................. 1688
D.2.5. Empty tags ...................................................................................... 1688
D.2.6. Usage of whitespace within documents .............................................. 1689
D.2.7. Program Listings .............................................................................. 1691
D.2.8. Notes on specific inline tags ............................................................. 1692
D.2.9. Notes on specific block tags ............................................................. 1693
D.3. Recommendations ...................................................................................... 1694
D.3.1. Use editors without autoformatting ..................................................... 1694
D.3.2. Use Images ..................................................................................... 1694
D.3.3. Use Case Examples ......................................................................... 1694
D.3.4. Avoid Replicating phpdoc Contents ................................................... 1694
D.3.5. Use Links ........................................................................................ 1694
E. Recommended Project Structure for Zend Framework MVC Applications ................... 1696
E.1. Overview .................................................................................................... 1696
E.2. Recommended Project Directory Structure .................................................... 1696
E.3. Module Structure ......................................................................................... 1698
E.4. Rewrite Configuration Guide ........................................................................ 1699
E.4.1. Apache HTTP Server ........................................................................ 1699

xxxv
Guide de référence
du programmeur

E.4.2. Microsoft Internet Information Server ................................................. 1699


F. Guide de performance Zend Framework ................................................................. 1701
F.1. Introduction ................................................................................................. 1701
F.2. Chargement des classes ............................................................................. 1701
F.2.1. Comment optimiser mon include_path ? ............................................. 1701
F.2.2. Comment éliminer les déclarations require_once non nécessaires ? ..... 1703
F.2.3. Comment accélérer le chargement des plugins ? ................................ 1704
F.3. Performance de Zend_Db ............................................................................ 1705
F.3.1. Comment réduire la surcharge introduite par Zend_Db_Table lors de la
récupération des métadonnées de table ? .................................................. 1705
F.3.2. Le SQL généré avec Zend_Db_Select n'utilise pas mes index ;
comment améliorer ceci ? .......................................................................... 1706
F.4. Internationalisation (i18n) and Localisation (l10n) ........................................... 1706
F.4.1. Quel adaptateur de traduction dois-je utiliser ? .................................... 1706
F.4.2. Comment peut-on améliorer les performances de la traduction et de la
localisation ? ............................................................................................. 1707
F.5. View Rendering ........................................................................................... 1707
F.5.1. How can I speed up resolution of view helpers? .................................. 1707
F.5.2. How can I speed up view partials? .................................................... 1709
F.5.3. How can I speed up calls to the action() view helper? .......................... 1709
G. Informations de copyright ....................................................................................... 1712

xxxvi
Partie I. Introduction
au Zend Framework
Table des matières
Présentation .................................................................................................................... 3
Installation ....................................................................................................................... 4

2
Présentation
Zend Framework (ZF) est un framework open-source destiné aux développements d'applications
web et de services web avec PHP5. Le Zend Framework est construit en utilisant 100% de
code orienté-objet. La structure des composants du Zend Framework est quelque peu unique ;
chaque composant est conçu avec de faibles dépendances envers les autres composants.
Cette architecture faiblement couplée permet aux développeurs d'utiliser les composants
individuellement. On appelle souvent ce type de conception "use-at-will".

Bien qu'ils puissent être utilisés individuellement, les composants de la librairie standard de
Zend Framework forment un framework d'application web puissant et extensible quand ils sont
combinés. Le ZF offre une robuste et performante implémentation du motif MVC, une abstraction
de base de données simple d'utilisation, et un composant de formulaire qui implémente un rendu
HTML, la validation et le filtrage des données, ainsi les développeurs peuvent consolider toutes
ces opérations en utilisant une interface orienté-objet facile d'utilisation. D'autres composants,
comme Zend_Auth ou Zend_Acl, fournissent l'authentification d'utilisateurs et l'autorisation
envers les solutions de stockage de crédits habituels. D'autres encore, implémentent des
librairies clientes pour simplifier l'accès aux services web disponibles les plus populaires.
Quelque soit le besoin de votre application, vous avez toutes les chances de trouver un
composant de Zend Framework qui peut être utilisé pour réduire drastiquement votre temps de
développement avec une base de tests solide.

Le sponsor principal du projet Zend Framework est Zend Technologies, mais un certain nombre
d'entreprises a contribué à des composants ou à des fonctionnalités significatives du framework.
Des entreprises comme Google, Microsoft et StrikeIron ont travaillé en partenariat avec Zend
pour fournir des interfaces vers des services web et d'autres technologies qu'ils souhaitaient
rendre disponible aux développeurs utilisant Zend Framework.

Zend Framework ne pourrait pas fournir et supporter toutes ces fonctionnalités sans l'aide de
la vibrante communauté du Zend Framework. Les membres de la communauté, incluant les
contributeurs, se rendent disponibles sur les listes de diffusion, canaux IRC, et autres forums.
Quelque soit la question que vous avez sur le Zend Framework, la communauté est toujours
disponible pour y répondre.

3
Installation
Veuillez vous reporter à l'annexe concernant la configuration système requise pour plus
d'informations.

Installer Zend Framework est extrêmement simple. Une fois que vous avez téléchargé et
décompressé le framework, vous devez ajouter le dossier "/library" de la distribution en début
de votre chemin d'inclusion ("include_path"). Vous pouvez bien entendu aussi déplacer la
librairie à tout autre position (partagée ou non) dans votre arborescence de fichiers.

• Téléchargement de la dernière version stable : Cette version, disponible à la fois au format


.zip et au format .tar.gz, est un bon choix pour ceux qui débutent avec Zend Framework.

• Téléchargement du dernier cliché nocturne : Pour ceux qui veulent être à l'avant-garde, les
clichés nocturnes représentent le dernier progrès de développement de Zend Framework.
Ces clichés sont empaquetés avec la documentation en anglais seulement ou dans toutes
les langues disponibles. Si vous prévoyez de travailler avec les derniers développements de
Zend Framework, considérez plutôt l'emploi d'un client subversion (SVN).

• Utilisation d'un client Subversion (SVN) : Zend Framework est un logiciel open-source,
et le référentiel Subversion utilisé pour son développement est disponible publiquement.
Considérer l'utilisation de SVN pour récupérer Zend Framework si vous utilisez déjà SVN pour
vos propres développements, si vous voulez contribuer à l'évolution du framework, ou si vous
désirez mettre à jour votre version du framework plus souvent que les sorties stables.

L'exportation est utile si vous souhaitez obtenir une révision particulière du framework sans
les dossiers .svn créé dans une copie de travail.

L'extraction d'une copie de travail est intéressante si vous contribuez à Zend Framework, et
une copie de travail peut être mise à jour à n'importe quel moment avec svn update et les
changements peuvent être livrés au référentiel SVN avec la commande svn commit.

Une définition externe est très pratique pour les développeurs utilisant déjà SVN pour gérer
les copies de travail de leurs applications.

L'URL du tronc du référentiel SVN de Zend Framework est : http://framework.zend.com/svn/


framework/standard/trunk

Une fois votre copie de Zend Framework disponible, votre application nécessite d'avoir accès aux
classes du framework. Bien qu'il y ait plusieurs manières de réaliser ceci, votre include_path
de PHP doit contenir le chemin vers la bibliothèque de Zend Framework.

Zend fournit un tutoriel de démarrage rapide ("QuickStart") pour vous permettre de démarrer
rapidement. Ceci est une excellente manière pour commencer à apprendre le framework avec
une présentation de cas concrets que vous pourriez avoir à utiliser.

Puisque les composants de Zend Framework sont plutôt connectés de manière lâche, divers
composants peuvent être choisis pour un usage indépendant si nécessaire. Les chapitres
suivants documente l'utilisation de Zend Framework composant par composant.

4
Partie II. Apprendre Zend Framework
Table des matières
Démarrez rapidement avec Zend Framework .................................................................... 8
1. Zend Framework & MVC Introduction ................................................................... 8
1.1. Zend Framework ....................................................................................... 8
1.2. Model-View-Controller ............................................................................... 8
2. Create Your Project ........................................................................................... 10
2.1. Install Zend Framework ........................................................................... 10
2.2. Create Your Project ................................................................................. 10
2.3. The Bootstrap ......................................................................................... 11
2.4. Configuration ........................................................................................... 12
2.5. Action Controllers .................................................................................... 12
2.6. Views ..................................................................................................... 13
2.7. Checkpoint .............................................................................................. 15
3. Create A Layout ................................................................................................ 15
4. Create a Model and Database Table ................................................................... 18
5. Create A Form ................................................................................................... 28
6. Congratulations! ................................................................................................. 31
Chargement automatique avec Zend Framework ............................................................. 33
1. Introduction ........................................................................................................ 33
2. Architecture et buts ............................................................................................ 33
2.1. Convention de noms des classes ............................................................. 33
2.2. Conventions et architecture d'Autoload ..................................................... 33
3. Utilisation de base de l'autoloader ....................................................................... 34
4. Auto-chargement de resources ........................................................................... 36
5. Conclusion ......................................................................................................... 37
Les plugins dans Zend Framework ................................................................................. 38
1. Introduction ........................................................................................................ 38
2. Using Plugins .................................................................................................... 38
3. Conclusion ......................................................................................................... 40
Bien démarrer avec Zend_Layout ................................................................................... 42
1. Introduction ........................................................................................................ 42
2. Utiliser Zend_Layout .......................................................................................... 42
2.1. Layout Configuration ............................................................................... 42
2.2. Créer un script de layout ......................................................................... 43
2.3. Accéder à l'objet Layout .......................................................................... 43
2.4. Autres opérations .................................................................................... 44
3. Zend_Layout: Conclusions .................................................................................. 45
Bien démarrer avec Zend_View ...................................................................................... 46
1. Introduction ........................................................................................................ 46
2. Basic Placeholder Usage ................................................................................... 46
3. Standard Placeholders ....................................................................................... 49
3.1. Setting the DocType ................................................................................ 49
3.2. Specifying the Page Title ......................................................................... 50
3.3. Specifying Stylesheets with HeadLink ....................................................... 51
3.4. Aggregating Scripts Using HeadScript ...................................................... 52
4. View Placeholders: Conclusion ........................................................................... 54
Bien comprendre et utiliser les décorateurs Zend Form .................................................... 55
1. Introduction ........................................................................................................ 55
2. Les bases des décorateurs ................................................................................ 55
2.1. Aperçu du pattern décorateur ................................................................... 55
2.2. Créer votre premier décorateur ................................................................ 57
3. Chainer les décorateurs ..................................................................................... 58

6
Apprendre Zend Framework

4. Rendu individuel des décorateurs ....................................................................... 62


5. Créer et rendre des éléments composites ........................................................... 66
5.1. L'élément ................................................................................................ 66
5.2. Le décorateur ......................................................................................... 68
5.3. Conclusion .............................................................................................. 71
6. Conclusion ......................................................................................................... 71
Bien démarrer avec Zend_Session, Zend_Auth, et Zend_Acl ............................................ 72
1. Fabrique une application Multi-Utilisateurs avec Zend Framework ......................... 72
1.1. Zend Framework ..................................................................................... 72
2. Gérer les sessions dans ZF ............................................................................... 72
2.1. Introduction aux sessions ........................................................................ 72
2.2. Utilisation classique de Zend_Session ...................................................... 73
2.3. Utilisation avancée de Zend_Session ....................................................... 74
3. Authentification d'utilisateurs dans Zend Framework ............................................. 74
3.1. Introduction à l'authentification ................................................................. 74
3.2. Utilisation de base de Zend_Auth ............................................................. 74
4. Fabriquer un système de gestion d'autorisations avec Zend Framework ................. 76
4.1. Introduction à l'autorisation ...................................................................... 76
4.2. Utilisation de base de Zend_Acl ............................................................... 76
Bien démarrer avec Zend_Search_Lucene ...................................................................... 80
1. Introduction à Zend_Search_Lucene ................................................................... 80
2. Structure d'index Lucene .................................................................................... 81
3. Ouverture et création d'index .............................................................................. 82
4. Indexation .......................................................................................................... 82
4.1. Politique d'indexation ............................................................................... 83
5. Recherche ......................................................................................................... 83
6. Requêtes supportées ......................................................................................... 84
7. Pagination de résultat de recherche .................................................................... 86
Bien démarrer avec Zend_Paginator ............................................................................... 88
1. Introduction ........................................................................................................ 88
2. Simple Examples ............................................................................................... 88
3. Contrôles de la pagination et styles de défilement ................................................ 90
4. Putting it all Together ......................................................................................... 91

7
Démarrez rapidement avec Zend
Framework
1. Zend Framework & MVC Introduction
1.1. Zend Framework
Zend Framework is an open source, object oriented web application framework for PHP 5.
Zend Framework is often called a 'component library', because it has many loosely coupled
components that you can use more or less independently. But Zend Framework also provides
an advanced Model-View-Controller (MVC) implementation that can be used to establish
a basic structure for your Zend Framework applications. A full list of Zend Framework
components along with short descriptions may be found in the components overview. This
QuickStart will introduce you to some of Zend Framework's most commonly used components,
including Zend_Controller, Zend_Layout, Zend_Config, Zend_Db, Zend_Db_Table,
Zend_Registry, along with a few view helpers.

Using these components, we will build a simple database-driven guest book application within
minutes. The complete source code for this application is available in the following archives:

• zip

• tar.gz

1.2. Model-View-Controller
So what exactly is this MVC pattern everyone keeps talking about, and why should you care?
MVC is much more than just a three-letter acronym (TLA) that you can whip out anytime you want
to sound smart; it has become something of a standard in the design of modern web applications.
And for good reason. Most web application code falls under one of the following three categories:
presentation, business logic, and data access. The MVC pattern models this separation of
concerns well. The end result is that your presentation code can be consolidated in one part of
your application with your business logic in another and your data access code in yet another.
Many developers have found this well-defined separation indispensable for keeping their code
organized, especially when more than one developer is working on the same application.

More Information

Let's break down the pattern and take a look at the individual pieces:

8
Démarrez rapidement
avec Zend Framework

• Model - This is the part of your application that defines its basic functionality
behind a set of abstractions. Data access routines and some business logic
can be defined in the model.

• View - Views define exactly what is presented to the user. Usually controllers
pass data to each view to render in some format. Views will often collect data
from the user, as well. This is where you're likely to find HTML markup in your
MVC applications.

• Controller - Controllers bind the whole pattern together. They manipulate


models, decide which view to display based on the user's request and other
factors, pass along the data that each view will need, or hand off control to
another controller entirely. Most MVC experts recommend keeping controllers
as skinny as possible.

9
Démarrez rapidement
avec Zend Framework

Of course there is more to be said about this critical pattern, but this should
give you enough background to understand the guestbook application we'll be
building.

2. Create Your Project


In order to create your project, you must first download and extract Zend Framework.

2.1. Install Zend Framework


The easiest way to get Zend Framework along with a complete PHP stack is by installing Zend
Server. Zend Server has native installers for Mac OSX, Windows, Fedora Core, and Ubuntu, as
well as a universal installation package compatible with most Linux distributions.

After you have installed Zend Server, the Framework files may be found under /usr/local/
zend/share/ZendFramework on Mac OSX and Linux, and C:\Program Files\Zend
\ZendServer\share\ZendFramework on Windows. The include_path will already be
configured to include Zend Framework.

Alternately, you can Download the latest version of Zend Framework and extract the contents;
make a note of where you have done so.

Optionally, you can add the path to the library/ subdirectory of the archive to your php.ini's
include_path setting.

That's it! Zend Framework is now installed and ready to use.

2.2. Create Your Project


zf Command Line Tool
In your Zend Framework installation is a bin/ subdirectory, containing the scripts
zf.sh and zf.bat for Unix-based and Windows-based users, respectively.
Make a note of the absolute path to this script.

Wherever you see references to zf.sh or zf.bat, please substitute the


absolute path to the script. On Unix-like systems, you may want to use your shell's
alias functionality: alias zf.sh=path/to/ZendFramework/bin/zf.sh.

If you have problems setting up the zf command-line tool, please refer to the
manual.

Open a terminal (in Windows, Start -> Run, and then use cmd). Navigate to a directory where
you would like to start a project. Then, use the path to the appropriate script, and execute one
of the following:

# Unix:
% zf.sh create project quickstart

# DOS/Windows:
C:> zf.bat create project quickstart

Running this command will create your basic site structure, including your initial controllers and
views. The tree looks like the following:

10
Démarrez rapidement
avec Zend Framework

quickstart
|-- application
| |-- Bootstrap.php
| |-- configs
| | `-- application.ini
| |-- controllers
| | |-- ErrorController.php
| | `-- IndexController.php
| |-- models
| `-- views
| |-- helpers
| `-- scripts
| |-- error
| | `-- error.phtml
| `-- index
| `-- index.phtml
|-- library
|-- public
| `-- index.php
`-- tests
|-- application
| `-- bootstrap.php
|-- library
| `-- bootstrap.php
`-- phpunit.xml

At this point, if you haven't added Zend Framework to your include_path, we recommend
either copying or symlinking it into your library/ directory. In either case, you'll want to either
recursively copy or symlink the library/Zend/ directory of your Zend Framework installation
into the library/ directory of your project. On unix-like systems, that would look like one of
the following:

# Symlink:
% cd library; ln -s path/to/ZendFramework/library/Zend .

# Copy:
% cd library; cp -r path/to/ZendFramework/library/Zend .

On Windows systems, it may be easiest to do this from the Explorer.

Now that the project is created, the main artifacts to begin understanding are the bootstrap,
configuration, action controllers, and views.

2.3. The Bootstrap


Your Bootstrap class defines what resources and components to initialize. By default, Zend
Framework's Front Controller is initialized, and it uses the application/controllers/ as
the default directory in which to look for action controllers (more on that later). The class looks
like the following:

// application/Bootstrap.php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
}

As you can see, not much is necessary to begin with.

11
Démarrez rapidement
avec Zend Framework

2.4. Configuration
While Zend Framework is itself configurationless, you often need to configure your application.
The default configuration is placed in application/configs/application.ini, and
contains some basic directives for setting your PHP environment (for instance, turning error
reporting on and off), indicating the path to your bootstrap class (as well as its class name), and
the path to your action controllers. It looks as follows:

; application/configs/application.ini

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Several things about this file should be noted. First, when using INI-style configuration, you
can reference constants directly and expand them; APPLICATION_PATH is actually a constant.
Additionally note that there are several sections defined: production, staging, testing, and
development. The latter three inherit settings from the "production" environment. This is a useful
way to organize configuration to ensure that appropriate settings are available in each stage of
application development.

2.5. Action Controllers


Your application's action controllers contain your application workflow, and do the work of
mapping your requests to the appropriate models and views.

An action controller should have one or more methods ending in "Action"; these methods
may then be requested via the web. By default, Zend Framework URLs follow the schema
/controller/action, where "controller" maps to the action controller name (minus the
"Controller" suffix) and "action" maps to an action method (minus the "Action" suffix).

Typically, you always need an IndexController, which is a fallback controller and which also
serves the home page of the site, and an ErrorController, which is used to indicate things
such as HTTP 404 errors (controller or action not found) and HTTP 500 errors (application errors).

The default IndexController is as follows:

// application/controllers/IndexController.php

class IndexController extends Zend_Controller_Action


{

public function init()

12
Démarrez rapidement
avec Zend Framework

{
/* Initialize action controller here */
}

public function indexAction()


{
// action body
}
}

And the default ErrorController is as follows:

// application/controllers/ErrorController.php

class ErrorController extends Zend_Controller_Action


{

public function errorAction()


{
$errors = $this->_getParam('error_handler');

switch ($errors->type) {
case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

// 404 error -- controller or action not found


$this->getResponse()->setHttpResponseCode(404);
$this->view->message = 'Page not found';
break;
default:
// application error
$this->getResponse()->setHttpResponseCode(500);
$this->view->message = 'Application error';
break;
}

$this->view->exception = $errors->exception;
$this->view->request = $errors->request;
}
}

You'll note that (1) the IndexController contains no real code, and (2) the
ErrorController makes reference to a "view" property. That leads nicely into our next subject.

2.6. Views
Views in Zend Framework are written in plain old PHP. View scripts are placed in application/
views/scripts/, where they are further categorized using the controller names. In our case,
we have an IndexController and an ErrorController, and thus we have corresponding
index/ and error/ subdirectories within our view scripts directory. Within these subdirectories,
you will then find and create view scripts that correspond to each controller action exposed; in the
default case, we thus have the view scripts index/index.phtml and error/error.phtml.

View scripts may contain any markup you want, and use the <?php opening tag and ?> closing
tag to insert PHP directives.

The following is what we install by default for the index/index.phtml view script:

13
Démarrez rapidement
avec Zend Framework

<!-- application/views/scripts/index/index.phtml -->


<style>

a:link,
a:visited
{
color: #0398CA;
}

span#zf-name
{
color: #91BE3F;
}

div#welcome
{
color: #FFFFFF;
background-image: url(http://framework.zend.com/images/bkg_header.jpg);
width: 600px;
height: 400px;
border: 2px solid #444444;
overflow: hidden;
text-align: center;
}

div#more-information
{
background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
height: 100%;
}

</style>
<div id="welcome">
<h1>Welcome to the <span id="zf-name">Zend Framework!</span><h1 />
<h3>This is your project's main page<h3 />
<div id="more-information">
<p>
<img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
</p>

<p>
Helpful Links: <br />
<a href="http://framework.zend.com/">Zend Framework Website</a> |
<a href="http://framework.zend.com/manual/en/">Zend Framework
Manual</a>
</p>
</div>
</div>

The error/error.phtml view script is slightly more interesting as it uses some PHP
conditionals:

<!-- application/views/scripts/error/error.phtml -->


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Zend Framework Default Application</title>

14
Démarrez rapidement
avec Zend Framework

</head>
<body>
<h1>An error occurred</h1>
<h2><?php echo $this->message ?></h2>

<?php if ('development' == $this->env): ?>


<h3>Exception information:</h3>
<p>
<b>Message:</b> <?php echo $this->exception->getMessage() ?>
</p>

<h3>Stack trace:</h3>
<pre><?php echo $this->exception->getTraceAsString() ?>
</pre>

<h3>Request Parameters:</h3>
<pre><?php echo var_export($this->request->getParams(), 1) ?>
</pre>
<?php endif ?>
</body>
</html>

2.7. Checkpoint
At this point, you should be able to fire up your initial Zend Framework application. Create a virtual
host in your web server, and point its document root to your application's public/ subdirectory.
Make sure your host's name is in your DNS or hosts file, and then point your browser to it. You
should be able to see a welcome page at this point.

3. Create A Layout
You may have noticed that the view scripts in the previous sections were HTML fragments- not
complete pages. This is by design; we want our actions to return content only related to the action
itself, not the application as a whole.

Now we must compose that generated content into a full HTML page. We'd also like to have a
consistent look and feel for the application. We will use a global site layout to accomplish both
of these tasks.

There are two design patterns that Zend Framework uses to implement layouts: Two Step View
and Composite View. Two Step View is usually associated with the Transform View pattern; the
basic idea is that your application view creates a representation that is then injected into the
master view for final transformation. The Composite View pattern deals with a view made of one
or more atomic, application views.

In Zend Framework, Zend_Layout combines the ideas behind these patterns. Instead of each
action view script needing to include site-wide artifacts, they can simply focus on their own
responsibilities.

Occasionally, however, you may need application-specific information in your site-wide view
script. Fortunately, Zend Framework provides a variety of view placeholders to allow you to
provide such information from your action view scripts.

To get started using Zend_Layout, first we need to inform our bootstrap to use the Layout
resource. This can be done by adding the following line to your application/configs/
application.ini file, within the production section:

15
Démarrez rapidement
avec Zend Framework

; application/configs/application.ini

; Add to [production] section:


resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"

The final INI file should look as follows:

; application/configs/application.ini

[production]
; PHP settings we want to initialize
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

This directive tells your application to look for layout view scripts in application/layouts/
scripts. Create those directories now.

We also want to ensure we have an XHTML DocType declaration for our application. To enable
this, we need to add a resource to our bootstrap.

The simplest way to add a bootstrap resource is to simply create a protected method beginning
with the phrase _init. In this case, we want to initialize the doctype, so we'll create an
_initDoctype() method within our bootstrap class:

// application/Bootstrap.php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initDoctype()
{
}
}

Within that method, we need to hint to the view to use the appropriate doctype. But where will
the view object come from? The easy solution is to initialize the View resource; once we have,
we can pull the view object from the bootstrap and use it.

To initialize the view resource, add the following line to your application/configs/
application.ini file, in the section marked production:

; application/configs/application.ini

16
Démarrez rapidement
avec Zend Framework

; Add to [production] section:


resources.view[] =

This tells us to initialize the view with no options (the '[]' indicates that the "view" key is an array,
and we pass nothing to it).

Now that we have a view, let's flesh out our _initDoctype() method. In it, we will first ensure
the View resource has run, fetch the view object, and then configure it:

// application/Bootstrap.php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initDoctype()
{
$this->bootstrap('view');
$view = $this->getResource('view');
$view->doctype('XHTML1_STRICT');
}
}

Now that we've initialized Zend_Layout and set the Doctype, let's create our site-wide layout:

// application/layouts/scripts/layout.phtml

echo $this->doctype() ?>


<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Zend Framework Quickstart Application</title>
<?php echo $this->headLink()->appendStylesheet('/css/global.css') ?>
</head>
<body>
<div id="header" style="background-color: #EEEEEE; height: 30px;">
<div id="header-logo" style="float: left">
<b>ZF Quickstart Application</b>
</div>
<div id="header-navigation" style="float: right">
<a href="<?php echo $this->url(
array('controller'=>'guestbook'),
'default',
true) ?>">Guestbook</a>
</div>
</div>

<?php echo $this->layout()->content ?>


</body>
</html>

We grab our application content using the layout() view helper, and accessing the "content"
key. You may render to other response segments if you wish to, but in most cases, this is all
that's necessary.

Note also the use of the headLink() placeholder. This is an easy way to generate the HTML
for <link> elements, as well as to keep track of them throughout your application. If you need to
add additional CSS sheets to support a single action, you can do so, and be assured it will be
present in the final rendered page.

17
Démarrez rapidement
avec Zend Framework

Checkpoint
Now go to "http://localhost" and check out the source. You should see your
XHTML header, head, title, and body sections.

4. Create a Model and Database Table


Before we get started, let's consider something: where will these classes live, and how will
we find them? The default project we created instantiates an autoloader. We can attach other
autoloaders to it so that it knows where to find different classes. Typically, we want our various
MVC classes grouped under the same tree -- in this case, application/ -- and most often
using a common prefix.

Zend_Controller_Front has a notion of "modules", which are individual mini-applications.


Modules mimic the directory structure that the zf tool sets up under application/, and
all classes inside them are assumed to begin with a common prefix, the module name.
application/ is itself a module -- the "default" or "application" module. As such, we'll want to
setup autoloading for resources within this directory.

Zend_Application_Module_Autoloader provides the functionality needed to map the


various resources under a module to the appropriate directories, and provides a standard naming
mechanism as well. An instance of the class is created by default during initialization of the
bootstrap object; your application bootstrap will be default use the module prefix "Application".
As such, our models, forms, and table classes will all begin with the class prefix "Application_".

Now, let's consider what makes up a guestbook. Typically, they are simply a list of entries with
a comment, timestamp, and, often, email address. Assuming we store them in a database, we
may also want a unique identifier for each entry. We'll likely want to be able to save an entry,
fetch individual entries, and retrieve all entries. As such, a simple guestbook model API might
look something like this:

// application/models/Guestbook.php

class Application_Model_Guestbook
{
protected $_comment;
protected $_created;
protected $_email;
protected $_id;

public function __set($name, $value);


public function __get($name);

public function setComment($text);


public function getComment();

public function setEmail($email);


public function getEmail();

public function setCreated($ts);


public function getCreated();

public function setId($id);


public function getId();

public function save();


public function find($id);

18
Démarrez rapidement
avec Zend Framework

public function fetchAll();


}

__get() and __set() will provide a convenience mechanism for us to access the individual
entry properties, and proxy to the other getters and setters. They also will help ensure that only
properties we whitelist will be available in the object.

find() and fetchAll() provide the ability to fetch a single entry or all entries.

Now from here, we can start thinking about setting up our database.

First we need to initialize our Db resource. As with the Layout and View resource,
we can provide configuration for the Db resource. In your application/configs/
application.ini file, add the following lines in the appropriate sections.

; application/configs/application.ini

; Add these lines to the appropriate sections:


[production]
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"

[testing : production]
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"

[development : production]
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"

Your final configuration file should look like the following:

; application/configs/application.ini

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"
resources.view[] =
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"

Note that the database(s) will be stored in data/db/. Create those directories, and make them
world-writeable. On unix-like systems, you can do that as follows:

% mkdir -p data/db; chmod -R a+rwX data

19
Démarrez rapidement
avec Zend Framework

On Windows, you will need to create the directories in Explorer and set the permissions to allow
anyone to write to the directory.

At this point we have a connection to a database; in our case, its a connection to a Sqlite database
located inside our application/data/ directory. So, let's design a simple table that will hold
our guestbook entries.

-- scripts/schema.sqlite.sql
--
-- You will need load your database schema with this SQL.

CREATE TABLE guestbook (


id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
email VARCHAR(32) NOT NULL DEFAULT 'noemail@test.com',
comment TEXT NULL,
created DATETIME NOT NULL
);

CREATE INDEX "id" ON "guestbook" ("id");

And, so that we can have some working data out of the box, lets create a few rows of information
to make our application interesting.

-- scripts/data.sqlite.sql
--
-- You can begin populating the database with the following SQL statements.

INSERT INTO guestbook (email, comment, created) VALUES


('ralph.schindler@zend.com',
'Hello! Hope you enjoy this sample zf application!',
DATETIME('NOW'));
INSERT INTO guestbook (email, comment, created) VALUES
('foo@bar.com',
'Baz baz baz, baz baz Baz baz baz - baz baz baz.',
DATETIME('NOW'));

Now that we have both the schema and some data defined. Lets get a script together that we can
now execute to build this database. Naturally, this is not needed in production, but this script will
help developers build out the database requirements locally so they can have the fully working
application. Create the script as scripts/load.sqlite.php with the following contents:

// scripts/load.sqlite.php

/**
* Script for creating and loading database
*/

// Initialize the application path and autoloading


defined('APPLICATION_PATH')
|| define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));
set_include_path(implode(PATH_SEPARATOR, array(
APPLICATION_PATH . '/../library',
get_include_path(),
)));
require_once 'Zend/Loader/Autoloader.php';
Zend_Loader_Autoloader::getInstance();

// Define some CLI options

20
Démarrez rapidement
avec Zend Framework

$getopt = new Zend_Console_Getopt(array(


'withdata|w' => 'Load database with sample data',
'env|e-s' => 'Application environment for which to create database (defaults to devel
'help|h' => 'Help -- usage message',
));
try {
$getopt->parse();
} catch (Zend_Console_Getopt_Exception $e) {
// Bad options passed: report usage
echo $e->getUsageMessage();
return false;
}

// If help requested, report usage message


if ($getopt->getOption('h')) {
echo $getopt->getUsageMessage();
return true;
}

// Initialize values based on presence or absence of CLI options


$withData = $getopt->getOption('w');
$env = $getopt->getOption('e');
defined('APPLICATION_ENV')
|| define('APPLICATION_ENV', (null === $env) ? 'development' : $env);

// Initialize Zend_Application
$application = new Zend_Application(
APPLICATION_ENV,
APPLICATION_PATH . '/configs/application.ini'
);

// Initialize and retrieve DB resource


$bootstrap = $application->getBootstrap();
$bootstrap->bootstrap('db');
$dbAdapter = $bootstrap->getResource('db');

// let the user know whats going on (we are actually creating a
// database here)
if ('testing' != APPLICATION_ENV) {
echo 'Writing Database Guestbook in (control-c to cancel): ' . PHP_EOL;
for ($x = 5; $x > 0; $x--) {
echo $x . "\r"; sleep(1);
}
}

// Check to see if we have a database file already


$options = $bootstrap->getOption('resources');
$dbFile = $options['db']['params']['dbname'];
if (file_exists($dbFile)) {
unlink($dbFile);
}

// this block executes the actual statements that were loaded from
// the schema file.
try {
$schemaSql = file_get_contents(dirname(__FILE__) . '/schema.sqlite.sql');
// use the connection directly to load sql in batches
$dbAdapter->getConnection()->exec($schemaSql);
chmod($dbFile, 0666);

21
Démarrez rapidement
avec Zend Framework

if ('testing' != APPLICATION_ENV) {
echo PHP_EOL;
echo 'Database Created';
echo PHP_EOL;
}

if ($withData) {
$dataSql = file_get_contents(dirname(__FILE__) . '/data.sqlite.sql');
// use the connection directly to load sql in batches
$dbAdapter->getConnection()->exec($dataSql);
if ('testing' != APPLICATION_ENV) {
echo 'Data Loaded.';
echo PHP_EOL;
}
}

} catch (Exception $e) {


echo 'AN ERROR HAS OCCURED:' . PHP_EOL;
echo $e->getMessage() . PHP_EOL;
return false;
}

// generally speaking, this script will be run from the command line
return true;

Now, let's execute this script. From a terminal or the DOS command line, do the following:

% php scripts/load.sqlite.php --withdata

You should see output like the following:

path/to/ZendFrameworkQuickstart/scripts$ php load.sqlite.php --withdata


Writing Database Guestbook in (control-c to cancel):
1
Database Created
Data Loaded.

Now we have a fully working database and table for our guestbook application. Our next few
steps are to build out our application code. This includes building a data source (in our case, we
will use Zend_Db_Table), and a data mapper to connect that data source to our domain model.
Finally we'll also create the controller that will interact with this model to both display existing
entries and process new entries.

We'll use a Table Data Gateway to connect to our data source; Zend_Db_Table provides
this functionality. To get started, lets create a Zend_Db_Table-based table class. First, create
the directory application/models/DbTable/. Then create and edit a file Guestbook.php
within it, and add the following contents:

// application/models/DbTable/Guestbook.php

/**
* This is the DbTable class for the guestbook table.
*/
class Application_Model_DbTable_Guestbook extends Zend_Db_Table_Abstract
{
/** Table name */
protected $_name = 'guestbook';
}

22
Démarrez rapidement
avec Zend Framework

Note the class prefix: Application_Model_DbTable. The class prefix for our module,
"Application", is the first segment, and then we have the component, "Model_DbTable"; the latter
is mapped to the models/DbTable/ directory of the module.

All that is truly necessary when extending Zend_Db_Table is to provide a table name and
optionally the primary key (if it is not "id").

Now let's create a Data Mapper. A Data Mapper maps a domain object to the database.
In our case, it will map our model, Application_Model_Guestbook, to our data source,
Application_Model_DbTable_Guestbook. A typical API for a data mapper is as follows:

// application/models/GuestbookMapper.php

class Application_Model_GuestbookMapper
{
public function save($model);
public function find($id, $model);
public function fetchAll();
}

In addition to these methods, we'll add methods for setting and retrieving the Table Data
Gateway. The final class, located in application/models/GuestbookMapper.php, looks
like this:

// application/models/GuestbookMapper.php

class Application_Model_GuestbookMapper
{
protected $_dbTable;

public function setDbTable($dbTable)


{
if (is_string($dbTable)) {
$dbTable = new $dbTable();
}
if (!$dbTable instanceof Zend_Db_Table_Abstract) {
throw new Exception('Invalid table data gateway provided');
}
$this->_dbTable = $dbTable;
return $this;
}

public function getDbTable()


{
if (null === $this->_dbTable) {
$this->setDbTable('Application_Model_DbTable_Guestbook');
}
return $this->_dbTable;
}

public function save(Application_Model_Guestbook $guestbook)


{
$data = array(
'email' => $guestbook->getEmail(),
'comment' => $guestbook->getComment(),
'created' => date('Y-m-d H:i:s'),
);

23
Démarrez rapidement
avec Zend Framework

if (null === ($id = $guestbook->getId())) {


unset($data['id']);
$this->getDbTable()->insert($data);
} else {
$this->getDbTable()->update($data, array('id = ?' => $id));
}
}

public function find($id, Application_Model_Guestbook $guestbook)


{
$result = $this->getDbTable()->find($id);
if (0 == count($result)) {
return;
}
$row = $result->current();
$guestbook->setId($row->id)
->setEmail($row->email)
->setComment($row->comment)
->setCreated($row->created);
}

public function fetchAll()


{
$resultSet = $this->getDbTable()->fetchAll();
$entries = array();
foreach ($resultSet as $row) {
$entry = new Application_Model_Guestbook();
$entry->setId($row->id)
->setEmail($row->email)
->setComment($row->comment)
->setCreated($row->created)
->setMapper($this);
$entries[] = $entry;
}
return $entries;
}
}

Now it's time to update our model class slightly, to accomodate the data mapper. Just like the
data mapper contains a reference to the data source, the model contains a reference to the data
mapper. Additionally, we'll make it easy to populate the model by passing an array of data either
to the constructor or a setOptions() method. The final model class, located in application/
models/Guestbook.php, looks like this:

// application/models/Guestbook.php

class Application_Model_Guestbook
{
protected $_comment;
protected $_created;
protected $_email;
protected $_id;
protected $_mapper;

public function __construct(array $options = null)


{
if (is_array($options)) {
$this->setOptions($options);
}

24
Démarrez rapidement
avec Zend Framework

public function __set($name, $value)


{
$method = 'set' . $name;
if (('mapper' == $name) || !method_exists($this, $method)) {
throw new Exception('Invalid guestbook property');
}
$this->$method($value);
}

public function __get($name)


{
$method = 'get' . $name;
if (('mapper' == $name) || !method_exists($this, $method)) {
throw new Exception('Invalid guestbook property');
}
return $this->$method();
}

public function setOptions(array $options)


{
$methods = get_class_methods($this);
foreach ($options as $key => $value) {
$method = 'set' . ucfirst($key);
if (in_array($method, $methods)) {
$this->$method($value);
}
}
return $this;
}

public function setComment($text)


{
$this->_comment = (string) $text;
return $this;
}

public function getComment()


{
return $this->_comment;
}

public function setEmail($email)


{
$this->_email = (string) $email;
return $this;
}

public function getEmail()


{
return $this->_email;
}

public function setCreated($ts)


{
$this->_created = $ts;
return $this;
}

25
Démarrez rapidement
avec Zend Framework

public function getCreated()


{
return $this->_created;
}

public function setId($id)


{
$this->_id = (int) $id;
return $this;
}

public function getId()


{
return $this->_id;
}

public function setMapper($mapper)


{
$this->_mapper = $mapper;
return $this;
}

public function getMapper()


{
if (null === $this->_mapper) {
$this->setMapper(new Application_Model_GuestbookMapper());
}
return $this->_mapper;
}

public function save()


{
$this->getMapper()->save($this);
}

public function find($id)


{
$this->getMapper()->find($id, $this);
return $this;
}

public function fetchAll()


{
return $this->getMapper()->fetchAll();
}
}

Lastly, to connect these elements all together, lets create a guestbook controller that will both
list the entries that are currently inside the database.

To create a new controller, open a terminal or DOS console, navigate to your project directory,
and enter the following:

# Unix-like systems:
% zf.sh create controller guestbook

# DOS/Windows:
C:> zf.bat create controller guestbook

26
Démarrez rapidement
avec Zend Framework

This will create a new controller, GuestbookController, in application/controllers/


GuestbookController.php, with a single action method, indexAction(). It will also create
a view script directory for the controller, application/views/scripts/guestbook/, with
a view script for the index action.

We'll use the "index" action as a landing page to view all guestbook entries.

Now, let's flesh out the basic application logic. On a hit to indexAction(), we'll display all
guestbook entries. This would look like the following:

// application/controllers/GuestbookController.php

class GuestbookController extends Zend_Controller_Action


{
public function indexAction()
{
$guestbook = new Application_Model_Guestbook();
$this->view->entries = $guestbook->fetchAll();
}
}

And, of course, we need a view script to go along with that. Edit application/views/
scripts/guestbook/index.phtml to read as follows:

<!-- application/views/scripts/guestbook/index.phtml -->

<p><a href="<?php echo $this->url(


array(
'controller' => 'guestbook',
'action' => 'sign'
),
'default',
true) ?>">Sign Our Guestbook</a></p>

Guestbook Entries: <br />


<dl>
<?php foreach ($this->entries as $entry): ?>
<dt><?php echo $this->escape($entry->email) ?></dt>
<dd><?php echo $this->escape($entry->comment) ?></dd>
<?php endforeach ?>
</dl>

Checkpoint

Now browse to "http://localhost/guestbook". You should see the following in your


browser:

27
Démarrez rapidement
avec Zend Framework

Using the data loader script


The data loader script introduced in this section (scripts/load.sqlite.php)
can be used to create the database for each environment you have defined, as
well as to load it with sample data. Internally, it utilizes Zend_Console_Getopt,
which allows it to provide a number of command line switches. If you pass the "-
h" or "--help" switch, it will give you the available options:

Usage: load.sqlite.php [ options ]


--withdata|-w Load database with sample data
--env|-e [ ] Application environment for which to create database
(defaults to development)
--help|-h Help -- usage message)]]

The "-e" switch allows you to specify the value to use for the constant
APPLICATION_ENV -- which in turn allows you to create a SQLite database for
each environment you define. Be sure to run the script for the environment you
choose for your application when deploying.

5. Create A Form
For our guestbook to be useful, we need a form for submitting new entries.

Our first order of business is to create the actual form class. First, create the directory
application/forms/. This directory will contain form classes for the application. Next, we'll
create a form class in application/forms/Guestbook.php:

// application/forms/Guestbook.php

class Application_Form_Guestbook extends Zend_Form


{
public function init()
{

28
Démarrez rapidement
avec Zend Framework

// Set the method for the display form to POST


$this->setMethod('post');

// Add an email element


$this->addElement('text', 'email', array(
'label' => 'Your email address:',
'required' => true,
'filters' => array('StringTrim'),
'validators' => array(
'EmailAddress',
)
));

// Add the comment element


$this->addElement('textarea', 'comment', array(
'label' => 'Please Comment:',
'required' => true,
'validators' => array(
array('validator' => 'StringLength', 'options' => array(0, 20))
)
));

// Add a captcha
$this->addElement('captcha', 'captcha', array(
'label' => 'Please enter the 5 letters displayed below:',
'required' => true,
'captcha' => array(
'captcha' => 'Figlet',
'wordLen' => 5,
'timeout' => 300
)
));

// Add the submit button


$this->addElement('submit', 'submit', array(
'ignore' => true,
'label' => 'Sign Guestbook',
));

// And finally add some CSRF protection


$this->addElement('hash', 'csrf', array(
'ignore' => true,
));
}
}

The above form defines five elements: an email address field, a comment field, a CAPTCHA for
preventing spam submissions, a submit button, and a CSRF protection token.

Next, we will add a signAction() to our GuestbookController which will process the form
upon submission. To create the action and related view script, execute the following:

# Unix-like systems:
% zf.sh create action sign guestbook

# DOS/Windows:
C:> zf.bat create action sign guestbook

This will create a signAction() method in our controller, as well as the appropriate view script.

29
Démarrez rapidement
avec Zend Framework

Let's add some logic into our guestbook controller's sign action. We need to first check if we're
getting a POST or a GET request; in the latter case, we'll simply display the form. However, if we
get a POST request, we'll want to validate the posted data against our form, and, if valid, create
a new entry and save it. The logic might look like this:

// application/controllers/GuestbookController.php

class GuestbookController extends Zend_Controller_Action


{
// snipping indexAction()...

public function signAction()


{
$request = $this->getRequest();
$form = new Application_Form_Guestbook();

if ($this->getRequest()->isPost()) {
if ($form->isValid($request->getPost())) {
$model = new Application_Model_Guestbook($form->getValues());
$model->save();
return $this->_helper->redirector('index');
}
}

$this->view->form = $form;
}
}

Of course, we also need to edit the view script; edit application/views/scripts/


guestbook/sign.phtml to read:

<!-- application/views/scripts/guestbook/sign.phtml -->

Please use the form below to sign our guestbook!

<?php
$this->form->setAction($this->url());
echo $this->form;

Better Looking Forms

No one will be waxing poetic about the beauty of this form anytime soon. No
matter - form appearance is fully customizable! See the decorators section in the
reference guide for details.

Additionally, you may be interested in this series of posts on decorators.

Checkpoint

Now browse to "http://localhost/guestbook/sign". You should see the following in


your browser:

30
Démarrez rapidement
avec Zend Framework

6. Congratulations!
You have now built a very simple application using some of the most commonly used Zend
Framework components. Zend Framework makes many components available to you which
address most common requirements in web applications, including web services, search, PDF

31
Démarrez rapidement
avec Zend Framework

reading and writing, authentication, authorization, and much more. The Reference Guide is a
great place to find out more about the components you've used in this QuickStart as well as other
components. We hope you find Zend Framework useful and - more importantly - fun!

32
Chargement automatique avec Zend
Framework
1. Introduction
L'auto-chargement est un mécanisme qui élimine les inclusions de dépendances manuelles au
sein du code PHP. Le manuel sur l'autoload en PHPprécise qu'une fois qu'un autoloader a été
défini, "il est appelé automatiquement dans le cas où l'on tente d'utiliser une classe ou une
interface qui n'a pas encore été définie"

En utilisant l'auto-chargement, vous n'avez pas besoin de vous inquiéter du lieu où la classe
existe au sein du projet. Avec des autoloaders bien définis, la résolution du fichier contenant la
classe utilisée sera effectuée de manière transparente.

Aussi, l'autoloader chargeant la classe uniquement lorsque celle-ci est strictement nécessaire,
ceci peut avoir des effets très positifs sur les performances globales -- particulièrement si vous
prenez soin de supprimer tous les appels à require_once() avant votre déploiement.

Zend Framework encourage l'utilisation de l'auto-chargement et propose différents outils pour


charger le code des librairies comme celui de l'application. Ce tutoriel couvre ces outils et la
manière de les utiliser efficacement.

2. Architecture et buts
2.1. Convention de noms des classes
Pour comprendre l'autochargement dans le Zend Framework, vous devez d'abord comprendre
la relation entre nom de classe et nom de fichier.

Zend Framework a emprunté une idée de PEAR, dans lequel les noms des classes ont une
relation 1:1 avec le système de fichiers. Simplement, le caractère underscore ("_") est remplacé
par un séparateur de dossier pour résoudre le chemin vers le fichier, puis le suffixe ".php"
est ajouté. Par exemple, une classe "Foo_Bar_Baz" va correspondre à "Foo/Bar/Baz.php"
sur le système de fichiers. La supposition est alors que PHP résoudra les fichier relativement
à l'include_path ce qui permet d'utiliser include() et require() pour chercher le fichier
relativement à l'include_path.

Aussi, conformément à PEAR et au PHP project, nous utilisons et vous recommandons d'utiliser
un préfixe à votre code. Cela signifie que toutes les classes que vous écrivez doivent partager un
préfixe unique, par exemple, dans Zend Framework le préfixe est "Zend_". Cette convention de
noms évite toute collision dans les noms des classes. Dans Zend Framework, nous utilisons la
notion "d'espace de noms" ("namespace"); attention à éviter la confusion avec l'implémentation
native des espaces de noms de PHP.

Zend Framework suit ces règles simples en interne et nos standards de code vous encouragent
à faire de même avec le code de vos propres librairies.

2.2. Conventions et architecture d'Autoload


Le support de l'autochargement (autoload) de Zend Framework, implémenté grâce à
Zend_Loader_Autoloader, possède l'architecture et les buts suivants:

33
Chargement automatique
avec Zend Framework

• Correspondance d'espace de noms. Si l'espace de noms de la classe (son préfixe) n'est pas
dans une liste pré-enregistrée, retourner FALSE immédiatement. Ceci permet une optimisation
de la recherche ainsi que l'utilisation d'autres autoloaders ou d'un autoloader global par défaut.

• Permettre un auto-chargement "de secours". Dans le cas où l'on ne peut lister ou


prédéterminer les préfixes de manière claire et sûre, l'autoloader doit pouvoir être configuré
pour charger n'importe quel espace de noms de classes. Notez que ce cas n'est pas
recommandé car il fait intervenir des algorithmes complexes et non optimisés.

• Permettre la non-suppression des erreurs. Nous pensons -- et la plus grande partie de la


communauté PHP aussi -- que la suppression des erreurs est une mauvaise idée. C'est
couteux en ressources et cela masque les problèmes réels de l'application. Ainsi, par défaut,
la suppression des erreurs devrait être désactivée. Cependant, si un développeur insiste pour
l'activer, nous le permettons.

• Autoriser l'utilisation de fonctions d'autoload personnalisées. Certaines personnes ne veulent


pas utiliser Zend_Loader::loadClass() pour l'autoload, mais veulent tout de même
bénéficier des mécanismes du Zend Framework. Zend_Loader_Autoloader permet de
préciser ses propres fonctions d'auto-chargement.

• Permettre la manipulation de la chaine des autoloads de la SPL. Ceci autorise la spécification


d'autoloaders additionnels -- par exemple les chargeurs de ressources pour les classes n'ayant
pas une correspondance 1:1 avec le système de fichiers -- ces autoloaders pouvant être
chargés avant ou après l'autoloader principal de Zend Framework.

3. Utilisation de base de l'autoloader


Maintenant que vous savez les buts et le fonctionnement des autoloaders de Zend Framework,
voyons comment utiliser Zend_Loader_Autoloader.

Dans le cas le plus simple, vous incluez cette classe et l'instanciez. Comme
Zend_Loader_Autoloader est un singleton (car l'autoloader de la SPL est unique), nous
utilisons getInstance() pour en récupérer l'instance.

require_once 'Zend/Loader/Autoloader.php';
Zend_Loader_Autoloader::getInstance();

Par défaut, ceci va permettre de charger des classes dont le préfixe est "Zend_" ou "ZendX_",
si leurs fichiers sont dans votre include_path.

Que se passe-t-il si vous avez d'autres espaces de noms à charger? Le mieux et le plus simple
est alors d'utiliser la méthode registerNamespace() de l'instance. Vous pouvez lui passer
un préfixe simple, ou un tableau de préfixes:

require_once 'Zend/Loader/Autoloader.php';
$loader = Zend_Loader_Autoloader::getInstance();
$loader->registerNamespace('Foo_');
$loader->registerNamespace(array('Foo_', 'Bar_'));

Aussi, vous pouvez indiquer à Zend_Loader_Autoloader d'agire comme autoloader par


défaut ("de secours"). Ceci signifie qu'il essayera de charger toute classe peu importe son
préfixe.

$loader->setFallbackAutoloader(true);

34
Chargement automatique
avec Zend Framework

N'utilisez pas l'autoloader de secours

Ce peut être tentant de se reposer abondamment sur


Zend_Loader_Autoloader comme chargeur de secours, nous ne
recommandons pas une telle pratique.

En interne, Zend_Loader_Autoloader utilise


Zend_Loader::loadClass() pour charger les classes. Cette méthode utilise
include() pour tenter de charger le fichier de la classe. include() retourne
FALSE s'il ne réussi pas -- mais renvoie aussi un warning PHP. Ce dernier point
peut mener à des problèmes:

• Si display_errors est activé, le warning sera inclus dans la sortie (l'affichage).

• Selon le niveau de error_reporting, le warning pourra aussi déclencher


l'écriture dans les journaux d'évènements.

Vous pouvez supprimer les messages d'erreur (la documentation de


Zend_Loader_Autoloader détaille cela), mais notez bien que la suppression
n'est utilisée que lorsque display_errors est activé; le journal des évènements
enregistrera toujours l'erreur. Pour ces raisons, nous vous recommandons de
bien configurer vos espaces de noms avec l'autoloader.

Préfixes d'espaces de nom et espaces de noms PHP

A l'heure de l'écriture de ces lignes, PHP 5.3 est sorti. Avec cette version, PHP
supporte maintenant officiellement les espaces de noms.

Cependant, Zend Framework date d'avant PHP 5.3, et donc les espaces de noms
PHP. Dans Zend Framework, lorsque nous parlons "d'espace de noms", nous
parlons d'une pratique consistant à préfixer le nom de la classe par un préfixe.
Par exemple, toutes les classes de Zend Framework commencent par "Zend_"
-- c'est notre espace de noms.

Zend Framework projette de supporter nativement les espaces de noms PHP


pour l'autoloader dans les versions futures. Il utilisera aussi ce support en interne,
à partir de la version 2.0.0.

Si vous possédez votre propre autoloader et que vous voulez l'utiliser avec Zend Framework
-- peut être un autoloader provenant d'une autre librairie que vous utilisez -- vous pouvez
l'enregistrer grâce aux méthodes de Zend_Loader_Autoloader pushAutoloader() et
unshiftAutoloader(). Ces méthodes ajoutent des autoloaders à la fin ou au début de
la chaine utilisée avant l'exécution des mecanismes internes d'auto-chargement de Zend
Framewor. Cette approche a les avantages suivants:

• Chaque méthode prend un deuxième paramètre : un espace de noms qui indique que
l'autoloader passé ne doit être utilisé que pour charger des classes dans cet espace de noms
là. Si la classe n'est pas dans cet espace de noms, l'autoloader sera alors ignoré, ce qui peut
amener à des optimisations de performance.

• Si vous devez manipuler le registre de spl_autoload(), prenez garde si vous préciser des
fonctions de rappels sous forme de méthodes de classes car spl_autoload_functions()
ne retourne pas exactement leurs définitions. Zend_Loader_Autoloader ne souffre pas de
ce problème.

35
Chargement automatique
avec Zend Framework

Voici une liste de définitions de fonctions de rappel pour auto-chargement valides en PHP.

// Ajoute à la suite de la pile la fonction 'my_autoloader',


// pour charger des classes commençant par 'My_':
$loader->pushAutoloader('my_autoloader', 'My_');

// Ajoute au début de la pile une méthode statique Foo_Loader::autoload(),


// pour charger des classes commençant par 'Foo_':
$loader->unshiftAutoloader(array('Foo_Loader', 'autoload'), 'Foo_');

4. Auto-chargement de resources
En développant des applications, il est souvent difficile de regrouper certaines classes dans
une relation 1:1 avec le système de fichiers que recommande le Zend framework, ou alors
ça ne semble pas intuitif de le faire. Cela signifie que les classes ne seront pas trouvées par
l'autoloader.

Si vous lisez les caractéristiques de l'architecture de l'autoloader, le dernier point de cette


section indique qu'une solution existe pour un tel problème. Zend Framework utilise alors
Zend_Loader_Autoloader_Resource .

Une ressource est juste un nom qui correspond à un espace de noms pour un composant (qui
est ajouté à l'espace de noms de l'autoloader) et un chemin (qui est relatif au chemin de base
de l'autoloader). Sous forme de code, vous feriez quelque chose comme:

$loader = new Zend_Application_Module_Autoloader(array(


'namespace' => 'Blog',
'basePath' => APPLICATION_PATH . '/modules/blog',
));

Une fois le chargeur en place, il faut l'informer des différents types de ressources qu'il va avoir
à gérer. Ces types sont simplement des paires d'arbres et de préfixes.

Considérons ce qui suit comme exemple:

path/to/some/resources/
|-- forms/
| `-- Guestbook.php // Foo_Form_Guestbook
|-- models/
| |-- DbTable/
| | `-- Guestbook.php // Foo_Model_DbTable_Guestbook
| |-- Guestbook.php // Foo_Model_Guestbook
| `-- GuestbookMapper.php // Foo_Model_GuestbookMapper

Le premier reflexe est de créer un chargeur de ressources:

$loader = new Zend_Loader_Autoloader_Resource(array(


'basePath' => 'path/to/some/resources/',
'namespace' => 'Foo',
));

Puis, nous définissons des types de ressources.


Zend_Loader_Autoloader_Resourse::addResourceType() prend trois arguments: le
"type" de resource (une chaine arbitraire), le chemin sous le chemin de base dans lequel le
type de ressource doit se trouver, et le préfixe particulier à utiliser pour ce type de ressource.
Dans l'arbre représenté ci-dessus, il y a trois types : form (dans le sous-dossier "forms", avec un

36
Chargement automatique
avec Zend Framework

préfixe "Form"), model (dans le sous-dossier "models", avec un préfixe "Model"), et dbtable (dans
le sous-dossier "models/DbTable", avec un préfixe "Model_DbTable"). Nous les définirons
comme ceci:

$loader->addResourceType('form', 'forms', 'Form')


->addResourceType('model', 'models', 'Model')
->addResourceType('dbtable', 'models/DbTable', 'Model_DbTable');

Il ne reste plus qu'à utiliser les classes:

$form = new Foo_Form_Guestbook();


$guestbook = new Foo_Model_Guestbook();

Autoload de ressource Module


La couche MVC de Zend Framework encourage l'utilisation de "modules", qui
sont des mini-applications de votre site. Les modules possèdent typiquement
des types de ressource par défaut, et Zend Framework recommande une
hiérarchie de répertoires standard pour les modules. Les autoloaders de
ressources sont particulièrement adaptés à cette situation -- tellement qu'ils sont
activés par défaut lorsque vous créez des classes de bootstrap qui étendent
Zend_Application_Module_Bootstrap. Pour plus d'informations, lisez la
documentation de Zend_Loader_Autoloader_Module.

5. Conclusion
Zend Framework encourage l'utilisation de l'auto-chargement, et l'initialise même par défaut dans
Zend_Application. Nous espérons que ce tutoriel vous a apporté toutes les informations
sur l'utilisation de Zend_Loader_Autoloader, ainsi que sur son extension pour ajouter des
autochargeurs personnalisés.

Pour plus d'informations sur son utilisation, lisez les sections du manuel sur
Zend_Loader_Autoloader et Zend_Loader_Autoloader_Resource.

37
Les plugins dans Zend Framework
1. Introduction
Zend Framework makes heavy use of plugin architectures. Plugins allow for easy extensibility
and customization of the framework while keeping your code separate from Zend Framework's
code.

Typically, plugins in Zend Framework work as follows:

• Plugins are classes. The actual class definition will vary based on the component -- you may
need to extend an abstract class or implement an interface, but the fact remains that the plugin
is itself a class.

• Related plugins will share a common class prefix. For instance, if you have created a number
of view helpers, they might all share the class prefix "Foo_View_Helper_".

• Everything after the common prefix will be considered the plugin name or short name
(versus the "long name", which is the full classname). For example, if the plugin prefix is
"Foo_View_Helper_", and the class name is "Foo_View_Helper_Bar", the plugin name
will be simply "Bar".

• Plugin names are typically case sensitive. The one caveat is that the initial letter can often be
either lower or uppercase; in our previous example, both "bar" and "Bar" would refer to the
same plugin.

Now let's turn to using plugins.

2. Using Plugins
Components that make use of plugins typically use Zend_Loader_PluginLoader to do their
work. This class has you register plugins by specifying one or more "prefix paths". The component
will then call the PluginLoader's load() method, passing the plugin's short name to it. The
PluginLoader will then query each prefix path to see if a class matching that short name exists.
Prefix paths are searched in LIFO (last in, first out) order, so it will match those prefix paths
registered last first -- allowing you to override existing plugins.

Some examples will make all of this more clear.

38
Les plugins dans Zend Framework

Exemple 1. Basic Plugin Example: Adding a single prefix path

In this example, we will assume some validators have been written and placed in the
directory foo/plugins/validators/, and that all these classes share the class prefix
"Foo_Validate_"; these two bits of information form our "prefix path". Furthermore, let's
assume we have two validators, one named "Even" (ensuring a number to be validated is
even), and another named "Dozens" (ensuring the number is a multiple of 12). The tree
might look like this:

foo/
|-- plugins/
| |-- validators/
| | |-- Even.php
| | |-- Dozens.php

Now, we'll inform a Zend_Form_Element instance of this prefix path.


Zend_Form_Element's addPrefixPath() method expects a third argument that
indicates the type of plugin for which the path is being registered; in this case, it's a "validate"
plugin.

$element->addPrefixPath('Foo_Validate', 'foo/plugins/validators/', 'validate');

Now we can simply tell the element the short name of the validators we want to use. In the
following example, we're using a mix of standard validators ("NotEmpty", "Int") and custom
validators ("Even", "Dozens"):

$element->addValidator('NotEmpty')
->addValidator('Int')
->addValidator('Even')
->addValidator('Dozens');

When the element needs to validate, it will then request the plugin class from the
PluginLoader. The first two validators will resolve to Zend_Validate_NotEmpty and
Zend_Validate_Int, respectively; the next two will resolve to Foo_Validate_Even and
Foo_Validate_Dozens, respectively.

What happens if a plugin is not found?

What happens if a plugin is requested, but the PluginLoader is unable to find a


class matching it? For instance, in the above example, if we registered the plugin
"Bar" with the element, what would happen?

The plugin loader will look through each prefix path, checking to see if a file
matching the plugin name is found on that path. If the file is not found, it then
moves on to the next prefix path.

Once the stack of prefix paths has been exhausted, if no matching file has been
found, it will throw a Zend_Loader_PluginLoader_Exception.

39
Les plugins dans Zend Framework

Exemple 2. Intermediate Plugin Usage: Overriding existing plugins

One strength of the PluginLoader is that its use of a LIFO stack allows you to override existing
plugins by creating your own versions locally with a different prefix path, and registering that
prefix path later in the stack.

For example, let's consider Zend_View_Helper_FormButton (view helpers are one form
of plugin). This view helper accepts three arguments, an element name (also used as the
element's DOM identifier), a value (used as the button label), and an optional array of
attributes. The helper then generates HTML markup for a form input element.

Let's say you want the helper to instead generate a true HTML button element; don't want
the helper to generate a DOM identifier, but instead use the value for a CSS class selector;
and that you have no interest in handling arbitrary attributes. You could accomplish this in a
couple of ways. In both cases, you'd create your own view helper class that implements the
behavior you want; the difference is in how you would name and invoke them.

Our first example will be to name the element with a unique name:
Foo_View_Helper_CssButton, which implies the plugin name "CssButton". While this
certainly is a viable approach, it poses several issues: if you've already used the Button
view helper in your code, you now have to refactor; alternately, if another developer starts
writing code for your application, they may inadvertently use the Button view helper instead
of your new view helper.

So, the better example is to use the plugin name "Button", giving us the class name
Foo_View_Helper_Button. We then register the prefix path with the view:

// Zend_View::addHelperPath() utilizes the PluginLoader; however, it inverts


// the arguments, as it provides a default value of "Zend_View_Helper" for the
// plugin prefix.
//
// The below assumes your class is in the directory 'foo/view/helpers/'.
$view->addHelperPath('foo/view/helpers', 'Foo_View_Helper');

Once done, anywhere you now use the "Button" helper will delegate to your custom
Foo_View_Helper_Button class!

3. Conclusion
Understanding the concept of prefix paths and overriding existing plugins will help you with your
understanding of many components within the framework. Plugins are used in a variety of places:

• Zend_Application: resources.

• Zend_Controller_Action: action helpers.

• Zend_Feed_Reader: plugins.

• Zend_Form: elements, filters, validators, and decorators.

• Zend_View: view helpers.

And several more places, besides. Learn the concepts early so you can leverage this important
extension point in Zend Framework.

40
Les plugins dans Zend Framework

Caveat
We'll note here that Zend_Controller_Front has a plugin system - but it does
not adhere to any of the guidelines offerred in this tutorial. The plugins registered
with the front controller must be instantiated directly and registered individually
with it. The reason for this is that this system predates any other plugin system
in the framework, and changes to it must be carefully weighed to ensure existing
plugins written by developers continue to work with it.

41
Bien démarrer avec Zend_Layout
1. Introduction
Dans une application utilisant les couches Zend Framework MVC, vos scripts de vue ne seront
que des blocs de HTML concernant l'action demandée. Par exemple, une action "/user/list"
mènerait vers un script de vue itérant sur les utilisateurs en présentant une liste:

<h2>Utilisateurs</h2>
<ul>
<?php if (!count($this->users)): ?>
<li>Pas d'utilisateurs</li>
<?php else: ?>
<?php foreach ($this->users as $user): ?>
<li>
<?php echo $this->escape($user->fullname) ?>
(<?php echo $this->escape($user->email) ?>)
</li>
<?php endforeach ?>
<?php endif ?>
</ul>

Comme c'est juste un bloc de code HTML, ce n'est pas une page valide, il manque le DOCTYPE
et la balise ouvrante HTML puis BODY. Quand seront-ils crées?

Dans les anciennes versions de Zend Framework, les développeurs créaient souvent des scripts
de vue "header" et "footer" qui servaient à cela. Ca fonctionnait certes, mais c'était difficile à
refactoriser, ou pour appeler du contenu provenant de plusieurs actions.

Le pattern Two-Step View solutionne beaucoup des problèmes indiqués. Avec, la vue
"application" est crée en premier, puis injectée dans une vue "page" ainsi présentée à l'utilisateur
client. la vue de page peut être imaginée comme un template global ou layout qui décrirait des
éléments communs utilisés au travers de multiples pages.

Dans Zend Framework, Zend_Layout implémente le pattern Two-Step View.

2. Utiliser Zend_Layout
L'utilisation classique de Zend_Layout est simple. En supposant que vous utilisez
Zend_Application, il suffit simplement de passer des options de configuration et créer un
script de layout.

2.1. Layout Configuration


L'endroit recommandé pour stocker les layouts est "layouts/scripts/" dans l'application:

application
|-- Bootstrap.php
|-- configs
| `-- application.ini
|-- controllers
|-- layouts
| `-- scripts
| |-- layout.phtml

42
Bien démarrer avec Zend_Layout

Pour initialiser Zend_Layout, ajouter ceci à votre fichier de configuration ("application/


configs/application.ini"):

resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"


resources.layout.layout = "layout"

La première ligne indique où chercher les scripts de layout; la seconde donne le nom du script
à utiliser (l'extension est supposée ".phtml" par défaut).

2.2. Créer un script de layout


Il convient maintenant de créer un script de layout. D'abord, vérifiez l'existance du dossier
"application/layouts/scripts"; puis ouvrez un éditeur et créez une mise en page
balisée. Les scripts de layout sont des scripts de vue, avec quelques différences tout de même.

<html>
<head>
<title>My Site</title>
</head>
<body>
<?php echo $this->layout()->content ?>
</body>
</html>

Dans l'exemple ci-dessus, un appel à l'aide de vue layout() y est effectué. Lorsque vous
activez l'instance de Zend_Layout, vous avez aussi accès à une aide d'acion et de vue qui
permettent d'accéder à l'instance de Zend_Layout; et vous pouvez ainsi appeler des méthodes
sur l'objet layout. Dans notre cas, nous récupérons une variable appelée $content, et nous
l'affichons. Par défaut, $content est peuplée du contenu de la vue rendue pour l'action en
cours. Sinon, tout ce que vous feriez dans un script de vue est valide dans un script de layout:
appel d'aides ou de méthodes sur la vue.

Maintenant, nous avons un script de layout fonctionnel et notre application sait où le trouver.

2.3. Accéder à l'objet Layout


Il est probable que vous ayez besoin d'accéder à l'objet instance layout. Cela est possible de
trois manières:

• Dans des scripts de vue: utilisez l'aide de vue layout(), qui retourne l'instance de
Zend_Layout enregistrée au moyen du plugin MVC.

<?php $layout = $this->layout(); ?>

Comme cela retourne l'objet de layout, vous pouvez appeler dessus toute méthode ou assigner
des variables.

• Dans vos contrôleurs: utilisez ici l'aide d'action layout(), qui agit comme l'aide de vue.

// Appel de l'aide comme méthode sur le gestionnaire d'aides:


$layout = $this->_helper->layout();

// Ou, de manière plus détaillée:


$helper = $this->_helper->getHelper('Layout');
$layout = $helper->getLayoutInstance();

43
Bien démarrer avec Zend_Layout

Comme avec l'aide de vue, vous pouvez appeler dès lors n'importe quelle méthode de layout
ou lui assigner des variables.

• Ailleurs: utilisez la méthode statique getMvcInstance(). Cette méthode retourne l'instance


de layout comme déja vu plus haut maintenant.

$layout = Zend_Layout::getMvcInstance();

• Via le bootstrap: utilisez la ressource layout qui crée, configure et retourne l'objet
Zend_Layout.

$layout = $bootstrap->getResource('Layout');

Partout où vous avez accès à l'objet bootstrap, il s'agit de la méthode recommandée par
rapport à getMvcInstance().

2.4. Autres opérations


Dans la plupart des cas, le script de configuration de layout ci-dessus (avec quelques
modifications) répondra à vos besoins. Cependant, dans certains cas il peut être intéressant
d'utiliser d'autres fonctionnalités. Dans les exemples qui suivent, vous allez utiliser une
desméthodes listées ci-dessus pour récupérer l'objet layout.

• Affecter les variables de layout. Zend_Layout garde en mémoire les variables de vue
spécifiques à la layout, la clé $content en est un exemple. Vous pouvez assigner et récupérer
ces variables grâce à la méthode assign() ou en y accédant comme des attributs classiques.

// Affecter du contenu:
$layout->somekey = "foo"

// Afficher ce même contenu:


echo $layout->somekey; // 'foo'

// Utiliser la méthode assign() :


$layout->assign('someotherkey', 'bar');

// Accéder à la variable reste identique:


echo $layout->someotherkey; // 'bar'

• disableLayout(). Occasionellement, vous pouriez vouloir d"sactiver totalement les


layouts, par exemple, pour répondre à une requête AJAX ou autravers d'une API RESTful.
Dans ces cas, appelez la méthode disableLayout() de l'objet layout.

$layout->disableLayout();

Le contraire de cette méthode, enableLayout(), permet de ré-activer le rendu des layouts


pour l'action en cours.

• Utiliser un autre script de layout: Si vous avez plusieurs scripts de layout pour votre application,
vous pouvez selectionner lequel rendre grâce à la méthode setLayout(). Précisez alors le
nom du script de layout, sans l'extension.

// Utiliser le script de layout "alternate.phtml":


$layout->setLayout('alternate');

44
Bien démarrer avec Zend_Layout

Le script de layout doit se trouver dans le $layoutPath précisé via la configuration (en
bootstrap générallement). Zend_Layout utilisera le nouveau script à rendre.

3. Zend_Layout: Conclusions
Zend_Layout est une simple surcouche à Zend_View en proposant un pattern Two-Step View,
offrant la fléxibilité de créer un design applicatif dans lequel le contenu est injecté.

Si vous regardez de près les exemple, vous sentirez peut-être que les fonctionnalités sont
limitées : comment modifier le titre de la page, injecter un tag script optionnel ou même créer
une sidebar? Ces questions concernent le concept de "Composite View" -- et trouveront réponse
dans le chapitre suivant couvrant des "placeholders."

45
Bien démarrer avec Zend_View
1. Introduction
In the previous chapter, we looked at primarily the Two Step View pattern, which allows you to
embed individual application views within a sitewide layout. At the end of that chapter, however,
we discussed some limitations:

• How do you alter the page title?

• How would you inject conditional scripts or stylesheets into the sitewide layout?

• How would you create and render an optional sidebar? What if there was some content that
was unconditional, and other content that was conditional for the sidebar?

These questions are addressed in the Composite View design pattern. One approach to that
pattern is to provide "hints" or content to the sitewide layout. In Zend Framework, this is achieved
through specialized view helpers called "placeholders." Placeholders allow you to aggregate
content, and then render that aggregate content elsewhere.

2. Basic Placeholder Usage


Zend Framework defines a generic placeholder() view helper that you may use for as many
custom placeholders you need. It also provides a variety of specific placeholder implementations
for often-needed functionality, such as specifying the DocType declaration, document title, and
more.

All placeholders operate in roughly the same way. They are containers, and thus allow you to
operate on them as collections. With them you can:

• Append or prepend items to the collection.

• Replace the entire collection with a single value.

• Specify a string with which to prepend output of the collection when rendering.

• Specify a string with which to append output of the collection when rendering.

• Specify a string with which to separate items of the collection when rendering.

• Capture content into the collection.

• Render the aggregated content.

Typically, you will call the helper with no arguments, which will return a container on which you
may operate. You will then either echo this container to render it, or call methods on it to configure
or populate it. If the container is empty, rendering it will simply return an empty string; otherwise,
the content will be aggregated according to the rules by which you configure it.

As an example, let's create a sidebar that consists of a number of "blocks" of content. You'll likely
know up-front the structure of each block; let's assume for this example that it might look like this:

<div class="sidebar">

46
Bien démarrer avec Zend_View

<div class="block">
<p>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus
consectetur aliquet odio ac consectetur. Nulla quis eleifend
tortor. Pellentesque varius, odio quis bibendum consequat, diam
lectus porttitor quam, et aliquet mauris orci eu augue.
</p>
</div>
<div class="block">
<ul>
<li><a href="/some/target">Link</a></li>
<li><a href="/some/target">Link</a></li>
</ul>
</div>
</div>

The content will vary based on the controller and action, but the structure will be the same. Let's
first setup the sidebar in a resource method of our bootstrap:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
// ...

protected function _initSidebar()


{
$this->bootstrap('View');
$view = $this->getResource('View');

$view->placeholder('sidebar')
// "prefix" -> markup to emit once before all items in collection
->setPrefix("<div class=\"sidebar\">\n <div class=\"block\">\n")
// "separator" -> markup to emit between items in a collection
->setSeparator("</div>\n <div class=\"block\">\n")
// "postfix" -> markup to emit once after all items in a collection
->setPostfix("</div>\n</div>");
}

// ...
}

The above defines a placeholder, "sidebar", that has no items. It configures the basic markup
structure of that placeholder, however, per our requirements.

Now, let's assume for the "user" controller that for all actions we'll want a block at the top
containing some information. We could accomplish this in two ways: (a) we could add the content
to the placeholder directly in the controller's preDispatch() method, or (b) we could render a
view script from within the preDispatch() method. We'll use (b), as it follows a more proper
separation of concerns (leaving view-related logic and functionality within a view script).

We'll name the view script "user/_sidebar.phtml", and populate it as follows:

<?php $this->placeholder('sidebar')->captureStart() ?>


<h4>User Administration</h4>
<ul>
<li><a href="<?php $this->url(array('action' => 'list')) ?>">
List</a></li>
<li><a href="<?php $this->url(array('action' => 'create')) ?>">
Create</a></a></li>

47
Bien démarrer avec Zend_View

</ul>
<?php $this->placeholder('sidebar')->captureEnd() ?>

The above example makes use of the content capturing feature of placeholders. By default,
content is appended as a new item in the container, allowing us to aggregate content. This
example makes use of view helpers and static HTML in order to generate markup, and the content
is then captured and appended into the placeholder itself.

To invoke the above view script, we would write the following in our preDispatch() method:

class UserController extends Zend_Controller_Action


{
// ...

public function preDispatch()


{
// ...

$this->view->render('user/_sidebar.phtml');

// ...
}

// ...
}

Note that we're not capturing the rendered value; there's no need, as the entierty of that view
is being captured into a placeholder.

Now, let's assume our "view" action in that same controller needs to present some information.
Within the "user/view.phtml" view script, we might have the following snippet of content:

$this->placeholder('sidebar')
->append('<p>User: ' . $this->escape($this->username) . '</p>');

This example makes use of the append() method, and passes it some simple markup to
aggregate.

Finally, let's modify our layout view script, and have it render the placeholder.

<html>
<head>
<title>My Site</title>
</head>
<body>
<div class="content">
<?php echo $this->layout()->content ?>
</div>
<?php echo $this->placeholder('sidebar') ?>
</body>
</html>

For controllers and actions that do not populate the "sidebar" placeholder, no content will be
rendered; for those that do, however, echoing the placeholder will render the content according to
the rules we created in our bootstrap, and the content we aggregated throughout the application.
In the case of the "/user/view" action, and assuming a username of "matthew", we would get
content for the sidebar as follows (formatted for readability):

48
Bien démarrer avec Zend_View

<div class="sidebar">
<div class="block">
<h4>User Administration</h4>
<ul>
<li><a href="/user/list">List</a></li>
<li><a href="/user/create">Create</a></a></li>
</ul>
</div>
<div class="block">
<p>User: matthew</p>
</div>
</div>

There are a large number of things you can do by combining placeholders and layout scripts;
experiment with them, and read the relevant manual sections for more information.

3. Standard Placeholders
In the previous section, we learned about the placeholder() view helper, and how it can be
used to aggregate custom content. In this section, we'll look at some of the concrete placeholders
shipped with Zend Framework, and how you can use them to your advantage when creating
complex composite layouts.

Most of the shipped placeholders are for generating content for the <head> section of your layout
content -- an area you typically cannot manipulate directly via your application view scripts, but
one you may want to influence. As examples: you may want your title to contain certain content
on every page, but specific content based on the controller and/or action; you may want to specify
CSS files to load based on what section of the application you're in; you may need specific
JavaScript scripts loaded at different times; or you may want to set the DocType declaration.

Zend Framework ships with placeholder implementations for each of these situations, and
several more.

3.1. Setting the DocType


DocType declarations are troublesome to memorize, and often essential to include in your
document to ensure the browser properly renders your content. The doctype() view helper
allows you to use simple string mnemonics to specify the desired DocType; additionally, other
helpers will query the doctype() helper to ensure the output generated conforms with the
requested DocType.

As an example, if you want to use the XHTML1 Strict DTD, you can simply specify:

$this->doctype('XHTML1_STRICT');

Among the other available mnemonics, you'll find these common types:

XHTML1_STRICT XHTML 1.0 Strict

XHTML1_TRANSITIONAL XHTML 1.0 Transitional

HTML4_STRICT HTML 4.01 Strict

HTML4_Loose HTML 4.01 Loose

HTML5 HTML 5

49
Bien démarrer avec Zend_View

You can assign the type and render the declaration in a single call:

echo $this->doctype('XHTML1_STRICT');

However, the better approach is to assign the type in your bootstrap, and then render it in your
layout. Try adding the following to your bootstrap class:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initDocType()
{
$this->bootstrap('View');
$view = $this->getResource('View');
$view->doctype('XHTML1_STRICT');
}
}

Then, in your layout script, simply echo the helper at the top of the file:

<?php echo $this->doctype() ?>


<html>
<!-- ... -->

This will ensure that your DocType-aware view helpers render the appropriate markup, ensure
that the type is set well before the layout is rendered, and provide a single location to change
the DocType.

3.2. Specifying the Page Title


Often, a site will include the site or business name as part of the page title, and then add additional
information based on the location within the site. As an example, the zend.com website includes
the string "Zend.com" on all pages, and the prepends information based on the page: "Zend
Server - Zend.com". Within Zend Framework, the headTitle() view helper can help simplify
this task.

At its simplest, the headTitle() helper allows you to aggregate content for the <title> tag;
when you echo it, it then assembles it based on the order in which segments are added. You
can control the order using prepend() and append(), and provide a separator to use between
segments using the setSeparator() method.

Typically, you should specify any segments common to all pages in your bootstrap, similar to how
we define the doctype. In this case, we'll define a _initPlaceholders() method for operating
on all the various placeholders, and specify an initial title as well as a separator.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
// ...

protected function _initPlaceholders()


{
$this->bootstrap('View');
$view = $this->getResource('View');
$view->doctype('XHTML1_STRICT');

// Set the initial title and separator:


$view->headTitle('My Site')

50
Bien démarrer avec Zend_View

->setSeparator(' :: ');
}

// ...
}

Within a view script, we might want to add another segment:

<?php $this->headTitle()->append('Some Page'); // place after other segments ?>


<?php $this->headTitle()->prepend('Some Page'); // place before ?>

In our layout, we will simply echo the headTitle() helper:

<?php echo $this->doctype() ?>


<html>
<?php echo $this->headTitle() ?>
<!-- ... -->

This will generate the following output:

<!-- If append() was used: -->


<title>My Site :: Some Page</title>

<!-- If prepend() was used: -->


<title>Some Page :: My Site</title>

3.3. Specifying Stylesheets with HeadLink


Good CSS developers will often create a general stylesheet for sitewide styles, and individual
stylesheets for specific sections or pages of the website, and load these latter conditionally so
as to decrease the amount of data needing to be transferred on each request. The headLink()
placeholder makes such conditional aggregation of stylesheets trivial within your application.

To accomplish this, headLink() defines a number of "virtual" methods (via overloading) to


make the process trivial. The ones we will be concerned with are appendStylesheet() and
prependStylesheet(). Each takes up to four arguments, $href (the relative path to the
stylesheet), $media (the MIME type, which defaults to "text/css"), $conditionalStylesheet
(which can be used to specify a "condition" under which the stylesheet will be evaluated), and
$extras (an associative array of key and value pairs, commonly used to specify a key for
"media"). In most cases, you will only need to specify the first argument, the relative path to the
stylesheet.

In our example, we'll assume that all pages need to load the stylesheet located in "/styles/
site.css" (relative to the document root); we'll specify this in our _initPlaceholders()
bootstrap method.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
// ...

protected function _initPlaceholders()


{
$this->bootstrap('View');
$view = $this->getResource('View');
$view->doctype('XHTML1_STRICT');

51
Bien démarrer avec Zend_View

// Set the initial title and separator:


$view->headTitle('My Site')
->setSeparator(' :: ');

// Set the initial stylesheet:


$view->headLink()->prependStylesheet('/styles/site.css');
}

// ...
}

Later, in a controller or action-specific view script, we can add more stylesheets:

<?php $this->headLink()->appendStylesheet('/styles/user-list.css') ?>

Within our layout view script, once again, we simply echo the placeholder:

<?php echo $this->doctype() ?>


<html>
<?php echo $this->headTitle() ?>
<?php echo $this->headLink() ?>
<!-- ... -->

This will generate the following output:

<link rel="stylesheet" type="text/css" href="/styles/site.css" />


<link rel="stylesheet" type="text/css" href="/styles/user-list.css" />

3.4. Aggregating Scripts Using HeadScript


Another common tactic to prevent long page load times is to only load JavaScript when
necessary. That said, you may need several layers of scripts: perhaps one for progressively
enhancing menus on the site, and another for page-specific content. In these situations, the
headScript() helper presents a solution.

Similar to the headLink() helper, headScript() provides the ability to append or prepend
scripts to the collection, and then echo the entire set. It provides the flexibility to specify
either script files themselves to load, or explicit JavaScript. You also have the option of
capturing JavaScript via captureStart()/captureEnd(), which allows you to simply inline
the JavaScript instead of requiring an additional call to your server.

Also like headLink(), headScript() provides "virtual" methods via overloading as a


convenience when specifying items to aggregate; common methods include prependFile(),
appendFile(), prependScript(), and appendScript(). The first two allow you to specify
files that will be referenced in a <script> tag's $src attribute; the latter two will take the content
provided and render it as literal JavaScript within a <script> tag.

In this example, we'll specify that a script, "/js/site.js" needs to be loaded on every page;
we'll update our _initPlaceholders() bootstrap method to do this.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
// ...

protected function _initPlaceholders()


{

52
Bien démarrer avec Zend_View

$this->bootstrap('View');
$view = $this->getResource('View');
$view->doctype('XHTML1_STRICT');

// Set the initial title and separator:


$view->headTitle('My Site')
->setSeparator(' :: ');

// Set the initial stylesheet:


$view->headLink()->prependStylesheet('/styles/site.css');

// Set the initial JS to load:


$view->headScript()->prependFile('/js/site.js');
}

// ...
}

Within a view script, we might then add an extra script file to source, or capture some JavaScript
to include in our document.

<?php $this->headScript()->appendFile('/js/user-list.js') ?>


<?php $this->headScript()->captureStart() ?>
site = {
baseUrl: "<?php echo $this->baseUrl() ?>"
};
<?php $this->headScript()->captureEnd() ?>

Within our layout script, we then simply echo the placeholder, just as we have all the others:

<?php echo $this->doctype() ?>


<html>
<?php echo $this->headTitle() ?>
<?php echo $this->headLink() ?>
<?php echo $this->headScript() ?>
<!-- ... -->

This will generate the following output:

<script type="text/javascript" src="/js/site.js"></script>


<script type="text/javascript" src="/js/user-list.js"></script>
<script type="text/javascript">
site = {
baseUrl: "<?php echo $this->baseUrl() ?>"
};
</script>

InlineScript Variant
Many browsers will often block display of a page until all scripts and stylesheets
referenced in the <head> section have loaded. If you have a number of such
directives, this can impact how soon somebody can start actually viewing the
page.

One way around this is to emit your <script> tags just prior to closing the
<body> of your document. (This is a practice specifically recommend by the Y!
Slow project.)

53
Bien démarrer avec Zend_View

Zend Framework supports this in two different ways:

• You can render your headScript() tag whereever you like in your layout
script; just because the title references "head" does not mean it needs to be
rendered in that location.

• Alternately, you may use the inlineScript() helper, which is simply a


variant on headScript(), and retains the same behavior, but uses a separate
registry.

4. View Placeholders: Conclusion


View placeholders are a simple and powerful method for creating rich layouts for your application.
You can use a variety of standard placeholders, such as those discussed (doctype(),
headTitle(), headLink(), and headScript()), or use the generic placeholder()
helper to aggregate content and render it in custom ways. Experiment with their exposed
functionality, and visit the appropriate sections in the reference guide to find out about the
additional features they offer -- and how you may leverage those features to create rich content
for your readers.

54
Bien comprendre et utiliser les
décorateurs Zend Form
1. Introduction
Zend_Form utilise le pattern décorateur afin de générer le rendu des éléments. Contrairement au
pattern classique du décorateur, dans lequel se sont des objets qui sont passés, les décorateur
de Zend_Form implémentent un pattern strategy , et utilisent les méta-données contenues dans
l'élément ou le formulaire afin de créer une représentation de celles-ci.

Ne vous laissez pas surprendre par ces termes, les décorateurs de Zend_Form ne sont pas
terriblement difficiles et les mini-tutoriels qui suivent vont vous le prouver. Ils vont vous guider
pour les bases et les techniques avancées de décoration.

2. Les bases des décorateurs


2.1. Aperçu du pattern décorateur
Pour commencer, nous allons voir un epu de théorie sur le pattern décorateur . Une
technique consiste à définir une interface commune que les objets originaux et les décorateurs
implémentent; les décorateurs ayant comme dépendance les objets originaux, ils vont alors
pouvoir redéfinir ou proxier les appels à leurs méthodes. Voyons un peu de code afin de mieux
comprendre:

interface Window
{
public function isOpen();
public function open();
public function close();
}

class StandardWindow implements Window


{
protected $_open = false;

public function isOpen()


{
return $this->_open;
}

public function open()


{
if (!$this->_open) {
$this->_open = true;
}
}

public function close()


{
if ($this->_open) {
$this->_open = false;
}

55
Bien comprendre et utiliser
les décorateurs Zend Form

}
}

class LockedWindow implements Window


{
protected $_window;

public function __construct(Window $window)


{
$this->_window = $window;
$this->_window->close();
}

public function isOpen()


{
return false;
}

public function open()


{
throw new Exception('Cannot open locked windows');
}

public function close()


{
$this->_window->close();
}
}

Nous créons un objet de type StandardWindow, le passons au constructeur de


LockedWindow, et le comportement de notre fenêtre a maintenant changé. Le point fort ici est
que nous n'avons pas besoin d'implémenter une fonctionnalité de verrou ("lock") dans l'objet de
base (StandardWindow) -- le décorateur s'occupe de cela. En plus, vous pouvez utiliser votre
fenêtre décorée à la place de la fenêtre standard : elles implémentent la même interface.

Une utilisation particulièrement pratique du pattern décorateur est pour tout ce qui concerne
la représentation des objets. Par exemple un objet "Personne" qui en lui-même n'a aucune
représentation textuelle. Grâce au pattern décorateur, vous pouvez créer un objet qui va agir
comme une Personne mais qui pourra aussi représenter textuellement cette Personne.

Dans cet exemple particulier, nous allons utiliser leduck typing plutôt qu'une interface explicite.
Ceci permet à notre implémentation d'être un peu plus fléxible tout en gardant l'utilisation de la
décoration intacte.

class Person
{
public function setFirstName($name) {}
public function getFirstName() {}
public function setLastName($name) {}
public function getLastName() {}
public function setTitle($title) {}
public function getTitle() {}
}

class TextPerson
{
protected $_person;

56
Bien comprendre et utiliser
les décorateurs Zend Form

public function __construct(Person $person)


{
$this->_person = $person;
}

public function __call($method, $args)


{
if (!method_exists($this->_person, $method)) {
throw new Exception('Invalid method called on HtmlPerson: '
. $method);
}
return call_user_func_array(array($this->_person, $method), $args);
}

public function __toString()


{
return $this->_person->getTitle() . ' '
. $this->_person->getFirstName() . ' '
. $this->_person->getLastName();
}
}

Dans cet exemple, nous passons une instance Person au constructeur de TextPerson. Grâce
à la surcharge des méthodes, nous pouvons continuer d'appeler les méthodes de Person --
affecter un nom, un prénom, ... -- mais nous pouvons en plus récupérer une représentation sous
forme de chaine grâce à __toString().

Cet exemple est proche du fonctionnement interne des décorateurs de Zend_Form. La


différence est qu'au lieu que le décorateur n'encapsule l'objet initial, c'est l'objet élément qui
possède en lui un ou plusieurs decorateurs à qui il passe lui-même pour effectuer le rendu visuel.
Les décorateurs peuvent ainsi accéder à l'élément et en créer une représentation.

2.2. Créer votre premier décorateur


Les décorateurs de Zend_Form implémentent tous, Zend_Form_Decorator_Interface.
Cette interface permet de régler les options du décorateur, enregistrer en lui l'élément ainsi
qu'effectuer le rendu. YUne classe de base, Zend_Form_Decorator_Abstract, propose une
implémentation de cette logique de base dont vous aurez besoin, à l'exception du rendu que
vous devrez définir.

Imaginons une situation dans laquelle nous souhaitons simplement rendre un élément comme
un tag html text avec un libéllé(label). Juste la base, nous verrons plus tard la gestion des erreurs
et les éventuels autres tags html. Un tel décorateur pourrait ressembler à ça:

class My_Decorator_SimpleInput extends Zend_Form_Decorator_Abstract


{
protected $_format = '<label for="%s">%s</label>'
. '<input id="%s" name="%s" type="text" value="%s"/>';

public function render($content)


{
$element = $this->getElement();
$name = htmlentities($element->getFullyQualifiedName());
$label = htmlentities($element->getLabel());
$id = htmlentities($element->getId());
$value = htmlentities($element->getValue());

$markup = sprintf($this->_format, $name, $label, $id, $name, $value);

57
Bien comprendre et utiliser
les décorateurs Zend Form

return $markup;
}
}

Créons un élément qui utilise ce décorateur:

$decorator = new My_Decorator_SimpleInput();


$element = new Zend_Form_Element('foo', array(
'label' => 'Foo',
'belongsTo' => 'bar',
'value' => 'test',
'decorators' => array($decorator),
));

Le visuel de cet élément donne:

<label for="bar[foo]">Foo</label>
<input id="bar-foo" name="bar[foo]" type="text" value="test"/>

Nous pourrions aussi ranger cette classe dans un dossier de librairie, il faut alors informer
l'élément du chemin vers ce dossier, et ensuite faire référence au décorateur comme
"SimpleInput":

$element = new Zend_Form_Element('foo', array(


'label' => 'Foo',
'belongsTo' => 'bar',
'value' => 'test',
'prefixPath' => array('decorator' => array(
'My_Decorator' => 'path/to/decorators/',
)),
'decorators' => array('SimpleInput'),
));

Ceci permet de partager du code entre projets et ouvre aussi la possibilité d'étendre dans le
futur les classes rangées.

Dans le chapitre suivant, nous allons voir comment combiner les décorateurs afin de créer un
affichage par morceaux (composite).

3. Chainer les décorateurs


Si vous avez bien suivi la section précédente, vous avez pu remarquer que la méthode
render() prend un argument, $content. Il est de type chaine de caractères. render() va
utiliser cette chaine et décider de la remplacer, de rajouter ou de faire précéder du contenu à
celle-ci. Ceci permet de chaine les décorateurs -- ce qui ouvre des possibilités de créer ses
propres décorateurs qui vont rendre une petite partie des données d'un élément chacun -- c'est
la chaine complet de décorateurs qui déterminera le rendu final réel de l'élément.

Voyons voir en pratique comment ça fonctionne.

Pour la plupart des éléments, les décorateurs suiovants sont chargés par défaut:

• ViewHelper: utilise une aide de vue pour rendre l'élément balise de formulaire à proprement
parlé.

• Errors: utilise l'aide de vue FormErrors pour afficher les erreurs de validation éventuelles.

58
Bien comprendre et utiliser
les décorateurs Zend Form

• Description: utilise l'aide de vue FormNote afin de rendre la description éventuelle de


l'élément.

• HtmlTag: encapsule les trois objets ci-dessus dans un tag <dd>.

• Label: rend l'intitulé de l'élément en utilisant l'aide de vue FormLabel (et en encapsulant le
tout dans un tag <dt>).

Notez bien que chaque décorateur na qu'une petite tâche particulière et opère sur une partie
spécifique des données de l'élément auquel il est rattaché, le décorateur Errors récupère les
messages de validation de l'élément et les rend, le décorateur Label rend simplement le libéllé.
Ceci fait que chaque décorateur est très petit, réutilisable, et surtout testable.

Cet argument $content vient de là aussi : chaque décorateur travaille avec sa méthode
render() sur un contenu (générallement généré par le décorateur immédiatement précédent
dans la pile globale) et embellit ce contenu en lui rajoutant ou en lui faisant précéder des
informations. Il peut aussi remplacer totallement son contenu.

Ainsi, pensez au mécanisme des décorateurs comme la conception d'un oignon de l'intérieur
vers l'exterieur.

Voyons voir un exemple, le même que celuide la section précédente:

class My_Decorator_SimpleInput extends Zend_Form_Decorator_Abstract


{
protected $_format = '<label for="%s">%s</label>'
. '<input id="%s" name="%s" type="text" value="%s"/>';

public function render($content)


{
$element = $this->getElement();
$name = htmlentities($element->getFullyQualifiedName());
$label = htmlentities($element->getLabel());
$id = htmlentities($element->getId());
$value = htmlentities($element->getValue());

$markup = sprintf($this->_format, $id, $label, $id, $name, $value);


return $markup;
}
}

Supprimons la fonctionnalité libéllé (label) et créons un décorateur spécifique pour lui.

class My_Decorator_SimpleInput extends Zend_Form_Decorator_Abstract


{
protected $_format = '<input id="%s" name="%s" type="text" value="%s"/>';

public function render($content)


{
$element = $this->getElement();
$name = htmlentities($element->getFullyQualifiedName());
$id = htmlentities($element->getId());
$value = htmlentities($element->getValue());

$markup = sprintf($this->_format, $id, $name, $value);


return $markup;
}
}

59
Bien comprendre et utiliser
les décorateurs Zend Form

class My_Decorator_SimpleLabel extends Zend_Form_Decorator_Abstract


{
protected $_format = '<label for="%s">%s</label>';

public function render($content)


{
$element = $this->getElement();
$id = htmlentities($element->getId());
$label = htmlentities($element->getLabel());

$markup = sprint($this->_format, $id, $label);


return $markup;
}
}

Ok, ca semble bon mais il y a un problème : le dernier décorateur va l'emporter. Vous allez vous
retrouver avec comme seul rendu, celui du dernier décorateur.

Pour faire fonctionner le tout comme il se doit, concaténez simplement le contenu précédent
$content avec le contenu généré:

return $content . $markup;

Le problème avec cette approche est que vous ne pouvez pas choisir où se place
le contenu du décorateur en question. Heureusement, un mécanisme standard existe;
Zend_Form_Decorator_Abstract possède le concept de place et définit des constantes
pour le régler. Aussi, il permet de préciser un séparateur à placer entre les 2. Voyons celà:

class My_Decorator_SimpleInput extends Zend_Form_Decorator_Abstract


{
protected $_format = '<input id="%s" name="%s" type="text" value="%s"/>';

public function render($content)


{
$element = $this->getElement();
$name = htmlentities($element->getFullyQualifiedName());
$id = htmlentities($element->getId());
$value = htmlentities($element->getValue());

$markup = sprintf($this->_format, $id, $name, $value);

$placement = $this->getPlacement();
$separator = $this->getSeparator();
switch ($placement) {
case self::PREPEND:
return $markup . $separator . $content;
case self::APPEND:
default:
return $content . $separator . $markup;
}
}
}

class My_Decorator_SimpleLabel extends Zend_Form_Decorator_Abstract


{
protected $_format = '<label for="%s">%s</label>';

60
Bien comprendre et utiliser
les décorateurs Zend Form

public function render($content)


{
$element = $this->getElement();
$id = htmlentities($element->getId());
$label = htmlentities($element->getLabel());

$markup = sprintf($this->_format, $id, $label);

$placement = $this->getPlacement();
$separator = $this->getSeparator();
switch ($placement) {
case self::APPEND:
return $markup . $separator . $content;
case self::PREPEND:
default:
return $content . $separator . $markup;
}
}
}

Notez que dans l'exemple ci-dessus, nous intervertissons les comportements par défaut avec
append et prepend.

Créons dès lors un élément de formulaire qui va utiliser tout celà:

$element = new Zend_Form_Element('foo', array(


'label' => 'Foo',
'belongsTo' => 'bar',
'value' => 'test',
'prefixPath' => array('decorator' => array(
'My_Decorator' => 'path/to/decorators/',
)),
'decorators' => array(
'SimpleInput',
'SimpleLabel',
),
));

Comment ça fonctionne? et bien nous appelons render(), l'élément va alors commencer une
itération sur tous ses décorateurs, en appelant render() sur chacun. Il va passer une chaine
vide comme contenu pour le premier décorateur, et le rendu de chaque décorateur va servir de
contenu pour le suivant, ainsi de suite:

• Contenu initial : chaine vide: ''.

• chaine vide ('') est passée au décorateur SimpleInput, qui génère un tag de formulaire
de type input qu'il ajoute à la chaine vide: <input id="bar-foo" name="bar[foo]" type="text"
value="test"/>.

• Ce contenu généré est alors passé comme contenu original pour le décorateur SimpleLabel
qui génère un libéllé et le place avant le contenu original avec comme séparateur PHP_EOL, ce
qui donne: <label for="bar-foo">\n<input id="bar-foo" name="bar[foo]" type="text" value="test"/
>.

Mais attendez une minute! Et si nous voulions que le libéllé soit rendu après le tag de formulaire
pour une raison quelconque? Vous souvenez-vous de l'option "placement"? Vous pouvez la
préciser comme option de décorateur, et le plus simple est alors de la passer à la création de
l'élément:

61
Bien comprendre et utiliser
les décorateurs Zend Form

$element = new Zend_Form_Element('foo', array(


'label' => 'Foo',
'belongsTo' => 'bar',
'value' => 'test',
'prefixPath' => array('decorator' => array(
'My_Decorator' => 'path/to/decorators/',
)),
'decorators' => array(
'SimpleInput'
array('SimpleLabel', array('placement' => 'append')),
),
));

Notez que passer des options vous oblige à préciser le nom du décorateur dans un tableau en
tant que premier élément, le deuxième élément est un tableau d'options.

Le code ci-dessus propose un rendu : <input id="bar-foo" name="bar[foo]" type="text"


value="test"/>\n<label for="bar-foo">.

Grâce à cette technique, vous pouvez avoir plusieurs décorateurs dont chacun s'occupe de
rendre une petite partie d'un élément; et c'est en utilisant plusieurs décorateurs et en les chainant
correctement que vous obtiendrez un rendu complet : l'oignon final.

Avantages et inconvénients d'une telle technique, commençons par les inconvénients:

• C'est plus complexe qu'un rendu simple. Vous devez faire attention à chaque décorateur mais
en plus à l'ordre dans lequel ils agissent.

• Ca consomme plus de ressources. Plus de décorateurs, plus d'objets, multipliés par le nombre
d'éléments dans un formulaire et la consommation en ressources augmente. La mise en cache
peut aider.

Les avantages sont:

• Réutilisabilité. Vous pouvez créer des décorateurs complètement réutilisables car vous ne
vous souciez pas du rendu final, mais de chaque petit bout de rendu.

• Fléxibilité. Il est en théorie possible d'arriver au rendu final voulu très exactement, et ceci avec
une petite poignée de décorateurs.

Les exemples ci-dessus montrent l'utilisation de décorateurs au sein même d'un objet
Zend_Form et nous avons vu comment les décorateurs jouent les uns avec les autres pour
arriver au rendu final. Afin de pouvoir les utiliser de manière indépendante, la version 1.7 a
ajouté des méthodes fléxibles rendant les formulaires ressemblant au style Rail. Nous allons
nous pencher sur ce fait dans la section suivante.

4. Rendu individuel des décorateurs


Dans la section précédente, nous avons vu comment combiner les décorateurs afin de créer
un rendu complexe. Ceci est très fléxible mais rajoute tout de même un part de compléxité à
l'ensemble. Dans ce chapitre, nous allons inspecter le rendu individuel des décorateurs afin de
créer du contenu visuel pour des formulaires ou des éléments.

Une fois des décorateurs enregistrés, vous pouvez les récupérer via leur nom depuis l'élément.
Revoyons l'exemple précédent:

$element = new Zend_Form_Element('foo', array(

62
Bien comprendre et utiliser
les décorateurs Zend Form

'label' => 'Foo',


'belongsTo' => 'bar',
'value' => 'test',
'prefixPath' => array('decorator' => array(
'My_Decorator' => 'path/to/decorators/',
)),
'decorators' => array(
'SimpleInput'
array('SimpleLabel', array('placement' => 'append')),
),
));

Si nous voulons récupérer le décorateur SimpleInput, nous passons par la méthode


getDecorator():

$decorator = $element->getDecorator('SimpleInput');
echo $decorator->render('');

C'est simple et ça peut l'être encore plus; ré-écrivons le tout sur une seule ligne:

echo $element->getDecorator('SimpleInput')->render('');

Pas mauvais, mais toujours un peu compliqué. Pour simplifier, une notation raccourcie a été
introduite dans Zend_Form en 1.7: vous pouvez rendre n'importe quel décorateur enregistré en
appelant une méthode de la forme renderDecoratorName(). Ceci effectue le rendu et fait en
sorte que $content soit optionnel ce qui simplifie l'utilisation:

echo $element->renderSimpleInput();

C'est une simplification astucieuse, mais comment et pourquoi l'utiliser?

Beaucoup de développeurs ont des besoins très précis en affichage des formulaires. Ils préfèrent
avoir un contrôle complet sur tout l'affichage plutôt que d'utiliser une solution automatisée
qui peut s'écarter de leur but initial. Dans d'autres cas, les formulaires peuvent demander un
affichage extrêmement spécifique, en groupant des éléments alors que d'autres doivent pouvoir
être invisibles avant que l'on n'effectue telle action sur la page, etc.

Utilisons la possibilité de rendre un seul décorateur pour créer un affichage précis.

D'abord, définissons un formulaire. Celui-ci récupèrera des détails démographiques sur


l'utilisateur. Le rendu sera hautement personnalisé et dans certains cas il utilisera les aides de
vue directement plutôt que les éléments. Voici une définition simple du formulaire:

class My_Form_UserDemographics extends Zend_Form


{
public function init()
{
// Ajoute un chemin pour les décorateurs personnalisés
$this->addElementPrefixPaths(array(
'decorator' => array('My_Decorator' => 'My/Decorator'),
));

$this->addElement('text', 'firstName', array(


'label' => 'First name: ',
));
$this->addElement('text', 'lastName', array(
'label' => 'Last name: ',

63
Bien comprendre et utiliser
les décorateurs Zend Form

));
$this->addElement('text', 'title', array(
'label' => 'Title: ',
));
$this->addElement('text', 'dateOfBirth', array(
'label' => 'Date of Birth (DD/MM/YYYY): ',
));
$this->addElement('text', 'email', array(
'label' => 'Your email address: ',
));
$this->addElement('password', 'password', array(
'label' => 'Password: ',
));
$this->addElement('password', 'passwordConfirmation', array(
'label' => 'Confirm Password: ',
));
}
}

Nous n'utilisons pas de validateurs ou de filtres ici, car ils n'ont rien à voir avec
le rendu visuel qui nous interesse. En réalité, il y en aurait.

Maintenant réfléchissons au rendu visuel du formulaire. Une communalité concernant les nom
et prénom est qu'on les affiche l'un à coté de l'autre, à coté de leur titre, si présent. Les dates,
si elles n'utilisent pas Javascript, affichent souvent des champs séparés pour chaque segment
de la date.

Utilisons la possibilité de rendre des décorateurs un par un pour accomplir notre tâche. D'abord,
notez qu'aucun décorateur spécifique n'a été renseigné dans les éléments. Rappelons donc les
décorateurs par défaut de la plupart des éléments:

• ViewHelper: utilise une aide de vue pour rendre l'élément balise de formulaire à proprement
parlé.

• Errors: utilise l'aide de vue FormErrors pour afficher les erreurs de validation éventuelles.

• Description: utilise l'aide de vue FormNote afin de rendre la description éventuelle de


l'élément.

• HtmlTag: encapsule les trois objets ci-dessus dans un tag <dd>.

• Label: rend l'intitulé de l'élément en utilisant l'aide de vue FormLabel (et en encapsulant le
tout dans un tag <dt>).

Nous vous rappelons aussi que vous pouvez accéder à tout élément individuellement en tant
qu'attribut du formulaire représentant son nom.

Notre script de vue ressemblerait à cela:

<?php
$form = $this->form;
// Enlève le <dt> depuis l'intitulé
foreach ($form->getElements() as $element) {
$element->getDecorator('label')->setOption('tag', null);
}
?>

64
Bien comprendre et utiliser
les décorateurs Zend Form

<form method="<?php echo $form->getMethod() ?>" action="<?php echo


$form->getAction()?>">
<div class="element">
<?php echo $form->title->renderLabel()
. $form->title->renderViewHelper() ?>
<?php echo $form->firstName->renderLabel()
. $form->firstName->renderViewHelper() ?>
<?php echo $form->lastName->renderLabel()
. $form->lastName->renderViewHelper() ?>
</div>
<div class="element">
<?php echo $form->dateOfBirth->renderLabel() ?>
<?php echo $this->formText('dateOfBirth[day]', '', array(
'size' => 2, 'maxlength' => 2)) ?>
/
<?php echo $this->formText('dateOfBirth[month]', '', array(
'size' => 2, 'maxlength' => 2)) ?>
/
<?php echo $this->formText('dateOfBirth[year]', '', array(
'size' => 4, 'maxlength' => 4)) ?>
</div>
<div class="element">
<?php echo $form->password->renderLabel()
. $form->password->renderViewHelper() ?>
</div>
<div class="element">
<?php echo $form->passwordConfirmation->renderLabel()
. $form->passwordConfirmation->renderViewHelper() ?>
</div>
<?php echo $this->formSubmit('submit', 'Save') ?>
</form>

Si vous utilisez le script ci-dessus, vous verrez un code HTML ressemblant à ceci:

<form method="post" action="">


<div class="element">
<label for="title" tag="" class="optional">Title:</label>
<input type="text" name="title" id="title" value=""/>

<label for="firstName" tag="" class="optional">First name:</label>


<input type="text" name="firstName" id="firstName" value=""/>

<label for="lastName" tag="" class="optional">Last name:</label>


<input type="text" name="lastName" id="lastName" value=""/>
</div>

<div class="element">
<label for="dateOfBirth" tag="" class="optional">Date of Birth
(DD/MM/YYYY):</label>
<input type="text" name="dateOfBirth[day]" id="dateOfBirth-day"
value="" size="2" maxlength="2"/>
/
<input type="text" name="dateOfBirth[month]" id="dateOfBirth-month"
value="" size="2" maxlength="2"/>
/
<input type="text" name="dateOfBirth[year]" id="dateOfBirth-year"
value="" size="4" maxlength="4"/>
</div>

65
Bien comprendre et utiliser
les décorateurs Zend Form

<div class="element">
<label for="password" tag="" class="optional">Password:</label>
<input type="password" name="password" id="password" value=""/>
</div>

<div class="element">
<label for="passwordConfirmation" tag="" class="" id="submit"
value="Save"/>
</form>

Ca peut ne pas ressembler à quelque chose de terminé, mais avec un peu de CSS, cela
peut ressembler exactement à ce que vous cherchez. Le point important ici, c'est que le
formulaire a été généré en utilisant de la décoration manuelle personnalisée (ainsi que l'utilisation
d'échappement avec htmlentities).

Grâce à cette partie du tutoriel, vous devriez être à l'aise avec les possibilité de rendu de
Zend_Form. Dans la section suivante, nous verrons comment monter un élément de date grâce
à des éléments et des décorateur uniques assemblés main.

5. Créer et rendre des éléments composites


Dans la dernière section, nous avions un exemple traitant un élément "date de naissance":

<div class="element">
<?php echo $form->dateOfBirth->renderLabel() ?>
<?php echo $this->formText('dateOfBirth[day]', '', array(
'size' => 2, 'maxlength' => 2)) ?>
/
<?php echo $this->formText('dateOfBirth[month]', '', array(
'size' => 2, 'maxlength' => 2)) ?>
/
<?php echo $this->formText('dateOfBirth[year]', '', array(
'size' => 4, 'maxlength' => 4)) ?>
</div>

Comment représenteriez-vous cet élément en tant que Zend_Form_Element? Comment écrire


un décorateur qui s'assure de son rendu ?

5.1. L'élément
Les questions à se poser sur le fonctionnement de l'élément sont:

• Comment affecter et récupérer une valeur?

• Comment valider la valeur?

• Comment proposer l'affectation personnalisée d'une valeur composées de trois segments


(jour, mois, année)?

Les deux première questions se positionnent sur l'élément de formulaire lui-même, comment
vont fonctionner les méthodes setValue() et getValue()? L'autre question nous suggère
de nous questionner sur comment récupérer les segments représentant la date, ou comment
les affecter dans l'élément?

La solution est de surcharger la méthode setValue() dans l'élément pour proposer sa propre
logique. Dans le cas de notre exemple, notre élément devrait avoir trois comportements distincts:

66
Bien comprendre et utiliser
les décorateurs Zend Form

• Si un timestamp entier est utilisé, il doit aider à la détermination des entités jour, mois, année.

• Si une chaine est utilisée, elle devrait être transformée en timestamp, et cette valeur sera
utiliser pour déterminer les entités jour, mois, année.

• Si un tableau contenant les clés jour, mois, année est utilisé, alors les valeurs doivent être
stockées.

En interne, les jour, mois et année seront stockés distinctement. Lorsque la valeur de l'élément
sera demandée, nous récupèrerons une chaine formatée et normalisée. Nous surchargerons
getValue() pour assembler les segments élémentaires composant la date.

Voici à quoi ressemblerait la classe:

class My_Form_Element_Date extends Zend_Form_Element_Xhtml


{
protected $_dateFormat = '%year%-%month%-%day%';
protected $_day;
protected $_month;
protected $_year;

public function setDay($value)


{
$this->_day = (int) $value;
return $this;
}

public function getDay()


{
return $this->_day;
}

public function setMonth($value)


{
$this->_month = (int) $value;
return $this;
}

public function getMonth()


{
return $this->_month;
}

public function setYear($value)


{
$this->_year = (int) $value;
return $this;
}

public function getYear()


{
return $this->_year;
}

public function setValue($value)


{
if (is_int($value)) {
$this->setDay(date('d', $value))
->setMonth(date('m', $value))

67
Bien comprendre et utiliser
les décorateurs Zend Form

->setYear(date('Y', $value));
} elseif (is_string($value)) {
$date = strtotime($value);
$this->setDay(date('d', $date))
->setMonth(date('m', $date))
->setYear(date('Y', $date));
} elseif (is_array($value)
&& (isset($value['day'])
&& isset($value['month'])
&& isset($value['year'])
)
) {
$this->setDay($value['day'])
->setMonth($value['month'])
->setYear($value['year']);
} else {
throw new Exception('Valeur de date invalide');
}

return $this;
}

public function getValue()


{
return str_replace(
array('%year%', '%month%', '%day%'),
array($this->getYear(), $this->getMonth(), $this->getDay()),
$this->_dateFormat
);
}
}

Cette classe est fléxible : nous pouvons affecter les valeurs par défaut depuis une base de
données et être certains qu'elles seront stockées correctement. Aussi, la valeur peut être affectée
depuis un tableau provenant des entrées du formulaire. Enfin, nous avons tous les accesseurs
distincts pour chaque segment de la date, un décorateur pourra donc créer l'élément comme
il le voudra.

5.2. Le décorateur
Toujours en suivant notre exemple, imaginons que nous voulions que notre utilisateur saisissent
chaque segment jour, mois, année séparément. Heureusement, PHP permet d'utiliser la notation
tableau pour créer des éléments, ainsi nous pourrons capturer ces trois valeurs en une seule et
nous crérons un élément Zend_Form traitant avec des valeurs en tableau.

Le décorateur est relativement simple: Il va récupérer le jour, le mois et l'année de l'élément et


passer chaque valeur à une aide de vue qui rendra chaque champ individuellement. Nous les
rassemblerons ensuite dans le rendu final.

class My_Form_Decorator_Date extends Zend_Form_Decorator_Abstract


{
public function render($content)
{
$element = $this->getElement();
if (!$element instanceof My_Form_Element_Date) {
// Nous ne rendons que des éléments Date
return $content;
}

68
Bien comprendre et utiliser
les décorateurs Zend Form

$view = $element->getView();
if (!$view instanceof Zend_View_Interface) {
// Nous utilisons des aides de vue, si aucune vue n'existe
// nous ne rendons rien
return $content;
}

$day = $element->getDay();
$month = $element->getMonth();
$year = $element->getYear();
$name = $element->getFullyQualifiedName();

$params = array(
'size' => 2,
'maxlength' => 2,
);
$yearParams = array(
'size' => 4,
'maxlength' => 4,
);

$markup = $view->formText($name . '[day]', $day, $params)


. ' / ' . $view->formText($name . '[month]', $month, $params)
. ' / ' . $view->formText($name . '[year]', $year, $yearParams);

switch ($this->getPlacement()) {
case self::PREPEND:
return $markup . $this->getSeparator() . $content;
case self::APPEND:
default:
return $content . $this->getSeparator() . $markup;
}
}
}

Il faut maintenant préciser à notre élément d'utiliser notre décorateur par défaut. Pour ceci, il
faut informer l'élément du chemin vers notre décorateur. Nous pouvons effectuer ceci par le
constructeur:

class My_Form_Element_Date extends Zend_Form_Element_Xhtml


{
// ...

public function __construct($spec, $options = null)


{
$this->addPrefixPath(
'My_Form_Decorator',
'My/Form/Decorator',
'decorator'
);
parent::__construct($spec, $options);
}

// ...
}

Notez que l'on fait cela en constructeur et non dans la méthode init(). Ceci pour deux raisons.
D'abord, ceci permet d'étendre dans le futur notre élément afin d'y ajouter de la logique dans

69
Bien comprendre et utiliser
les décorateurs Zend Form

init sans se soucier de l'appel à parent::init(). Ensuite, celà permet aussi de redéfinir
le décorateur par défaut Date dans le futur si celà devient nécessaire, via le constructeur ou
la méthode init.

Ensuite, nous devons réécrire la méthode loadDefaultDecorators() pour lui indiquer


d'utiliser notre décorateur Date:

class My_Form_Element_Date extends Zend_Form_Element_Xhtml


{
// ...

public function loadDefaultDecorators()


{
if ($this->loadDefaultDecoratorsIsDisabled()) {
return;
}

$decorators = $this->getDecorators();
if (empty($decorators)) {
$this->addDecorator('Date')
->addDecorator('Errors')
->addDecorator('Description', array(
'tag' => 'p',
'class' => 'description'
))
->addDecorator('HtmlTag', array(
'tag' => 'dd',
'id' => $this->getName() . '-element'
))
->addDecorator('Label', array('tag' => 'dt'));
}
}

// ...
}

A qyuoi ressemble le rendu final ? Considérons l'élément suivant:

$d = new My_Form_Element_Date('dateOfBirth');
$d->setLabel('Date de naissance: ')
->setView(new Zend_View());

// Ces deux procédés sont équivalents:


$d->setValue('20 April 2009');
$d->setValue(array('year' => '2009', 'month' => '04', 'day' => '20'));

Si vous affichez cet élément, vous obtiendrez ce rendu (avec quelques modifications concernant
la mise en page du manuel et sa lisibilité):

<dt id="dateOfBirth-label"><label for="dateOfBirth" class="optional">


Date de naissance:
</label></dt>
<dd id="dateOfBirth-element">
<input type="text" name="dateOfBirth[day]" id="dateOfBirth-day"
value="20" size="2" maxlength="2"> /
<input type="text" name="dateOfBirth[month]" id="dateOfBirth-month"
value="4" size="2" maxlength="2"> /
<input type="text" name="dateOfBirth[year]" id="dateOfBirth-year"

70
Bien comprendre et utiliser
les décorateurs Zend Form

value="2009" size="4" maxlength="4">


</dd>

5.3. Conclusion
Nous avons maintenant un élément qui peut rendre de multiples champs de formulaire, et les
traiter comme une seule entité -- la valeur dateOfBirth sera passée comme un tableau à
l'élément et celui-ci créra les segments de date appropriés et retournera une valeur normalisée.

Aussi, nous pouvons toujours utiliser des décorateurs différents avec l'élément. Si nous avions
voulu utiliser un décorateur Dojo DateTextBox -- qui accepte et retourne des chaines -- we
aurions pu, sans modification sur l'élément lui-même.

Enfin, vous avez une API uniforme pour décrire un élement se composant se plusieurs segments
distincts.

6. Conclusion
Les décorateur de formulaire sont un système qui peut prendre du temps à maitriser. A première
vue, ils semblent complexes et rudes. Mais les différents sujets traités dans ce chapitre vous
aident à comprendre leur fonctionnement et vous montrent des manières de faire pour les utiliser
efficacement dans vos formulaires.

71
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl
1. Fabrique une application Multi-Utilisateurs avec Zend
Framework
1.1. Zend Framework
Lorsque le web a été crée, il s'agissait d'un média permettant de consulter des documents
statiques. La demande de contenu a cru, le nombre d'internautes aussi et les sites webs sont
devenus des applications tournant sur de grosses plateformes.

HTTP est le protocole du web: sans état, des requêtes/réponses à courte durée de vie. Ce
protocole a été crée comme cela pour assurer le web tel qu'on l'entendait avant : servir du
contenu statique et c'est ce design qui a fait du web un immense succès. C'est aussi ce design
qui mène à des notions que les développeurs veulent utiliser dans leurs applications.

Ces informations nous mènent à trois questions:

• Comment distinguer les clients d'une application?

• Comment identifier ces clients?

• Comment contrôler les droits d'un client identifié?

Client contre Utilisateur

Nous utilisons le terme "client" et pas utilisateur. Les applications web deviennent
des fournisseurs de services. Ceci signifie que les "gens", les utilisateurs
humains avec des navigateurs web ne sont pas les seuls à consommer
l'application et ses services. Beaucoup d'autres applications web consomment
elles-mêmes des ressources sur une application via des technologies comme
REST, SOAP, ou XML-RPC. On voit bien qu'on ne peut parler d'utilisateur, nous
traitons donc les utilisateurs humains des utilisateurs machines sous le même
nom : des "clients" web.

Dans les chapitres qui suivent, nous nous attaquerons à ces problèmes que sont
l'authentification, l'identification et les détails. Nous allons découvrir trois composants:
Zend_Session, Zend_Auth, et Zend_Acl; nous montrerons des exemples concrets et des
possibilités d'extension.

2. Gérer les sessions dans ZF


2.1. Introduction aux sessions
Le succès du web est en grande partie dûe aux protocoles qui le supportent: HTTP. HTTP sur
TCP est par nature sans état ce qui signifie que le web n'a pas "de mémoire". Ce fait pose des
problèmes pour les développeurs voulant traiter leur application comme un service riche.

72
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

Interagir avec l'application web c'est en fait faire la somme de toutes les requêtes que celle-ci
reçoit. Et comme il y a beaucoup de clients, il y a beaucoup de requête, et le moyen d'associer
une requête à un client est appelé "session".

En PHP, le problème des sessions a été résolu au travers de l'extension session qui utilise un
système de persistance, typiquement basé sur des cookies et un stockage local des variables
dans $_SESSION. Dans Zend Framework, le composant Zend_Session ajoute de la valeur au
système de session de PHP notamment une manipulation objet.

2.2. Utilisation classique de Zend_Session


Le composant Zend_Session est un gestionnaire de session et une API pour stocker des
données dans la session de manière objet. L'API de la classe Zend_Session API permet de régler
des options et de démarrer/arrêter la session alors que Zend_Session_Namespace représente
un objet contenant des données à stocker en session.

C'est générallement une bonne pratique que de démarrer sa session en bootstrap, cependant
la première création d'un objet Zend_Session_Namespace démarrera la session par défaut.

Zend_Application peut permettre de configurer Zend_Session grâce aux parties


Zend_Application_Resource. Pour les utiliser, en supposant que votre projet utilise
Zend_Application, ajoutez le code suivant à application.ini:

resources.session.save_path = APPLICATION_PATH "/../data/session"


resources.session.use_only_cookies = true
resources.session.remember_me_seconds = 864000

Comme vous le remarquez, les options utilisées sont les mêmes que celles que reconnait ext/
session (l'extension session de PHP). Le chemin de stockage des session par exemple. Les
fichiers ini peuvent utiliser des constantes, nous réutilisons APPLICATION_PATH pour calculer
le chemin relatif vers un dossier arbitraire sensé stocker les sessions.

La plupart des composants de Zend Framework utilisant les sessions n'ont rien besoin de plus.
Dès lors, vous pouvez utiliser un composant faisant appel à la session, ou manipuler la session
vous-même au travers d'un ou plusieurs objets Zend_Session_Namespace.

Zend_Session_Namespace est une classe qui guide ses données vers $_SESSION. La
classe s'appelle Zend_Session_Namespace car elle crée des espaces de noms au sein de
$_SESSION, autorisant plusieurs composants ou objets à stocker des valeurs sans se marcher
dessus. Nous allons voir dans l'exemple qui suit comment créer un simple compteur de session
qui commence à 1000 et se remet à zéro après 1999.

$mysession = Zend_Session_Namespace('mysession');

if (!isset($mysession->counter)) {
$mysession->counter = 1000;
} else {
$mysession->counter++;
}

if ($mysession->counter > 1999) {


unset($mysession->counter);
}

Comme vous le remarquez, l'objet de session utilise les méthodes magiques __get, __set,
__isset, et __unset pour proposer une API intuitive. Les informations stockées dans notre
exemple le sont en réalité dans $_SESSION['mysession']['counter'].

73
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

2.3. Utilisation avancée de Zend_Session


Si vous voulez utiliser le gestionnaire de sauvegarde des sessions "DbTable", vous pouvez
simplement ajouter ces options à application.ini:

resources.session.saveHandler.class = "Zend_Session_SaveHandler_DbTable"
resources.session.saveHandler.options.name = "session"
resources.session.saveHandler.options.primary.session_id = "session_id"
resources.session.saveHandler.options.primary.save_path = "save_path"
resources.session.saveHandler.options.primary.name = "name"
resources.session.saveHandler.options.primaryAssignment.sessionId = "sessionId"
resources.session.saveHandler.options.primaryAssignment.sessionSavePath = "sessionSavePath"
resources.session.saveHandler.options.primaryAssignment.sessionName = "sessionName"
resources.session.saveHandler.options.modifiedColumn = "modified"
resources.session.saveHandler.options.dataColumn = "session_data"
resources.session.saveHandler.options.lifetimeColumn = "lifetime"

3. Authentification d'utilisateurs dans Zend Framework


3.1. Introduction à l'authentification
Une fois que l'application a récupéré les informations d'un utilisateur, elle doit vérifier leur
"authenticité", c'est l'authentification. Pour celà, deux informations sont nécessaires : l'identifiant
et un ensemble de règles régissant cet identifiant, aujourd'hui typiquement une chaine de
caractères servant de mot de passe est très classique, mais d'autres procédés existent
(reconnaissances digitales, occulaires...)

Un identifiant peut lui aussi être un "login" tout banal, mais pourquoi pas un numéro de membre,
une adresse email... le secret, lui, est donc souvent un mot de passe sous forme de chaine de
caractères.

3.2. Utilisation de base de Zend_Auth


Dans l'exemple suivant, nous utiliserons Zend_Auth afin d'effectuer une authentification des
plus classiques: champ login et password puis vérification en base de données. Cet exemple
suppose que vous utilisez Zend_Application afin de configurer une connexion à une base
de données.

Zend_Auth effectue deux tâches. D'abord elle doit récupérer un adaptateur d'authentification
afin de déclencher le processus d'authentification, puis si celui-ci est correct, elle doit faire
persister ces informations entre requêtes. Pour assurer cette persistance, Zend_Auth utilise un
Zend_Session_Namespace, mais en général vous n'aurez pas besoin d'agir sur cet objet.

Supposant une table de base de données suivante:

CREATE TABLE users (


id INTEGER NOT NULL PRIMARY KEY,
username VARCHAR(50) UNIQUE NOT NULL,
password VARCHAR(32) NULL,
password_salt VARCHAR(32) NULL,
real_name VARCHAR(150) NULL
)

C'est une table qui inclue des champs nom, password et aussi grain de sel. Le grain de sel est
utilisé pour améliorer la sécurité contre les attaques par force brute qui cibleraient l'alogithme de
hashage du mot de passe. Plus d'informations sur le grain de sel.

74
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

Créons un formulaire de login simple. Nous utiliserons Zend_Form.

// localisé à application/forms/Auth/Login.php

class Default_Form_Auth_Login extends Zend_Form


{
public function init()
{
$this->setMethod('post');

$this->addElement(
'text', 'username', array(
'label' => 'Username:',
'required' => true,
'filters' => array('StringTrim'),
));

$this->addElement('password', 'password', array(


'label' => 'Password:',
'required' => true,
));

$this->addElement('submit', 'submit', array(


'ignore' => true,
'label' => 'Login',
));

}
}

Ce formulaire nous mène vers la création du contrôleur de traitement. Nous


l'appellerons "AuthController", et le logerons dans application/controllers/
AuthController.php. Il possèdera une seule méthode "loginAction()" vers laquelle le
formulaire enverra, la méthode va donc réagir à GET et à POST, elle encapsule toute la logique.

Le code suivant montre comment construire l'adaptateur d'authentification et l'intégration du


formulaire:

class AuthController extends Zend_Controller_Action


{

public function loginAction()


{
$db = $this->_getParam('db');

$loginForm = new Default_Form_Auth_Login($_POST);

if ($loginForm->isValid()) {

$adapter = new Zend_Auth_Adapter_DbTable(


$db,
'users',
'username',
'password',
'MD5(CONCAT(?, password_salt))'
);

$adapter->setIdentity($loginForm->getValue('username'));
$adapter->setCredential($loginForm->getValue('password'));

75
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

$result = $auth->authenticate($adapter);

if ($result->isValid()) {
$this->_helper->FlashMessenger('Successful Login');
$this->redirect('/');
return;
}

$this->view->loginForm = $loginForm;

Le script de vue est quant à lui enfantin, il sera logé dans application/views/scripts/
auth/login.phtml:

$this->form->setAction($this->url());
echo $this->form;

Et voila! Avec ce scénario de base, vous pouvez étendre les possibilités et répondre à vos
besoins précis. Tous les adaptateurs Zend_Auth se trouvent décrits dans le guide de réference.

4. Fabriquer un système de gestion d'autorisations avec


Zend Framework
4.1. Introduction à l'autorisation
Après qu'un utilisateur se soit authentifié, une application peut proposer différentes règles
d'accès à ses différentes ressources (parties). Le procédé qui consiste à savoir "qui a le droit
de faire quoi" est nommé "gestion des autorisations". Dans sa forme la plus simple l'autorisation
est la composition de trois facteurs:

• l'identitié de la personne souhaitant des droits - le rôle (qui?)

• la ressource demandée (sur quoi?)

• et optionnellement le privilège - le droit (quoi?)

Dans Zend Framework, le composant Zend_Acl vous propose de créer ces trois entités
remarquables, de les associer et de les interroger dans le futur.

4.2. Utilisation de base de Zend_Acl


En utilisant Zend_Acl, n'importe quel modèle peut servir de rôle ou de
ressource en implémentant l'interface adéquate. Pour créer des rôles, implémentez
Zend_Acl_Role_Interface, qui définit la méthode getRoleId(). Pour créer des
ressources, implémentez Zend_Acl_Resource_Interface qui définit la méthode
getResourceId().

Nous allons faire une démonstration avec un modèle simple. On peut le relier avec notre système
d'ACL en implémentant Zend_Acl_Role_Interface. La méthode getRoleId() retournera
"guest" lorsque l'ID est inconnu, ou l'ID du rôle lorsque celui-ci aura été affecté. Cette valeur

76
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

peut provenir de n'importe où, probablement qu'elle proviendra d'une définition faite en base de
données.

class Default_Model_User implements Zend_Acl_Role_Interface


{
protected $_aclRoleId = null;

public function getRoleId()


{
if ($this->_aclRoleId == null) {
return 'guest';
}

return $this->_aclRoleId;
}
}

Le concept des utilisateurs ayant des rôles est simple à comprendre, mais l'application peut
consommer plusieurs modèles et en retrouver des "ressources" qui seront consommables par
les rôles. Nous utiliserons simplement des billets de blog comme ressources dans nos exemples,
et comme les ressources sont des objets, nous ferons en sorte que l'ID d'un billet blog soir
'blogPost', naturellement cette valeur peut être calculée dynamiquement en fonction du besoin.

class Default_Model_BlogPost implements Zend_Acl_Resource_Interface


{
public function getResourceId()
{
return 'blogPost';
}
}

Maintenant que nous avons au minimum un rôle et une ressource, définissons règles qui les
lient. Ces règles seront lues lorsque le système recevra une requête d'acl demandant ce qu'il
est possible de faire avec tel rôle, telle ressource et éventuellement tel privilège.

Imaginons les règles suivantes:

$acl = new Zend_Acl();

// mise en place des rôles


$acl->addRole('guest');
// owner hérite du rôle guest
$acl->addRole('owner', 'guest');

// ajout de ressources
$acl->addResource('blogPost');

// ajout de privilèges liant des rôles et des ressources


$acl->allow('guest', 'blogPost', 'view');
$acl->allow('owner', 'blogPost', 'post');
$acl->allow('owner', 'blogPost', 'publish');

Les règles ci-dessus sont très simples: deux rôles "guest"(invité) et "owner" (propriétaire), et une
ressource "blogPost"(billet). Les invités sont autorisés à voir les billets, les propriétaires peuvent
poster et publier des billets. Pour requêter le système, procédez alors comme suit:

// Imaginons que le modèle User soit de type "guest"

77
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

$guestUser = new Default_Model_User();


$ownerUser = new Default_Model_Owner('OwnersUsername');

$post = new Default_Model_BlogPost();

$acl->isAllowed($guestUser, $post, 'view'); // true


$acl->isAllowed($ownerUser, $post, 'view'); // true
$acl->isAllowed($guestUser, $post, 'post'); // false
$acl->isAllowed($ownerUser, $post, 'post'); // true

Comme vous pouvez le voir le système répond comme il faut dans la mesure où les invités
peuvent lire les billets mais seuls les propriétaires peuvent en ajouter. Cependant ce système
peut sembler manquer de dynamisme. Comment vérifier qu'un utilisateur spécifique est bien
propriétaire d'un billet spécifique avant de l'autoriser à le publier ? Autrement dit, on veut s'assurer
que seuls les propriétaires des billets peuvent publier ceux-ci, et pas ceux des autres.

C'est là qu'entrent en jeu les assertions. Les assertions sont des vérifications supplémentaires à
effectuer en même temps que la vérification de la règle d'acl. Ce sont des objets. Utilisons notre
exemple avec une assertion:

class OwnerCanPublishBlogPostAssertion implements Zend_Acl_Assert_Interface


{
/**
* Cette assertion va recevoir le User et le BlogPost actuels.
*
* @param Zend_Acl $acl
* @param Zend_Acl_Role_Interface $user
* @param Zend_Acl_Resource_Interface $blogPost
* @param $privilege
* @return bool
*/
public function assert(Zend_Acl $acl,
Zend_Acl_Role_Interface $user = null,
Zend_Acl_Resource_Interface $blogPost = null,
$privilege = null)
{
if (!$user instanceof Default_Model_User) {
throw new Exception(__CLASS__
. '::'
. __METHOD__
. ' s'attend à un rôle'
. ' instance de User');
}

if (!$blogPost instanceof Default_Model_BlogPost) {


throw new Exception(__CLASS__
. '::'
. __METHOD__
. ' s'attend à un rôle'
. ' instance de BlogPost');
}

// Si le rôle est publisher, il peut toujours modifier son billet


if ($user->getRoleId() == 'publisher') {
return true;
}

// vérifions que qui que ce soit, il modifie uniquement ses propres billets
if ($user->id != null && $blogPost->ownerUserId == $user->id) {

78
Bien démarrer avec Zend_Session,
Zend_Auth, et Zend_Acl

return true;
} else {
return false;
}
}
}

Pour faire intervenir l'assertion dans les ACL, nous les utilisons comme ceci:

// remplacez ceci:
// $acl->allow('owner', 'blogPost', 'publish');
// par cela:
$acl->allow('owner',
'blogPost',
'publish',
new OwnerCanPublishBlogPostAssertion());

// ajoutons aussi le rôle "publisher" qui a accès à tout


$acl->allow('publisher', 'blogPost', 'publish');

Maintenant, dès que l'ACL est consultée pour savoir si un propriétaire peut publier un billet, cette
assertion sera vérifiée. Elle s'assure que sauf si le rôle est 'publisher' le propriétaire a bien écrit le
billet. Dans cet exemple, nous vérifions pour savoir si l'attribut ownerUserId du billet correspond
à l'identifiant de l'utilisateur en question.

79
Bien démarrer avec
Zend_Search_Lucene
1. Introduction à Zend_Search_Lucene
Le composant Zend_Search_Lucene est prévu pour fournir une solution de recherche full-text
1
prête à l'emploi. Il ne nécessite aucunes extensions PHP ni que des logiciels supplémentaires
soient installés, et peut être utilisé tout de suite après l'installation du Framework Zend.

Zend_Search_Lucene est un portage PHP du moteur de recherche full-text open source


populaire connu comme Apache Lucene. Voir http://lucene.apache.org/ pour plus de détails.

L'information doit être indexée pour être disponible à la recherche. Zend_Search_Lucene


et Java Lucene utilise un concept de document connu sous le nom d'"indexation atomique
d'élément."

Chaque document est un ensemble de champs : paires <nom, valeur> où le nom et la valeur sont
2
des chaînes UTF-8 . N'importe quel sous ensemble de champs de document peut être marqué
comme "indexé" pour inclure des données de champ durant le processus d'indexation de texte.

Les valeurs de champs peuvent être indexées segmentées durant l'indexation. Si un champ
n'est pas segmenté, alors la valeur du champ est stockée comme un seul terme ; autrement,
l'analyseur courant est utilisé pour la segmentation.

Plusieurs analyseurs sont fournis dans le paquet Zend_Search_Lucene. L'analyseur par


défaut fonctionne avec du texte ASCII (comme l'analyseur UTF-8 a besoin que l'extension
mbstring soit activée). Il n'est pas sensible à la case, et saute les nombres. Utilisez d'autres
analyseurs ou créez votre propre analyseur si vous avez besoin de changer ce comportement.

Utilisation des analyseurs durant l'indexation et la recherche

Note importante ! Les requêtes de recherches sont aussi segmentées en utilisant


"l'analyseur courant", ainsi le même analyseur doit être défini par défaut durant
le processus d'indexation et le processus de recherche. Ceci garantira que la
source et le texte recherché seront transformés en termes de la même manière.

Les valeurs de champs sont stockés optionnellement au sein de l'index. Ceci permet aux
données originale du champ d'être récupérée pendant la recherche. C'est le seul moyen
d'associer les résultats de recherche avec les données originales (l'ID interne du document peut
avoir changé après une optimisation d'index ou une auto-optimisation).

Ce qui doit être gardé en mémoire, c'est que l'index Lucene n'est pas une base de données. Il ne
fournit pas un mécanisme de sauvegarde de l'index à l'exception de la sauvegarde du répertoire
du système de fichier. Il ne fournit pas de mécanisme transactionnel bien que soient supportés
la mise à jour concurrente d'index ainsi que que la mise à jour et la lecture concurrente. Il n'est
pas comparable aux bases de données en terme de vitesse de récupération de données.

Donc c'est une bonne idée :


1
Bien que quelques fonctionnalités de traitement UTF-8 nécessitent que l'extension mbstring soit activée
2
Les chaînes Binaires sont aussi autorisées pour être utilisées comme des valeurs de champs

80
Bien démarrer avec
Zend_Search_Lucene

• De ne pas utiliser l'index Lucene comme du stockage car cela réduirait les performance de
récupération de résultat de recherche. Stocker uniquement les identifiants de documents
(chemin de documents, URLs, identifiant unique de base données) et associer les données
au sein de l'index. Ex. titre, annotation, categorie, information de langue, avatar. (Note : un
champs peut être inclu dans l'indexation, mais pas stocké, ou stocké, mais pas indexé).

• D'écrire des fonctionalités qui peuvent reconstruire intégralement l'index, si il a été corrompu
pour une raison ou pour une autre.

Les documents individuels dans l'index peuvent avoir des ensemble de champs totalement
différents. Le même champ dans différents documents n'a pas besoin d'avoir les mêmes
attributs. Ex. un champs peu être indexé pour l'un des documents mais sauté pour l'indexation
d'un autre. Le même principe s'applique au stockage, à la segmentation, ou traitement de valeur
de champ comme chaîne binaire.

2. Structure d'index Lucene


Afin d'utiliser l'intégralité des fonctionnalités de Zend_Search_Lucene avec un maximum de
performances, il est nécessaire que vous compreniez la structure interne d'un index.

Un index est stocké dans un ensemble de fichier au sein d'un seul répertoire.

Un index est un ensemble indépendant de segments dans lesquels sont stockées des
informations au sujet d'un sous-ensemble de documents indexés. Chaque segment a son propre
dictionnaire de terme, son propre index de dictionnaire de terme, et son propre stockage de
3
document (valeur de champ stocké) . Toutes les informations de segments sont stockées dans
un fichier _xxxxx.cfs, où xxxxx est le nom d'un segment.

Dès qu'un fichier de segment d'index est créé, il ne peut être mis à jour. De nouveaux documents
sont ajoutés à de nouveaux segments. Les documents supprimés sont seulement marqués
comme supprimés dans un fichier facultatif <segmentname>.del.

La mise à jour de document est effectuée en tant qu'opérations distincts de suppression et


4
d'ajout, même si elle est effectuée en utilisant un appel à l'API update() . Ceci simplifie l'ajout
de nouveaux documents, et permet de mettre à jour simultanément à l'aide des opérations de
recherche.

D'un autre coté, utiliser plusieurs segments (avoir un document par segment est un cas
exceptionnel) augmente le temps de recherche :

• La récupération d'un terme depuis le dictionnaire est effectué pour chaque segment ;

• Le dictionnaire de terme de l'index est préchargé pour chaque segment (ce processus occupe
la plupart du temps de recherche pour de simples requêtes et nécessite aussi de la mémoire
supplémentaire).

Si les termes du dictionnaires de recherche atteignent un point de saturation, la recherche à


travers un segment est N fois plus rapide que la recherche à travers N segments dans la plupart
des cas.

L'optimisation d'index fusionne deux segments ou plus en un segment unique. Un nouveau


segment est ajouté à la liste des segments de l'index, et les anciens segments sont exclus.
3
Depuis Lucene 2.3, les fichiers de stockage de document peuvent être partagés entre les segments; cependant,
Zend_Search_Lucene n'utilise pas cette possibilité
4
Cet appel est fourni uniquement par Java Lucene pour le moment, mais il est prévu d'étendre l'API Zend_Search_Lucene avec
une fonctionnalité similaire

81
Bien démarrer avec
Zend_Search_Lucene

La mise à jour de la liste de segments s'effectue de manière atomique. Ceci donne la capacité
d'ajouter de nouveaux documents simultanément, d'effectuer des optimisations d'index, et de
chercher à travers l'index.

L'auto-optimisation d'index s'effectue après chaque génération de segment. Elle fusionne


l'ensemble des plus petits segments en des segments plus grands, et les segments plus grands
en des segments encore plus grands, si nous avons suffisamment de segments à fusionner.

L'auto optimisation d'index est contrôlé par trois options :

• MaxBufferedDocs (Le nombre minimal de documents requis avant que les documents mis en
mémoire tampon soit écrits dans un nouveau segment) ;

• MaxMergeDocs (Le plus grand nombre de documents fusionnés par une opération
d'optimisation) ; et

• MergeFactor (qui détermine la fréquence à laquelle les indices de segments sont fusionnés
par les opérations d'auto-optimisation).

Si nous ajoutons un documents par exécution de script, MaxBufferedDocs n'est finalement pas
utilisé (seul un segment avec un seul document est créé à la fin de l'exécution du script, moment
auquel démarre le processus d'auto-optimisation).

3. Ouverture et création d'index


Toutes les opérations sur l'index (ex: créer un nouvel index, ajouter un document à l'index,
supprimer un document, chercher dans l'index) nécessite un objet index. Il peut être obtenu avec
l'une des méthodes suivantes.

Exemple 3. Création d'index Lucene

$index = Zend_Search_Lucene::create($indexPath);

Exemple 4. Ouverture d'index Lucene

$index = Zend_Search_Lucene::open($indexPath);

4. Indexation
L'indexation s'effectue en ajoutant un nouveau document à un index existant ou à un nouvel
index :

$index->addDocument($doc);

Il y a deux manières de créer un objet document. La première est de le faire manuellement.

Exemple 5. Construction manuel de document

$doc = new Zend_Search_Lucene_Document();


$doc->addField(Zend_Search_Lucene_Field::Text('url', $docUrl));
$doc->addField(Zend_Search_Lucene_Field::Text('title', $docTitle));
$doc->addField(Zend_Search_Lucene_Field::unStored('contents', $docBody));
$doc->addField(Zend_Search_Lucene_Field::binary('avatar', $avatarData));

La seconde méthode est de le charger depuis un fichier HTML ou Microsoft Office 2007 :

82
Bien démarrer avec
Zend_Search_Lucene

Exemple 6. Chargement de document

$doc = Zend_Search_Lucene_Document_Html::loadHTML($htmlString);
$doc = Zend_Search_Lucene_Document_Docx::loadDocxFile($path);
$doc = Zend_Search_Lucene_Document_Pptx::loadPptFile($path);
$doc = Zend_Search_Lucene_Document_Xlsx::loadXlsxFile($path);

Si un document est chargé depuis l'un des formats supportés, il peut quand même être étendu
manuellement avec des champs définis par l'utilisateur.

4.1. Politique d'indexation


Vous devrez définir votre politique d'indexation au sein de la conception de l'architecture de votre
application.

Vous pourriez avoir besoin d'une configuration d'indexation à la demande (quelque chose
comme le système OLTP). Sur de test systèmes, vous ajoutez généralement un document par
requête utilisateur. De cette manière, l'option MaxBufferedDocs n'affectera pas le système. D'un
autre coté, MaxMergeDocs est vraiment utile, car il vous permet de limiter le temps d'exécution
maximum du script. MergeFactor doit être définis par une valeur qui conserve un équilibre
entre le temps moyen d'indexation (il est aussi affecté par temps d'optimisation moyen) et les
performance de recherche (le niveau d'optimisation dépend du nombre de segments).

Si vous allez surtout effectuer des mises à jour d'index par lot, votre configuration devrait
utiliser une option MaxBufferedDocs définis à la valeur maximum supporté par la quantité de
mémoire disponible. MaxMergeDocs et MergeFactor doivent être définis à des valeurs réduisant
5
au maximum le recours à l'auto-optimisation . Les optimisations complètes d'index doivent être
appliquées après l'indexation.

Exemple 7. Optimisation d'index

$index->optimize();

Dans certaines configuration, il est plus efficace d'effectuer une série de mise à jour de l'index en
organisant une file de requête de mise à jour et de traiter plusieurs requête de mise à jour dans
une seule exécution de script. Ceci réduit la charge d'ouverture de l'index et permet d'utiliser le
tampon de document de l'index.

5. Recherche
La recherche s'effectue en utilisant la méthode find() :

Exemple 8. Recherche à travers l'index

$hits = $index->find($query);
foreach ($hits as $hit) {
printf("%d %f %s\n", $hit->id, $hit->score, $hit->title);
}

Cet exemple montre l'utilisation de deux propriétés particulières des résultats de recherche - id
et score.

id est un identifiant interne de document utilisé dans un index Lucene. Il peut être utilisé pour un
certains nombre d'opérations, tels que la suppression d'un document de l'index :
5
Une limite additionnelle est le nombre maximum de gestionnaire de fichiers supporter par le système d'exploitation pour les opérations
concurrente d'ouverture

83
Bien démarrer avec
Zend_Search_Lucene

Exemple 9. Suppression d'un document indexé

$index->delete($id);

Ou récupération d'un document à partir de l'index :

Exemple 10. Récupération d'un document indexé

$doc = $index->getDocument($id);

Identifiant interne de document

Note importante ! Les identifiants de documents internes peuvent changer suite


à une optimisation de l'index ou au processus d'auto-optimisation, mais il ne sera
jamais changé pendant l'exécution d'un script à moins que ne soient appellées
les méthodes addDocument() (ce qui peut impliquer une procédure d'auto-
optimisation) ou optimize().

Le champ score est un score de résultat. Les résultats de recherche sont triés par score
(meilleurs résultats en premier).

Il est aussi possible de trier l'ensemble de résultats en fonction d'une valeur de champ spécifique.
Voir la documentation Zend_Search_Lucene pour plus de détails sur cette possibilité.

Cette exemple montre aussi la possibilité d'accéder à des champs stockés (ex : $hit->title).
Les champs de documents stockés sont chargés lors du premier accès à l'une des propriété du
résultat autre que id ou score, et la valeur du champ correspondant est retournée.

Ceci cause une ambiguïté car les documents ont leurs propres champs id ou score par
conséquence, il n'est pas recommendé d'utiliser ces noms de champs dans les documents
stockés. Cependant, ils peuvent être accédé via la méthode : getDocument()

Exemple 11. Accéder aux champs "id" et "score" original du documents

$id = $hit->getDocument()->id;
$score = $hit->getDocument()->score;

6. Requêtes supportées
Zend_Search_Lucene et Lucene Java supportent un langage de requête puissant. Il permet
de rechercher des termes individuels, des phrases, des ensembles de termes ; en utilisant des
jokers ou des recherches floues ; en combinant des requêtes à l'aide d'opérateurs booléens et
ainsi de suite.

Une description détaillée du langage de requête peut être trouvé dans la documentation du
composant Zend_Search_Lucene.

Ci-dessous, des exemples de quelques requêtes types communes et de stratégies.

Exemple 12. Effectuer une requête pour un mot seul

hello

Recherche le mot "hello" à travers les champs de tous les documents.

84
Bien démarrer avec
Zend_Search_Lucene

Champ de recherche par défaut


Note importante ! Lucene Java recherche uniquement dans les champs de
"contenu" par défaut, mais Zend_Search_Lucene recherche à travers tous
les champs. Ce comportement peut être modifié en utilisant la méthode
Zend_Search_Lucene::setDefaultSearchField($fieldName).

Exemple 13. Effectuer une recherche de mots multiples

hello dolly

Recherche deux mots. Les deux mots sont facultatifs, au moins l'un des deux doit être
présent dans le résultat

Exemple 14. Mots requis dans une requête

+hello dolly

Recherche deux mots ; "hello" est requis, "dolly" est facultatif.

Exemple 15. Interdire des mots dans les documents recherchés

+hello -dolly

Recherche avec deux mots ; "hello" est requis, 'dolly' est interdit. En d'autres termes, si le
document contient "hello", mais contient aussi le mot "dolly", il ne sera pas retourné dans
l'ensemble de résultats.

Exemple 16. Rechercher des phrases

"hello dolly"

Recherche de la phrases "hello dolly" ; un document correspond uniquement si la chaine


exacte est présente.

Exemple 17. Effectuer des recherches dans des champs en particulier

title:"The Right Way" AND text:go

Recherche la phrase "The Right Way" au sein du champ title et le mot "go" dans la propriété
text.

Exemple 18. Effectuer des recherches dans des champs en particulier aussi bien
que dans le document complet

title:"The Right Way" AND go

Recherche la phrase "The Right Way" dans la propriété title et le mot "go" dans tous les
champs du document.

Exemple 19. Effectuer des recherches dans des champs en particulier aussi bien
que dans le document complet (Alternatif)

title:Do it right

Recherche le mot "Do" dans la propriété title et les mots "it" and "right" dans tous les champs ;
si l'un d'entre eux correspond, le document correspondra à un résultat de recherche.

85
Bien démarrer avec
Zend_Search_Lucene

Exemple 20. Faire des requêtes avec le joker "?"

te?t

Recherche les mots correspondants au motif "te?t", où "?" est n'importe quel caractère
unique.

Exemple 21. Faire des requêtes avec le joker "*"

test*

Recherche les mots correspondants au motif "test*", où "*" est n'importe quelle séquence
de 0 caractère ou plus.

Exemple 22. Rechercher une gamme inclusive de termes

mod_date:[20020101 TO 20030101]

Recherche la gamme de termes (inclusif).

Exemple 23. Rechercher une gamme exclusive de termes

title:{Aida to Carmen}

Recherche la gamme de termes (exculsif).

Exemple 24. Recherches floues

roam~

Recherche foue pour le mot "roam".

Exemple 25. Recherches booléennes

(framework OR library) AND php

Requête booléenne.

Toutes les requêtes supportées peuvent être construites via l'API de construction de requêtes
de Zend_Search_Lucene. De plus l'analyse et la construction de requêtes peuvent être
combinées :

Exemple 26. Combinaison d'analyse et de construction de requêtes

$userQuery = Zend_Search_Lucene_Search_QueryParser::parse($queryStr);
$query = new Zend_Search_Lucene_Search_Query_Boolean();
$query->addSubquery($userQuery, true /* required */);
$query->addSubquery($constructedQuery, true /* required */);

7. Pagination de résultat de recherche


Comme mentionné plus haut, les objets de résultats de recherche utilisent le lazy loading pour
les champs de documents stockés. Lorsque l'on accède à l'un des champs stockés, le document
complet est chargé.

86
Bien démarrer avec
Zend_Search_Lucene

Ne récupérez pas tous les documents si vous avez seulement besoin de travailler sur une partie.
Parcourez les résultats de recherche et stockez l'ID du document (et éventuellement son score)
afin de récupérer les documents depuis l'index pendant la prochaine exécution du script.

Exemple 27. Exemple de pagination de résultat de recherche

$cacheId = md5($query);
if (!$resultSet = $cache->load($cacheId)) {
$hits = $index->find($query);
$resultSet = array();
foreach ($hits as $hit) {
$resultSetEntry = array();
$resultSetEntry['id'] = $hit->id;
$resultSetEntry['score'] = $hit->score;
$resultSet[] = $resultSetEntry;
}
$cache->save($resultSet, $cacheId);
}
$publishedResultSet = array();
for ($resultId = $startId; $resultId < $endId; $resultId++) {
$publishedResultSet[$resultId] = array(
'id' => $resultSet[$resultId]['id'],
'score' => $resultSet[$resultId]['score'],
'doc' => $index->getDocument($resultSet[$resultId]['id']),
);
}

87
Bien démarrer avec Zend_Paginator
1. Introduction
Let's say you're creating a blogging application that will be home to your vast collection of blog
posts. There is a good chance that you do not want all of your blog posts to appear on one
single page when someone visits your blog. An obvious solution would be to only display a
small number of blog posts on the screen at a time, and allow the user to browse through the
different pages, much like your favorite search engine shows you the result of your search query.
Zend_Paginator is designed to help you achieve the goal of dividing collections of data in
smaller, more manageable sets more easily, with more consistency, and with less duplicate code.

Zend_Paginator uses Adapters to support various data sources and ScrollingStyles to support
various methods of showing the user which pages are available. In later sections of this text we
will have a closer look at what these things are and how they can help you to make the most
out of Zend_Paginator.

Before going in-depth, we will have a look at some simple examples first. After these simple
examples, we will see how Zend_Paginator supports the most common use-case; paginating
database results.

This introduction has given you a quick overview of Zend_Paginator. To get started and to
have a look at some code snippets, let's have a look at some simple examples.

2. Simple Examples
In this first example we won't do anything spectacular, but hopefully it will give you a good idea
of what Zend_Paginator is designed to do. Let's say we have an array called $data with the
numbers 1 to 100 in it, which we want to divide over a number of pages. We can use the static
factory() method in the Zend_Paginator class to get a Zend_Paginator object with our
array in it.

// Create an array with numbers 1 to 100


$data = range(1, 100);

// Get a Paginator object using Zend_Paginator's built-in factory.


$paginator = Zend_Paginator::factory($data);

We're already almost done! The $paginator variable now contains a reference to the Paginator
object. By default it is setup to display 10 items per page. To display the items for the currently
active page, all you need to do is iterate over the Paginator object with a foreach loop. The
currently active page defaults to the first page if it's not explicitly specified. We will see how you
can select a specific page later on. The snippet below will display an unordered list containing
the numbers 1 to 10, which are the numbers on the first page.

// Create an array with numbers 1 to 100


$data = range(1, 100);

// Get a Paginator object using Zend_Paginator's built-in factory.


$paginator = Zend_Paginator::factory($data);

?><ul><?php

88
Bien démarrer avec Zend_Paginator

// Render each item for the current page in a list-item


foreach ($paginator as $item) {
echo '<li>' . $item . '</li>';
}

?></ul>

Now let's try and render the items on the second page. You can use the
setCurrentPageNumber() method to select which page you want to view.

// Create an array with numbers 1 to 100


$data = range(1, 100);

// Get a Paginator object using Zend_Paginator's built-in factory.


$paginator = Zend_Paginator::factory($data);

// Select the second page


$paginator->setCurrentPageNumber(2);

?><ul><?php

// Render each item for the current page in a list-item


foreach ($paginator as $item) {
echo '<li>' . $item . '</li>';
}

?></ul>

As expected, this little snippet will render an unordered list with the numbers 11 to 20 in it.

These simple examples demonstrate a small portion of what can be achieved with
Zend_Paginator. However, a real application rarely reads its data from a plain array, so the
next section is dedicated to showing you how you can use Paginator to paginate the results of a
database query. Before reading on, make sure you're familiar with the way Zend_Db_Select
works!

In the database examples we will look at a table with blog posts called 'posts'. The 'posts' table
has four columns: id, title, body, date_created. Let's dive right in and have a look at a simple
example.

// Create a select query. $db is a Zend_Db_Adapter object, which we assume


// already exists in your script.
$select = $db->select()->from('posts')->order('date_created DESC');

// Get a Paginator object using Zend_Paginator's built-in factory.


$paginator = Zend_Paginator::factory($select);

// Select the second page


$paginator->setCurrentPageNumber(2);

?><ul><?php

// Render each the title of each post for the current page in a list-item
foreach ($paginator as $item) {
echo '<li>' . $item->title . '</li>';
}

89
Bien démarrer avec Zend_Paginator

?></ul>

As you can see, this example is not that different from the previous one. The only difference is
that you pass a Zend_Db_Select object to the Paginator's factory() method, rather than
an array. For more details on how the database adapter makes sure that your query is being
executed efficiently, see the Zend_Paginator chapter in the reference manual on the DbSelect
and DbTableSelect adapters.

3. Contrôles de la pagination et styles de défilement


Rendre visuellement les éléments d'une page est un bon départ. Dans les sections précédentes,
nous avons aperçu la méthode setCurrentPageNumber() pour déterminer la page active. Le
point suivant est la navigation au travers de ces pages. Le paginateur vous fournit des outils pour
ça comme la possibilité de rendre un script de vue partiel et le support des styles de défilement
(ScrollingStyles).

La vue partiel est un bout de vue qui rend juste les contrôles de la pagination comme les boutons
suivant et précédent. Le design de la vue partielle est libre, il vous faudra simplement un objet
Zend_View. Commencez donc par créer un nouveau script de vue dans le dossier des scripts
de vue. Vous pouvez l'appeler comme vous voulez, nous l'appellerons "controls.phtml" de notre
coté. Le manuel comporte des exemples de tels scripts, en voici un.

<?php if ($this->pageCount): ?>


<!-- First page link -->
<?php if (isset($this->previous)): ?>
<a href="<?php echo $this->url(array('page' => $this->first)); ?>">
First
</a> |
<?php else: ?>
<span class="disabled">First</span> |
<?php endif; ?>
<!-- Previous page link -->
<?php if (isset($this->previous)): ?>
<a href="<?php echo $this->url(array('page' => $this->previous)); ?>">
Previous
</a> |
<?php else: ?>
<span class="disabled"> Previous</span> |
<?php endif; ?>
<!-- Next page link -->
<?php if (isset($this->next)): ?>
<a href="<?php echo $this->url(array('page' => $this->next)); ?>">
Next
</a> |
<?php else: ?>
<span class="disabled">Next </span> |
<?php endif; ?>
<!-- Last page link -->
<?php if (isset($this->next)): ?>
<a href="<?php echo $this->url(array('page' => $this->last)); ?>">
Last
</a>
<?php else: ?>
<span class="disabled">Last</span>
<?php endif; ?>
</div>
<?php endif; ?>

90
Bien démarrer avec Zend_Paginator

Il faut maintenant indiquer à Zend_Paginator la vue partielle à utiliser. Ajoutez ceci à votre
bootstrap:

Zend_View_Helper_PaginationControl::setDefaultViewPartial('controls.phtml');

La dernière étape est la plus simple. Passez un objet Paginator à un script de vue (PAS
'controls.phtml'!). Ensuite, demandez simplement l'affichage de l'objet Paginator lui-même. Ceci
va faire intervenir l'aide de vue PaginationControl. Dans l'exemple qui suit, l'objet Paginator a
été affecté comme variable de vue 'paginator'. Ne vous inquiétez pas si vous ne comprenez pas
totalement le fonctionnement, les sections suivantes le détaillent.

<?php echo $this->paginator; ?>

Pour décider quels numéros de page afficher, le paginateur utilise des styles de défilement. Le
style par défaut est "Sliding", qui ressemble à la présentation des résultats de Yahoo! Un style
ressemblant à Google est "Elastic". Le style par défaut se règle au moyen de la méthode statique
setDefaultScrollingStyle(), ou lors du rendu du paginateur dans le script de vue mais
ceci nécessite un appel manuel à l'aide de vue.

// $this->paginator est un objet Paginator


<?php echo $this->paginationControl($this->paginator, 'Elastic', 'controls.phtml'); ?>

Pour une liste de tous les styles de défilement, consultez le manuel.

4. Putting it all Together


You have seen how to create a Paginator object, how to render the items on the current page,
and how to render a navigation element to browse through your pages. In this section you will
see how Paginator fits in with the rest of your MVC application.

In the following examples we will ignore the best practice implementation of using a Service
Layer to keep the example simple and easier to understand. Once you get familiar with using
Service Layers, it should be easy to see how Paginator can fit in with the best practice approach.

Lets start with the controller. The sample application is simple, and we'll just put everything in
the IndexController and the IndexAction. Again, this is for demonstration purposes only. A real
application should not use controllers in this manner.

class IndexController extends Zend_Controller_Action


{
public function indexAction()
{
// Setup pagination control view script. See the pagation control tutorial page
// for more information about this view script.
Zend_View_Helper_PaginationControl::setDefaultViewPartial('controls.phtml');

// Fetch an already instantiated database connection from the registry


$db = Zend_Registry::get('db');

// Create a select object which fetches blog posts, sorted decending by date of crea
$select = $db->select()->from('posts')->sort('date_created DESC');

// Create a Paginator for the blog posts query


$paginator = Zend_Paginator::factory($select);

// Read the current page number from the request. Default to 1 if no explicit page n

91
Bien démarrer avec Zend_Paginator

$paginator->setCurrentPageNumber($this->_getParam('page', 1));

// Assign the Paginator object to the view


$this->view->paginator = $paginator;
}
}

The following view script is the index.phtml view script for the IndexController's indexAction. The
view script can be kept simple. We're assuming the use of the default ScrollingStyle.

<ul>
<?php
// Render each the title of each post for the current page in a list-item
foreach ($this->paginator as $item) {
echo '<li>' . $item->title . '</li>';
}
?>
</ul>
<?php echo $this->paginator; ?>

Now navigate to your project's index and see Paginator in action. What we have discussed in
this tutorial is just the tip of the iceberg. The reference manual and API documentation can tell
you more about what you can do with Zend_Paginator.

92
Partie III. Guide de
référence Zend Framework
Table des matières
Zend_Acl ..................................................................................................................... 124
1. Introduction ...................................................................................................... 124
1.1. A propos des ressources ....................................................................... 124
1.2. A propos des rôles ................................................................................ 124
1.3. Créer la Liste de Contrôle d'Accès ......................................................... 125
1.4. Registre des rôles ................................................................................. 126
1.5. Définir les Contrôles d'Accès .................................................................. 127
1.6. Interroger les ACL ................................................................................. 127
2. Affiner les Contrôles d'Accès ............................................................................ 128
2.1. Mieux définir les Contrôles d'Accès ........................................................ 128
2.2. Retirer les Contrôles d'Accès ................................................................. 130
3. Utilisation avancée ........................................................................................... 130
3.1. Rendre les données ACL persistantes .................................................... 130
3.2. Écrire des règles ACL conditionnelles avec des assertions ....................... 131
Zend_Amf .................................................................................................................... 132
1. Introduction ...................................................................................................... 132
2. Zend_Amf_Server ............................................................................................ 132
2.1. Connecting to the Server from Flex ........................................................ 134
2.2. Error Handling ....................................................................................... 136
2.3. AMF Responses .................................................................................... 136
2.4. Typed Objects ....................................................................................... 136
2.5. Resources ............................................................................................. 138
2.6. Connecting to the Server from Flash ...................................................... 138
2.7. Authentication ....................................................................................... 140
Zend_Application .......................................................................................................... 142
1. Introduction ...................................................................................................... 142
2. Zend_Application démarrage rapide .................................................................. 142
2.1. Utiliser Zend_Tool ................................................................................. 142
2.2. Ajouter Zend_Application à votre existant ................................................ 144
2.3. Ajouter et créer des ressources .............................................................. 145
2.4. Aller plus loin avec Zend_Application ...................................................... 147
3. Théorie générale .............................................................................................. 147
3.1. Bootstrapping ........................................................................................ 148
3.2. Resource Plugins .................................................................................. 152
4. Exemples ......................................................................................................... 153
5. Fonctionnalités principales ................................................................................ 156
5.1. Zend_Application ................................................................................... 156
5.2. Zend_Application_Bootstrap_Bootstrapper .............................................. 160
5.3. Zend_Application_Bootstrap_ResourceBootstrapper ................................ 161
5.4. Zend_Application_Bootstrap_BootstrapAbstract ....................................... 162
5.5. Zend_Application_Bootstrap_Bootstrap ................................................... 165
5.6. Zend_Application_Resource_Resource ................................................... 166
5.7. Zend_Application_Resource_ResourceAbstract ....................................... 166
6. Plugins de ressources disponibles .................................................................... 168
6.1. Zend_Application_Resource_Cachemanager ........................................... 168
6.2. Zend_Application_Resource_Db ............................................................. 169
6.3. Zend_Application_Resource_Frontcontroller ............................................ 170
6.4. Zend_Application_Resource_Layout ....................................................... 171
6.5. Zend_Application_Resource_Locale ....................................................... 171
6.6. Zend_Application_Resource_Log ............................................................ 172
6.7. Zend_Application_Resource_Multidb ....................................................... 173

94
Guide de référence
Zend Framework

6.8. Zend_Application_Resource_Mail ........................................................... 174


6.9. Zend_Application_Resource_Modules ..................................................... 174
6.10. Zend_Application_Resource_Navigation ................................................ 176
6.11. Zend_Application_Resource_Router ..................................................... 176
6.12. Zend_Application_Resource_Session .................................................... 176
6.13. Zend_Application_Resource_View ........................................................ 177
Zend_Auth ................................................................................................................... 178
1. Introduction ...................................................................................................... 178
1.1. Adaptateurs ........................................................................................... 178
1.2. Résultats ............................................................................................... 179
1.3. Persistance d'identité ............................................................................. 180
1.4. Utilisation de Zend_Auth ........................................................................ 183
2. Authentification avec une table de base de données .......................................... 184
2.1. Introduction ........................................................................................... 184
2.2. Utilisation avancée : maintenir persistant l'objet de résultat DbTable .......... 186
2.3. Utilisation avancée par l'exemple ............................................................ 186
3. Authentification "Digest" .................................................................................... 188
3.1. Introduction ........................................................................................... 188
3.2. Spécifications ........................................................................................ 188
3.3. Identité .................................................................................................. 188
4. Adaptateur d'authentification HTTP ................................................................... 189
4.1. Introduction ........................................................................................... 189
4.2. Fonctionnement ..................................................................................... 189
4.3. Options de configuration ........................................................................ 190
4.4. Résolveurs ............................................................................................ 190
4.5. Usage général : ..................................................................................... 191
5. LDAP Authentication ........................................................................................ 192
5.1. Introduction ........................................................................................... 192
5.2. Usage ................................................................................................... 192
5.3. The API ................................................................................................ 194
5.4. Server Options ...................................................................................... 195
5.5. Collecting Debugging Messages ............................................................. 198
5.6. Common Options for Specific Servers .................................................... 199
6. Authentification OpenID .................................................................................... 201
6.1. Introduction ........................................................................................... 201
6.2. Spécifications ........................................................................................ 201
Zend_Barcode ............................................................................................................. 203
1. Introduction ...................................................................................................... 203
2. Création de code-barres avec la classe Zend_Barcode ....................................... 203
2.1. Utilisation de la fabrique Zend_Barcode::factory ...................................... 203
2.2. Tracer un code-barres ........................................................................... 204
2.3. Générer le rendu d'un code-barres ......................................................... 204
3. Zend_Barcode Objects ..................................................................................... 205
3.1. Common Options .................................................................................. 206
3.2. Common Additional Getters ................................................................... 208
3.3. Description of shipped barcodes ............................................................. 208
4. Zend_Barcode Renderers ................................................................................. 215
4.1. Common Options .................................................................................. 215
4.2. Zend_Barcode_Renderer_Image ............................................................ 216
4.3. Zend_Barcode_Renderer_Pdf ................................................................ 217
Zend_Cache ................................................................................................................ 218
1. Introduction ...................................................................................................... 218
2. Aspect théorique .............................................................................................. 220
2.1. La méthode de fabrique de Zend_Cache ................................................ 221

95
Guide de référence
Zend Framework

2.2. Baliser les enregistrements .................................................................... 222


2.3. Nettoyer le cache .................................................................................. 222
3. Les frontends Zend_Cache ............................................................................... 223
3.1. Zend_Cache_Core ................................................................................ 223
3.2. Zend_Cache_Frontend_Output ............................................................... 226
3.3. Zend_Cache_Frontend_Function ............................................................ 227
3.4. Zend_Cache_Frontend_Class ................................................................ 228
3.5. Zend_Cache_Frontend_File ................................................................... 229
3.6. Zend_Cache_Frontend_Page ................................................................. 230
4. Les backends Zend_Cache .............................................................................. 235
4.1. Zend_Cache_Backend_File .................................................................... 235
4.2. Zend_Cache_Backend_Sqlite ................................................................. 237
4.3. Zend_Cache_Backend_Memcached ....................................................... 237
4.4. Zend_Cache_Backend_Apc ................................................................... 238
4.5. Zend_Cache_Backend_Xcache .............................................................. 239
4.6. Zend_Cache_Backend_ZendPlatform ..................................................... 239
4.7. Zend_Cache_Backend_TwoLevels ......................................................... 239
4.8. Zend_Cache_Backend_ZendServer_Disk et
Zend_Cache_Backend_ZendServer_ShMem ................................................ 241
5. Le gestionnaire de Cache ................................................................................. 241
Zend_Captcha ............................................................................................................. 245
1. Introduction ...................................................................................................... 245
2. Opération Captcha ........................................................................................... 245
3. Adaptateurs CAPTCHA .................................................................................... 246
3.1. Zend_Captcha_Word ............................................................................. 246
3.2. Zend_Captcha_Dumb ............................................................................ 247
3.3. Zend_Captcha_Figlet ............................................................................. 247
3.4. Zend_Captcha_Image ............................................................................ 247
3.5. Zend_Captcha_ReCaptcha .................................................................... 248
Zend_CodeGenerator ................................................................................................... 249
1. Introduction ...................................................................................................... 249
1.1. Théorie ................................................................................................. 249
2. Exemples Zend_CodeGenerator ....................................................................... 251
3. Zend_CodeGenerator Réference ....................................................................... 255
3.1. Classes abstraites et interfaces .............................................................. 255
3.2. Classes CodeGenerator concrêtes ......................................................... 256
Zend_Config ................................................................................................................ 262
1. Introduction ...................................................................................................... 262
2. Aspect théorique .............................................................................................. 263
3. Zend_Config_Ini ............................................................................................... 264
4. Zend_Config_Xml ............................................................................................. 266
Zend_Config_Writer ...................................................................................................... 271
1. Zend_Config_Writer .......................................................................................... 271
Zend_Console_Getopt .................................................................................................. 274
1. Introduction ...................................................................................................... 274
2. Déclarer les règles Getopt ................................................................................ 275
2.1. Déclarer des options avec la syntaxe courte ........................................... 275
2.2. Déclarer des options avec la syntaxe longue ........................................... 275
3. Extraire les options et les arguments ................................................................. 276
3.1. Manipuler les exceptions Getopt ............................................................. 276
3.2. Extraire les options par nom .................................................................. 277
3.3. Extraire les options ................................................................................ 277
3.4. Extraction des arguments sans option .................................................... 278
4. Configurer Zend_Console_Getopt ..................................................................... 278

96
Guide de référence
Zend Framework

4.1. Ajouter des règles d'options ................................................................... 278


4.2. Ajouter des messages d'aide ................................................................. 279
4.3. Ajouter des alias aux options ................................................................. 279
4.4. Ajouter des listes d'arguments ................................................................ 279
4.5. Ajouter une configuration ....................................................................... 280
Zend_Controller ........................................................................................................... 282
1. Zend_Controller - Démarrage rapide ................................................................. 282
1.1. Introduction ........................................................................................... 282
1.2. Démarrage rapide ................................................................................. 282
2. Fondations de Zend_Controller ......................................................................... 286
3. Le contrôleur frontal (Front Controller) ............................................................... 289
3.1. Présentation générale ............................................................................ 289
3.2. Méthodes principales ............................................................................. 290
3.3. Méthodes d'accès à l'environnement ...................................................... 292
3.4. Paramètres du contrôleur frontal ............................................................ 293
3.5. Étendre le contrôleur frontal ................................................................... 294
4. L'objet Requête ................................................................................................ 294
4.1. Introduction ........................................................................................... 294
4.2. Les requêtes HTTP ............................................................................... 295
4.3. Sous-classer l'objet Requête .................................................................. 298
5. Routeur Standard ............................................................................................. 299
5.1. Introduction ........................................................................................... 299
5.2. Utilisation d'un routeur ........................................................................... 301
5.3. Utilisation basique du routeur de réécriture ............................................. 301
5.4. Routes par défaut ................................................................................. 302
5.5. Base URL et sous dossiers .................................................................... 303
5.6. Paramètres globaux ............................................................................... 304
5.7. Types de route ...................................................................................... 304
5.8. Utiliser Zend_Config avec le RewriteRouter ............................................. 315
5.9. Dérivation de l'objet Router .................................................................... 316
6. Le distributeur .................................................................................................. 316
6.1. Vue d'ensemble .................................................................................... 316
6.2. Sous-classer le distributeur .................................................................... 318
7. Contrôleurs d'action .......................................................................................... 321
7.1. Introduction ........................................................................................... 321
7.2. Initialisation d'objet ................................................................................ 322
7.3. Détournement Pre et Post-Dispatch (Hook) ............................................. 323
7.4. Accesseurs ........................................................................................... 323
7.5. Intégration des Vues ............................................................................. 324
7.6. Méthodes utiles ..................................................................................... 326
7.7. Sous-classer le contrôleur d'action ......................................................... 326
8. Aides d'action (Helper) ..................................................................................... 328
8.1. Introduction ........................................................................................... 328
8.2. Initialisation des aides ............................................................................ 328
8.3. Le gestionnaire d'aide (Broker) ............................................................... 329
8.4. Aides d'action intégrées ......................................................................... 330
8.5. Écrire vos propres aides ........................................................................ 358
9. Objet de réponse ............................................................................................. 359
9.1. Utilisation .............................................................................................. 359
9.2. Manipulation des en-têtes ...................................................................... 361
9.3. Segments nommés ................................................................................ 361
9.4. Manipulation des exceptions dans l'objet de réponse ............................... 363
9.5. Dériver l'objet de réponse ...................................................................... 363
10. Plugins .......................................................................................................... 363

97
Guide de référence
Zend Framework

10.1. Introduction ......................................................................................... 363


10.2. Écrire des plugins ................................................................................ 364
10.3. Utilisation des plugins .......................................................................... 364
10.4. Récupération et manipulations des plugins ............................................ 366
10.5. Plugins inclus dans Zend Framework .................................................... 366
11. Utilisation de conventions de dossiers modulaires ............................................ 371
11.1. Introduction ......................................................................................... 371
11.2. Spécification des dossiers de modules .................................................. 372
11.3. Routage des modules .......................................................................... 373
11.4. Module ou contrôleur Default global ...................................................... 373
12. Exceptions avec MVC .................................................................................... 373
12.1. Introduction ......................................................................................... 373
12.2. Gestion des exceptions ........................................................................ 373
12.3. Différents types d'exceptions que vous pouvez rencontrer ...................... 375
Zend_Currency ............................................................................................................ 378
1. Introduction à Zend_Currency ........................................................................... 378
1.1. Pourquoi devriez-vous utiliser Zend_Currency ? ...................................... 378
2. Utiliser Zend_Currency ..................................................................................... 378
2.1. Utilisation de base ................................................................................. 378
2.2. Créer une monnaie basée sur une locale ................................................ 379
3. Options des monnaies ...................................................................................... 379
4. Qu'est ce qui définit une monnaie? ................................................................... 380
5. Où est le symbole monnétaire? ........................................................................ 382
6. A quoi ressemble une monnaie? ....................................................................... 383
7. Travailler avec les valeurs des monnaies (les montants) ..................................... 384
7.1. Travailler avec les valeurs des monnaies ................................................ 384
7.2. Utiliser la précision des monnaies .......................................................... 385
8. Calculs avec les monnaies ............................................................................... 386
9. Echanger (convertir) des monnaies ................................................................... 387
10. Informations complémentaires pour Zend_Currency .......................................... 388
10.1. Informations sur les monnaies .............................................................. 388
10.2. Optimisation des performances des monnaies ....................................... 389
Zend_Date ................................................................................................................... 390
1. Introduction ...................................................................................................... 390
1.1. Définissez toujours un fuseau horaire par défaut ..................................... 390
1.2. Pourquoi utiliser Zend_Date ? ................................................................ 390
2. Aspect théorique .............................................................................................. 391
2.1. Fonctionnement interne ......................................................................... 391
3. Méthodes de base ........................................................................................... 392
3.1. La date courante ................................................................................... 392
3.2. Zend_Date : exemples ........................................................................... 392
4. Zend_Date API Overview ................................................................................. 394
4.1. Zend_Date Options ............................................................................... 394
4.2. Working with Date Values ...................................................................... 395
4.3. Basic Zend_Date Operations Common to Many Date Parts ...................... 396
4.4. Comparing Dates .................................................................................. 399
4.5. Getting Dates and Date Parts ................................................................ 401
4.6. Working with Fractions of Seconds ......................................................... 402
4.7. Sunrise / Sunset .................................................................................... 402
5. Créer des dates ............................................................................................... 403
5.1. Créer la date actuelle ............................................................................ 403
5.2. Créer une date depuis une base de données .......................................... 403
5.3. Créer des dates depuis un tableau ......................................................... 404
6. Constants for General Date Functions ............................................................... 404

98
Guide de référence
Zend Framework

6.1. Using Constants .................................................................................... 404


6.2. List of All Constants .............................................................................. 405
6.3. Self-Defined OUTPUT Formats with ISO ................................................. 409
6.4. Self-Defined OUTPUT Formats Using PHP's date() Format Specifiers ....... 412
7. Exemples concrets ........................................................................................... 415
7.1. Vérifier des dates .................................................................................. 415
7.2. Levé et couché du soleil ........................................................................ 416
7.3. Fuseaux horaires (Timezones) ............................................................... 418
Zend_Db ...................................................................................................................... 420
1. Zend_Db_Adapter ............................................................................................ 420
1.1. Se connecter à un SGBD en utilisant un adaptateur ................................ 420
1.2. La base de données d'exemple .............................................................. 425
1.3. Lecture de résultats de requête .............................................................. 426
1.4. Effectuer des changements dans la base de données .............................. 429
1.5. Échapper des valeurs ou des identifiants ................................................ 433
1.6. Gérer les transactions dans une base de données ................................... 435
1.7. Lister et décrire les tables ...................................................................... 436
1.8. Fermer une connexion ........................................................................... 437
1.9. Exécuter des requêtes sur le driver directement ...................................... 438
1.10. Récupérer la version du serveur SGBD ................................................ 439
1.11. Notes sur des adaptateur spécifiques ................................................... 439
2. Zend_Db_Statement ......................................................................................... 443
2.1. Créer un statement ............................................................................... 443
2.2. Exécuter un statement ........................................................................... 443
2.3. Récupérer des résultats depuis un statement SELECT ............................ 444
3. Zend_Db_Profiler ............................................................................................. 446
3.1. Introduction ........................................................................................... 446
3.2. Utiliser le profileur ................................................................................. 447
3.3. Utilisation avancée du profileur ............................................................... 449
3.4. Profileurs spécialisés ............................................................................. 450
4. Zend_Db_Select .............................................................................................. 451
4.1. Introduction ........................................................................................... 451
4.2. Créer un objet Select ............................................................................ 452
4.3. Construction de requêtes Select ............................................................. 452
4.4. Exécuter des requêtes Select ................................................................. 465
4.5. Autres méthodes ................................................................................... 466
5. Zend_Db_Table ............................................................................................... 468
5.1. Introduction ........................................................................................... 468
5.2. Définir une classe de Table ................................................................... 468
5.3. Créer une instance de la classe de Table ............................................... 471
5.4. Insérer des enregistrement dans une table .............................................. 472
5.5. Mettre à jour des enregistrements dans une table .................................... 474
5.6. Supprimer des enregistrements d'une Table ............................................ 475
5.7. Récupérer des enregistrements par clé primaire ...................................... 475
5.8. Requêter pour plusieurs enregistrements ................................................ 477
5.9. Récupérer un seul enregistrement .......................................................... 480
5.10. Récupérer les méta données d'une Table ............................................. 480
5.11. Cacher les méta données de la table .................................................... 481
5.12. Personnaliser et étendre une classe de Table ....................................... 484
6. Zend_Db_Table_Row ....................................................................................... 487
6.1. Introduction ........................................................................................... 487
6.2. Récupérer un résultat (un "Row") ........................................................... 487
6.3. Sauvegarde un Row en base de données ............................................... 489
6.4. Sérialisation et désérialisation d'un Row ................................................. 490

99
Guide de référence
Zend Framework

6.5. Étendre la classe Row ........................................................................... 492


7. Zend_Db_Table_Rowset ................................................................................... 494
7.1. Introduction ........................................................................................... 494
7.2. Récupérer un Rowset ............................................................................ 494
7.3. Atteindre les Rows depuis un Rowset ..................................................... 495
7.4. Récupérer un Rowset en tant que tableau (Array) ................................... 497
7.5. Sérialisation et Désérialisation d'un Rowset ............................................. 497
7.6. Étendre la classe Rowset ...................................................................... 498
8. Relations Zend_Db_Table ................................................................................ 499
8.1. Introduction ........................................................................................... 499
8.2. Définir ses relations ............................................................................... 500
8.3. Récupérer des enregistrements dépendants (enfants) .............................. 502
8.4. Récupérer l'enregistrement parent .......................................................... 503
8.5. Récupérer des enregistrements dans une relation N-N (plusieurs-à-
plusieurs ou "many-to-many") ...................................................................... 505
8.6. Opérations d'écritures en cascade .......................................................... 507
9. Zend_Db_Table_Definition ................................................................................ 509
9.1. Introduction ........................................................................................... 509
9.2. Utilisation de base ................................................................................. 509
9.3. Utilisation avancée ................................................................................ 511
Zend_Debug ................................................................................................................ 513
1. Afficher des informations .................................................................................. 513
Zend_Dojo ................................................................................................................... 514
1. Introduction ...................................................................................................... 514
2. Zend_Dojo_Data: dojo.data Envelopes .............................................................. 514
2.1. Zend_Dojo_Data Usage ......................................................................... 514
2.2. Adding metadata to your containers ....................................................... 516
2.3. Advanced Use Cases ............................................................................ 516
3. Les aides de vues Dojo .................................................................................... 518
3.1. dojo() View Helper ................................................................................. 518
3.2. Dijit-Specific View Helpers ..................................................................... 523
4. Les éléments de formulaire et les décorateurs Dojo ........................................... 536
4.1. Dijit-Specific Form Decorators ................................................................ 537
4.2. Dijit-Specific Form Elements .................................................................. 539
4.3. Dojo Form Examples ............................................................................. 556
5. Zend_Dojo build layer support .......................................................................... 557
5.1. Introduction ........................................................................................... 557
5.2. Generating Custom Module Layers with Zend_Dojo_BuildLayer ................ 558
5.3. Generating Build Profiles with Zend_Dojo_BuildLayer .............................. 560
Zend_Dom ................................................................................................................... 563
1. Introduction ...................................................................................................... 563
2. Zend_Dom_Query ............................................................................................ 563
2.1. Aspect théorique ................................................................................... 563
2.2. Méthodes disponibles ............................................................................ 564
Zend_Exception ........................................................................................................... 566
1. Utiliser les exceptions ....................................................................................... 566
2. Utilisation classique .......................................................................................... 566
3. Exceptions précédentes .................................................................................... 567
Zend_Feed .................................................................................................................. 568
1. Introduction ...................................................................................................... 568
2. Importer des flux .............................................................................................. 569
2.1. Flux personnalisés ................................................................................. 570
3. Obtenir des flux à partir de pages Web ............................................................. 574
4. Consommer un flux RSS .................................................................................. 574

100
Guide de référence
Zend Framework

5.
Consommer un flux Atom ................................................................................. 576
6.
Consommer une entrée Atom particulière .......................................................... 577
7.
Modifier la structure du flux ou des entrées ....................................................... 577
8.
Classes personnalisées pour les flux et entrées ................................................. 578
9.
Zend_Feed_Reader .......................................................................................... 580
9.1. Introduction ........................................................................................... 580
9.2. Importing Feeds .................................................................................... 580
9.3. Retrieving Underlying Feed and Entry Sources ........................................ 581
9.4. Cache Support and Intelligent Requests ................................................. 582
9.5. Locating Feed URIs from Websites ........................................................ 583
9.6. Attribute Collections ............................................................................... 584
9.7. Retrieving Feed Information ................................................................... 585
9.8. Retrieving Entry/Item Information ............................................................ 588
9.9. Extending Feed and Entry APIs ............................................................. 591
10. Zend_Feed_Writer .......................................................................................... 595
10.1. Introduction ......................................................................................... 595
10.2. Architecture ......................................................................................... 595
10.3. Getting Started .................................................................................... 596
10.4. Setting Feed Data Points ..................................................................... 597
10.5. Setting Entry Data Points ..................................................................... 599
11. Zend_Feed_Pubsubhubbub ............................................................................ 601
11.1. What is Pubsubhubbub? ...................................................................... 601
11.2. Architecture ......................................................................................... 602
11.3. Zend_Feed_Pubsubhubbub_Publisher .................................................. 602
11.4. Zend_Feed_Pubsubhubbub_Subscriber ................................................ 603
Zend_File .................................................................................................................... 611
1. Zend_File_Transfer .......................................................................................... 611
1.1. Adaptateurs supportés par Zend_File_Transfer ....................................... 612
1.2. Options de Zend_File_Transfer .............................................................. 612
1.3. Vérification des fichiers .......................................................................... 613
1.4. Informations complémentaires sur les fichiers .......................................... 613
1.5. Progress for file uploads ........................................................................ 615
2. Validateurs pour Zend_File_Transfer ................................................................. 617
2.1. Utiliser les validateurs avec Zend_File_Transfer ...................................... 618
2.2. Validateur Count ................................................................................... 620
2.3. Validateur Crc32 ................................................................................... 621
2.4. Validateur ExcludeExtension .................................................................. 621
2.5. Validateur ExcludeMimeType ................................................................. 622
2.6. Validateur Exists ................................................................................... 623
2.7. Validateur Extension .............................................................................. 623
2.8. Validateur FilesSize ............................................................................... 624
2.9. Validateur ImageSize ............................................................................. 625
2.10. Validateur IsCompressed ..................................................................... 626
2.11. Validateur IsImage ............................................................................... 626
2.12. Validateur Hash ................................................................................... 626
2.13. Validateur Md5 .................................................................................... 627
2.14. Validateur MimeType ........................................................................... 627
2.15. Validateur NotExists ............................................................................. 629
2.16. Validateur Sha1 ................................................................................... 629
2.17. Validateur Size .................................................................................... 629
2.18. Validateur WordCount .......................................................................... 630
3. Filtres pour Zend_File_Transfer ........................................................................ 631
3.1. Utiliser les filtres avec Zend_File_Transfer .............................................. 631
3.2. Filtre Decrypt ........................................................................................ 632

101
Guide de référence
Zend Framework

3.3. Filtre Encrypt ......................................................................................... 633


3.4. Filtre LowerCase ................................................................................... 633
3.5. Filtre Rename ....................................................................................... 634
3.6. Filtre UpperCase ................................................................................... 635
Zend_Filter .................................................................................................................. 636
1. Introduction ...................................................................................................... 636
1.1. Qu'est-ce qu'un filtre ? ........................................................................... 636
1.2. Utilisation basique des filtres .................................................................. 636
1.3. Utilisation de la méthode statique staticFilter() ......................................... 636
2. Classes de filtre standards ............................................................................... 637
2.1. Alnum ................................................................................................... 637
2.2. Alpha .................................................................................................... 637
2.3. BaseName ............................................................................................ 637
2.4. Boolean ................................................................................................ 637
2.5. Callback ................................................................................................ 640
2.6. Compression et décompression .............................................................. 641
2.7. Decrypt ................................................................................................. 646
2.8. Digits .................................................................................................... 648
2.9. Dir ........................................................................................................ 648
2.10. Encrypt ............................................................................................... 648
2.11. HtmlEntities ......................................................................................... 651
2.12. Int ....................................................................................................... 651
2.13. LocalizedToNormalized ........................................................................ 651
2.14. NormalizedToLocalized ........................................................................ 653
2.15. Null ..................................................................................................... 654
2.16. PregReplace ....................................................................................... 655
2.17. RealPath ............................................................................................. 656
2.18. StringToLower ..................................................................................... 656
2.19. StringToUpper ..................................................................................... 657
2.20. StringTrim ........................................................................................... 657
2.21. Int ....................................................................................................... 657
2.22. StripTags ............................................................................................ 657
3. Chaînes de filtrage ........................................................................................... 658
3.1. Changing filter chain order ..................................................................... 658
4. Écriture de filtres .............................................................................................. 658
5. Zend_Filter_Input ............................................................................................. 659
5.1. Déclarer des règles de filtre et de validateur ........................................... 660
5.2. Créer le processeur de filtres et validateurs ............................................. 661
5.3. Récupérer les champs validés/filtré, et les éventuels rapports ................... 661
5.4. Utiliser des méta commandes pour contrôler les règles des filtres et
validateurs ................................................................................................... 664
5.5. Ajouter des espaces de noms comme noms de classes ........................... 669
6. Zend_Filter_Inflector ......................................................................................... 670
6.1. Opération .............................................................................................. 671
6.2. Créer des chemins vers des filtres alternatifs .......................................... 671
6.3. Paramétrer la cible de l'inflecteur ............................................................ 671
6.4. Règles d'inflexion .................................................................................. 672
6.5. Autres méthodes utilitaires ..................................................................... 674
6.6. Zend_Config avec Zend_Filter_Inflector .................................................. 675
Zend_Form .................................................................................................................. 676
1. Zend_Form ...................................................................................................... 676
2. Zend_Form démarrage rapide ........................................................................... 676
2.1. Créer un objet de formulaire .................................................................. 676
2.2. Ajouter des éléments au formulaire ........................................................ 676

102
Guide de référence
Zend Framework

2.3. Rendre (visuellement) un formulaire ....................................................... 678


2.4. Vérifier qu'un formulaire est valide .......................................................... 680
2.5. Les statuts d'erreur ................................................................................ 680
2.6. Assembler le tout ensemble ................................................................... 681
2.7. Utiliser un objet Zend_Config .............................................................. 682
2.8. Conclusion ............................................................................................ 683
3. Creating Form Elements Using Zend_Form_Element .......................................... 683
3.1. Plugin Loaders ...................................................................................... 683
3.2. Filters ................................................................................................... 686
3.3. Validators .............................................................................................. 687
3.4. Decorators ............................................................................................ 692
3.5. Metadata and Attributes ......................................................................... 694
3.6. Standard Elements ................................................................................ 695
3.7. Zend_Form_Element Methods ................................................................ 695
3.8. Configuration ......................................................................................... 697
3.9. Custom Elements .................................................................................. 698
4. Creating Forms Using Zend_Form .................................................................... 699
4.1. Plugin Loaders ...................................................................................... 700
4.2. Elements ............................................................................................... 701
4.3. Display Groups ..................................................................................... 705
4.4. Sub Forms ............................................................................................ 709
4.5. Metadata and Attributes ......................................................................... 710
4.6. Decorators ............................................................................................ 711
4.7. Validation .............................................................................................. 713
4.8. Methods ................................................................................................ 715
4.9. Configuration ......................................................................................... 718
4.10. Custom forms ...................................................................................... 719
5. Créer un visuel personnalisé en utilisant Zend_Form_Decorator .......................... 721
5.1. Configuration ......................................................................................... 721
5.2. Décorateurs standards ........................................................................... 722
5.3. Décorateurs personnalisés ..................................................................... 722
5.4. Rendre des décorateurs individuellement ................................................ 725
6. Standard Form Elements Shipped With Zend Framework ................................... 725
6.1. Zend_Form_Element_Button .................................................................. 725
6.2. Zend_Form_Element_Captcha ............................................................... 726
6.3. Zend_Form_Element_Checkbox ............................................................. 727
6.4. Zend_Form_Element_File ...................................................................... 727
6.5. Zend_Form_Element_Hidden ................................................................. 730
6.6. Zend_Form_Element_Hash .................................................................... 731
6.7. Zend_Form_Element_Image .................................................................. 731
6.8. Zend_Form_Element_MultiCheckbox ...................................................... 731
6.9. Zend_Form_Element_Multiselect ............................................................ 732
6.10. Zend_Form_Element_Password ........................................................... 732
6.11. Zend_Form_Element_Radio ................................................................. 733
6.12. Zend_Form_Element_Reset ................................................................. 733
6.13. Zend_Form_Element_Select ................................................................. 733
6.14. Zend_Form_Element_Submit ............................................................... 734
6.15. Zend_Form_Element_Text ................................................................... 734
6.16. Zend_Form_Element_Textarea ............................................................. 734
7. Décorateurs standards fournis avec Zend Framework ......................................... 734
7.1. Zend_Form_Decorator_Callback ..................................................... 734
7.2. Zend_Form_Decorator_Captcha ....................................................... 735
7.3. Zend_Form_Decorator_Description ............................................... 735
7.4. Zend_Form_Decorator_DtDdWrapper ............................................... 735

103
Guide de référence
Zend Framework

7.5. Zend_Form_Decorator_Errors ......................................................... 736


7.6. Zend_Form_Decorator_Fieldset ..................................................... 736
7.7. Zend_Form_Decorator_File ............................................................. 736
7.8. Zend_Form_Decorator_Form ............................................................. 736
7.9. Zend_Form_Decorator_FormElements ............................................. 736
7.10. Zend_Form_Decorator_FormErrors ............................................... 736
7.11. Zend_Form_Decorator_HtmlTag ..................................................... 737
7.12. Zend_Form_Decorator_Image ......................................................... 737
7.13. Zend_Form_Decorator_Label ......................................................... 737
7.14. Zend_Form_Decorator_PrepareElements ..................................... 738
7.15. Zend_Form_Decorator_ViewHelper ............................................... 738
7.16. Zend_Form_Decorator_ViewScript ............................................... 738
8. Internationaliser un formulaire Zend_Form ......................................................... 740
8.1. Initialiser l'i18n dans les formulaires ........................................................ 740
8.2. Cibles gérées par l'I18n ......................................................................... 741
9. Advanced Zend_Form Usage ........................................................................... 741
9.1. Array Notation ....................................................................................... 741
9.2. Multi-Page Forms .................................................................................. 744
Zend_Gdata ................................................................................................................. 746
1. Introduction ...................................................................................................... 746
1.1. Structure of Zend_Gdata ........................................................................ 746
1.2. Interacting with Google Services ............................................................ 747
1.3. Obtaining instances of Zend_Gdata classes ............................................ 747
1.4. Google Data Client Authentication .......................................................... 748
1.5. Dependencies ....................................................................................... 748
1.6. Creating a new Gdata client ................................................................... 748
1.7. Common Query Parameters ................................................................... 749
1.8. Fetching a Feed .................................................................................... 750
1.9. Working with Multi-page Feeds .............................................................. 750
1.10. Working with Data in Feeds and Entries ................................................ 751
1.11. Updating Entries .................................................................................. 751
1.12. Posting Entries to Google Servers ........................................................ 751
1.13. Deleting Entries on Google Servers ...................................................... 752
2. Authentification par procédé AuthSub ................................................................ 752
2.1. Création d'un client HTTP authentifié avec AuthSub ................................ 753
2.2. Destruction de l'authentification AuthSub ................................................. 754
3. Using the Book Search Data API ...................................................................... 754
3.1. Authenticating to the Book Search service .............................................. 754
3.2. Searching for books .............................................................................. 755
3.3. Using community features ...................................................................... 756
3.4. Book collections and My Library ............................................................. 758
4. Authentification avec ClientLogin ....................................................................... 759
4.1. Création d'un client HTTP "ClientLogin" authentifié .................................. 760
4.2. Fermer un client HTTP authentifié par ClientLogin ................................... 760
5. Using Google Calendar .................................................................................... 760
5.1. Connecting To The Calendar Service ..................................................... 761
5.2. Retrieving A Calendar List ..................................................................... 763
5.3. Retrieving Events .................................................................................. 764
5.4. Creating Events ..................................................................................... 766
5.5. Modifying Events ................................................................................... 769
5.6. Deleting Events ..................................................................................... 769
5.7. Accessing Event Comments ................................................................... 770
6. Using Google Documents List Data API ............................................................ 770
6.1. Get a List of Documents ........................................................................ 770

104
Guide de référence
Zend Framework

6.2. Upload a Document ............................................................................... 771


6.3. Searching the documents feed ............................................................... 772
7. Using Google Health ........................................................................................ 772
7.1. Connect To The Health Service ............................................................. 773
7.2. Profile Feed .......................................................................................... 775
7.3. Profile List Feed .................................................................................... 777
7.4. Sending Notices to the Register Feed ..................................................... 777
8. Using Google Spreadsheets ............................................................................. 778
8.1. Create a Spreadsheet ............................................................................ 778
8.2. Get a List of Spreadsheets .................................................................... 778
8.3. Get a List of Worksheets ....................................................................... 779
8.4. Interacting With List-based Feeds ........................................................... 779
8.5. Interacting With Cell-based Feeds .......................................................... 781
9. Using Google Apps Provisioning ....................................................................... 782
9.1. Setting the current domain ..................................................................... 783
9.2. Interacting with users ............................................................................. 783
9.3. Interacting with nicknames ..................................................................... 786
9.4. Interacting with email lists ...................................................................... 788
9.5. Interacting with email list recipients ......................................................... 789
9.6. Handling errors ..................................................................................... 790
10. Using Google Base ........................................................................................ 791
10.1. Connect To The Base Service .............................................................. 791
10.2. Retrieve Items ..................................................................................... 794
10.3. Insert, Update, and Delete Customer Items ........................................... 795
11. Utilisation des albums Web Picasa .................................................................. 797
11.1. Se connecter au service ...................................................................... 797
11.2. Comprendre et construire des requêtes ................................................ 800
11.3. Récupérer des flux et des éléments ...................................................... 801
11.4. Créer des ressources .......................................................................... 804
11.5. Supprimer des éléments ...................................................................... 806
12. Using the YouTube Data API .......................................................................... 807
12.1. Authentication ...................................................................................... 808
12.2. Developer Keys and Client ID .............................................................. 808
12.3. Retrieving public video feeds ................................................................ 808
12.4. Retrieving video comments .................................................................. 810
12.5. Retrieving playlist feeds ....................................................................... 810
12.6. Retrieving a list of a user's subscriptions ............................................... 811
12.7. Retrieving a user's profile ..................................................................... 811
12.8. Uploading Videos to YouTube .............................................................. 812
12.9. Browser-based upload ......................................................................... 813
12.10. Checking upload status ...................................................................... 814
12.11. Other Functions ................................................................................. 815
13. Attraper les exceptions Gdata ......................................................................... 815
Zend_Http .................................................................................................................... 817
1. Introduction ...................................................................................................... 817
1.1. Utilisation de Zend_Http_Client .............................................................. 817
1.2. Les paramètres de configuration ............................................................ 817
1.3. Utilisation basique ................................................................................. 818
1.4. Ajouts de paramètres GET et POST ....................................................... 819
1.5. Accéder à la dernière requête, ou réponse .............................................. 820
2. Zend_Http_Client - Utilisation avancée .............................................................. 820
2.1. Redirections HTTP ................................................................................ 820
2.2. Ajout de cookies et gestion de leur persistance ....................................... 820
2.3. Définir des en-têtes personnalisés .......................................................... 821

105
Guide de référence
Zend Framework

2.4. Envoi de fichiers ................................................................................... 822


2.5. Envoyer des données brutes via POST .................................................. 823
2.6. Authentification HTTP ............................................................................ 824
2.7. Envoyer plusieurs requêtes avec le même client ...................................... 824
2.8. Data Streaming ..................................................................................... 825
3. Zend_Http_Client - Adaptateurs de connexion ................................................... 826
3.1. Présentation globale .............................................................................. 826
3.2. Adaptateur Socket ................................................................................. 827
3.3. Adaptateur Proxy ................................................................................... 829
3.4. The cURL Adapter ................................................................................ 830
3.5. Adaptateur Test ..................................................................................... 831
3.6. Créer vos propres adaptateurs de connexion .......................................... 834
4. Zend_Http_Cookie and Zend_Http_CookieJar .................................................... 836
4.1. Introduction ........................................................................................... 836
4.2. Instancier des objets Zend_Http_Cookie ................................................. 836
4.3. Zend_Http_Cookie méthodes getter ........................................................ 837
4.4. Zend_Http_Cookie: Correspondance de scénario .................................... 838
4.5. Classe Zend_Http_CookieJar : Instanciation ............................................ 839
4.6. Ajouter des cookies à un objet Zend_Http_CookieJar ............................... 840
4.7. Récupérer les cookies présents dans un objet Zend_Http_CookieJar ........ 840
5. Zend_Http_Response ....................................................................................... 841
5.1. Introduction ........................................................................................... 841
5.2. Méthodes de tests booléennes ............................................................... 842
5.3. Méthodes accesseurs ............................................................................ 842
5.4. Analyseurs statiques de réponse HTTP .................................................. 843
Zend_InfoCard ............................................................................................................. 845
1. Introduction ...................................................................................................... 845
1.1. Basic Theory of Usage .......................................................................... 845
1.2. Using as part of Zend_Auth ................................................................... 845
1.3. Using the Zend_InfoCard component standalone ..................................... 847
1.4. Working with a Claims object ................................................................. 847
1.5. Attaching Information Cards to existing accounts ..................................... 848
1.6. Creating Zend_InfoCard Adapters .......................................................... 849
Zend_Json ................................................................................................................... 851
1. Introduction ...................................................................................................... 851
2. Utilisation de base ........................................................................................... 851
2.1. Pretty-printing JSON .............................................................................. 851
3. Utilisation avancée de Zend_Json ..................................................................... 852
3.1. Objets JSON ......................................................................................... 852
3.2. Encoding PHP objects ........................................................................... 852
3.3. Internal Encoder/Decoder ....................................................................... 852
3.4. JSON Expressions ................................................................................ 852
4. XML to JSON conversion ................................................................................. 853
5. Zend_Json_Server - JSON-RPC server ............................................................. 855
5.1. Advanced Details .................................................................................. 857
Zend_Layout ................................................................................................................ 863
1. Introduction ...................................................................................................... 863
2. Zend_Layout - Démarrage rapide ...................................................................... 863
2.1. Scripts de layout ................................................................................... 863
2.2. Utilisation de Zend_Layout avec le système MVC de Zend Framework ...... 864
2.3. Utilisation de Zend_Layout en composant indépendant ............................ 865
2.4. Layout d'exemple .................................................................................. 866
3. Zend_Layout options de configuration ............................................................... 868
3.1. Exemples .............................................................................................. 868

106
Guide de référence
Zend Framework

4. Zend_Layout, utilisation avancée ...................................................................... 870


4.1. Objets de vue personnalisés .................................................................. 870
4.2. Plugin de contrôleur frontal personnalisé ................................................. 871
4.3. Aide d'action personnalisée .................................................................... 871
4.4. Résolution de chemin de script personnalisé (inflecteur) ........................... 871
Zend_Ldap .................................................................................................................. 873
1. Introduction ...................................................................................................... 873
1.1. Theory of operation ............................................................................... 873
2. API overview ................................................................................................... 876
2.1. Configuration / options ........................................................................... 876
2.2. API Reference ....................................................................................... 878
3. Usage Scenarios .............................................................................................. 903
3.1. Authentication scenarios ........................................................................ 903
3.2. Basic CRUD operations ......................................................................... 904
3.3. Extended operations .............................................................................. 905
4. Tools ............................................................................................................... 906
4.1. Creation and modification of DN strings .................................................. 906
4.2. Using the filter API to create search filters ............................................... 906
4.3. Modify LDAP entries using the Attribute API ............................................ 906
5. Object oriented access to the LDAP tree using Zend_Ldap_Node ........................ 906
5.1. Basic CRUD operations ......................................................................... 906
5.2. Extended operations .............................................................................. 907
5.3. Tree traversal ........................................................................................ 907
6. Getting information from the LDAP server .......................................................... 907
6.1. RootDSE ............................................................................................... 907
6.2. Schema Browsing ................................................................................. 907
7. Serializing LDAP data to and from LDIF ............................................................ 908
7.1. Serialize a LDAP entry to LDIF .............................................................. 908
7.2. Deserialize a LDIF string into a LDAP entry ............................................ 909
Zend_Loader ............................................................................................................... 911
1. Charger les fichiers et les classes dynamiquement ............................................. 911
1.1. Charger des fichiers .............................................................................. 911
1.2. Charger des classes .............................................................................. 911
1.3. Tester si un fichier est lisible .................................................................. 912
1.4. Utiliser l'autoloader ................................................................................ 913
2. L'autoloader ..................................................................................................... 914
2.1. Utiliser le chargeur automatique (autoloader) ........................................... 914
2.2. Selecting a Zend Framework version ...................................................... 915
2.3. L'interface de l'autoloader ...................................................................... 917
2.4. Référence de l'autoloader ...................................................................... 917
3. Autoloaders de ressources ............................................................................... 920
3.1. Utilisation de l'autoloader de ressources ................................................. 920
3.2. L'autoloader de ressource Module .......................................................... 922
3.3. Utiliser les autoloaders de ressources comme fabriques d'objets ............... 922
3.4. Référence de l'autoloader de ressources ................................................ 922
4. Chargeur de Plugins ........................................................................................ 922
4.1. Utilisation basique ................................................................................. 923
4.2. Manipulation des chemins des Plugins .................................................... 924
4.3. Test des Plugins et récupération des noms de classe .............................. 924
4.4. Obtenir de meilleures performances avec les Plugins ............................... 924
Zend_Locale ................................................................................................................ 926
1. Introduction ...................................................................................................... 926
1.1. What is Localization .............................................................................. 926
1.2. What is a Locale? ................................................................................. 927

107
Guide de référence
Zend Framework

1.3. How are Locales Represented? ............................................................. 927


1.4. Selecting the Right Locale ..................................................................... 928
1.5. Usage of automatic Locales ................................................................... 928
1.6. Using a default Locale ........................................................................... 929
1.7. ZF Locale-Aware Classes ...................................................................... 930
1.8. Application wide locale .......................................................................... 930
1.9. Zend_Locale_Format::setOptions(array $options) .................................... 931
1.10. Speed up Zend_Locale and its subclasses ............................................ 931
2. Using Zend_Locale .......................................................................................... 932
2.1. Copying, Cloning, and Serializing Locale Objects .................................... 932
2.2. Equality ................................................................................................. 932
2.3. Default locales ...................................................................................... 933
2.4. Set a new locale ................................................................................... 933
2.5. Getting the language and region ............................................................ 933
2.6. Obtaining localized strings ..................................................................... 934
2.7. Obtaining translations for "yes" and "no" ................................................. 948
2.8. Get a list of all known locales ................................................................ 949
2.9. Detecting locales ................................................................................... 949
3. Normalization and Localization .......................................................................... 951
3.1. Number normalization: getNumber($input, Array $options) ....................... 951
3.2. Number localization ............................................................................... 952
3.3. Number testing ...................................................................................... 954
3.4. Float value normalization ....................................................................... 954
3.5. Floating point value localization .............................................................. 954
3.6. Floating point value testing .................................................................... 954
3.7. Integer value normalization .................................................................... 955
3.8. Integer point value localization ............................................................... 955
3.9. Integer value testing .............................................................................. 955
3.10. Numeral System Conversion ................................................................ 955
4. Working with Dates and Times ......................................................................... 957
4.1. Normalizing Dates and Times ................................................................ 957
4.2. Testing Dates ........................................................................................ 960
4.3. Normalizing a Time ............................................................................... 961
4.4. Testing Times ....................................................................................... 961
5. Supported locales ............................................................................................ 961
Zend_Log .................................................................................................................... 973
1. Présentation ..................................................................................................... 973
1.1. Créer un log ......................................................................................... 973
1.2. Messages de logs ................................................................................. 973
1.3. Détruire un log ...................................................................................... 974
1.4. Utiliser les priorités intégrées ................................................................. 974
1.5. Ajouter ses propres priorités .................................................................. 974
1.6. Comprendre les événements de logs ...................................................... 975
2. Rédacteurs (Writers) ........................................................................................ 975
2.1. Écrire vers un flux (stream) .................................................................... 975
2.2. Écrire dans des bases de données ......................................................... 976
2.3. Écrire vers Firebug ................................................................................ 976
2.4. Écrire vers un émail .............................................................................. 979
2.5. Ecrire dans lee journal du système ......................................................... 981
2.6. Ecrire vers le moniteur Zend Server ....................................................... 982
2.7. Déraciner les rédacteurs ........................................................................ 986
2.8. Tester avec un simulacre ....................................................................... 986
2.9. Additionner les rédacteurs ...................................................................... 986
3. Formateurs (mise en forme) ............................................................................. 987

108
Guide de référence
Zend Framework

3.1. Formatage simple .................................................................................. 987


3.2. Formater vers le XML ............................................................................ 987
4. Filtres .............................................................................................................. 988
4.1. Filtrer pour tous les rédacteurs (Writers) ................................................. 988
4.2. Filtrer pour une seule instance de rédacteur ............................................ 989
5. Utiliser la fabrique pour créer des logs .............................................................. 989
5.1. Options pour les objets d'écriture ........................................................... 990
5.2. Options des filtres ................................................................................. 991
5.3. Créer des objets d'écriture et des filtres configurés .................................. 991
Zend_Mail .................................................................................................................... 994
1. Introduction ...................................................................................................... 994
1.1. Pour commencer ................................................................................... 994
1.2. Configurer le transport sendmail par défaut ............................................. 994
2. Envoyer des émail en utilisant SMTP ................................................................ 995
3. Envoyer plusieurs émail par connexion SMTP ................................................... 996
4. Utiliser différents transports .............................................................................. 997
5. Émail HTML ..................................................................................................... 997
6. Fichiers joints ................................................................................................... 998
7. Ajouter des destinataires .................................................................................. 999
8. Contrôler les limites MIME ................................................................................ 999
9. En-têtes additionnels ........................................................................................ 999
10. Jeux de caractères ....................................................................................... 1000
11. Encodage ..................................................................................................... 1000
12. Authentification SMTP .................................................................................. 1001
13. Sécuriser les transports SMTP ...................................................................... 1001
14. Lire des émail .............................................................................................. 1002
14.1. Exemple simple avec Pop3 ................................................................ 1002
14.2. Ouvrir un stockage local ..................................................................... 1002
14.3. Ouvrir un stockage distant .................................................................. 1003
14.4. Extraire des messages et autres méthodes simples ............................. 1004
14.5. Travailler avec les messages ............................................................. 1004
14.6. Vérifier les drapeaux ("flags") ............................................................. 1006
14.7. Utiliser les dossiers ............................................................................ 1007
14.8. Utilisation avancée ............................................................................. 1009
Zend_Markup ............................................................................................................. 1013
1. Introduction .................................................................................................... 1013
2. Guide de démarrage avec Zend_Markup ......................................................... 1013
3. Analyseurs Zend_Markup (parsers) ................................................................. 1014
3.1. Theorie de l'analyse ............................................................................. 1014
3.2. L'analyseur BBCode ............................................................................ 1015
3.3. L'analyseur Textile ............................................................................... 1015
4. Moteurs de rendu Zend_Markup ..................................................................... 1016
4.1. Ajouter vos propres tags ...................................................................... 1016
4.2. Liste de tags ....................................................................................... 1017
Zend_Measure ........................................................................................................... 1019
1. Introduction .................................................................................................... 1019
2. Création d'une mesure ................................................................................... 1019
2.1. Créer des mesures à partir de nombres entiers et décimaux ................... 1020
2.2. Créer des mesures à partir de chaînes de caractères ............................. 1020
2.3. Mesures à partir de chaînes localisées ................................................. 1020
3. Récupérer des mesures ................................................................................. 1021
3.1. Récupération automatique .................................................................... 1021
3.2. Récupération des valeurs ..................................................................... 1022
3.3. Récupération de l'unité de mesure ........................................................ 1022

109
Guide de référence
Zend Framework

3.4. Récupération en tant que chaîne régionale ........................................... 1022


4. Manipuler des mesures .................................................................................. 1022
4.1. Convertir ............................................................................................. 1023
4.2. Ajouter et soustraire ............................................................................ 1023
4.3. Vérifier l'égalité des mesures ................................................................ 1024
4.4. Comparer les mesures ......................................................................... 1024
4.5. Changer manuellement des valeurs ...................................................... 1025
4.6. Changer manuellement de type ............................................................ 1025
5. Types de mesures ......................................................................................... 1025
5.1. Conseils pour Zend_Measure_Binary .................................................... 1028
5.2. Conseils pour Zend_Measure_Number ................................................. 1028
5.3. Chiffres romains .................................................................................. 1029
Zend_Memory ............................................................................................................ 1030
1. Présentation ................................................................................................... 1030
1.1. Introduction ......................................................................................... 1030
1.2. Aspect théorique ................................................................................. 1030
2. Manager de mémoire ..................................................................................... 1031
2.1. Créer un manager de mémoire ............................................................. 1031
2.2. Manager les objets mémoire ................................................................ 1032
2.3. Régler le manager de mémoire ............................................................ 1033
3. Objet mémoire ............................................................................................... 1034
3.1. Mobile ................................................................................................. 1034
3.2. Verrouillé ............................................................................................. 1034
3.3. Propriété "value" du manager de mémoire ............................................ 1034
3.4. Interface du conteneur de mémoire ...................................................... 1035
Zend_Mime ................................................................................................................ 1037
1. Zend_Mime .................................................................................................... 1037
1.1. Introduction ......................................................................................... 1037
1.2. Méthodes statiques et constantes ......................................................... 1037
1.3. Instancier Zend_Mime .......................................................................... 1038
2. Zend_Mime_Message ..................................................................................... 1038
2.1. Introduction ......................................................................................... 1038
2.2. Instancier Zend_Mime_Message .......................................................... 1038
2.3. Ajouter des parties MIME ..................................................................... 1038
2.4. Gérer les frontières .............................................................................. 1038
2.5. Parser une chaîne de caractère pour créer un objet Zend_Mime_Message
(expérimental) ............................................................................................ 1039
3. Zend_Mime_Part ............................................................................................ 1039
3.1. Introduction ......................................................................................... 1039
3.2. Instanciation ........................................................................................ 1039
3.3. Méthodes pour retourner la partie du message en une chaîne de
caractères .................................................................................................. 1039
Zend_Navigation ........................................................................................................ 1041
1. Introduction .................................................................................................... 1041
1.1. Pages et Conteneurs ........................................................................... 1041
1.2. Séparation des données (modèle) et du rendu (vue) .............................. 1041
2. Pages ............................................................................................................ 1041
2.1. Caractéristiques communes aux pages ................................................. 1042
2.2. Zend_Navigation_Page_Mvc ................................................................ 1044
2.3. Zend_Navigation_Page_Uri .................................................................. 1048
2.4. Créer des pages de type personnalisé .................................................. 1049
2.5. Créer des pages avec la fabrique ......................................................... 1050
3. Containers ..................................................................................................... 1052
3.1. Creating containers .............................................................................. 1052

110
Guide de référence
Zend Framework

3.2. Adding pages ...................................................................................... 1055


3.3. Removing pages ................................................................................. 1055
3.4. Finding pages ..................................................................................... 1056
3.5. Iterating containers .............................................................................. 1058
3.6. Other operations .................................................................................. 1058
Zend_Oauth ............................................................................................................... 1061
1. Introduction to OAuth ..................................................................................... 1061
1.1. Protocol Workflow ................................................................................ 1061
1.2. Security Architecture ............................................................................ 1062
1.3. Getting Started .................................................................................... 1063
Zend_OpenId ............................................................................................................. 1067
1. Introduction .................................................................................................... 1067
1.1. Qu'est ce qu'OpenID ? ......................................................................... 1067
1.2. Comment cela fonctionne-t-il ? ............................................................. 1067
1.3. Zend_OpenId Structure ........................................................................ 1068
1.4. Standards OpenID supportés ............................................................... 1068
2. Zend_OpenId_Consumer Basics ..................................................................... 1068
2.1. OpenID Authentication ......................................................................... 1068
2.2. Combining all Steps in One Page ......................................................... 1070
2.3. Consumer Realm ................................................................................. 1070
2.4. Immediate Check ................................................................................. 1071
2.5. Zend_OpenId_Consumer_Storage ........................................................ 1071
2.6. Simple Registration Extension .............................................................. 1074
2.7. Integration with Zend_Auth ................................................................... 1075
2.8. Integration with Zend_Controller ........................................................... 1077
3. Zend_OpenId_Provider ................................................................................... 1077
3.1. Quick Start .......................................................................................... 1077
3.2. Combined Provide Scripts .................................................................... 1080
3.3. Simple Registration Extension .............................................................. 1081
3.4. Anything Else? .................................................................................... 1083
Zend_Paginator .......................................................................................................... 1084
1. Introduction .................................................................................................... 1084
2. Utilisation ....................................................................................................... 1084
2.1. Paginer des collections de données ...................................................... 1084
2.2. The DbSelect and DbTableSelect adapter ............................................. 1085
2.3. Rendre des pages avec les scripts de vue ............................................ 1086
3. Configuration .................................................................................................. 1090
4. Utilisation avancée ......................................................................................... 1091
4.1. Adaptateurs de source de données personnalisée ................................. 1091
4.2. Styles de défilement personnalisés ....................................................... 1091
4.3. Fonctionnalité de mise en cache .......................................................... 1092
4.4. Zend_Paginator_AdapterAggregate Interface ......................................... 1093
Zend_Pdf ................................................................................................................... 1094
1. Introduction .................................................................................................... 1094
2. Créer et charger des documents PDF ............................................................. 1094
3. Sauvegarder les changement dans un document PDF ...................................... 1095
4. Les pages d'un document ............................................................................... 1095
4.1. Création de page ................................................................................. 1095
4.2. Clonage de page ................................................................................. 1096
5. Dessiner ........................................................................................................ 1097
5.1. Géométrie ........................................................................................... 1097
5.2. Couleurs ............................................................................................. 1097
5.3. Dessiner des formes ............................................................................ 1098
5.4. Dessiner du texte ................................................................................ 1100

111
Guide de référence
Zend Framework

5.5. Utiliser des polices de caractères ......................................................... 1101


5.6. Limitations des polices standard PDF ................................................... 1103
5.7. Extraction des polices .......................................................................... 1104
5.8. Insertion d'images ................................................................................ 1106
5.9. Style de lignes .................................................................................... 1106
5.10. Style de remplissage .......................................................................... 1107
5.11. Transformations linéaires ................................................................... 1108
5.12. Sauvegarder et restaurer l'état graphique ............................................ 1109
5.13. Zone de dessin ................................................................................. 1109
5.14. Styles ................................................................................................ 1110
5.15. Transparence .................................................................................... 1113
6. Interactive Features ........................................................................................ 1113
6.1. Destinations ........................................................................................ 1113
6.2. Actions ................................................................................................ 1118
6.3. Document Outline (bookmarks) ............................................................ 1120
6.4. Annotations ......................................................................................... 1122
7. Informations du document et métadonnées ...................................................... 1123
8. Exemple d'utilisation du module Zend_Pdf ....................................................... 1125
Zend_ProgressBar ...................................................................................................... 1127
1. Zend_ProgressBar .......................................................................................... 1127
1.1. Introduction ......................................................................................... 1127
1.2. Utilisation basique de Zend_Progressbar .............................................. 1127
1.3. Adaptateurs standard ........................................................................... 1127
Zend_Queue .............................................................................................................. 1132
1. Introduction .................................................................................................... 1132
2. Example usage .............................................................................................. 1132
3. Framework ..................................................................................................... 1133
3.1. Introduction ......................................................................................... 1134
3.2. Commonality among adapters .............................................................. 1134
4. Adapters ........................................................................................................ 1134
4.1. Specific Adapters - Configuration settings ............................................. 1135
4.2. Notes for Specific Adapters .................................................................. 1137
5. Customizing Zend_Queue ............................................................................... 1139
5.1. Creating your own adapter ................................................................... 1139
5.2. Creating your own message class ........................................................ 1140
5.3. Creating your own message iterator class ............................................. 1141
5.4. Creating your own queue class ........................................................... 1141
6. Stomp ............................................................................................................ 1141
6.1. Stomp - Supporting classes ................................................................. 1141
Zend_Reflection ......................................................................................................... 1142
1. Introduction .................................................................................................... 1142
2. Zend_Reflection Exemples .............................................................................. 1142
3. Réference de Zend_Reflection ........................................................................ 1143
3.1. Zend_Reflection_Docblock ................................................................... 1144
3.2. Zend_Reflection_Docblock_Tag ............................................................ 1144
3.3. Zend_Reflection_Docblock_Tag_Param ................................................ 1144
3.4. Zend_Reflection_Docblock_Tag_Return ................................................ 1145
3.5. Zend_Reflection_File ........................................................................... 1145
3.6. Zend_Reflection_Class ........................................................................ 1145
3.7. Zend_Reflection_Extension .................................................................. 1146
3.8. Zend_Reflection_Function .................................................................... 1146
3.9. Zend_Reflection_Method ...................................................................... 1146
3.10. Zend_Reflection_Parameter ............................................................... 1146
3.11. Zend_Reflection_Property .................................................................. 1147

112
Guide de référence
Zend Framework

Zend_Registry ............................................................................................................ 1148


1. Utiliser le registre ........................................................................................... 1148
1.1. Mettre des valeurs dans le registre ....................................................... 1148
1.2. Lire des valeurs du registre .................................................................. 1148
1.3. Construire un objet registre .................................................................. 1148
1.4. Accéder au registre comme à un tableau .............................................. 1149
1.5. Accéder au registre comme à un objet .................................................. 1149
1.6. Vérifier si un index existe ..................................................................... 1150
1.7. Étendre le registre ............................................................................... 1150
1.8. Décharger le registre statique ............................................................... 1151
Zend_Rest ................................................................................................................. 1152
1. Introduction .................................................................................................... 1152
2. Zend_Rest_Client ........................................................................................... 1152
2.1. Introduction ......................................................................................... 1152
2.2. Réponses ............................................................................................ 1153
2.3. Arguments de requêtes ........................................................................ 1154
3. Zend_Rest_Server .......................................................................................... 1155
3.1. Introduction ......................................................................................... 1155
3.2. Utilisation d'un serveur REST ............................................................... 1155
3.3. Appelé un service Zend_Rest_Server ................................................... 1156
3.4. Envoyer un statut personnalisé ............................................................. 1156
3.5. Renvoyer une réponse XML personnalisée ........................................... 1157
Zend_Search_Lucene ................................................................................................. 1158
1. Vue d'ensemble ............................................................................................. 1158
1.1. Introduction ......................................................................................... 1158
1.2. Objet "Document" et "Field" .................................................................. 1158
1.3. Comprendre les types de champs ........................................................ 1160
1.4. Documents HTML ................................................................................ 1160
1.5. Documents Word 2007 ........................................................................ 1161
1.6. Document Powerpoint 2007 ................................................................. 1163
1.7. Documents Excel 2007 ........................................................................ 1164
2. Créer des index ............................................................................................. 1165
2.1. Créer un nouvel index ......................................................................... 1165
2.2. Mettre à jour un index ......................................................................... 1165
2.3. Mise à jour de Documents ................................................................... 1165
2.4. Récupération de la taille de l'index ....................................................... 1166
2.5. Optimisation d'index ............................................................................. 1166
2.6. Permissions ......................................................................................... 1168
2.7. Limitations ........................................................................................... 1168
3. Searching an Index ........................................................................................ 1168
3.1. Building Queries .................................................................................. 1168
3.2. Search Results .................................................................................... 1170
3.3. Limiting the Result Set ......................................................................... 1171
3.4. Results Scoring ................................................................................... 1171
3.5. Search Result Sorting .......................................................................... 1172
3.6. Search Results Highlighting .................................................................. 1172
4. Langage de requêtes ..................................................................................... 1174
4.1. Termes ............................................................................................... 1174
4.2. Champs .............................................................................................. 1175
4.3. Jokers (Wildcards) ............................................................................... 1175
4.4. Term Modifiers .................................................................................... 1176
4.5. Range Searches .................................................................................. 1176
4.6. Fuzzy Searches ................................................................................... 1177
4.7. Matched terms limitation ...................................................................... 1177

113
Guide de référence
Zend Framework

4.8. Proximity Searches .............................................................................. 1177


4.9. Boosting a Term .................................................................................. 1177
4.10. Boolean Operators ............................................................................. 1178
4.11. Grouping ........................................................................................... 1179
4.12. Field Grouping ................................................................................... 1179
4.13. Escaping Special Characters .............................................................. 1180
5. API de construction de requêtes ..................................................................... 1180
5.1. Les Exceptions du parseur de requêtes ................................................ 1180
5.2. Requête sur un terme .......................................................................... 1181
5.3. Requête multi-termes ........................................................................... 1181
5.4. Requête booléene ............................................................................... 1182
5.5. Requête Joker (wildcard) ..................................................................... 1184
5.6. Requête floue (fuzzy query) ................................................................. 1184
5.7. Requête de phrase .............................................................................. 1185
5.8. Requête d'intervalle ............................................................................. 1187
6. Jeu de caractères .......................................................................................... 1188
6.1. Support UTF-8 et caractères sur un octet .............................................. 1188
6.2. Analyseur de texte par défaut .............................................................. 1188
6.3. Analyseurs de texte compatibles UTF-8 ................................................ 1188
7. Extensibilité .................................................................................................... 1190
7.1. Analyse de texte ................................................................................. 1190
7.2. Filtrage des segments .......................................................................... 1192
7.3. Algorithme de score ............................................................................. 1193
7.4. Conteneur de stockage ........................................................................ 1194
8. Agir avec Lucene Java ................................................................................... 1196
8.1. Formats de fichier ................................................................................ 1196
8.2. Répertoire Index .................................................................................. 1196
8.3. Code source Java ............................................................................... 1196
9. Avancé .......................................................................................................... 1197
9.1. Depuis Zend Framework 1.6, gestion des transformations de format
d'index ....................................................................................................... 1197
9.2. Utiliser les propriétés statiques de l'index .............................................. 1198
10. Bonnes pratiques ......................................................................................... 1199
10.1. Nommage des champs ...................................................................... 1199
10.2. Performance de l'indexation ............................................................... 1200
10.3. Indexation à l'arrêt du programme ...................................................... 1202
10.4. Récupération de documents par leur id unique .................................... 1202
10.5. Utilisation de la mémoire .................................................................... 1203
10.6. Encodage .......................................................................................... 1204
10.7. Maintenance de l'index ....................................................................... 1205
Zend_Serializer .......................................................................................................... 1206
1. Introduction .................................................................................................... 1206
1.1. Utiliser l'interface statique de Zend_Serializer ........................................ 1206
2. Zend_Serializer_Adapter ................................................................................. 1207
2.1. Zend_Serializer_Adapter_PhpSerialize .................................................. 1207
2.2. Zend_Serializer_Adapter_Igbinary ......................................................... 1207
2.3. Zend_Serializer_Adapter_Wddx ............................................................ 1207
2.4. Zend_Serializer_Adapter_Json ............................................................. 1208
2.5. Zend_Serializer_Adapter_Amf 0 et 3 ..................................................... 1208
2.6. Zend_Serializer_Adapter_PythonPickle ................................................. 1208
2.7. Zend_Serializer_Adapter_PhpCode ...................................................... 1209
Zend_Server .............................................................................................................. 1210
1. Introduction .................................................................................................... 1210
2. Zend_Server_Reflection .................................................................................. 1210

114
Guide de référence
Zend Framework

2.1. Introduction ......................................................................................... 1210


2.2. Utilisation ............................................................................................ 1210
Zend_Service ............................................................................................................. 1212
1. Introduction .................................................................................................... 1212
2. Zend_Service_Akismet ................................................................................... 1212
2.1. Introduction ......................................................................................... 1212
2.2. Verify an API key ................................................................................ 1213
2.3. Check for spam ................................................................................... 1213
2.4. Submitting known spam ....................................................................... 1214
2.5. Submitting false positives (ham) ........................................................... 1214
2.6. Zend-specific Methods ......................................................................... 1215
3. Zend_Service_Amazon ................................................................................... 1215
3.1. Introduction ......................................................................................... 1215
3.2. Codes de pays .................................................................................... 1216
3.3. Rechercher un produit Amazon spécifique avec son ASIN ...................... 1217
3.4. Lancer des recherches de produits sur Amazon .................................... 1217
3.5. Utiliser l'API alternative de requêtes ...................................................... 1218
3.6. Classes Zend_Service_Amazon ........................................................... 1218
4. Zend_Service_Amazon_Ec2 ........................................................................... 1224
4.1. Introduction ......................................................................................... 1224
4.2. What is Amazon Ec2? ......................................................................... 1224
4.3. Static Methods .................................................................................... 1224
5. Zend_Service_Amazon_Ec2: Instances ........................................................... 1224
5.1. Instance Types .................................................................................... 1224
5.2. Running Amazon EC2 Instances .......................................................... 1226
5.3. Amazon Instance Utilities ..................................................................... 1227
6. Zend_Service_Amazon_Ec2: Windows Instances ............................................. 1229
6.1. Windows Instances Usage ................................................................... 1230
7. Zend_Service_Amazon_Ec2: Reserved Instances ............................................ 1231
7.1. How Reserved Instances are Applied .................................................... 1231
7.2. Reserved Instances Usage .................................................................. 1231
8. Zend_Service_Amazon_Ec2: CloudWatch Monitoring ....................................... 1232
8.1. CloudWatch Usage .............................................................................. 1232
9. Zend_Service_Amazon_Ec2: Amazon Machine Images (AMI) ........................... 1234
9.1. AMI Information Utilities ....................................................................... 1234
9.2. AMI Attribute Utilities ........................................................................... 1235
10. Zend_Service_Amazon_Ec2: Elastic Block Stroage (EBS) ............................... 1236
10.1. Create EBS Volumes and Snapshots .................................................. 1237
10.2. Describing EBS Volumes and Snapshots ............................................ 1237
10.3. Attach and Detaching Volumes from Instances .................................... 1238
10.4. Deleting EBS Volumes and Snapshots ................................................ 1239
11. Zend_Service_Amazon_Ec2: Elastic IP Addresses ......................................... 1239
12. Zend_Service_Amazon_Ec2: Keypairs ........................................................... 1240
13. Zend_Service_Amazon_Ec2: Regions and Availability Zones .......................... 1241
13.1. Amazon EC2 Regions ........................................................................ 1241
13.2. Amazon EC2 Availability Zones .......................................................... 1242
14. Zend_Service_Amazon_Ec2: Security Groups ................................................ 1242
14.1. Security Group Maintenance .............................................................. 1242
14.2. Authorizing Access ............................................................................ 1243
14.3. Revoking Access ............................................................................... 1244
15. Zend_Service_Amazon_S3 ........................................................................... 1245
15.1. Introduction ....................................................................................... 1245
15.2. Registering with Amazon S3 ............................................................... 1245
15.3. API Documentation ............................................................................ 1245

115
Guide de référence
Zend Framework

15.4. Features ............................................................................................ 1245


15.5. Getting Started .................................................................................. 1245
15.6. Bucket operations .............................................................................. 1246
15.7. Object operations ............................................................................... 1247
15.8. Data Streaming ................................................................................. 1249
15.9. Stream wrapper ................................................................................. 1249
16. Zend_Service_Amazon_Sqs .......................................................................... 1250
16.1. Introduction ....................................................................................... 1250
16.2. Registering with Amazon SQS ............................................................ 1250
16.3. API Documentation ............................................................................ 1250
16.4. Features ............................................................................................ 1250
16.5. Getting Started .................................................................................. 1250
16.6. Queue operations .............................................................................. 1251
16.7. Message operations ........................................................................... 1252
17. Zend_Service_Audioscrobbler ....................................................................... 1252
17.1. Introduction ....................................................................................... 1252
17.2. Users ................................................................................................ 1253
17.3. Artists ............................................................................................... 1254
17.4. Tracks ............................................................................................... 1255
17.5. Tags ................................................................................................. 1255
17.6. Groups .............................................................................................. 1255
17.7. Forums ............................................................................................. 1256
18. Zend_Service_Delicious ................................................................................ 1256
18.1. Introduction ....................................................................................... 1256
18.2. Récupérer vos entrées ....................................................................... 1256
18.3. Zend_Service_Delicious_PostList ........................................................ 1257
18.4. Édition des entrées ............................................................................ 1258
18.5. Supprimer des entrées ....................................................................... 1259
18.6. Ajout d'entrées .................................................................................. 1259
18.7. Les étiquettes ("tags") ........................................................................ 1260
18.8. Les groupes d'étiquettes .................................................................... 1260
18.9. Données publiques ............................................................................ 1260
18.10. Client HTTP ..................................................................................... 1261
19. Zend_Service_DeveloperGarden ................................................................... 1262
19.1. Introduction to DeveloperGarden ........................................................ 1262
19.2. BaseUserService ............................................................................... 1263
19.3. IP Location ........................................................................................ 1264
19.4. Local Search ..................................................................................... 1264
19.5. Send SMS ......................................................................................... 1265
19.6. SMS Validation .................................................................................. 1265
19.7. Voice Call ......................................................................................... 1266
19.8. ConferenceCall .................................................................................. 1267
19.9. Performance and Caching .................................................................. 1268
20. Zend_Service_Flickr ..................................................................................... 1269
20.1. Introduction ....................................................................................... 1269
20.2. Trouver les photos et les informations des utilisateurs Flickr .................. 1269
20.3. Trouver des photos dans le pool d'un groupe ...................................... 1270
20.4. Récupérer les détails d'une image ...................................................... 1270
20.5. Classes de résultats Zend_Service_Flickr ............................................ 1270
21. Zend_Service_LiveDocx ................................................................................ 1272
21.1. Introduction to LiveDocx ..................................................................... 1272
21.2. Zend_Service_LiveDocx_MailMerge .................................................... 1274
22. Zend_Service_Nirvanix ................................................................................. 1286
22.1. Introduction ....................................................................................... 1286

116
Guide de référence
Zend Framework

22.2. Registering with Nirvanix .................................................................... 1286


22.3. API Documentation ............................................................................ 1286
22.4. Features ............................................................................................ 1287
22.5. Getting Started .................................................................................. 1287
22.6. Understanding the Proxy .................................................................... 1288
22.7. Examining Results ............................................................................. 1288
22.8. Handling Errors ................................................................................. 1289
23. Zend_Service_ReCaptcha ............................................................................. 1290
23.1. Introduction ....................................................................................... 1290
23.2. Utilisation la plus simple ..................................................................... 1290
23.3. Hiding email addresses ...................................................................... 1291
24. Zend_Service_Simpy .................................................................................... 1292
24.1. Introduction ....................................................................................... 1292
24.2. Liens ................................................................................................. 1292
24.3. Mots-clés ........................................................................................... 1294
24.4. Notes ................................................................................................ 1295
24.5. Listes de surveillance ......................................................................... 1296
25. Introduction .................................................................................................. 1297
25.1. Démarrage avec Zend_Service_SlideShare .................................. 1297
25.2. L'objet SlideShow .............................................................................. 1298
25.3. Récupérer un diaporama simplement .................................................. 1300
25.4. Récupérer des groupes de diaporamas ............................................... 1300
25.5. Politique de cache de Zend_Service_SlideShare .......................... 1301
25.6. Changer le comportement du client HTTP ........................................... 1302
26. Zend_Service_StrikeIron ............................................................................... 1302
26.1. Overview ........................................................................................... 1302
26.2. Registering with StrikeIron .................................................................. 1303
26.3. Getting Started .................................................................................. 1303
26.4. Making Your First Query .................................................................... 1303
26.5. Examining Results ............................................................................. 1304
26.6. Handling Errors ................................................................................. 1305
26.7. Checking Your Subscription ................................................................ 1305
27. Zend_Service_StrikeIron: Bundled Services ................................................... 1306
27.1. ZIP Code Information ......................................................................... 1306
27.2. U.S. Address Verification .................................................................... 1307
27.3. Sales & Use Tax Basic ...................................................................... 1308
28. Zend_Service_StrikeIron: Advanced Uses ...................................................... 1308
28.1. Using Services by WSDL ................................................................... 1308
28.2. Viewing SOAP Transactions ............................................................... 1309
29. Zend_Service_Technorati .............................................................................. 1309
29.1. Introduction ....................................................................................... 1309
29.2. Getting Started .................................................................................. 1310
29.3. Making Your First Query .................................................................... 1310
29.4. Consuming Results ............................................................................ 1311
29.5. Handling Errors ................................................................................. 1312
29.6. Checking Your API Key Daily Usage ................................................... 1312
29.7. Available Technorati Queries .............................................................. 1313
29.8. Zend_Service_Technorati Classes ...................................................... 1316
30. Zend_Service_Twitter ................................................................................... 1319
30.1. Introduction ....................................................................................... 1319
30.2. Authentication .................................................................................... 1320
30.3. Account Methods ............................................................................... 1320
30.4. Status Methods ................................................................................. 1321
30.5. User Methods .................................................................................... 1323

117
Guide de référence
Zend Framework

30.6. Direct Message Methods .................................................................... 1323


30.7. Friendship Methods ........................................................................... 1324
30.8. Favorite Methods ............................................................................... 1325
30.9. Block Methods ................................................................................... 1325
30.10. Zend_Service_Twitter_Search ........................................................... 1326
31. Zend_Service_WindowsAzure ....................................................................... 1328
31.1. Introduction ....................................................................................... 1328
31.2. Installing the Windows Azure SDK ...................................................... 1328
31.3. API Documentation ............................................................................ 1328
31.4. Features ............................................................................................ 1328
31.5. Architecture ....................................................................................... 1328
31.6. Zend_Service_WindowsAzure_Storage_Blob ....................................... 1328
31.7. Zend_Service_WindowsAzure_Storage_Table ..................................... 1333
31.8. Zend_Service_WindowsAzure_Storage_Queue ................................... 1340
32. Zend_Service_Yahoo .................................................................................... 1342
32.1. Introduction ....................................................................................... 1342
32.2. Rechercher sur le Web avec Yahoo! ................................................... 1342
32.3. Trouver des images avec Yahoo! ....................................................... 1343
32.4. Trouver des vidéos avec Yahoo! ......................................................... 1343
32.5. Trouver des entreprises et des services locaux avec Yahoo! ................. 1343
32.6. Rechercher dans Yahoo! News .......................................................... 1343
32.7. Rechercher avec Yahoo! Site Explorer Inbound Links ........................... 1344
32.8. Rechercher avec Yahoo! Site Explorer's PageData .............................. 1344
32.9. Classes Zend_Service_Yahoo ............................................................ 1344
Zend_Session ............................................................................................................ 1351
1. Introduction .................................................................................................... 1351
2. Usage basique ............................................................................................... 1351
2.1. Tutoriel d'exemples .............................................................................. 1352
2.2. Énumérer les espaces de noms de session ........................................... 1353
2.3. Accesseurs pour les espaces de noms de session ................................. 1353
3. Utilisation avancée ......................................................................................... 1354
3.1. Démarrer une session .......................................................................... 1354
3.2. Verrouiller les espaces de noms de session .......................................... 1355
3.3. Expiration d'un espace de noms ........................................................... 1355
3.4. Encapsulation de session et Contrôleurs ............................................... 1356
3.5. Limiter les instances multiples par espace de noms ............................... 1357
3.6. Travailler avec les tableaux .................................................................. 1357
3.7. Utiliser les sessions avec des objets ..................................................... 1358
3.8. Utiliser les sessions avec les tests unitaires .......................................... 1359
4. Gestion générale de la session ....................................................................... 1360
4.1. Options de configuration ...................................................................... 1361
4.2. L'erreur: "Headers Already Sent" .......................................................... 1364
4.3. Identifiants de session ......................................................................... 1364
4.4. rememberMe(integer $seconds) ................................................... 1365
4.5. forgetMe() ....................................................................................... 1366
4.6. sessionExists() ............................................................................. 1366
4.7. destroy(bool $remove_cookie = true, bool $readonly =
true) ....................................................................................................... 1366
4.8. stop() ............................................................................................... 1366
4.9. writeClose($readonly = true) .................................................. 1366
4.10. expireSessionCookie() ............................................................... 1367
4.11. setSaveHandler(Zend_Session_SaveHandler_Interface
$interface) ............................................................................................ 1367
4.12. namespaceIsset($namespace) ..................................................... 1367

118
Guide de référence
Zend Framework

4.13. namespaceUnset($namespace) ..................................................... 1367


4.14. namespaceGet($namespace) ......................................................... 1367
4.15. getIterator() ............................................................................... 1367
5. Zend_Session_SaveHandler_DbTable ............................................................. 1368
Zend_Soap ................................................................................................................ 1370
1. Zend_Soap_Server ......................................................................................... 1370
1.1. Constructeur de Zend_Soap_Server .................................................. 1370
1.2. Méthodes de définitions de l'API du service ........................................... 1371
1.3. Gestion des objets de requête et de réponse ........................................ 1372
2. Zend_Soap_Client .......................................................................................... 1374
2.1. Constructeur de Zend_Soap_Client .................................................. 1374
2.2. Effectuer des requêtes SOAP ............................................................... 1375
3. WSDL ............................................................................................................ 1376
3.1. Constructeur Zend_Soap_Wsdl ............................................................ 1376
3.2. addMessage() ..................................................................................... 1376
3.3. addPortType() ................................................................................. 1377
3.4. addPortOperation() ....................................................................... 1377
3.5. addBinding() ................................................................................... 1378
3.6. addBindingOperation() ................................................................. 1378
3.7. addSoapBinding() ........................................................................... 1378
3.8. addSoapOperation() ....................................................................... 1378
3.9. addService() ................................................................................... 1379
3.10. Correspondance de type .................................................................... 1379
3.11. addDocumentation() ..................................................................... 1381
3.12. Récupérer un document WSDL finalisé ............................................... 1381
4. Auto découverte ............................................................................................. 1381
4.1. Introduction à l'auto découverte ............................................................ 1381
4.2. Auto découverte de classe ................................................................... 1383
4.3. Auto découverte des fonctions ............................................................. 1383
4.4. Types de donnée auto découverts ........................................................ 1384
4.5. Styles de liaisons WSDL ...................................................................... 1385
Zend_Tag .................................................................................................................. 1386
1. Introduction .................................................................................................... 1386
2. Zend_Tag_Cloud ............................................................................................ 1386
2.1. Decorateurs ......................................................................................... 1387
Zend_Test .................................................................................................................. 1389
1. Introduction .................................................................................................... 1389
2. Zend_Test_PHPUnit ....................................................................................... 1389
2.1. Amorcer votre TestCase ...................................................................... 1391
2.2. Tester vos contrôleurs et vos applications MVC ..................................... 1392
2.3. Assertions ........................................................................................... 1394
2.4. Exemples ............................................................................................ 1396
3. Zend_Test_PHPUnit_Db ................................................................................. 1398
3.1. Quickstart ............................................................................................ 1398
3.2. Utilisation, API et possibilités d'extension .............................................. 1402
3.3. Utiliser l'adaptateur de tests ................................................................. 1404
Zend_Text .................................................................................................................. 1406
1. Zend_Text_Figlet ............................................................................................ 1406
2. Zend_Text_Table ........................................................................................... 1407
Zend_TimeSync ......................................................................................................... 1410
1. Introduction .................................................................................................... 1410
1.1. Pourquoi Zend_TimeSync ? ............................................................... 1410
1.2. Qu'est ce que NTP ? ........................................................................... 1411
1.3. Qu'est ce que SNTP? .......................................................................... 1411

119
Guide de référence
Zend Framework

1.4. Problèmes courants d'utilisation ............................................................ 1411


1.5. Décider quel serveur de temps utiliser .................................................. 1411
2. Utiliser Zend_TimeSync .................................................................................. 1412
2.1. Requêter un serveur de temps public .................................................... 1412
2.2. Serveurs de temps multiples ................................................................ 1412
2.3. Les protocoles des serveurs de temps .................................................. 1413
2.4. Utiliser les ports pour les serveurs de temps ......................................... 1413
2.5. Options pour les serveurs de temps ..................................................... 1413
2.6. Utiliser des serveurs de temps différents ............................................... 1414
2.7. Informations sur les serveurs de temps ................................................. 1414
2.8. Gérer les exceptions ............................................................................ 1414
Zend_Tool .................................................................................................................. 1416
1. Using Zend_Tool On The Command Line ........................................................ 1416
1.1. Installation ........................................................................................... 1416
1.2. General Purpose Commands ............................................................... 1417
1.3. Project Specific Commands .................................................................. 1417
1.4. Environment Customization .................................................................. 1420
2. Extending Zend_Tool ...................................................................................... 1421
2.1. Overview of Zend_Tool ........................................................................ 1421
2.2. Zend_Tool_Framework Extensions ....................................................... 1422
2.3. Zend_Tool_Project Extensions ............................................................. 1430
Zend_Tool_Framework ............................................................................................... 1432
1. Introduction .................................................................................................... 1432
2. Using the CLI Tool ......................................................................................... 1432
2.1. Setting up the CLI tool ......................................................................... 1433
2.2. Setting up the CLI tool on Unix-like Systems ......................................... 1433
2.3. Setting up the CLI tool on Windows ...................................................... 1435
2.4. Other Setup Considerations ................................................................. 1436
2.5. Where To Go Next? ............................................................................ 1436
3. Architecture .................................................................................................... 1437
3.1. Registry .............................................................................................. 1437
3.2. Providers ............................................................................................. 1438
3.3. Loaders ............................................................................................... 1439
3.4. Manifests ............................................................................................ 1440
3.5. Clients ................................................................................................ 1442
4. Creating Providers to use with Zend_Tool_Framework ...................................... 1442
4.1. How Zend Tool finds your Providers ..................................................... 1443
4.2. Basic Instructions for Creating Providers ............................................... 1443
4.3. The response object ............................................................................ 1444
4.4. Advanced Development Information ...................................................... 1444
5. Shipped System Providers .............................................................................. 1447
5.1. The Version Provider ........................................................................... 1447
5.2. The Manifest Provider .......................................................................... 1447
6. Extending and Configuring Zend_Tool_Framework ........................................... 1447
6.1. Customizing Zend_Tool Console Client ................................................. 1447
Zend_Tool_Project ..................................................................................................... 1450
1. Introduction .................................................................................................... 1450
2. Créer un projet ............................................................................................... 1450
3. Fournisseurs de Zend_Tool_Project ................................................................ 1451
4. Rouages internes de Zend_Tool_Project ......................................................... 1451
4.1. Structure xml interne de Zend_Tool_Project .......................................... 1451
4.2. Etendre les rouages de Zend_Tool_Project ........................................... 1451
Zend_Translate .......................................................................................................... 1452
1. Introduction .................................................................................................... 1452

120
Guide de référence
Zend Framework

1.1. Démarrer avec le multi-linguisme .......................................................... 1452


2. Adaptateurs pour Zend_Translate ................................................................... 1453
2.1. Comment décider quel adaptateur de traduction utiliser ? ....................... 1454
2.2. Intégrer ses propres adaptateurs .......................................................... 1456
2.3. Améliorer les performances de tous les adaptateurs .............................. 1456
3. Utiliser les adaptateurs de traduction ............................................................... 1457
3.1. Structures des sources de traduction .................................................... 1458
3.2. Créer des fichiers sources de type tableau ............................................ 1460
3.3. Créer des fichiers sources Gettext ........................................................ 1461
3.4. Créer des fichiers source TMX ............................................................. 1462
3.5. Créer des fichiers source CSV ............................................................. 1462
3.6. Créer des fichiers sources INI .............................................................. 1463
3.7. Options pour les adaptateurs ............................................................... 1464
3.8. Gérer les langues ................................................................................ 1466
3.9. Détéction automatique de la source ...................................................... 1468
3.10. Vérifier les traductions ........................................................................ 1471
3.11. How to log not found translations ........................................................ 1472
3.12. Access to the source data .................................................................. 1473
4. Creating source files ....................................................................................... 1474
4.1. Creating Array source files ................................................................... 1474
4.2. Creating Gettext source files ................................................................ 1474
4.3. Creating TMX source files .................................................................... 1475
4.4. Creating CSV source files .................................................................... 1476
4.5. Creating INI source files ....................................................................... 1476
5. Additional features for translation .................................................................... 1477
5.1. Options for adapters ............................................................................ 1477
5.2. Handling languages ............................................................................. 1480
5.3. Automatic source detection .................................................................. 1482
5.4. Checking for translations ...................................................................... 1484
5.5. How to log not found translations ......................................................... 1485
5.6. Accessing source data ......................................................................... 1486
6. Notation des pluriels pour Translation .............................................................. 1487
6.1. Méthode traditionnelle .......................................................................... 1487
6.2. Méthode moderne de traduction du pluriel ............................................. 1487
6.3. Fichiers sources de pluriels .................................................................. 1488
6.4. Custom plural rules .............................................................................. 1489
Zend_Uri .................................................................................................................... 1491
1. Zend_Uri ........................................................................................................ 1491
1.1. Aperçu ................................................................................................ 1491
1.2. Créer un nouvel URI ............................................................................ 1491
1.3. Manipuler un URI existant .................................................................... 1491
1.4. Validation d'URI ................................................................................... 1492
1.5. Méthodes communes ........................................................................... 1492
Zend_Validate ............................................................................................................ 1494
1. Introduction .................................................................................................... 1494
1.1. Qu'est-ce qu'un validateur ? ................................................................. 1494
1.2. Utilisation basique des validateurs ........................................................ 1494
1.3. Messages personnalisés ...................................................................... 1495
1.4. Utilisation de la méthode statique is() ................................................ 1496
1.5. Translating messages .......................................................................... 1497
2. Classes de validation standard ........................................................................ 1498
2.1. Alnum ................................................................................................. 1498
2.2. Alpha .................................................................................................. 1498
2.3. Barcode .............................................................................................. 1498

121
Guide de référence
Zend Framework

2.4. Between .............................................................................................. 1498


2.5. Ccnum ................................................................................................ 1499
2.6. Date .................................................................................................... 1499
2.7. Db_RecordExists et Db_NoRecordExists .............................................. 1499
2.8. Digits .................................................................................................. 1501
2.9. EmailAddress ...................................................................................... 1501
2.10. Float ................................................................................................. 1503
2.11. GreaterThan ...................................................................................... 1503
2.12. Hex ................................................................................................... 1503
2.13. Hostname .......................................................................................... 1503
2.14. Iban .................................................................................................. 1505
2.15. InArray .............................................................................................. 1506
2.16. Int ..................................................................................................... 1506
2.17. Ip ...................................................................................................... 1506
2.18. LessThan .......................................................................................... 1506
2.19. NotEmpty .......................................................................................... 1506
2.20. Regex ............................................................................................... 1506
2.21. Validateurs de Sitemap ...................................................................... 1506
2.22. StringLength ...................................................................................... 1507
3. Chaînes de validation ..................................................................................... 1507
4. Écrire des validateurs ..................................................................................... 1508
5. Messages de validation .................................................................................. 1512
5.1. Limiter la taille d'un message de validation ............................................ 1517
Zend_Version ............................................................................................................. 1519
1. Lire la version de Zend Framework ................................................................. 1519
Zend_View ................................................................................................................. 1520
1. Introduction .................................................................................................... 1520
1.1. Script du Contrôleur ............................................................................. 1520
1.2. Script de vue ....................................................................................... 1520
1.3. Options ............................................................................................... 1521
1.4. Balises courtes dans les scripts de vue ................................................. 1521
1.5. Accesseurs utiles ................................................................................. 1522
2. Scripts de contrôleur ...................................................................................... 1523
2.1. Assigner des variables ......................................................................... 1523
2.2. Effectuer le rendu d'un script de vue ..................................................... 1524
2.3. Chemin des scripts de vue ................................................................... 1524
3. Scripts de vue ................................................................................................ 1525
3.1. Échapper la sortie ............................................................................... 1525
3.2. Utiliser des systèmes de gabarit (template) alternatifs ............................ 1526
4. Aides de vue ................................................................................................. 1532
4.1. Aides initiales ...................................................................................... 1532
4.2. Chemin des aides ............................................................................... 1584
4.3. Écrire des aides personnalisées ........................................................... 1585
4.4. Registering Concrete Helpers ............................................................... 1586
5. Zend_View_Abstract ....................................................................................... 1587
Zend_Wildfire ............................................................................................................. 1588
1. Zend_Wildfire ................................................................................................. 1588
Zend_XmlRpc ............................................................................................................ 1589
1. Introduction .................................................................................................... 1589
2. Zend_XmlRpc_Client ...................................................................................... 1589
2.1. Introduction ......................................................................................... 1589
2.2. Appels de méthodes ............................................................................ 1589
2.3. Types et conversions ........................................................................... 1590
2.4. Objet proxy du serveur ........................................................................ 1592

122
Guide de référence
Zend Framework

2.5. Gestion des erreurs ............................................................................. 1592


2.6. Introspection du serveur ....................................................................... 1593
2.7. De la requête à la réponse .................................................................. 1594
2.8. Client HTTP et tests ............................................................................ 1594
3. Zend_XmlRpc_Server ..................................................................................... 1594
3.1. Introduction ......................................................................................... 1594
3.2. Usage de base .................................................................................... 1594
3.3. Structures du serveur .......................................................................... 1595
3.4. Conventions ........................................................................................ 1595
3.5. Utiliser des espaces de noms (Namespaces) ........................................ 1596
3.6. Requêtes personnalisées ..................................................................... 1596
3.7. Réponses personnalisées .................................................................... 1596
3.8. Gérer les exceptions grâce aux erreurs (Faults) ..................................... 1597
3.9. Cacher la définition du serveur entre les requêtes .................................. 1597
3.10. Exemples d'utilisation ......................................................................... 1598
ZendX_Console_Process_Unix ................................................................................... 1602
1. ZendX_Console_Process_Unix ....................................................................... 1602
1.1. Introduction ......................................................................................... 1602
1.2. Basic usage of ZendX_Console_Process_Unix ...................................... 1602
ZendX_JQuery ........................................................................................................... 1604
1. Introduction .................................................................................................... 1604
2. ZendX_JQuery View Helpers .......................................................................... 1604
2.1. jQuery() View Helper ........................................................................... 1604
2.2. JQuery Helpers ................................................................................... 1610
3. ZendX_JQuery Form Elements and Decorators ................................................ 1616
3.1. General Elements and Decorator Usage ............................................... 1616
3.2. Form Elements .................................................................................... 1617
3.3. Form Decorators ................................................................................. 1617

123
Zend_Acl
1. Introduction
Zend_Acl fournit une implémentation légère et flexible de listes de contrôle d'accès (ACL) pour
la gestion de privilèges. En général, une application peut utiliser ces ACL pour contrôler l'accès
à certains objets par d'autres objets demandeurs.

Dans le cadre de cette documentation :

• une ressource est un objet dont l'accès est contrôlé,

• un rôle est un objet qui peut demander l'accès à une ressource.

Dit simplement, les rôles demandent l'accès à des ressources. Par exemple, si une personne
demande l'accès à une voiture, alors la personne est le rôle demandeur et la voiture est la
ressource, puisque l'accès à la voiture est soumis à un contrôle.

Grâce à la définition et à la mise en oeuvre d'une ACL, une application peut contrôler comment
les objets demandeurs (rôles) reçoivent l'accès (ou non) à des objets protégés (ressources).

1.1. A propos des ressources


Avec Zend_Acl, créer une ressource est très simple. Zend_Acl fournit
Zend_Acl_Resource_Interface pour faciliter la tâche aux développeurs. Une classe
a simplement besoin d'implémenter cette interface, qui consiste en une seule méthode,
getResourceId(), pour que Zend_Acl reconnaît l'objet comme étant une ressource. Par
ailleurs, Zend_Acl_Resource est fourni par Zend_Acl comme une implémentation basique
de ressource que les développeurs peuvent étendre si besoin.

Zend_Acl fournit une structure en arbre à laquelle plusieurs ressources (ou "zone sous contrôle
d'accès") peuvent être ajoutées. Puisque les ressources sont sauvées dans cet arbre, elles
peuvent être organisées du général (via la racine de l'arbre) jusqu'au particulier (via les feuilles
de l'arbre). Les requêtes envers une ressource spécifique vont automatiquement entraîner la
recherche de règles sur ses parents au sein de la structure hiérarchique des ressources, ce qui
permet un héritage simple des règles. Par exemple, si une règle par défaut doit être appliquée
à tous les bâtiments d'une ville, on pourra simplement assigner la règle à la ville elle-même, au
lieu de la répéter à tous les bâtiments. Mais certains bâtiments peuvent nécessiter des règles
spécifiques, et ceci peut se faire aisément avec Zend_Acl en assignant les règles nécessaires
à chaque bâtiment de la ville qui nécessite une exception. Une ressource peut hériter d'un seul
parent ressource, qui hérite lui même de son propre parent, et ainsi de suite.

Zend_Acl supporte aussi des privilèges pour chaque ressource (par exemple : "créer", "lire",
"modifier", "supprimer"), et le développeur peut assigner des règles qui affectent tous les
privilèges ou seuls certains privilèges d'une ressource.

1.2. A propos des rôles


Comme pour les ressources, créer un rôle est très simple. Tout rôle doit implémenter
Zend_Acl_Role_Interface qui consiste en une seule méthode getRoleId(). De plus,
Zend_Acl_Role est inclus dans Zend_Acl comme une implémentation basique de rôle que
les développeurs peuvent étendre si besoin.

Dans Zend_Acl, un rôle peut hériter de un ou plusieurs rôles. Ceci permet de supporter
l'héritage de règles à travers plusieurs rôles. Par exemple, un rôle utilisateur, comme "Éric", peut

124
Zend_Acl

appartenir à un ou plusieurs rôles d'action, tels que "éditeur" ou "administrateur". Le développeur


peut créer des règles pour "éditeur" et "administrateur" séparément, et "Éric" va hériter des règles
des deux sans avoir à définir des règles directement pour "Éric".

Bien que la possibilité d'hériter de plusieurs rôles soit très utile, l'héritage multiple introduit aussi
un certain degré de complexité. L'exemple ci-dessous illustre l'ambiguïté et la manière dont
Zend_Acl la résout.

Exemple 28. Héritages multiples entre rôles

Le code ci-dessous définit trois rôles de base - "guest", "member", et "admin" - desquels
d'autres rôles peuvent hériter. Ensuite, un rôle identifié par "someUser" est créé et hérite des
trois autres rôles. L'ordre selon lequel ces rôles apparaissent dans le tableau $parents est
important. Lorsque cela est nécessaire Zend_Acl recherche les règles d'accès définies non
seulement pour le rôle demandé (ici "someUser"), mais aussi pour les autres rôles desquels
le rôle recherché hérite (ici "guest", "member", et "admin") :

$acl = new Zend_Acl();

$acl->addRole(new Zend_Acl_Role('guest'))
->addRole(new Zend_Acl_Role('member'))
->addRole(new Zend_Acl_Role('admin'));

$parents = array('guest', 'member', 'admin');


$acl->addRole(new Zend_Acl_Role('someUser'), $parents);

$acl->add(new Zend_Acl_Resource('someResource'));

$acl->deny('invite', 'someResource');
$acl->allow('membre', 'someResource');

echo $acl->isAllowed('someUser', 'someResource') ? 'autorisé' : 'refusé';

Puisqu'il n'y a pas de règle spécifiquement définie pour le rôle "someUser" et


"someResource", Zend_Acl doit rechercher des règles qui pourraient être définies pour
des rôles dont "someUser" hérite. Premièrement, le rôle "admin" est contrôlé, et il n'y a pas
de règle d'accès définie pour lui. Ensuite, le rôle "member" est visité, et Zend_Acl trouve
qu'il y a une règle qui spécifie que "member" a un accès autorisé à "someResource".

Si Zend_Acl continuait à examiner toutes les règles de tous les rôles parents, il trouverait
que "someResource" est interdit d'accès à "someResource". Ceci introduit une ambiguïté
puisque maintenant "someUser" est à la fois autorisé et interdit d'accès à "someResource",
puisqu'il hérite de règles opposées de ses différents parents.

Zend_Acl résout cette ambiguïté en arrêtant la recherche de règles d'accès dès qu'une
première règle est découverte. Dans notre exemple, puisque le rôle "member" est examiné
avant le rôle "guest", le résultat devrait afficher "autorisé".

Lorsque vous spécifiez plusieurs parents pour un rôle, conservez à l'esprit


que le dernier parent listé est le premier dans lequel une règle utilisable sera
recherchée.

1.3. Créer la Liste de Contrôle d'Accès


Une ACL peut représenter n'importe quel ensemble d'objets physiques ou virtuels que vous
souhaitez. Pour les besoins de la démonstration, nous allons créer un système basique d'ACL

125
Zend_Acl

pour une Gestion de Contenus (CMS) qui comporte plusieurs niveaux de groupes au sein d'une
grande variété de zones. Pour créer un nouvel objet ACL, nous créons une nouvelle instance
d'ACL sans paramètres :

$acl = new Zend_Acl();

Jusqu'à ce que le développeur spécifie une règle "allow", Zend_Acl refuse


l'accès pour tous les privilèges sur chaque ressource pour chaque rôle.

1.4. Registre des rôles


Les systèmes de gestion de contenu (ou CMS) vont pratiquement toujours nécessiter une
hiérarchie de permissions afin de déterminer les droits de rédaction de ses utilisateurs. Il pourrait
y avoir un groupe "Invités" qui donne accès aux démonstrations, un groupe "Staff" pour la
majorité des utilisateurs du CMS qui réalisent la plupart du travail quotidien, un groupe "Éditeur"
pour ceux qui sont responsables de la publication, l'archivage, la relecture et la suppression, et
enfin un groupe "Administrateur" dont les tâches incluent toutes les tâches des autres groupes
plus des tâches de maintenance, de gestion des utilisateurs, configuration et backup ou export.
Cet ensemble de permissions peut être représenté dans un registre de rôles, permettant à
chaque groupe d'hériter des privilèges des groupes "parents". Les permissions peuvent être
rendues de la manière suivante :

Tableau 1. Contrôles d'Accès pour un exemple de CMS

Nom Permissions Permissions héritées de


Invité Voir N/A
Staff Modifier, Soumettre, Relire Invité
Éditeur Publier, Archiver, Supprimer Staff
Administrateur (Reçoit tous les accès) N/A

Pour cet exemple, Zend_Acl_Role est utilisé, mais n'importe quel objet qui implémente
Zend_Acl_Role_Interface est acceptable. Ces groupes peuvent être ajoutés au registre
des rôles comme suit :

$acl = new Zend_Acl();

// Ajoute des groupes au registre des rôles en utilisant Zend_Acl_Role

// Invité n'hérite d'aucun accès


$roleinvite = new Zend_Acl_Role('invite');
$acl->addRole($roleinvite);

// Staff hérite de Invité


$acl->addRole(new Zend_Acl_Role('staff'), $roleinvite);

// Ce que précède pourrait aussi être écrit:


// $acl->addRole(new Zend_Acl_Role('staff'), 'invite');

// Editeur hérite de staff


$acl->addRole(new Zend_Acl_Role('editeur'), 'staff');

// Administrateur n'hérite pas d'accès

126
Zend_Acl

$acl->addRole(new Zend_Acl_Role('administrateur'));

1.5. Définir les Contrôles d'Accès


Maintenant que l'ACL contient les rôles nécessaires, on peut établir des règles qui définissent
comment les ressources accèdent aux rôles. Vous avez sans doute noté que nous n'avons défini
aucune ressource particulière pour cet exemple, ce qui est plus simple pour illustrer comment les
règles s'appliquent à toutes les ressources. Zend_Acl fournit une implémentation dans laquelle
les règles doivent simplement être assignées du général au particulier, ce qui réduit le nombre
de règles spécifiques à ajouter. Ceci grâce à l'héritage.

Généralement Zend_Acl se conforme à une règle donnée si et seulement si


une règle plus spécifique ne s'applique pas.

En conséquence, on peut définir un nombre assez complexe de règles avec un nombre minimal
de code. Pour définir les permissions comme définies ci-dessus :

$acl = new Zend_Acl();

$roleinvite = new Zend_Acl_Role('invité');


$acl->addRole($roleinvite);
$acl->addRole(new Zend_Acl_Role('staff'), $roleinvite);
$acl->addRole(new Zend_Acl_Role('editeur'), 'staff');
$acl->addRole(new Zend_Acl_Role('administrateur'));

// Invité peut uniquement voir le contenu


$acl->allow($roleinvite, null, 'voir');

/*
ce qui précède peut aussi être écrit :
$acl->allow('invité', null, 'voir');
*/

// Staff hérite des privilèges de Invité, mais a aussi ses propres


// privilèges
$acl->allow('staff', null, array('edit', 'submit', 'relire'));

// Editeur hérite les privilèges voir, modifier, soumettre,


// et relire de Staff, mais a aussi besoin de certains privilèges
$acl->allow('editeur', null, array('publier', 'archiver', 'supprimer'));

// Administrateur hérite de rien, mais reçoit tous les privilèges


$acl->allow('administrateur');

Les valeurs NULL dans les appels allow() ci-dessus sont utilisées pour indiquer que les règles
s'appliquent à toutes les ressources.

1.6. Interroger les ACL


Nous avons maintenant une ACL flexible, qui peut être utilisée pour déterminer si l'objet appelant
a les permissions pour réaliser les fonctions au sein de l'application web. Interroger cette liste
est assez simple en utilisant la méthode isAllowed() :

echo $acl->isAllowed('invité', null, 'voir') ?


"autorisé" : "refusé";
// autorisé

127
Zend_Acl

echo $acl->isAllowed('staff', null, 'publier') ?


"autorisé" : "refusé";
// refusé

echo $acl->isAllowed('staff', null, 'relire') ?


"autorisé" : "refusé";
// autorisé

echo $acl->isAllowed('editeur', null, 'voir') ?


"autorisé" : "refusé";
// autorisé parce que hérité de Invité

echo $acl->isAllowed('editeur', null, 'modifier') ?


"autorisé" : "refusé";
// refusé parce qu'il n'y a pas de règle pour 'modifier'

echo $acl->isAllowed('administrateur', null, 'voir') ?


"autorisé" : "refusé";
// autorisé car administrateur est autorisé pour tout

echo $acl->isAllowed('administrateur') ?
"autorisé" : "refusé";
// autorisé car administrateur est autorisé pour tout

echo $acl->isAllowed('administrateur', null, 'modifier') ?


"autorisé" : "refusé";
// autorisé car administrateur est autorisé pour tout

2. Affiner les Contrôles d'Accès


2.1. Mieux définir les Contrôles d'Accès
L'ACL basique définie dans le chapitre précédentmontre comment plusieurs privilèges peuvent
être alloués pour l'ensemble de l'ACL (toutes les ressources). En pratique, toutefois, les contrôles
d'accès ont souvent des exceptions et des degrés de complexité variables. Zend_Acl permet
d'atteindre ce degré de finesse d'une manière directe et flexible.

Pour l'exemple du CMS, nous avons déterminé que bien que le groupe "Staff" couvre les besoins
de la plupart des utilisateurs, un groupe "Marketing" est nécessaire. Ce groupe doit avoir accès à
la newsletter et aux dernières news dans le CMS. Le groupe va recevoir la possibilité de publier
et d'archiver à la fois des newsletters et des news.

De plus, il a été demandé que le groupe "Staff" puisse voir les nouveaux textes, mais
pas les nouvelles news. Enfin, il devrait être impossible pour tout le monde (y compris les
administrateurs) d'archiver un contenu qui n'aurait une durée de vie que de 1 ou 2 jours.

En premier lieu, nous modifions le registre des rôles pour refléter ces changements. Nous avons
dit que le groupe "Marketing" a les même permissions de base que "Staff". Donc nous créons
"marketing" pour qu'il hérite des permissions de "staff".

// Le nouveau groupe Marketing hérite des permissions de Staff


$acl->addRole(new Zend_Acl_Role('marketing'), 'staff');

Ensuite, notez que les contrôles d'accès plus haut font référence à des ressources (ex.
"newsletters", "dernières news", "annonces"). Maintenant, nous ajoutons ces Ressources :

128
Zend_Acl

// Créer les Ressources pour les règles

// newsletter
$acl->addResource(new Zend_Acl_Resource('newsletter'));

// news
$acl->addResource(new Zend_Acl_Resource('news'));

// dernières news
$acl->addResource(new Zend_Acl_Resource('latest'), 'news');

// annonces
$acl->addResource(new Zend_Acl_Resource('announcement'), 'news');

Ensuite c'est simplement une manière de définir ces règles spécifiques sur les parties cibles de
l'ACL :

// Le Marketing doit être capable de publier


// et d'archiver les newsletters et les dernières news
$acl->allow('marketing',
array('newsletter', 'latest'),
array('publish', 'archive'));

// Staff (et marketing, par héritage),


// n'ont pas la permission de relire les dernières news
$acl->deny('staff', 'latest', 'relire');

// Personne (y compris les administrateurs)


// n'a la permission d'archiver des annonces
$acl->deny(null, 'annonce', 'archive');

On peut maintenant interroger les ACL sur base des dernières modifications :

echo $acl->isAllowed('staff', 'newsletter', 'publish') ?


"autorisé" : "refusé"; // refusé

echo $acl->isAllowed('marketing', 'newsletter', 'publish') ?


"autorisé" : "refusé"; // autorisé

echo $acl->isAllowed('staff', 'latest', 'publish') ?


"autorisé" : "refusé"; // refusé

echo $acl->isAllowed('marketing', 'latest', 'publish') ?


"autorisé" : "refusé"; // autorisé

echo $acl->isAllowed('marketing', 'latest', 'archive') ?


"autorisé" : "refusé"; // autorisé

echo $acl->isAllowed('marketing', 'latest', 'revise') ?


"autorisé" : "refusé"; // refusé

echo $acl->isAllowed('editor', 'announcement', 'archive') ?


"autorisé" : "refusé"; // refusé

echo $acl->isAllowed('administrator', 'announcement', 'archive') ?


"autorisé" : "refusé"; // refusé

129
Zend_Acl

2.2. Retirer les Contrôles d'Accès


Pour retirer une ou plusieurs règles des ACL, utilisez simplement la méthode removeAllow()
ou removeDeny(). Comme pour allow() et deny(), vous pouvez utiliser une valeur NULL
pour indiquer que la méthode s'applique à tous les rôles, ressources et / ou privilèges.

// Retire l'interdiction de relire les dernières news au Staff


// (et au marketing, par héritage)
$acl->removeDeny('staff', 'latest', 'relire');

echo $acl->isAllowed('marketing', 'latest', 'relire') ?


"autorisé" : "refusé"; // autorisé

// Retire l'autorisation de publier


// et archiver les newsletters au Marketing
$acl->removeAllow('marketing',
'newsletter',
array('publish', 'archive'));

echo $acl->isAllowed('marketing', 'newsletter', 'publish') ?


"autorisé" : "refusé"; // refusé

echo $acl->isAllowed('marketing', 'newsletter', 'archive') ?


"autorisé" : "refusé"; // refusé

Les privilèges peuvent être modifiés de manière incrémentielle comme indiqué au dessus, mais
une valeur NULL pour les privilèges écrase ces modifications incrémentielles.

// donne au groupe Marketing toutes les permissions


// sur les dernières nouvelles
$acl->allow('marketing', 'latest');

echo $acl->isAllowed('marketing', 'latest', 'publish') ?


"autorisé" : "refusé"; // autorisé

echo $acl->isAllowed('marketing', 'latest', 'archive') ?


"autorisé" : "refusé"; // autorisé

echo $acl->isAllowed('marketing', 'latest', 'anything') ?


"autorisé" : "refusé"; // autorisé

3. Utilisation avancée
3.1. Rendre les données ACL persistantes
Zend_Acl a été conçu pour ne pas nécessiter de technologie spécifique comme une base
de données ou un serveur de cache pour conserver les données ACL. Son implémentation
PHP permet de créer des outils d'administration basés sur Zend_Acl assez facilement. De
nombreuses situations nécessitent une certaine forme de maintenance ou de gestion des ACL,
et Zend_Acl fournit les méthodes pour définir et interroger les règles d'accès d'une application.

Le stockage des données ACL est dès lors laissé aux bons soins du développeur, dans la mesure
où les cas d'utilisation peuvent grandement varier d'un cas à l'autre. Puisque Zend_Acl est
sérialisable, les objets ACL peuvent être sérialisés avec la fonction serialize() de PHP, et le
résultat peut être stocké n'importe où le développeur le désire : fichier, base de donnée, cache.

130
Zend_Acl

3.2. Écrire des règles ACL conditionnelles avec des assertions


Parfois, une règle pour autoriser ou interdire l'accès d'un rôle à une ressource n'est pas absolu,
mais dépend de plusieurs critères. Par exemple, supposons qu'un certain accès peut être
autorisé, mais uniquement entre 8h du matin et 5h du soir. Un autre exemple consisterait à
interdire l'accès parce que la requête provient d'une adresse IP qui est notée comme source
d'abus. Zend_Acl dispose d'un support intégré pour implémenter des règles sur quoique ce soit
dont le développeur ait besoin.

Zend_Acl fourni le support pour les règles conditionnelles via


Zend_Acl_Assert_Interface. Pour mettre en oeuvre cette interface, il suffit d'implémenter
la méthode assert() :

class CleanIPAssertion implements Zend_Acl_Assert_Interface


{
public function assert(Zend_Acl $acl,
Zend_Acl_Role_Interface $role = null,
Zend_Acl_Resource_Interface $resource = null,
$privilege = null)
{
return $this->_isCleanIP($_SERVER['REMOTE_ADDR']);
}

protected function _isCleanIP($ip)


{
//...
}
}

Lorsqu'une classe d'assertion est disponible, le développeur doit fournir une instance de cette
classe lorsqu'il assigne une règle conditionnelle. Une règle qui est créée avec une assertion
s'applique uniquement dans les cas où l'assertion retourne une valeur TRUE.

$acl = new Zend_Acl();


$acl->allow(null, null, null, new CleanIPAssertion());

Le code ci-dessus crée une règle conditionnelle qui autorise l'accès à tous les privilèges, sur
tout et pour tout le monde, sauf lorsque l'adresse IP de la requête fait partie de la liste noire.
Si une requête provient d'une adresse IP qui n'est pas considérée comme "propre", alors la
règle d'autorisation ne s'applique pas. Puisque la règle s'applique à tous les rôles, toutes les
Ressources, et tous les privilèges, une IP "sale" aboutira à un refus d'accès. Ceci constitue un
cas spécial, et il faut bien noter que tous les autres cas (donc, si un rôle, une ressource ou un
privilège est défini pour la règle), une assertion qui échoue aboutit à une règle qui ne s'applique
pas et ce sont alors les autres règles qui servent à déterminer si l'accès est autorisé ou non.

La méthode assert() d'un objet d'assertion reçoit l'ACL, le rôle, la ressource et le privilège
auquel une requête d'autorisation (c.-à-d., isAllowed()) s'applique, afin de fournir un contexte
à la classe d'assertion pour déterminer ses conditions lorsque cela est nécessaire.

131
Zend_Amf
1. Introduction
Zend_Amf fournit le support pour l' Action Message Format(AMF) d'Adobe, permettant la
communication entre le Flash Playerd'Adobe et PHP. De manière spécifique, il fournit une
implémentation serveur pour gérer les requêtes envoyées par le Flash Player au serveur et fait
correspondre ces requêtes à des objets, à des méthodes de classe et à des callbacks arbitraires.

La spécification AMF3est librement disponible, et sert de référence pour les types de messages
qui peuvent être envoyés entre le Flash Player et le serveur.

2. Zend_Amf_Server
Zend_Amf_Server provides an RPC-style server for handling requests made from the Adobe
Flash Player using the AMF protocol. Like all Zend Framework server classes, it follows the
SoapServer API, providing an easy to remember interface for creating servers.

132
Zend_Amf

Exemple 29. Basic AMF Server

Let's assume that you have created a class Foo with a variety of public methods. You may
create an AMF server using the following code:

$server = new Zend_Amf_Server();


$server->setClass('Foo');
$response = $server->handle();
echo $response;

Alternately, you may choose to attach a simple function as a callback instead:

$server = new Zend_Amf_Server();


$server->addFunction('myUberCoolFunction');
$response = $server->handle();
echo $response;

You could also mix and match multiple classes and functions. When doing so, we suggest
namespacing each to ensure that no method name collisions occur; this can be done by
simply passing a second string argument to either addFunction() or setClass():

$server = new Zend_Amf_Server();


$server->addFunction('myUberCoolFunction', 'my')
->setClass('Foo', 'foo')
->setClass('Bar', 'bar');
$response = $server->handle();
echo $response;

The Zend_Amf_Server also allows services to be dynamically loaded based on a supplied


directory path. You may add as many directories as you wish to the server. The order
that you add the directories to the server will be the order that the LIFO search will be
performed on the directories to match the class. Adding directories is completed with the
addDirectory() method.

$server->addDirectory(dirname(__FILE__) .'/../services/');
$server->addDirectory(dirname(__FILE__) .'/../package/');

When calling remote services your source name can have underscore ("_") and dot (".")
directory delimiters. When an underscore is used PEAR and Zend Framework class naming
conventions will be respected. This means that if you call the service com_Foo_Bar the
server will look for the file Bar.php in the each of the included paths at com/Foo/Bar.php.
If the dot notation is used for your remote service such as com.Foo.Bar each included
path will have com/Foo/Bar.php append to the end to autoload Bar.php

All AMF requests sent to the script will then be handled by the server, and an AMF response
will be returned.

All Attached Methods and Functions Need Docblocks


Like all other server components in Zend Framework, you must document your
class methods using PHP docblocks. At the minimum, you need to provide
annotations for each required argument as well as the return value. As examples:

// Function to attach:

/**

133
Zend_Amf

* @param string $name


* @param string $greeting
* @return string
*/
function helloWorld($name, $greeting = 'Hello')
{
return $greeting . ', ' . $name;
}

// Attached class

class World
{
/**
* @param string $name
* @param string $greeting
* @return string
*/
public function hello($name, $greeting = 'Hello')
{
return $greeting . ', ' . $name;
}
}

Other annotations may be used, but will be ignored.

2.1. Connecting to the Server from Flex


Connecting to your Zend_Amf_Server from your Flex project is quite simple; you simply need
to point your endpoint URI to your Zend_Amf_Server script.

Say, for instance, you have created your server and placed it in the server.php file in your
application root, and thus the URI is http://example.com/server.php. In this case, you
would modify your services-config.xml file to set the channel endpoint uri attribute to this
value.

If you have never created a service-config.xml file you can do so by opening your project
in your Navigator window. Right click on the project name and select 'properties'. In the Project
properties dialog go into 'Flex Build Path' menu, 'Library path' tab and be sure the 'rpc.swc' file
is added to your projects path and Press Ok to close the window.

You will also need to tell the compiler to use the service-config.xml to find the
RemoteObject endpoint. To do this open your project properties panel again by right clicking
on the project folder from your Navigator and selecting properties. From the properties popup
select 'Flex Compiler' and add the string: -services "services-config.xml". Press Apply then
OK to return to update the option. What you have just done is told the Flex compiler to look to the
services-config.xml file for runtime variables that will be used by the RemotingObject class.

We now need to tell Flex which services configuration file to use for connecting to our remote
methods. For this reason create a new 'services-config.xml' file into your Flex project src
folder. To do this right click on the project folder and select 'new' 'File' which will popup a new
window. Select the project folder and then name the file 'services-config.xml' and press
finish.

Flex has created the new services-config.xml and has it open. Use the following example
text for your services-config.xml file. Make sure that you update your endpoint to match
that of your testing server. Make sure you save the file.

134
Zend_Amf

<?xml version="1.0" encoding="UTF-8"?>


<services-config>
<services>
<service id="zend-service"
class="flex.messaging.services.RemotingService"
messageTypes="flex.messaging.messages.RemotingMessage">
<destination id="zend">
<channels>
<channel ref="zend-endpoint"/>
</channels>
<properties>
<source>*</source>
</properties>
</destination>
</service>
</services>
<channels>
<channel-definition id="zend-endpoint"
class="mx.messaging.channels.AMFChannel">
<endpoint uri="http://example.com/server.php"
class="flex.messaging.endpoints.AMFEndpoint"/>
</channel-definition>
</channels>
</services-config>

There are two key points in the example. First, but last in the listing, we create an AMF channel,
and specify the endpoint as the URL to our Zend_Amf_Server:

<channel-definition id="zend-endpoint"
<endpoint uri="http://example.com/server.php"
class="flex.messaging.endpoints.AMFEndpoint"/>
</channel-definition>

Notice that we've given this channel an identifier, "zend-endpoint". The example create a service
destination that refers to this channel, assigning it an ID as well -- in this case "zend".

Within our Flex MXML files, we need to bind a RemoteObject to the service. In MXML, this might
be done as follows:

<mx:RemoteObject id="myservice"
fault="faultHandler(event)"
showBusyCursor="true"
destination="zend">

Here, we've defined a new remote object identified by "myservice" bound to the service
destination "zend" we defined in the services-config.xml file. We then call methods on it
in our ActionScript by simply calling "myservice.<method>". As an example:

myservice.hello("Wade");

When namespacing, you would use "myservice.<namespace>.<method>":

myservice.world.hello("Wade");

For more information on Flex RemoteObject invocation, visit the Adobe Flex 3 Help site.

135
Zend_Amf

2.2. Error Handling


By default, all exceptions thrown in your attached classes or functions will be caught and returned
as AMF ErrorMessages. However, the content of these ErrorMessage objects will vary based on
whether or not the server is in "production" mode (the default state).

When in production mode, only the exception code will be returned. If you disable production
mode -- something that should be done for testing only -- most exception details will be returned:
the exception message, line, and backtrace will all be attached.

To disable production mode, do the following:

$server->setProduction(false);

To re-enable it, pass a TRUE boolean value instead:

$server->setProduction(true);

Disable production mode sparingly!


We recommend disabling production mode only when in development. Exception
messages and backtraces can contain sensitive system information that you may
not wish for outside parties to access. Even though AMF is a binary format,
the specification is now open, meaning anybody can potentially deserialize the
payload.

One area to be especially careful with is PHP errors themselves. When the display_errors INI
directive is enabled, any PHP errors for the current error reporting level are rendered directly
in the output -- potentially disrupting the AMF response payload. We suggest turning off the
display_errors directive in production to prevent such problems

2.3. AMF Responses


Occasionally you may desire to manipulate the response object slightly, typically to return extra
message headers. The handle() method of the server returns the response object, allowing
you to do so.

Exemple 30. Adding Message Headers to the AMF Response

In this example, we add a 'foo' MessageHeader with the value 'bar' to the response prior
to returning it.

$response = $server->handle();
$response->addAmfHeader(new Zend_Amf_Value_MessageHeader('foo', true, 'bar'))
echo $response;

2.4. Typed Objects


Similar to SOAP, AMF allows passing objects between the client and server. This allows a great
amount of flexibility and coherence between the two environments.

Zend_Amf provides three methods for mapping ActionScript and PHP objects.

• First, you may create explicit bindings at the server level, using the setClassMap() method.
The first argument is the ActionScript class name, the second the PHP class name it maps to:

136
Zend_Amf

// Map the ActionScript class 'ContactVO' to the PHP class 'Contact':


$server->setClassMap('ContactVO', 'Contact');

• Second, you can set the public property $_explicitType in your PHP class, with the value
representing the ActionScript class to map to:

class Contact
{
public $_explicitType = 'ContactVO';
}

• Third, in a similar vein, you may define the public method getASClassName() in your PHP
class; this method should return the appropriate ActionScript class:

class Contact
{
public function getASClassName()
{
return 'ContactVO';
}
}

Although we have created the ContactVO on the server we now need to make its corresponding
class in AS3 for the server object to be mapped to.

Right click on the src folder of the Flex project and select New -> ActionScript File. Name the
file ContactVO and press finish to see the new file. Copy the following code into the file to finish
creating the class.

package
{
[Bindable]
[RemoteClass(alias="ContactVO")]
public class ContactVO
{
public var id:int;
public var firstname:String;
public var lastname:String;
public var email:String;
public var mobile:String;
public function ProductVO():void {
}
}
}

The class is syntactically equivalent to the PHP of the same name. The variable names are
exactly the same and need to be in the same case to work properly. There are two unique AS3
meta tags in this class. The first is bindable which makes fire a change event when it is updated.
The second tag is the RemoteClass tag which defines that this class can have a remote object
mapped with the alias name in this case ContactVO. It is mandatory that this tag the value that
was set is the PHP class are strictly equivalent.

[Bindable]
private var myContact:ContactVO;

private function getContactHandler(event:ResultEvent):void {

137
Zend_Amf

myContact = ContactVO(event.result);
}

The following result event from the service call is cast instantly onto the Flex ContactVO. Anything
that is bound to myContact will be updated with the returned ContactVO data.

2.5. Resources
Zend_Amf provides tools for mapping resource types returned by service classes into data
consumable by ActionScript.

In order to handle specific resource type, the user needs to create a plugin class named after the
resource name, with words capitalized and spaces removed (so, resource type "mysql result"
becomes MysqlResult), with some prefix, e.g. My_MysqlResult. This class should implement
one method, parse(), receiving one argument - the resource - and returning the value that
should be sent to ActionScript. The class should be located in the file named after the last
component of the name, e.g. MysqlResult.php.

The directory containing the resource handling plugins should be registered with Zend_Amf type
loader:

Zend_Amf_Parse_TypeLoader::addResourceDirectory(
"My",
"application/library/resources/My"
);

For detailed discussion of loading plugins, please see the plugin loader section.

Default directory for Zend_Amf resources is registered automatically and currently contains
handlers for "mysql result" and "stream" resources.

// Example class implementing handling resources of type mysql result


class Zend_Amf_Parse_Resource_MysqlResult
{
/**
* Parse resource into array
*
* @param resource $resource
* @return array
*/
public function parse($resource) {
$result = array();
while($row = mysql_fetch_assoc($resource)) {
$result[] = $row;
}
return $result;
}
}

Trying to return unknown resource type (i.e., one for which no handler plugin exists) will result
in an exception.

2.6. Connecting to the Server from Flash


Connecting to your Zend_Amf_Server from your Flash project is slightly different than from
Flex. However once the connection Flash functions with Zend_Amf_Server the same way is

138
Zend_Amf

flex. The following example can also be used from a Flex AS3 file. We will reuse the same
Zend_Amf_Server configuration along with the World class for our connection.

Open Flash CS and create and new Flash File (ActionScript 3). Name the document
ZendExample.fla and save the document into a folder that you will use for this example.
Create a new AS3 file in the same directory and call the file Main.as. Have both files open in your
editor. We are now going to connect the two files via the document class. Select ZendExample
and click on the stage. From the stage properties panel change the Document class to Main. This
links the Main.as ActionScript file with the user interface in ZendExample.fla. When you run
the Flash file ZendExample the Main.as class will now be run. Next we will add ActionScript
to make the AMF call.

We now are going to make a Main class so that we can send the data to the server and display
the result. Copy the following code into your Main.as file and then we will walk through the code
to describe what each element's role is.

package {
import flash.display.MovieClip;
import flash.events.*;
import flash.net.NetConnection;
import flash.net.Responder;

public class Main extends MovieClip {


private var gateway:String = "http://example.com/server.php";
private var connection:NetConnection;
private var responder:Responder;

public function Main() {


responder = new Responder(onResult, onFault);
connection = new NetConnection;
connection.connect(gateway);
}

public function onComplete( e:Event ):void{


var params = "Sent to Server";
connection.call("World.hello", responder, params);
}

private function onResult(result:Object):void {


// Display the returned data
trace(String(result));
}
private function onFault(fault:Object):void {
trace(String(fault.description));
}
}
}

We first need to import two ActionScript libraries that perform the bulk of the work. The first
is NetConnection which acts like a by directional pipe between the client and the server. The
second is a Responder object which handles the return values from the server related to the
success or failure of the call.

import flash.net.NetConnection;
import flash.net.Responder;

In the class we need three variables to represent the NetConnection, Responder, and the
gateway URL to our Zend_Amf_Server installation.

139
Zend_Amf

private var gateway:String = "http://example.com/server.php";


private var connection:NetConnection;
private var responder:Responder;

In the Main constructor we create a responder and a new connection to the Zend_Amf_Server
endpoint. The responder defines two different methods for handling the response from the server.
For simplicity I have called these onResult and onFault.

responder = new Responder(onResult, onFault);


connection = new NetConnection;
connection.connect(gateway);

In the onComplete function which is run as soon as the construct has completed we send the
data to the server. We need to add one more line that makes a call to the Zend_Amf_Server
World->hello function.

connection.call("World.hello", responder, params);

When we created the responder variable we defined an onResult and onFault function to handle
the response from the server. We added this function for the successful result from the server.
A successful event handler is run every time the connection is handled properly to the server.

private function onResult(result:Object):void {


// Display the returned data
trace(String(result));
}

The onFault function, is called if there was an invalid response from the server. This happens
when there is an error on the server, the URL to the server is invalid, the remote service or
method does not exist, and any other connection related issues.

private function onFault(fault:Object):void {


trace(String(fault.description));
}

Adding in the ActionScript to make the remoting connection is now complete. Running the
ZendExample file now makes a connection to Zend Amf. In review you have added the required
variables to open a connection to the remote server, defined what methods should be used when
your application receives a response from the server, and finally displayed the returned data to
output via trace().

2.7. Authentication
Zend_Amf_Server allows you to specify authentication and authorization hooks to control
access to the services. It is using the infrastructure provided by Zend_Auth and Zend_Acl
components.

In order to define authentication, the user provides authentication adapter extening


Zend_Amf_Auth_Abstract abstract class. The adapter should implement the
authenticate() method just like regular authentication adapter.

The adapter should use properties _username and _password from the parent
Zend_Amf_Auth_Abstract class in order to authenticate. These values are set by the server
using setCredentials() method before call to authenticate() if the credentials are
received in the AMF request headers.

140
Zend_Amf

The identity returned by the adapter should be an object containing property role for the ACL
access control to work.

If the authentication result is not successful, the request is not proceseed further and failure
message is returned with the reasons for failure taken from the result.

The adapter is connected to the server using setAuth() method:

$server->setAuth(new My_Amf_Auth());

Access control is performed by using Zend_Acl object set by setAcl() method:

$acl = new Zend_Acl();


createPermissions($acl); // create permission structure
$server->setAcl($acl);

If the ACL object is set, and the class being called defines initAcl() method, this method will
be called with the ACL object as an argument. The class then can create additional ACL rules
and return TRUE, or return FALSE if no access control is required for this class.

After ACL have been set up, the server will check if access is allowed with role set by the
authentication, resource being the class name (or NULL for function calls) and privilege being
the function name. If no authentication was provided, then if the anonymous role was defined,
it will be used, otherwise the access will be denied.

if($this->_acl->isAllowed($role, $class, $function)) {


return true;
} else {
require_once 'Zend/Amf/Server/Exception.php';
throw new Zend_Amf_Server_Exception("Access not allowed");
}

141
Zend_Application
1. Introduction
Zend_Application propose une interface de lancement (bootstrap) pour vos applications,
permettant la réutilisabilité des ressources utilisées, la vérification de dépendances et des
classes de bootstrap basées sur des modules. Ce composant s'occupe aussi de configurer
l'environnement PHP et propose l'autoload par défaut.

2. Zend_Application démarrage rapide


Il existe deux manières d'aborder Zend_Application, elles dépendent de la manière dont
vous commencez votre projet. Dans tous les cas, vous devrez créer une classe Bootstrap et
un fichier de configuration.

Si vous souhaitez utiliser Zend_Tool pour créer votre projet, continuez votre lecture. Si vous
ajoutez Zend_Application à un projet existant, vous devriez passer à la suite.

2.1. Utiliser Zend_Tool


La manière la plus rapide d'utiliser Zend_Application est d'appeler Zend_Tool pour créer
votre projet. Ceci va aussi créer la classe de Bootstrap.

Pour créer un projet, éxecutez la commande zf (sur les systèmes *nix) :

% zf create project newproject

Pour Windows, zf.bat:

C:> zf.bat create project newproject

Ceci va créer une structure de projet ressemblant à:

newproject
|-- application
| |-- Bootstrap.php
| |-- configs
| | `-- application.ini
| |-- controllers
| | |-- ErrorController.php
| | `-- IndexController.php
| |-- models
| `-- views
| |-- helpers
| `-- scripts
| |-- error
| | `-- error.phtml
| `-- index
| `-- index.phtml
|-- library
|-- public
| `-- index.php
`-- tests
|-- application
| `-- bootstrap.php

142
Zend_Application

|-- library
| `-- bootstrap.php
`-- phpunit.xml

Dans une telle structure, le bootstrap est newproject/application/Bootstrap.php, et


ressemble en premier lieux à ceci:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
}

Notez aussi la présence d'un fichier de configuration newproject/application/configs/


application.ini, il contient :

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Tous ces paramètres s'utilisent avec Zend_Application et avec le bootstrap.

Un autre fichier intéressant est newproject/public/index.php, qui invoque


Zend_Application et le démarre.

// Define path to application directory


defined('APPLICATION_PATH')
|| define('APPLICATION_PATH',
realpath(dirname(__FILE__) . '/../application'));

// Define application environment


defined('APPLICATION_ENV')
|| define('APPLICATION_ENV',
(getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
: 'production'));

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run


$application = new Zend_Application(
APPLICATION_ENV,
APPLICATION_PATH . '/configs/application.ini'
);
$application->bootstrap()
->run();

143
Zend_Application

Pour continuer le guide de démarrage rapide,voyez la section sur les Ressources.

2.2. Ajouter Zend_Application à votre existant


Les bases de Zend_Application sont très simples :

• Créez un fichier application/Bootstrap.php contenant une classe Bootstrap.

• Créez un fichier application/configs/application.ini contenant la configuration de


base pour Zend_Application.

• Modifiez public/index.php afin d'utiliser Zend_Application.

D'abord, créez la classe Bootstrap class. Dans le fichier application/Bootstrap.php,


voici le contenu :

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
}

Créez maintenant votre configuration. Pour ce tutoriel, nous utilisons une syntaxe INI, bien sûr
une syntaxe XML ou PHP est utilisable aussi. Créez donc le fichier application/configs/
application.ini, et ajoutez lui ce contenu :

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Maintenant, modifions le script de démarrage public/index.php. Si le fichier n'existe pas,


créez le, et placez ce contenu dedans :

// Define path to application directory


defined('APPLICATION_PATH')
|| define('APPLICATION_PATH',
realpath(dirname(__FILE__) . '/../application'));

// Define application environment


defined('APPLICATION_ENV')
|| define('APPLICATION_ENV',
(getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
: 'production'));

// Typically, you will also want to add your library/ directory


// to the include_path, particularly if it contains your ZF installed
set_include_path(implode(PATH_SEPARATOR, array(

144
Zend_Application

dirname(dirname(__FILE__)) . '/library',
get_include_path(),
)));

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run


$application = new Zend_Application(
APPLICATION_ENV,
APPLICATION_PATH . '/configs/application.ini'
);
$application->bootstrap()
->run();

Notez que l'environnement applicatif est défini dans une constante "APPLICATION_ENV". Nous
recommandons la spécification d'un tel paramètre dans la configuration générale du serveur web.
Pour Apache, vous pouvez utiliser .htaccess si votre serveur le permet. Nous recommandons
un fichier public/.htaccess avec le contenu suivant :

SetEnv APPLICATION_ENV development

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ index.php [NC,L]

Apprenez mod_rewrite
Les règles de réécriture ci-dessus autorisent l'accès à tout fichier existant dans
l'hôte virtuel. S'il existe des fichiers que vous ne voulez pas exposer, utilisez des
règles plus restrictives. Le site web d'Apache vous permettra d'en apprendre plus
au sujet de mod_rewrite.

Voila, à partir de maintenant nous sommes prêts à tirer partie de la puissance de


Zend_Application.

2.3. Ajouter et créer des ressources


Si vous avez suivi les instructions jusqu'à maintenant, alors votre classe de bootstrap utilisera
le contrôleur frontal et lorsque lancée, lancera le dispatch du contrôleur frontal. En vérité, il va
être rapidement nécessaire de rajouter de la configuration, concernant d'autres objets divers
(appelés "ressources").

Nous allons voir ici comment créer et configurer des ressources. D'abord un layout, puis nous
personnaliserons un objet de vue.

Une ressource assez standard proposée par Zend_Application est "layout". Cette ressource
attend une configuration qu'elle fera suivre immédiatement à Zend_Layout.

Pour l'utiliser, vous devrez modifier votre fichier de configuration comme suit:

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0

145
Zend_Application

bootstrap.path = APPLICATION_PATH "/Bootstrap.php"


bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

; AJOUTEZ CES LIGNES


resources.layout.layout = "layout"
resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Si ce n'est pas déja fait, créez le dossier application/layouts/scripts/, et le fichier


layout.phtml dans ce même dossier. Voici un exemple de script de layout tout à fait classique:

<?php echo $this->doctype() ?>


<html>
<head>
<?php echo $this->headTitle() ?>
<?php echo $this->headLink() ?>
<?php echo $this->headStyle() ?>
<?php echo $this->headScript() ?>
</head>
<body>
<?php echo $this->layout()->content ?>
</body>
</html>

Voila, vous avez un layout fonctionnel.

Maintenant passons à la vue. Nous voulons un DocType HTML et une valeur de titre par défaut
à utiliser dans la partie "head" du HTML. Nous pouvons ordonner ceci en éditant la classe
Bootstrap et en ajoutant une méthode.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initView()
{
// Initialisons la vue
$view = new Zend_View();
$view->doctype('XHTML1_STRICT');
$view->headTitle('My First Zend Framework Application');

// Ajoutons là au ViewRenderer
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
'ViewRenderer'
);
$viewRenderer->setView($view);

// Retourner la vue pour qu'elle puisse être stockée par le bootstrap


return $view;
}
}

146
Zend_Application

Cette méthode va être lancée automatiquement lors du bootstrap et configurera une vue.

2.4. Aller plus loin avec Zend_Application


Nous vennons de voir comment configurer de manière basique Zend_Application ainsi que
les principes du bootstrap. Pour un maximum de réutilisation de code, vous devriez songer à
utiliser des plugins de ressources. Continuez à lire la suite !

3. Théorie générale
Monter une application MVC configurée et prête à être lancée requière de plus en plus de code
au fur et à mesure de l'ajout de fonctionnalités : monter une base de données, configurer la vue
et ses aides, les layouts, enregistrer des plugins, des aides d'action et bien plus encore...

Aussi, vous réutiliserez souvent le même code dans vos tests, dans une tâche cron ou encore
un service. Il est certes possible d'inclure le script de bootstrap dans de tels cas, mais souvent
des variables seront dépendantes de l'environnement. Par exemple, vous n'aurez pas besoin
de MVC dans une tâche cron, ou alors vous aurez juste besoin de l'accès à la base de données
dans un script de service.

Zend_Application a pour but de simplifier ces processus et de promouvoir la réutilisabilité


de code en encapsulant les étages de définition du bootstrap en concepts orientés objet (OO).

Zend_Application se décompose en 3 parties :

• Zend_Application charge l'environnement PHP, à savoir les include_paths et les


autoloads, et instancie la classe de bootstrap demandée.

• Zend_Application_Bootstrap regroupe les interfaces pour les classes de bootstrap.


Zend_Application_Bootstrap_Bootstrap propose des fonctionnalités de base
concernant l'amorçage (le bootstrap), à savoir des algorithmes de vérification des
dépendances et la possibilité de charger des ressources à la demande.

• Zend_Application_Resource est une interface pour les ressources de bootstrap qui


peuvent être chargées à la demande depuis les instances de bootstrap.

Les développeurs créent une classe de bootstrap pour leur application en


étendant Zend_Application_Bootstrap_Bootstrap ou en implémentant (au minimum)
Zend_Application_Bootstrap_Bootstrapper. Le point d'entrée (public/index.php)
chargera Zend_Application en l'instanciant et en lui passant :

• L'environnement courant

• Des options de bootstrapping

Les options de bootstrap incluent le chemin vers le fichier contenant la classe de bootstrap, et
optionnellement :

• Des include_paths supplémentaires

• Des espaces de nom d'autoload à enregistrer

• Des paramètres php.ini à initialiser

• Le nom de la classe pour le bootstrap (sinon "Bootstrap" sera utilisée)

• Des paires préfixe / chemin pour les ressources à utiliser

• N'importe quelle ressource à utiliser (nom de classe ou nom court)

147
Zend_Application

• Des chemins additionnels vers un fichier de configuration à charger

• Des options de configuration supplémentaires

Les options peuvent être un tableau, un objet Zend_Config, ou le chemin vers un fichier de
configuration.

3.1. Bootstrapping
Zend_Application's second area of responsibility is executing the application bootstrap.
Bootstraps minimally need to implement Zend_Application_Bootstrap_Bootstrapper,
which defines the following API:

interface Zend_Application_Bootstrap_Bootstrapper
{
public function __construct($application);
public function setOptions(array $options);
public function getApplication();
public function getEnvironment();
public function getClassResources();
public function getClassResourceNames();
public function bootstrap($resource = null);
public function run();
}

This API allows the bootstrap to accept the environment and configuration from the application
object, report the resources its responsible for bootstrapping, and then bootstrap and run the
application.

You can implement this interface on your own, extend


Zend_Application_Bootstrap_BootstrapAbstract, or use
Zend_Application_Bootstrap_Bootstrap.

Besides this functionality, there are a number of other areas of concern you should familiarize
yourself with.

3.1.1. Resource Methods


The Zend_Application_Bootstrap_BootstrapAbstract implementation provides a
simple convention for defining class resource methods. Any protected method beginning with a
name prefixed with _init will be considered a resource method.

To bootstrap a single resource method, use the bootstrap() method, and pass it the name of
the resource. The name will be the method name minus the _init prefix.

To bootstrap several resource methods, pass an array of names. Too bootstrap all resource
methods, pass nothing.

Take the following bootstrap class:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initFoo()
{
// ...
}

protected function _initBar()


{

148
Zend_Application

// ...
}

protected function _initBaz()


{
// ...
}
}

To bootstrap just the _initFoo() method, do the following:

$bootstrap->bootstrap('foo');

To bootstrap the _initFoo() and _initBar() methods, do the following:

$bootstrap->bootstrap(array('foo', 'bar'));

To bootstrap all resource methods, call bootstrap() with no arguments:

$bootstrap->bootstrap();

3.1.2. Bootstraps that use resource plugins


To make your bootstraps more re-usable, we have provided the ability to push your resources into
resource plugin classes. This allows you to mix and match resources simply via configuration. We
will cover how to create resources later; in this section we will show you how to utilize them only.

If your bootstrap should be capable of using resource plugins, you will need to implement
an additional interface, Zend_Application_Bootstrap_ResourceBootstrapper. This
interface defines an API for locating, registering, and loading resource plugins:

interface Zend_Application_Bootstrap_ResourceBootstrapper
{
public function registerPluginResource($resource, $options = null);
public function unregisterPluginResource($resource);
public function hasPluginResource($resource);
public function getPluginResource($resource);
public function getPluginResources();
public function getPluginResourceNames();
public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader);
public function getPluginLoader();
}

Resource plugins basically provide the ability to create resource intializers that can be re-used
between applications. This allows you to keep your actual bootstrap relatively clean, and to
introduce new resources without needing to touch your bootstrap itself.

Zend_Application_Bootstrap_BootstrapAbstract (and
Zend_Application_Bootstrap_Bootstrap by extension) implement this interface as well,
allowing you to utilize resource plugins.

To utilize resource plugins, you must specify them in the options passed to the application object
and/or bootstrap. These options may come from a configuration file, or be passed in manually.
Options will be of key to options pairs, with the key representing the resource name. The resource
name will be the segment following the class prefix. For example, the resources shipped with
Zend Framework have the class prefix "Zend_Application_Resource_"; anything following
this would be the name of the resource. As an example,

149
Zend_Application

$application = new Zend_Application(APPLICATION_ENV, array(


'resources' => array(
'FrontController' => array(
'controllerDirectory' => APPLICATION_PATH . '/controllers',
),
),
));

This indicates that the "FrontController" resource should be used, with the options specified.

If you begin writing your own resource plugins, or utilize third-party resource plugins, you
will need to tell your bootstrap where to look for them. Internally, the bootstrap utilizes
Zend_Loader_PluginLoader, so you will only need to indicate the common class prefix an
path pairs.

As an example, let's assume you have custom resource plugins in APPLICATION_PATH/


resources/ and that they share the common class prefix of My_Resource. You would then
pass that information to the application object as follows:

$application = new Zend_Application(APPLICATION_ENV, array(


'pluginPaths' => array(
'My_Resource' => APPLICATION_PATH . '/resources/',
),
'resources' => array(
'FrontController' => array(
'controllerDirectory' => APPLICATION_PATH . '/controllers',
),
),
));

You would now be able to use resources from that directory.

Just like resource methods, you use the bootstrap() method to execute resource plugins.
Just like with resource methods, you can specify either a single resource plugin, multiple plugins
(via an array), or all plugins. Additionally, you can mix and match to execute resource methods
as well.

// Execute one:
$bootstrap->bootstrap('FrontController');

// Execute several:
$bootstrap->bootstrap(array('FrontController', 'Foo'));

// Execute all resource methods and plugins:


$bootstrap->bootstrap();

3.1.3. Resource Registry


Many, if not all, of your resource methods or plugins will initialize objects, and in many cases,
these objects will be needed elsewhere in your application. How can you access them?

Zend_Application_Bootstrap_BootstrapAbstract provides a local registry for these


objects. To store your objects in them, you simply return them from your resources.

For maximum flexibility, this registry is referred to as a "container" internally; its only requirements
are that it is an object. Resources are then registered as properties named after the resource
name. By default, an instance of Zend_Registry is used, but you may also specify any
other object you wish. The methods setContainer() and getContainer() may be used

150
Zend_Application

to manipulate the container itself. getResource($resource) can be used to fetch a given


resource from the container, and hasResource($resource) to check if the resource has
actually been registered.

As an example, consider a basic view resource:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initView()
{
$view = new Zend_View();
// more initialization...

return $view;
}
}

You can then check for it and/or fetch it as follows:

// Using the has/getResource() pair:


if ($bootstrap->hasResource('view')) {
$view = $bootstrap->getResource('view');
}

// Via the container:


$container = $bootstrap->getContainer();
if (isset($container->view)) {
$view = $container->view;
}

Please note that the registry and also the container is not global. This
means that you need access to the bootstrap in order to fetch resources.
Zend_Application_Bootstrap_Bootstrap provides some convenience for this: during its
run() execution, it registers itself as the front controller parameter "bootstrap", which allows you
to fetch it from the router, dispatcher, plugins, and action controllers.

As an example, if you wanted access to the view resource from above within your action
controller, you could do the following:

class FooController extends Zend_Controller_Action


{
public function init()
{
$bootstrap = $this->getInvokeArg('bootstrap');
$view = $bootstrap->getResource('view');
// ...
}
}

3.1.4. Dependency Tracking


In addition to executing resource methods and plugins, it's necessary to ensure that these
are executed once and once only; these are meant to bootstrap an application, and executing
multiple times can lead to resource overhead.

At the same time, some resources may depend on other resources being executed. To
solve these two issues, Zend_Application_Bootstrap_BootstrapAbstract provides a
simple, effective mechanism for dependency tracking.

151
Zend_Application

As noted previously, all resources -- whether methods or plugins -- are bootstrapped by calling
bootstrap($resource), where $resource is the name of a resource, an array of resources,
or, left empty, indicates all resources should be run.

If a resource depends on another resource, it should call bootstrap() within its code to ensure
that resource has been executed. Subsequent calls to it will then be ignored.

In a resource method, such a call would look like this:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initRequest()
{
// Ensure the front controller is initialized
$this->bootstrap('FrontController');

// Retrieve the front controller from the bootstrap registry


$front = $this->getResource('FrontController');

$request = new Zend_Controller_Request_Http();


$request->setBaseUrl('/foo');
$front->setRequest($request);

// Ensure the request is stored in the bootstrap registry


return $request;
}
}

3.2. Resource Plugins


As noted previously, a good way to create re-usable bootstrap resources and to offload much of
your coding to discrete classes is to utilize resource plugins. While Zend Framework ships with
a number of standard resource plugins, the intention is that developers should write their own
to encapsulate their own initialization needs.

Resources plugins need only implement Zend_Application_Resource_Resource, or,


more simply still, extend Zend_Application_Resource_ResourceAbstract. The basic
interface is simply this:

interface Zend_Application_Resource_Resource
{
public function __construct($options = null);
public function setBootstrap(
Zend_Application_Bootstrap_Bootstrapper $bootstrap
);
public function getBootstrap();
public function setOptions(array $options);
public function getOptions();
public function init();
}

The interface defines simply that a resource plugin should accept options to the constructor,
have mechanisms for setting and retrieving options, have mechanisms for setting and retrieving
the bootstrap object, and an initialization method.

As an example, let's assume you have a common view intialization you use in your applications.
You have a common doctype, CSS and JavaScript, and you want to be able to pass in a base
document title via configuration. Such a resource plugin might look like this:

152
Zend_Application

class My_Resource_View extends Zend_Application_Resource_ResourceAbstract


{
protected $_view;

public function init()


{
// Return view so bootstrap will store it in the registry
return $this->getView();
}

public function getView()


{
if (null === $this->_view) {
$options = $this->getOptions();
$title = '';
if (array_key_exists('title', $options)) {
$title = $options['title'];
unset($options['title']);
}

$view = new Zend_View($options);


$view->doctype('XHTML1_STRICT');
$view->headTitle($title);
$view->headLink()->appendStylesheet('/css/site.css');
$view->headScript()->appendfile('/js/analytics.js');

$viewRenderer =
Zend_Controller_Action_HelperBroker::getStaticHelper(
'ViewRenderer'
);
$viewRenderer->setView($view);

$this->_view = $view;
}
return $this->_view;
}
}

As long as you register the prefix path for this resource plugin, you can then use it in your
application. Even better, because it uses the plugin loader, you are effectively overriding the
shipped "View" resource plugin, ensuring that your own is used instead.

4. Exemples
La classe de bootstrap elle-même sera typiquement minimaliste ; souvent, elle s'agira
simplement d'une extension vide de la classe de bootstrap de base :

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
}

Avec un fichier de configuration tel que :

; APPLICATION_PATH/configs/application.ini
[production]
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

153
Zend_Application

[testing : production]
[development : production]

Cependant, si de l'initialisation personnalisée est nécessaire, alors vous avez 2 choix. D'abord
vous pouvez écrire des méthodes préfixées par _init pour ajouter du code au bootstrap. De telles
méthodes seront appelées par bootstrap(), et peuvent être appelées comme si elles étaient
publiques, par : bootstrap<resource>(). Elles peuvent accepter un tableau d'options.

Si votre méthode de ressource retourne une valeur, elle sera stockée dans un conteneur du
bootstrap. Ceci peut être utile quand différentes ressources ont besoin d'interagir (comme une
ressource s'injectant elle-même dans une autre). La méthode getResource() peut être utilisée
pour récupérer ces valeurs.

L'exemple ci-dessous montre une méthode de ressource pour l'initialisation d'un objet requête.
Il utilise le traqueur de dépendances (il dépend de la ressource de contrôleur frontal), récupère
une ressource à partir du bootstrap, et retourne une valeur à stocker dans le bootstrap.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap


{
protected function _initRequest()
{
// Vérifie que le contrôleur frontal est bien présent, et le récupère
$this->bootstrap('FrontController');
$front = $this->getResource('FrontController');

// Initialise l'objet requête


$request = new Zend_Controller_Request_Http();
$request->setBaseUrl('/foo');

// On l'ajoute au contrôleur frontal


$front->setRequest($request);

// Le bootstrap va stocker cette valeur dans la clé 'request'


// de son conteneur
return $request;
}
}

Notez l'appel à bootstrap() ; Ceci permet de s'assurer que le contrôleur frontal a bien été
initialisé avant d'appeler cette méthode.

Une autre option consiste à utiliser des ressources de bootstrap. Les plugins de ressources sont
des objets qui s'occupent d'initialisations spéciales, elles peuvent être spécifiées :

• à l'instanciation d'un objet Zend_Application ;

• pendant l'initialisation de l'objet bootstrap ;

• en les activant spécifiquement via des appels de méthodes sur l'objet de bootstrap.

Les plugins de ressources implémentent


Zend_Application_Resource_ResourceAbstract, qui définit simplement qu'elles
peuvent être injectées dans l'objet les appelant, et qu'elles ont une méthode init(). Voici un
exemple d'un bootstrap de vue :

class My_Bootstrap_Resource_View

154
Zend_Application

extends Zend_Application_ResourceAbstract
{
public function init()
{
$view = new Zend_View($this->getOptions());
Zend_Dojo::enableView($view);

$view->doctype('XHTML1_STRICT');
$view->headTitle()->setSeparator(' - ')->append('My Site');
$view->headMeta()->appendHttpEquiv('Content-Type',
'text/html; charset=utf-8');

$view->dojo()->setDjConfigOption('parseOnLoad', true)
->setLocalPath('/js/dojo/dojo.js')
->registerModulePath('../spindle', 'spindle')
->addStylesheetModule('spindle.themes.spindle')
->requireModule('spindle.main')
->disable();

$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
'ViewRenderer'
);
$viewRenderer->setView($view);

return $view;
}
}

Pour dire au bootstrap d'utiliser cette classe, vous devrez fournir le nom de la classe pour ce
plugin de ressource, ou une combinaison préfixe / chemin de chargeur de plugin (plugin loader)
et le nom court du plugin de ressource ("view") :

$application = new Zend_Application(


APPLICATION_ENV,
array(
'resources' => array(
'My_Bootstrap_Resource_View' => array(), // nom de la classe OU
'view' => array(), // nom court

'FrontController' => array(


'controllerDirectory' => APPLICATION_PATH . '/controllers',
),
),

// Pour les noms courts, définissez les chemins :


'resourcePaths = array(
'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
)
)
);

Les plugins de ressource peuvent en appeler d'autres via le bootstrap parent :

class My_Bootstrap_Resource_Layout
extends Zend_Application_ResourceAbstract
{
public function init()
{
// Assurons nous que la vue est initialisée...

155
Zend_Application

$this->getBootstrap()->bootstrap('view');

// Récupère l'objet de vue :


$view = $this->getBootstrap()->getResource('view');

// ...
}
}

En usage normal, vous instancierez votre application, lancerez le bootstrap, puis l'application :

$application = new Zend_Application(...);


$application->bootstrap()
->run();

Pour un script personnalisé, vous auriez peut être besoin de ne lancer que des ressources
spécifiques :

$application = new Zend_Application(...);


$application->getBootstrap()->bootstrap('db');

$service = new Zend_XmlRpc_Server();


$service->setClass('Foo'); // uses database...
echo $service->handle();

Plutôt que d'utiliser la méthode bootstrap() pour appeler les méthodes internes, vous pouvez
surcharger :

$application = new Zend_Application(...);


$application->getBootstrap()->bootstrapDb();

5. Fonctionnalités principales
Ici vous trouverez une documentation type API concernant les composants coeurs de
Zend_Application.

5.1. Zend_Application
Zend_Application est la classe de base du composant et le point d'entrée de votre
application Zend Framework. Ses buts sont multiples : configurer l'environnement PHP (incluant
l'autoloading) et exécuter le bootstrap de votre application.

Typiquement, vous allez passer toute la configuration au constructeur de Zend_Application,


mais vous pouvez aussi configurer l'objet via ses méthodes. Ce chapitre illustrera les deux
aspects.

Tableau 2. Zend_Application options


Option Description
phpSettings Tableau de paramètres php.ini à utiliser.
Les clés doivent être des clés reconnues dans
php.ini.
includePaths Chemins additionnels à ajouter à include_path.
Ces chemins sont ajoutés avant l'include_path.
L'option doit être un tableau de chemins.

156
Zend_Application

Option Description
autoloaderNamespaces Tableau d'espaces de noms à enregistrer dans
Zend_Loader_Autoloader.
bootstrap Soit une chaîne vers le fichier contenant la
classe de bootstrap, soit un tableau avec les
clés 'path' et 'class' menant vers le bootstrap.

Noms des options

Notez que les noms des options ne sont pas sensibles à la casse.

Tableau 3. Méthodes dans Zend_Application

Méthode Valeur de retour Paramètres Description


Void
__construct($environment, • $environment : Une instance de
$options = null) requis, Chaîne Zend_Loader_Autoloader
représentant est enregistrée lors
l'environnement de l'instanciation. Les
actuel dans lequel options passées au
tourne l'application. constructeur sont
Par exemple passées à
"development", setOptions().
"testing", "qa", ou
"production". Les
significations de ces
chaînes sont à
définir par la suite.

• $options :
optionnel.

• String : chemin
vers un fichier
Zend_Config à
charger pour la
configuration de
votre application.
$environment
sera utilisé pour
déterminer la
section de
configuration à
charger depuis le
fichier.

• Array : tableau
associatif de
données de
configuration pour
votre application.

• Zend_Config :
un instance

157
Zend_Application

Méthode Valeur de retour Paramètres Description


d'objet de
configuration.
getEnvironment() String N/A Récupère
l'environnement passé
au constructeur.
getAutoloader() N/A
Zend_Loader_Autoloader Récupère l'objet
Zend_Loader_Autoloader
enregistré lors de
l'instanciation.
setOptions(array Zend_Application • $options : requis. Toutes les options
$options) Un tableau d'options sont stockées en
pour l'application. interne, et appeler
plusieurs fois la même
méthode fusionnera
les options qu'elle
définit. Les options
qui correspondent aux
diverses méthodes
setter seront passées
à ces méthodes.
Par exemple, l'option
"phpSettings" sera
passée à
setPhpSettings().
getOptions() Array N/A Récupère toutes
les options utilisées
pour initialiser l'objet.
Pourrait être utilisé
pour mettre en
cache les options
Zend_Config entre
chaque requête, par
exemple.
hasOption($key) Boolean • $key : La clé de Indique si une option
l'option à chercher correspondant à une
clé précise a été
utilisée ou pas. Les
clés sont insensibles à
la casse.
getOption($key) Mixed • $key : La clé de Récupère l'option
l'option à récupérer correspondant à la clé
passée, NULL si celle-
ci n'existe pas.
Zend_Application • $settings : requis.
setPhpSettings(array Affecte à la
$settings, Tableau associatif volée des paramètres
$prefix = '') de paramètres PHP de php.ini. Les
INI paramètres séparés
par des points peuvent
• $prefix : être imbriqués
optionnel. Préfixe

158
Zend_Application

Méthode Valeur de retour Paramètres Description


pour construire la hiérarchiquement
chaîne des clés (comme dans le cas
d'options. Utilisée des paramètres INI de
en interne pour Zend_Config).
faire correspondre
les clés php.ini
séparés par des
points (".") avec
des tableaux à
plusieurs niveaux.
En temps normal,
cet argument ne
devrait jamais être
utilisé par
l'utilisateur.
Zend_Application • $namespaces
setAutoloaderNamespaces(array : Enregistre des
$namespaces) requis. Tableau de espaces de noms
chaînes dans
représentant les Zend_Loader_Autoloader.
espaces de noms
à enregistrer dans
Zend_Loader_Autoloader.
Zend_Application • $path : requis. Peut
setBootstrap($path,
$class = null) être soit un objet de
Zend_Application_Bootstrap_Bootstrapper,
soit une chaîne
représentant le
chemin vers la
classe de bootstrap,
soit un tableau
associatif nom de
classe => chemin
de fichier, ou encore
un tableau associatif
avec les clés "class"
et "path".

• $class : optionnel.
Si $path est
une chaîne, $class
doit être indiqué
et doit être une
chaîne représentant
le nom d'une classe
contenue dans le
fichier représenté
par le chemin.
getBootstrap() NULL | N/A Récupère l'instance du
bootstrap enregistrée.
Zend_Application_Bootstrap_Bootstrapper
bootstrap() Void N/A Appelle la méthode
bootstrap() du

159
Zend_Application

Méthode Valeur de retour Paramètres Description


bootstrap pour lancer
l'application.
run() Void N/A Appelle la méthode
run() du bootstrap
pour lancer le dispatch
de l'application.

5.2. Zend_Application_Bootstrap_Bootstrapper
Zend_Application_Bootstrap_Bootstrapper est l'interface de base que toutes les
classes de bootstrap doivent implémenter. Les fonctionnalités apportées sont la configuration,
l'identification des ressources, le bootstrap (d'une ressource ou de l'application entière), et le
lancement (dispatching) de l'application.

Voici les méthodes définies par l'interface.

Tableau 4. Méthodes de Zend_Application_Bootstrap_Bootstrapper


Méthode Valeur de retour Paramètres Description
Void
__construct($application) • $application : Constructeur. Accepte
requis. Accepte un un argument qui peut
argument instance être une instance de
de Zend_Application
Zend_Applicationou un autre objet
ou de bootstrap.
Zend_Application_Bootstrap_Bootstrapper
• $options : requis. Une
setOptions(array Zend_Application_Bootstrap_Bootstrapper option qui
$options) Tableaux d'options à correspond à un setter
configurer. lui sera passé, sinon
l'option est stockée
pour pouvoir être
utilisée plus tard.
getApplication() Zend_Application | N/A Récupère l'objet
d'application passé au
Zend_Application_Bootstrap_Bootstrapper
constructeur.
getEnvironment() String N/A Récupère la chaîne
d'environnement
enregistrée dans
l'objet d'application.
Array
getClassResources() N/A Retourne la liste
des classes utilisées
comme classes de
ressources.
Mixed
bootstrap($resource • $resource : Si $resource est
= null) optionnel. vide, exécute toutes
les ressources. Si une
chaîne est passée,
exécute uniquement la
ressource considérée.
Enfin, si un tableau
de chaînes est passé,

160
Zend_Application

Méthode Valeur de retour Paramètres Description


toutes les ressources
représentées par
ses chaînes sont
exécutées.
run() Void N/A Définit la logique à
lancer après avoir
lancé le bootstrap.

5.3. Zend_Application_Bootstrap_ResourceBootstrapper
Zend_Application_Bootstrap_ResourceBootstrapper est une interface utilisée
lorsqu'une classe de bootstrap chargera une ressource externe, ce qui signifie que les
ressources peuvent ne pas être définies comme de simples méthodes, mais via des classes
"plugins". Cette interface devrait être utilisée avec Zend_Application_Bootstrap_Bootstrapper ;
Zend_Application_Bootstrap_BootstrapAbstract implémente cette fonctionnalité.

Voici les méthodes définies par l'interface.

Tableau 5. Méthodes de Zend_Application_Bootstrap_ResourceBootstrapper


Méthode Valeur de retour Paramètres Description
registerPluginResource($resource, • $resource : requis. Enregistre
Zend_App