Zend Framework 1-10-x FR

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
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
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
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
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
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
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.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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.4. Features .................................................................................... 1250
16.5. Getting Started .......................................................................... 1250
16.6. Queue operations ...................................................................... 1251
16.7. Message operations ................................................................... 1252
xxvi
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.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
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.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
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
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
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
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
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
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.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.3. Zend_Locale .................................................................................... 1661
B.4.4. Zend_Translate ................................................................................ 1663
B.4.5. Zend_View ....................................................................................... 1664
B.5. Zend Framework 1.6 ................................................................................... 1664
B.6. Zend Framework 1.5 ................................................................................... 1665
B.7. Zend Framework 1.0 ................................................................................... 1667
B.7.2. Zend_Currency ................................................................................. 1669
B.8. Zend Framework 0.9 ................................................................................... 1669
xxxiv
du programmeur
B.9. Zend Framework 0.8 ................................................................................... 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
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
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
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
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]
[development : production]
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
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
avec Zend Framework


<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:


<!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
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
avec Zend Framework
; Add to [production] section:

resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"
The final INI file should look as follows:
[production]
; PHP settings we want to initialize
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:

{
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:
16
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:

{
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
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
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.
; Add these lines to the appropriate sections:

[production]
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"
Your final configuration file should look like the following:
[production]
resources.view[] =
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"
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
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
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
avec Zend Framework
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);
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
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
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
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
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
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

{
{
$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:

<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
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

{
{
28
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
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:

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
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
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.
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:
$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
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
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
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
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
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
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
Pour initialiser Zend_Layout, ajouter ceci à votre fichier de configuration ("application/

configs/application.ini"):

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>
</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
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
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
<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:

{
// ...
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
</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">
</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
<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
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:

{
protected function _initDocType()
{
}
}
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.

{
// ...
protected function _initPlaceholders()

{
// Set the initial title and separator:

$view->headTitle('My Site')
50
->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:

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

This will generate the following output:


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


<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.

{
// ...

{
51

// 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:

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

<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.

{
// ...

{
52

// 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:

<html>
<?php echo $this->headScript() ?>

<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
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
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
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":

'label' => 'Foo',
'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
• 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:

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

{
$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.

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

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

return $markup;
}
}
59
class My_Decorator_SimpleLabel extends Zend_Form_Decorator_Abstract

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

{
$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à:

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

{
$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

{
$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à:

'label' => 'Foo',
'value' => 'test',
)),
'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

'label' => 'Foo',
'value' => 'test',
)),
'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:
62
'label' => 'Foo',

'value' => 'test',
)),
'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

{
{
// 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
));
$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
<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>
<?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>
<?php echo $form->password->renderLabel()
. $form->password->renderViewHelper() ?>
</div>
<?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="">

<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>
<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"
/
<input type="text" name="dateOfBirth[year]" id="dateOfBirth-year"
</div>
65
<label for="password" tag="" class="optional">Password:</label>
<input type="password" name="password" id="password" value=""/>
</div>
<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":
<?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
• 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
->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

{
{
if (!$element instanceof My_Form_Element_Date) {
// Nous ne rendons que des éléments Date
return $content;
}
68
$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:

{
// ...
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
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:

{
// ...
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
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
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
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
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

{
{
$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
$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
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
$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
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.


?><ul><?php
88
// 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.


// Select the second page

$paginator->setCurrentPageNumber(2);
?><ul><?php
// Render each item for the current page in a list-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');

$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
echo '<li>' . $item->title . '</li>';
}
89
?></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): ?>


<?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; ?>

<?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; ?>

<?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; ?>

<?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
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

{
{
// 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
$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
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
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
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
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
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.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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.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
Zend Framework
22.2. Registering with Nirvanix .................................................................... 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
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.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
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
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
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
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
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->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 :
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 :
// 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 :
$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') ?

// refusé
echo $acl->isAllowed('staff', null, 'relire') ?

// autorisé
echo $acl->isAllowed('editeur', null, 'voir') ?

// autorisé parce que hérité de Invité
echo $acl->isAllowed('editeur', null, 'modifier') ?

// refusé parce qu'il n'y a pas de règle pour 'modifier'
echo $acl->isAllowed('administrateur', null, 'voir') ?

// autorisé car administrateur est autorisé pour tout
echo $acl->isAllowed('administrateur') ?
echo $acl->isAllowed('administrateur', null, 'modifier') ?

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') ?

echo $acl->isAllowed('marketing', 'latest', 'publish') ?

echo $acl->isAllowed('marketing', 'latest', 'archive') ?

echo $acl->isAllowed('marketing', 'latest', 'revise') ?

echo $acl->isAllowed('editor', 'announcement', 'archive') ?

echo $acl->isAllowed('administrator', 'announcement', 'archive') ?

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') ?

// Retire l'autorisation de publier

// et archiver les newsletters au Marketing
$acl->removeAllow('marketing',
'newsletter',
array('publish', 'archive'));
echo $acl->isAllowed('marketing', 'newsletter', 'publish') ?

echo $acl->isAllowed('marketing', 'newsletter', 'archive') ?

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') ?

echo $acl->isAllowed('marketing', 'latest', 'archive') ?

echo $acl->isAllowed('marketing', 'latest', 'anything') ?

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->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->addFunction('myUberCoolFunction');
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->addFunction('myUberCoolFunction', 'my')
->setClass('Foo', 'foo')
->setClass('Bar', 'bar');
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->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:

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:

{
}
Notez aussi la présence d'un fichier de configuration newproject/application/configs/

application.ini, il contient :
[production]
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

|| define('APPLICATION_PATH',
realpath(dirname(__FILE__) . '/../application'));
// Define application environment

|| define('APPLICATION_ENV',
(getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
: 'production'));
/** Zend_Application */
require_once 'Zend/Application.php';
// Create application, bootstrap, and run

APPLICATION_ENV,
);
$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 :

{
}
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]
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

|| define('APPLICATION_PATH',
realpath(dirname(__FILE__) . '/../application'));
// Define application environment

|| 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_ENV,
);
->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]
145
Zend_Application

; AJOUTEZ CES LIGNES

resources.layout.layout = "layout"
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:

<html>
<head>
<?php echo $this->headStyle() ?>
<?php echo $this->headScript() ?>
</head>
<body>
</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.

{
protected function _initView()
{
// Initialisons la vue
$view = new Zend_View();
$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:

{
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/',
),
),
),
));
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:

{
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

{
{
$bootstrap = $this->getInvokeArg('bootstrap');
// ...
}
}
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:

{
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;

{
// 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->headTitle($title);
$view->headLink()->appendStylesheet('/css/site.css');
$view->headScript()->appendfile('/js/analytics.js');
$viewRenderer =
Zend_Controller_Action_HelperBroker::getStaticHelper(
'ViewRenderer'
);
$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 :

{
}
Avec un fichier de configuration tel que :
; APPLICATION_PATH/configs/application.ini
[production]
153
Zend_Application
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.

{
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
{
{
$view = new Zend_View($this->getOptions());
Zend_Dojo::enableView($view);
$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'
);
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_ENV,
array(
'My_Bootstrap_Resource_View' => array(), // nom de la classe OU
'view' => array(), // nom court

),
),
// 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
{
{
// 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(...);

->run();
Pour un script personnalisé, vous auriez peut être besoin de ne lancer que des ressources
spécifiques :

$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->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

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

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

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

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.
• $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
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

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

registerPluginResource($resource, • $resource : requis. Enregistre
Zend_Application_Bootstrap_ResourceBootstrapper une
$options = null) Un nom de ressource avec la
ressource ou un classe, ajoutant une
objet configuration
optionnelle à fournir à
Zend_Application_Resource_Resource
la ressource.
• $options :
optionnel. Un
tableau d'objets
Zend_Config à
passer au
constructeur de la
ressource.
unregisterPluginResource($resource) • $resource : requis. Supprime un plugin de
Zend_Application_Bootstrap_ResourceBootstrapper
Nom de la ressource ressource de la classe.
à effacer de la
liste des ressources
chargées.
Boolean
hasPluginResource($resource) • $resource : requis. Détermine si une
Nom de la ressource donnée a
ressource. été enregistrée.
getPluginResource($resource) • $resource : requis. Récupère
Zend_Application_Resource_Resource une
Nom de la ressource instance de plugin
à récupérer (string). de ressource par son
nom.
Array
getPluginResourceNames() N/A Récupère une liste de
noms de tous les
plugins enregistrés.
• $loader : requis. Enregistre
setPluginLoader(Zend_Loader_PluginLoader_Interface
Zend_Application_Bootstrap_ResourceBootstrapper un
$loader) Instance de PluginLoader
161
Zend_Application

PluginLoader (chargeur de classes)
(chargeur de à utiliser pour résoudre
classes) à utiliser les noms de plugins en
pour résoudre les classes.
noms de plugins en
classes.
N/A
getPluginLoader() Zend_Loader_PluginLoader_Interface Récupère l'objet
pluginLoader chargé.
5.4. Zend_Application_Bootstrap_BootstrapAbstract
Zend_Application_Bootstrap_BootstrapAbstract est une classe abstraite
qui propose les fonctionnalités de base d'un bootstrap classique.
Elle implémente à la fois Zend_Application_Bootstrap_Bootstrapper et
Zend_Application_Bootstrap_ResourceBootstrapper.
Tableau 6. Méthodes de Zend_Application_Bootstrap_BootstrapAbstract

Void
__construct($application) • $application : Constructeur. Accepte
requis. Accepte un un seul argument de
objet type
Zend_ApplicationZend_Application,
ou ou un autre objet
bootstrap.
• $options : requis. Toute
setOptions(array Zend_Application_Bootstrap_Bootstrapper option
$options) Tableau d'options à possédant un setter
configurer. l'invoquera, sinon
l'option sera stockée
pour une utilisation
ultérieure. Par
exemple, si votre
classe fille définit une
méthode setFoo(),
l'option 'foo' passera
sa valeur à cette
méthode.
Deux options
supplémentaires
spéciales peuvent
aussi être utilisée.
pluginPaths spécifie
des préfixes de chemin
vers les plugins ; on
attend ici un tableau
de paires préfixes,
chemins. resources
permet de spécifier un
plugin à utiliser.
162
Zend_Application

getOptions() Array N/A Retourne toutes les
options enregistrées
via setOptions().
hasOption($key) Boolean • $key : requis. Détermine si une
Option dont on veut option est présente.
tester la présence.
getOption($key) Mixed • $key: requis. Option Récupère la valeur
à récupérer. de l'option associée à
la clé passée comme
paramètre retourne
NULL si aucune option
n'est enregistrée avec
cette clé.
setApplication(Zend_Application • $application : Enregistre
Zend_Application_Bootstrap_BootstrapAbstract l'objet
| requis. application parent, ou
Zend_Application_Bootstrap_Bootstrapper un objet de bootstrap.
$application)
getApplication() Zend_Application | N/A Récupère l'objet
application
Zend_Application_Bootstrap_Bootstrapper ou
bootstrap passé par le
constructeur.
getEnvironment() String N/A Récupère
l'environnement
(chaîne) enregistré
dans l'objet parent,
application ou
bootstrap.
Array
getClassResources() N/A Récupère la liste des
noms des chargeurs
de ressources définis
dans la classe.
Spécifique à
l'implémentation.
getContainer() Object N/A Récupère le conteneur
stockant les
ressources. Si aucun
conteneur n'est
spécifié, un objet
Zend_Registry sera
crée pour cet usage,
puis retourné.
setContainer($container) • $container, Définit un conteneur
Zend_Application_Bootstrap_BootstrapAbstract
requis. Un objet mémorisant les
dans lequel stocker ressources.
les ressources. Lorsqu'une ressource
est demandée, elle est
chargée puis stocker
dans ce conteneur
pour être retournée
163
Zend_Application

lors des prochains
appels.
hasResource($name)Boolean • $name, requis. Nom Lorsqu'une ressource
de la ressource dont est demandée
on veut vérifier la (retournée par une
présence. méthode ou un
plugin), elle est
stockée dans un
objet conteneur (voyez
getContainer() et
setContainer().)
Cette méthode
interroge le conteneur
pour savoir si une
ressource y est
présente.
getResource($name)Mixed • $name, requis. Nom Lorsqu'une ressource
de la ressource à est demandée
récupérer (retournée par une
méthode ou un
plugin), elle est
stockée dans un
objet conteneur (voyez
getContainer() et
setContainer().)
Cette méthode
récupère une
ressource depuis le
conteneur.
Mixed
bootstrap($resource • $resource: Si $resource est
= null) optionnel. vide, charge toutes les
ressources
(bootstrap). Si une
chaîne est passée,
charge uniquement la
ressource demandée.
Enfin si un tableau
est passé, charge les
ressources nommées
dans ce tableau.
Cette méthode peut

être utilisée pour
déclencher le
chargement d'une
ressource, définit sous
forme de méthode
ou de plugin (c'est
égal). Attention si vous
spécifiez à la fois
une méthode et un
164
Zend_Application

plugin pour une même
ressource, alors la
méthode sera préférée
comme bootstrap, le
plugin sera ignoré.
run() Void N/A Définit la logique
applicative à lancer
après le bootstrap (la
configuration)
__call($method, Mixed • $method : requis. Propose une interface
$args) Nom de la méthode agréable pour
appelée configurer (bootstrap)
des ressources
• $args : requis. individuelles en
Tableau appelant
d'arguments 'bootstrap<NomDeLaRessource>()'
d'invocation pour la à la place de
méthode. bootstrap().
5.5. Zend_Application_Bootstrap_Bootstrap
Zend_Application_Bootstrap_Bootstrap est une implémentation concrète de
Zend_Application_Bootstrap_BootstrapAbstract. Ces caractéristiques principales sont
l'enregistrement de la ressource Front Controller, et la méthode run() qui vérifie d'abord la
présence d'un module par défaut dans le contrôleur frontal, avant de lancer le dispatching.
Dans la plupart des cas, vous étendrez cette classe dans vos bootstraps, ou encore vous
utiliserez cette classe en lui fournissant une liste de plugins à utiliser.
5.5.1. Activer l'autoload de l'application

De plus, cette implémentation de bootstrap fournit la possibilité de spécifier l'espace de noms
ou le préfixe de classe pour les ressources situées dans son arborescence, ce qui va activer
le chargement automatique des différentes resources de l'application ; essentiellement, ceci
instancie un objet Zend_Application_Module_Autoloader, en fournissant l'espace de noms
requêté et le dossier de bootstrap en tant qu'arguments. Vous pouvez activer cette fonctionnalité
en fournissant l'espace de noms à l'option de configuration "appnamespace". Par exemple avec
un fichier INI :
appnamespace = "Application"
Ou en XML :
<appnamespace>Application</appnamespace>
Par défaut, Zend_Tool va activer cette option avec la valeur "Application".
Alternativement, vous pouvez simplement définir la propriété $_appNamespace de votre classe

de bootstrap avec la valeur appropriée :

{
165
Zend_Application
protected $_appNamespace = 'Application';

}
5.6. Zend_Application_Resource_Resource
Zend_Application_Resource_Resource est une interface implémentée par les plugins
de ressources lorsqu'ils sont utilisés par des classes de bootstrap implémentant
Zend_Application_Bootstrap_ResourceBootstrapper. Les classes de plugins de
ressources doivent accepter de la configuration, doivent pouvoir être lancées ("bootstrapées")
et doivent utiliser un pattern strategy pour initialiser la ressource.
Tableau 7. Méthodes de Zend_Application_Resource_Resource

Void
__construct($options • $options: Le constructeur doit
= null) optionnel. Options posséder un
d'initialisation. paramètre permettant
de configurer l'état de
la ressource.
• $bootstrap:
setBootstrap(Zend_Application_Bootstrap_Bootstrapper
Zend_Application_Resource_Resource Doit autoriser
$bootstrap) requis. Bootstrap l'enregistrement du
parent initialisant bootstrap parent.
cette ressource.
getBootstrap() N/A Récupère
Zend_Application_Bootstrap_Bootstrapper l'objet
bootstrap enregistré.
• $options: requis. Définit
setOptions(array Zend_Application_Resource_Resource l'état
$options) Options de d'initialisation de la
configuration de la ressource.
ressource
getOptions() Array N/A Récupère les options
enregistrées.
init() Mixed N/A Pattern strategy:
exécute l'initialisation
de la ressource.
5.7. Zend_Application_Resource_ResourceAbstract
Zend_Application_Resource_ResourceAbstract est une classe abstaite implementant
Zend_Application_Resource_Resource, c'est un bon point de départ pour créer vos propres
plugins de ressources.
Note: Cette classe abstraite n'implémente pas la méthode init(); elle doit donc être
implémentée par les extensions concrêtes de cette classe.
Tableau 8. Méthodes de Zend_Application_Resource_ResourceAbstract

Void
__construct($options • $options: Le constructeur doit
= null) optionnel. Options accepter un
de configuration de paramètres permettant
la ressource.
166
Zend_Application

de définir l'état de la
ressource.
• $bootstrap
setBootstrap(Zend_Application_Bootstrap_Bootstrapper : Doit
Zend_Application_Resource_ResourceAbstract accepter
$bootstrap) requis. Bootstrap l'enregistrement du
parent initialisant bootstrap parent.
cette resource.
getBootstrap() N/A Récupère
Zend_Application_Bootstrap_Bootstrapper l'objet
bootstrap enregistré.
• $options : Définit l'état
setOptions(array Zend_Application_Resource_ResourceAbstract de la
$options) required. Options de ressource.
la ressource.
getOptions() Array N/A Retourne les options
enregistrées.
5.7.1. Noms des resources

Lorque vous enregistrez des plugins de ressources, il existe alors 3 manières d'y faire référence
dans la classe du bootstrap parent, en fonction de la manière dont vous avez configuré le
bootstrap.
D'abord, si vos classes de plugins existent dans un chemin précis, vous pouvez alors y faire
référence simplement par leur nom court -- la portion du nom de la classe située après le
préfixe de classe. Par exemple, la classe "Zend_Application_Resource_View" peut être
référencée simplement via "View" car le préfixe "Zend_Application_Resource" est déja
enregistré. Vous pouvez aussi utiliser le nom long de classe complet :
$app = new Zend_Application(APPLICATION_ENV, array(

'pluginPaths' => array(
'My_Resource' => 'My/Resource/',
),
// Si la classe suivante existe:
'My_Resource_View' => array(),
// alors ceci est équivalent:

'View' => array(),
),
));
Quoiqu'il en soit, vous pouvez lancer (bootstrap) la ressource ou la récupérer via son nom court:
$bootstrap->bootstrap('view');
Ensuite, si aucun chemin précis n'est enregistré, il reste possible de passer ses plugins de
ressources via leur nom de classe complet :
$app = new Zend_Application(APPLICATION_ENV, array(

// Ceci va charger le plugin de ressource standard 'View':
'View' => array(),
167
Zend_Application
// Alors que ceci charge une classe spécifiquement via son nom:
'My_Resource_View' => array(),
),
));
La récupération de ces objets se fait alors de manière plus clarifiée :
$bootstrap->bootstrap('My_Resource_View');
$view = $bootstrap->getResource('My_Resource_View');
La troisième méthode découle des deux précédentes. Il est possible de donner un nom court
à n'importe quelle classe. Ajoutez une variable publique $_explicitType dans la classe du
plugin, sa valeur sera alors utilisée comme nom court pour référencer le plugin dans le bootstrap.
Définissons par exemple notre propre vue :
class My_Resource_View extends Zend_Application_Resource_ResourceAbstract

{
public $_explicitType = 'My_View';

{
// du code ici...
}
}
Nous pouvons dès lors lancer cette ressource (bootstrap) ou la récupérer via le nom "My_View":
$bootstrap->bootstrap('My_View');
$view = $bootstrap->getResource('My_View');
Grâce à ses différentes manières de faire, vous pouvez redéfinir des plugins existants, en ajouter
ou encore les mixer pour accomplir des tâches d'initialisation complexes.
6. Plugins de ressources disponibles

Vous trouverez ci-après la documentation de type API concernant tous les plugins disponibles
par défaut dans Zend_Application.
6.1. Zend_Application_Resource_Cachemanager
Zend_Application_Resource_Cachemanager peut être utilisé pour configurer un jeu
d'ensemble d'options Zend_Cache permettant de paramétrer des caches à chargement tardifs
("lazy loading") avec Zend_Cache_Manager
Comme le gestionnaire de cache est un mécanisme à chargement tardif, les options sont
traduites en modèle d'options utilisé pour instancier un objet de cache à la demande.
168
Zend_Application
Exemple 31. Exemple de configuration d'une ressource de gestionnaire de cache
Ci-dessous vous trouverez un extrait de fichier INI montrant comment

Zend_Cache_Manager peut être configuré. Le format est le préfixe de la ressource
Cachemanager (resources.cachemanager) suivi par le nom d'un modèle (par exemple
resources.cachemanager.database) et finalement suivi par une option habituelle de
Zend_Cache.
resources.cachemanager.database.frontend.name = Core
resources.cachemanager.database.frontend.options.lifetime = 7200
resources.cachemanager.database.frontend.options.automatic_serialization = true
resources.cachemanager.database.backend.name = File
resources.cachemanager.database.backend.options.cache_dir = "/path/to/cache"
Ensuite reécupérer ce cache à partir du gestionnaire est aussi simple que d'accéder à
l'instance du gestionnaire et d'appeler $cacheManager->getCache('database');.
6.2. Zend_Application_Resource_Db
Zend_Application_Resource_Db initialisera un adaptateur Zend_Db basé sur les options
qui lui seront fournis. Par défaut, il spécifiera aussi cet adaptateur comme adaptateur par défaut
à utiliser avec Zend_Db_Table. Si vous souhaitez utiliser simultanément de multiples bases de
données, vous pouvez utiliser la plugin de ressource Multidb.
Les clés de configuration suivantes sont reconnues :
• adapter : le type de l'adaptateur Zend_Db.
• params : un tableau associatif des paramètres de configuration à utiliser pour la récupération

de l'instance de l'adaptateur.
• isDefaultTableAdapter : spécifie si l'adaptateur est celui par défaut des tables.
Exemple 32. Exemple de configuration d'une ressource d'adaptateur de base

données
Voici un exmple de configuration INI qui peut-être utilisé pour initialiser une ressource de
base de données.
[production]
resources.db.adapter = "pdo_mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "webuser"
resources.db.params.password = "XXXXXXX"
resources.db.params.dbname = "test"
resources.db.isDefaultTableAdapter = true
Récupération de l'instance de l'adaptateur

Si vous choisissez de ne pas utiliser l'adaptateur instancié avec cette ressource
comme adaptateur par défaut pour les tables, comment pourrez-vous récupérer
l'instance ?
Comme tout plugin de ressource, vous pouvez extraire votre plugin de ressource
de votre fichier d'initialisation :
$resource = $bootstrap->getPluginResource('db');
169
Zend_Application
Une fois que vous avez l'objet ressource, vous pouvez récupérer l'adaptateur de
base de données en utilisant la méthode getDbAdapter() :
$db = $resource->getDbAdapter();
6.3. Zend_Application_Resource_Frontcontroller
Probablement la ressource que vous allez le plus communément charger avec
Zend_Application sera la ressource de contrôleur frontal qui fournit la possibilité de
configurer Zend_Controller_Front. Cette ressource permet de spécifier n'importe quel
paramètre du contrôleur frontal, de spécifier les plugins à initialiser, et bien plus...
Une fois initialisée, la ressource assigne la propriété $frontController du fichier

d'initialisation à l'instance Zend_Controller_Front.
Les clés de configuration disponibles incluent les suivantes et sont sensibles à la casse :
• controllerDirectory : une chaîne de caractères spécifiant un seul dossier de contrôleurs, ou un

tableau associant un nom de module et un dossier de contrôleurs.
• moduleControllerDirectoryName : une chaîne de caractères indiquant un sous-dossier dans

ce module qui contient les contrôleurs.
• moduleDirectory : un dossier dans lequel tous les modules peuvent être trouvés.
• defaultControllerName : nom du contrôleur par défaut (normalement "index").
• defaultAction : nom de l'action par défaut (normalement "index").
• defaultModule : nom du module par défaut (normalement "default").
• baseUrl : URL de base explicite vers l'application (normalement auto-détecté).
• plugins : tableau de nom de classe de plugins de contrôleurs. La ressource instanciera chaque

classe (sans arguments de contructeur) et les enregistrera dans le contrôleur frontal.
• params : tableau de paires clés / valeurs à enregistrer dans le contrôleur frontal.
Si une clé non-connue est fournie, elle sera enregistrée comme paramètre du contrôleur frontal
en la fournissant à setParam().
Exemple 33. Exemple de configuration d'une ressource de contrôleur frontal
Voici un extrait de configuration INI montrant comment configurer la ressource de contrôleur

frontal.
[production]
resources.frontController.moduleControllerDirectoryName = "actions"
resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"
resources.frontController.defaultControllerName = "site"
resources.frontController.defaultAction = "home"
resources.frontController.defaultModule = "static"
resources.frontController.baseUrl = "/subdir"
resources.frontController.plugins.foo = "My_Plugin_Foo"
resources.frontController.plugins.bar = "My_Plugin_Bar"
resources.frontController.env = APPLICATION_ENV
170
Zend_Application
Exemple 34. Récupération de votre contrôleur frontal à partir de votre initialiseur
Une fois la ressource de contrôleur frontal initialisée, vous pouvez récupérer l'instance via
la propriété $frontController de votre initialiseur.
$bootstrap->bootstrap('frontController');
$front = $bootstrap->frontController;
6.4. Zend_Application_Resource_Layout
Zend_Application_Resource_Layout peut être utilisé pour configurer Zend_Layout. Les
options de configurations sont les mêmes que celles de Zend_Layout.
Exemple 35. Exemple de configuration de layout
Ci-dessous un exemple de code INI montrant comment configurer la ressource navigation.
resources.layout.layout = "NomDuLayoutParDefaut"
resources.layout.layoutPath = "/chemin/vers/layouts"
6.5. Zend_Application_Resource_Locale
Zend_Application_Resource_Locale can be used to set an application-wide locale which
is then used in all classes and components which work with localization or internationalization.
There are basically three usecases for the Locale Resource Plugin. Each of them should be used
depending on the applications need.
6.5.1. Autodetect the locale to use

Without specifying any options for Zend_Application_Resource_Locale, Zend_Locale
will detect the locale, which your application will use, automatically.
This detection works because your client sends the wished language within his HTTP request.
Normally the clients browser sends the languages he wants to see, and Zend_Locale uses
this information for detection.
But there are 2 problems with this approach:
• The browser could be setup to send no language
• The user could have manually set a locale which does not exist
In both cases Zend_Locale will fallback to other mechanism to detect the locale:
• When a locale has been set which does not exist, Zend_Locale tries to downgrade this string.
When, for example, en_ZZ is set it will automatically be degraded to en. In this case en will
be used as locale for your application.
• When the locale could also not be detected by downgrading, the locale of your environment
(web server) will be used. Most available environments from Web Hosters use en as locale.
• When the systems locale could not be detected Zend_Locale will use it's default locale, which
is set to en per default.
171
Zend_Application
For more informations about locale detection take a look into this chapter on Zend_Locale's
automatic detection.
6.5.2. Autodetect the locale and adding a own fallback

The above autodetection could lead to problems when the locale could not be
detected and you want to have another default locale than en. To prevent this,
Zend_Application_Resource_Locale allows you to set a own locale which will be used in
the case that the locale could not be detected.
Exemple 36. Autodetect locale and setting a fallback
The following snippet shows how to set a own default locale which will be used when the
client does not send a locale himself.
; Try to determine automatically first,

; if unsuccessful, use nl_NL as fallback.
resources.locale.default = "nl_NL"
6.5.3. Forcing a specific locale to use

Sometimes it is useful to define a single locale which has to be used. This can be done by using
the force option.
In this case this single locale will be used and the automatic detection is turned off.
Exemple 37. Defining a single locale to use
The following snippet shows how to set a single locale for your entire application.
; No matter what, the nl_NL locale will be used.

resources.locale.default = "nl_NL"
resources.locale.force = true
6.6. Zend_Application_Resource_Log
Zend_Application_Resource_Log permet d'instancier une instance Zend_Log avec
une nombre quelconque de rédacteurs. La configuration sera fournie à la méthode
Zend_Log::factory() vous permettant de spécifier les combinaisons de rédacteurs et
de filtres. L'instance de journalisation peut ensuite être récupérée à partir du bootstrap afin
d'enregistrer les événements.
Exemple 38. Exemple de configuration d'une ressource de journalisation
Ci-dessous, vous avez un extrait de fichier INI montrant comment configurer la ressource
de journalisation.
resources.log.stream.writerName = "Stream"
resources.log.stream.writerParams.stream = APPLICATION_PATH "/../data/logs/application.l
resources.log.stream.writerParams.mode = "a"
resources.log.stream.filterName = "Priority"
resources.log.stream.filterParams.priority = 4
Pour plus d'informations concernant les options disponibles, vous pouvez consulter la
documentation de Zend_Log::factory().
172
Zend_Application
6.7. Zend_Application_Resource_Multidb
Zend_Application_Resource_Multidb est utilisé pour initialiser de multiples connexions
vers des bases de données. Vous pouvez utiliser les mêmes options qu'avec le plugin de
ressource Db. Cependant, pour spécifier une connexion par défaut, vous pouvez aussi utiliser
la directive 'default'.
Exemple 39. Paramétrer de multiples connexions vers des bases de données
Ci-dessous vous avez un exemple de configuration INI montrant l'initialisation de deux

connexions.
[production]
resources.multidb.db1.adapter = "pdo_mysql"
resources.multidb.db1.host = "localhost"
resources.multidb.db1.username = "webuser"
resources.multidb.db1.password = "XXXX"
resources.multidb.db1.dbname = "db1"
resources.multidb.db2.adapter = "pdo_pgsql"
resources.multidb.db2.host = "example.com"
resources.multidb.db2.username = "dba"
resources.multidb.db2.password = "notthatpublic"
resources.multidb.db2.dbname = "db2"
resources.multidb.db2.default = true
Exemple 40. Récupérer un adaptateur de bases de données spécifique
Lorsque vous utilisez ce plugin de ressource, vous aurez sans doute besoin de récupérer un
adaptateur spécifique. Ceci peut être réalisé en utilisant la méthode getDb(). La méthode
getDb() retourne l'instance d'une classe qui étend Zend_Db_Adapter_Abstract. Si
vous n'avez pas activé un adaptateur par défaut, une exception sera levée lorsque vous
appelerez cette méthode sans lui fournir de paramètre.
$resource = $bootstrap->getPluginResource('multidb');
$db1 = $resource->getDb('db1');
$db2 = $resource->getDb('db2');
$defaultDb = $resource->getDb();
Exemple 41. Récupérer l'adaptateur de base de données par défaut
De plus, vous pouvez récupérer l'adaptateur par défaut en utilisant la méthode

getDefaultDb(). Si vous n'avez pas activé d'adaptateur par défaut, le premier configuré
sera retourné. Si vous spécifiez FALSE en tant que premier paramètre, alors vous récupérez
NULL si adaptateur par défaut n'est configuré.
Ci-dessous vous avez un exemple qui suppose que le plugin de ressource Multidb a été
configuré avec l'exemple INI ci-dessus :
$resource = $bootstrap->getPluginResource('multidb');
$db2 = $resource->getDefaultDb();
// Même config, mais maintenant sans adaptateur par défaut :

$db1 = $resource->getDefaultDb();
$null = $resource->getDefaultDb(false); // null
173
Zend_Application
6.8. Zend_Application_Resource_Mail
Zend_Application_Resource_Mail peut être utilisé pour instancier un transport pour
Zend_Mail ou pour paramétrer le nom par défaut et l'adresse, ainsi que le nom et l'adresse
de réponse par défaut.
Lors de l'instanciation d'un transport, il est automatiquement enregistré avec Zend_Mail.

Cependant en paramétrant la directive transport.register à FALSE, ce comportement n'apparait
pas.
Exemple 42. Exemple de configuration de la ressource Mail
Ci-dessous, vous avez un extrait d'un fichier INI montrant comment configurer le plugin de
ressource Mail.
resources.mail.transport.type = smtp
resources.mail.transport.host = "smtp.example.com"
resources.mail.transport.auth = login
resources.mail.transport.username = myUsername
resources.mail.transport.password = myPassword
resources.mail.transport.register = true ; True by default
resources.mail.defaultFrom.email = john@example.com
resources.mail.defaultFrom.name = "John Doe"
resources.mail.defaultReplyTo.email = Jane@example.com
resources.mail.defaultReplyTo.name = "Jane Doe"
6.9. Zend_Application_Resource_Modules
Zend_Application_Resource_Modules est utilisé pour initialiser les modules de votre
application. Si votre module possède un fichier Bootstrap.php à sa racine, et que celui-ci
contient une classe nommée Module_Bootstrap (où "Module" est le nom du module), alors
celle-ci sera utiliser pour lancer votre module.
Par défaut, une instance de Zend_Application_Module_Autoloader sera créée pour le

module en question, utilisant le nom du module et son dossier pour s'initialiser.
Puisque la ressource Modules ne prend pas d'argument par défaut, pour l'activer via la
configuration, vous devez créer un tableau vide. Since the Modules resource does not take any
arguments by default, in order to enable it via configuration, you need to create it as an empty
array. En configuration de type INI cela ressemblerait à ceci :
resources.modules[] =
En configuration de type XML cela ressemblerait à ceci :
<resources>
<modules>

<placeholder />
</modules>
</resources>
En utilisant un tableau PHP, il suffit de le créer comme un tableau vide :
$options = array(
174
Zend_Application
'modules' => array()

)
);
Dépendance envers le contrôleur frontal

La ressource Modules possède une dépendance envers la ressource Front
Controller. Vous pouvez bien sûr proposer votre propre implémentation de
la ressource du contrôleur frontal, si tant est que sa classe se termine par
"Frontcontroller", ou, si vous choisissez d'utiliser une méthode d'initialisation,
celle-ci doit être "_initFrontController".
Exemple 43. Configurer les modules
Vous pouvez spécifier la configuration en utilisant le nom du module comme préfixe de

section dans le fichier de configuration.
Par exemple, supposons que vous possédiez un module appelé "news". Voici des exemples
INI et XML de fichiers de configuration pour ce module.
[production]
news.resources.db.adapter = "pdo_mysql"
news.resources.db.params.host = "localhost"
news.resources.db.params.username = "webuser"
news.resources.db.params.password = "XXXXXXX"
news.resources.db.params.dbname = "news"
<?xml version="1.0"?>
<config>
<production>
<news>
<resources>
<db>
<adapter>pdo_mysql</adapter>
<params>
<host>localhost</host>
<username>webuser</username>
<password>XXXXXXX</password>
<dbname>news</dbname>
</params>
<isDefaultAdapter>true</isDefaultAdapter>
</db>
</resources>
</news>
</production>
</config>
Exemple 44. Récupérer un bootstrap de module
Il peut être utile de pouvoir récupérer l'objet bootstrap de votre module, pour en exécuter par
exemple des méthodes spécifiques, ou encore pour en récupérer l'autoloader. La méthode
getExecutedBootstraps() peut être utilisée dans ce cas là, elle s'applique sur un objet
ressource de modules.
$resource = $bootstrap->getPluginResource('modules');
$moduleBootstraps = $resource->getExecutedBootstraps();
$newsBootstrap = $moduleBootstraps['news'];
175
Zend_Application
6.10. Zend_Application_Resource_Navigation
Zend_Application_Resource_Navigation peut être utilisé pour configurer une instance
de Zend_Navigation. Les options de configurations sont les mêmes que celles de
Zend_Navigation.
Une fois configuré, l'objet de navigation est ajouté à Zend_View_Helper_Navigation par

défaut.
Exemple 45. Exemple de configuration de la ressource Navigation
Voici un exemple de syntaxe INI concernant la configuration de la ressource navigation.
resources.navigation.pages.page1.label = "Nom de la première page"

resources.navigation.pages.page1.route = "Route concernant la première page"
; Page 2 est une sous-page de page 1

resources.navigation.pages.page1.pages.page2.type = "Zend_Navigation_Page_Uri"
resources.navigation.pages.page1.pages.page2.label = "Nom de la seconde page"
resources.navigation.pages.page1.pages.page2.uri = "/url/to/page/2"
6.11. Zend_Application_Resource_Router
Zend_Application_Resource_Router est utilisé pour configurer le routeur enregistré
grâce aux options du contrôleur frontal. Les options sont identiques à celles de
Zend_Controller_Router_Route.
Exemple 46. Exemple de configuration du routeur
Voici l'exemple d'un fichier INI qui configure une ressource de type routeur.
resources.router.routes.route_id.route = "/login"
resources.router.routes.route_id.defaults.module = "user"
resources.router.routes.route_id.defaults.controller = "login"
resources.router.routes.route_id.defaults.action = "index"
; Optionellement, un séparateur de chaines peut être précisé:

resources.router.chainNameSeparator = "_"
Pour plus d'informations sur le séparateur de chaines, voyez sa section.
6.12. Zend_Application_Resource_Session
Zend_Application_Resource_Session est utilisé pour configurer Zend_Session et
éventuellement un support de sauvegarde sessions (SaveHandler).
Pour créer un support de sauvegarde session, passez la clé saveHandler (case insensitive) à la
ressource. La valeur d'une telle option peut être :
• String : cette chaîne indique le nom d'une classe implémentant

Zend_Session_SaveHandler_Interface.
• Array : avec les clés "class" et optionnellement "options", indiquant une classe à instancier
(implémentant Zend_Session_SaveHandler_Interface) et un tableau d'options à
passer à son constructeur.
176
Zend_Application
• Zend_Session_SaveHandler_Interface : un objet implémentant cette interface.
Toute autre option non reconnue sera alors passée à Zend_Session::setOptions() pour
configurer Zend_Session.
Exemple 47. Exemple de ressource session
Voici un fichier INI permettant de configurer une session via la ressource.

Il affecte des options à Zend_Session et configure une instance de
Zend_Session_SaveHandler_DbTable.
resources.session.save_path = APPLICATION_PATH "/../data/session"

resources.session.use_only_cookies = true
resources.session.remember_me_seconds = 864000
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 = "sessionSavePa
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"
Configurez votre base de données avant !

Si vous configurez le gestionnaire Zend_Session_SaveHandler_DbTable,
vous devez configurer votre base de données avant. Pour cela, servez vous de
la ressource Db et assurez vous que la clé "resources.db" apparaît bien avant
la clé "resources.session". Vous pouvez aussi utiliser votre propre ressource qui
initialise la base de données et affecte l'adaptateur Zend_Db_Table par défaut.
6.13. Zend_Application_Resource_View
Zend_Application_Resource_View peut être utilisée pour configurer une instance
Zend_View instance. Les clés de configurations sont celles de Zend_View.
Dès que l'instance est configurée, ceci crée une instace de

Zend_Controller_Action_Helper_ViewRenderer et enregistre le ViewRenderer avec
Zend_Controller_Action_HelperBroker - à partir duquel vous pourrez le récupérer plus
tard.
Exemple 48. Exemple de configuration d'une ressource de vue
Voici un extrait de configuration INI montrant comment configurer une ressource de vue.
resources.view.encoding = "UTF-8"
resources.view.basePath = APPLICATION_PATH "/views/scripts"
177
Zend_Auth
1. Introduction
Zend_Auth fournit une API pour l'authentification et inclut des adaptateurs concrets
d'authentification pour les cas les plus courants.
Zend_Auth est uniquement concerné par le processus d'authentification et non pas par
le processus d'autorisation. L'authentification est définie de manière lâche (souple) afin de
déterminer si une entité donnée est bien celle qu'elle prétend être (c.-à-d. identification), sur la
base d'identifiants fournis. L'autorisation, l'action de décider si une entité donnée peut accéder
à d'autres entités et / ou exécuter des opérations sur celles-ci ne fait pas partie des prérogatives
de Zend_Auth. Pour plus d'informations sur les autorisations et le contrôle d'accès via Zend
Framework, voyez Zend_Acl.
La classe Zend_Auth inclut un singleton - uniquement une instance de la

classe est disponible - à travers la méthode statique getInstance(). Celle ci
utilise un opérateur new et le mot-clé clone ne fonctionnera pas avec la classe
Zend_Auth, utilisez plutôt getInstance().
1.1. Adaptateurs
Un adaptateur Zend_Auth est utilisé pour authentifier via un service particulier d'authentification,
comme LDAP, RDBMS ou un stockage basé sur des fichiers. Les différents adaptateurs peuvent
posséder des options et des comportements très divers. Cependant, quelques méthodes de
base leur sont communes. Par exemple, accepter des éléments d'authentification (incluant
une identité prétendue), authentifier et retourner un résultat sont des éléments communs aux
adaptateurs Zend_Auth.
Chaque classe d'adaptateur Zend_Auth implémente Zend_Auth_Adapter_Interface.

Cette interface définit une méthode, authenticate(), celle-ci est implémentée par une classe
adaptateur à fin de réaliser l'authentification. Chaque classe adaptateur doit être préparée avant
tout appel de authenticate(). Cela implique que chaque adaptateur fournisse la possibilité
de définir des éléments d'authentification (par exemple identifiant et mot de passe) et de définir
des valeurs pour les options spécifiques de l'adaptateur, tels que les paramètres de connexion
à une base de données pour un adaptateur qui en fait usage.
L'exemple suivant est un adaptateur d'authentification qui requiert un identifiant et un mot de

passe. D'autres détails, tel que la manière d'interroger le service d'authentification, ont été omis
par souci de clarté :
class MonAdaptateurAuth implements Zend_Auth_Adapter_Interface

{
/**
* Définition de l'identifiant et du mot de passe
* pour authentification
*
* @return void
*/
public function __construct($identifiant, $motdepasse)
{
178
Zend_Auth
// ...
}
/**
* Réalise une tentative d'authentification
*
* @throws Zend_Auth_Adapter_Exception Si l'authentification
* ne peut pas être réalisée
* @return Zend_Auth_Result
*/
public function authenticate()
{
// ...
}
}
Comme indiqué dans la documentation "docblock", authenticate() doit retourner une

instance de Zend_Auth_Result (ou d'une classe dérivée de Zend_Auth_Result). Si
pour quelque raison que ce soit, la requête d'authentification ne peut pas être réalisée,
authenticate() retournera une exception dérivée de Zend_Auth_Adapter_Exception.
1.2. Résultats
Les adaptateurs Zend_Auth retournent une instance de Zend_Auth_Result via
authenticate() de manière à présenter les résultats d'une tentative d'authentification. Les
adaptateurs alimentent l'objet Zend_Auth_Result lors de sa construction, de manière à ce que
les quatre méthodes suivantes fournissent de base un lot d'opérations communes aux résultats
des adaptateurs Zend_Auth :
• isValid() : retourne TRUE si et seulement si le résultat représente une tentative réussie

d'authentification.
• getCode() : retourne une constante Zend_Auth_Result qui détermine le type de retour

accepté ou refusé (N.D.T. : voir tableau ci dessous). Cela peut être utilisé pour les
développeurs voulant distinguer en amont les différents types de résultat. Il est possible
d'avoir des statistiques détaillées, par exemple. Une autre utilisation est la personnalisation du
message de retour au client. Attention cependant à ne pas trop donner de détails aux clients
pour des raisons de sécurité. Pour plus de détails, consultez les notes ci-dessous.
• getIdentity() : retourne l'identité de la tentative d'authentification.
• getMessages() : retourne un tableau de messages relatifs à une tentative infructueuse

d'authentification.
Un développeur peut connecter le résultat de l'authentification avec des opérations spécifiques.

Certaines opérations développées peuvent bloquer le compte après plusieurs refus du mot de
passe, bannir une adresse IP après plusieurs essais sur des comptes inexistants ou fournir un
message spécifique à l'utilisateur final. Les codes suivants sont disponibles :
Zend_Auth_Result::SUCCESS
Zend_Auth_Result::FAILURE
Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND
Zend_Auth_Result::FAILURE_IDENTITY_AMBIGUOUS
Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID
Zend_Auth_Result::FAILURE_UNCATEGORIZED
179
Zend_Auth
L'exemple suivant illustre comment utiliser le retour :
// A l'intérieur de la méthode AuthController / loginAction

$resultat = $this->_auth->authenticate($adapter);
switch ($resultat->getCode()) {
case Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND:
/** l'identifiant n'existe pas **/
break;
case Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID:
/** mauvaise authentification **/
break;
case Zend_Auth_Result::SUCCESS:
/** authentification acceptée **/
break;
default:
/** autres cas **/
break;
}
1.3. Persistance d'identité

Authentifier une requête qui contient des paramètres d'authentification est utile en soi, mais il est
également important de permettre le maintien de l'identité authentifiée sans avoir à représenter
ces paramètres d'authentification à chaque requête.
HTTP est un protocole sans état, cependant, des techniques telles que les cookies ou les
sessions ont été développées de manière à faciliter le maintien d'un contexte lors de multiples
requêtes dans les applications Web.
1.3.1. Persistance par défaut dans une session PHP
Par défaut, Zend_Auth fournit un stockage persistant de l'identité, après une

authentification réussie, via les sessions PHP. Après une authentification réussie,
Zend_Auth::authenticate() conserve l'identité résultant de l'authentification dans un
stockage persistant. A moins d'une configuration particulière, Zend_Auth utilise une
classe de stockage nommée Zend_Auth_Storage_Session, qui utilise Zend_Session.
Une classe personnalisée peut être utilisée pour fournir un objet implémentant
Zend_Auth_Storage_Interface à Zend_Auth::setStorage().
Si la persistance automatique de l'identité n'est pas souhaitable dans un cas

particulier, alors le développeur peut renoncer à utiliser la classe Zend_Auth et
préférer utiliser directement une classe adaptateur.
180
Zend_Auth
Exemple 49. Changer l'espace de nommage de la session
Zend_Auth_Storage_Session utilise un espace de nommage de Zend_Auth.

Cet espace peut être écrit en passant les valeurs au constructeur de
Zend_Auth_Storage_Session, et ces valeurs sont passées en interne au constructeur
de Zend_Session_Namespace. Cela doit être fait avant l'authentification, et avant que
Zend_Auth::authenticate() ait accompli le stockage automatique de l'identité.
// Sauver une référence du singleton, instance de Zend_Auth

$auth = Zend_Auth::getInstance();
// Utiliser 'unEspaceDeNommage' instance de 'Zend_Auth'

$auth->setStorage(new Zend_Auth_Storage_Session('unEspaceDeNommage'));
/**
* @todo Paramètrage de l'adaptateur d'authentification :
* $authAdaptateur
*/
// authentification, sauvegarde du résultat

// et stockage du résultat en cas de succès
$resultat = $auth->authenticate($authAdaptateur);
1.3.2. Installer un stockage personnalisé
Parfois les développeurs ont besoin d'utiliser un comportement de persistance d'identité

différent de celui fourni par Zend_Auth_Storage_Session. Dans ces cas, les développeurs
implémentent simplement Zend_Auth_Storage_Interface et fournissent t une instance de
la classe à Zend_Auth::setStorage().
181
class MonStockage implements Zend_Auth_Storage_Interface
{
Pour utiliser une classe de stockage d'identité persistante autre que
/** Zend_Auth
Zend_Auth_Storage_Session, le développeur commence par implémenter
* Retourne true si et seulement si le stockage est vide
Zend_Auth_Storage_Interface
* :
* @throws Zend_Auth_Storage_Exception S'il est impossible de déterminer
Exemple
* 50. Utiliser une classe de stockage personnalisée
si le stockage est vide
* @return boolean
*/
public function isEmpty()
{
/**
* @todo implémentation
*/
}
/**
* Retourne le contenu du stockage
*
* Comportement à définir si le stockage est vide.
*
* @throws Zend_Auth_Storage_Exception Si la lecture du stockage
* est impossible
* @return mixed
*/
public function read()
{
/**
* @todo implémentation
*/
}
/**
* Ecrit $contents dans le stockage
*
* @param mixed $contents
* @throws Zend_Auth_Storage_Exception Si l'écriture de $contents
* est impossible
* @return void
*/
public function write($contents)
{
/**
* @todo implementation
*/
}
/**
* RAZ du stockage
*
* @throws Zend_Auth_Storage_Exception Si la remise à zéro (RAZ)
* est impossible
* @return void
*/
// Définit function
public la classeclear()
personnalisée à utiliser
{
Zend_Auth::getInstance()->setStorage(new MonStockage());
/**
Ensuite la *classe
@todopersonnalisée est invoquée, avant la requête d'authentification, avec
implementation
/**
Zend_Auth::setStorage()
*/ :
* @todo Paramètrage de l'adaptateur d'authentification :
* } $authAdaptateur
*/
}
// Authentification, sauvegarde et
// persistance du résultat en cas de succès.
$result = Zend_Auth::getInstance()->authenticate($authAdaptateur);
182
Zend_Auth
1.4. Utilisation de Zend_Auth

Deux manières d'utiliser les adaptateurs Zend_Auth sont proposées :
1. indirectement, via Zend_Auth::authenticate() ;
2. directement, via la méthode authenticate() de l'adaptateur.
L'exemple suivant illustre la manière d'utiliser un adaptateur Zend_Auth de manière indirecte

via l'utilisation de la classe Zend_Auth :
// Obtention d'une référence de l'instance du Singleton de Zend_Auth

// Définition de l'adaptateur d'authentification

$authAdaptateur = new MonAdaptateurAuth($identifiant, $motdepasse);
// Tentative d'authentification et stockage du résultat

$resultat = $auth->authenticate($authAdaptateur);
if (!$resultat->isValid()) {
// Echec de l'authentification ; afficher pourquoi
foreach ($resultat->getMessages() as $message) {
echo "$message\n";
}
} else {
// Authentification réussie ; l'identité ($identifiant) est
// stockée dans la session
// $resultat->getIdentity() === $auth->getIdentity()
// $resultat->getIdentity() === $identifiant
}
Une fois la tentative d'authentification réalisée, tel que montré ci-dessus, il est très simple de
vérifier si une identité correctement authentifiée existe :
if ($auth->hasIdentity()) {
// l'identité existe ; on la récupère
$identite = $auth->getIdentity();
}
Pour retirer une identité du stockage persistant, utilisez simplement la méthode

clearIdentity(). A utiliser typiquement pour implémenter une opération de déconnexion
d'une application :
Zend_Auth::getInstance()->clearIdentity();
Quand l'utilisation automatique du stockage persistant n'est pas appropriée, le développeur peut
simplement contourner l'utilisation de la classe Zend_Auth en utilisant directement une classe
adaptateur. L'usage direct d'une classe adaptateur implique de configurer et préparer l'objet
adaptateur et d'appeler ensuite sa méthode authenticate(). Les détails spécifiques à un
adaptateur sont décrits dans la documentation de chacun d'entre-eux. L'exemple suivant utilise
directement MonAdaptateurAuth :
// Définition de l'adaptateur d'authentification
183
Zend_Auth
$authAdaptateur = new MonAdaptateurAuth($identifiant, $motdepasse);
// Tentative d'authentification, stockage du résultat

$resultat = $authAdaptateur->authenticate();
if (!$resultat->isValid()) {
// échec de l'authentification ; afficher pourquoi
foreach ($resultat->getMessages() as $message) {
echo "$message\n";
}
} else {
// Authentification réussie
// $resultat->getIdentity() === $identifiant
}
2. Authentification avec une table de base de données

2.1. Introduction
Zend_Auth_Adapter_DbTable fournit la possibilité d'authentifier sur la base de crédits
stockés dans une table de base de données. Comme Zend_Auth_Adapter_DbTable requiert
qu'une instance de Zend_Db_Adapter_Abstract soit fournie à son constructeur, chaque
instance est liée à une connexion de base de données particulière. Les autres options de
configuration peuvent être réglées grâce au constructeur ou au travers de différentes méthodes,
une pour chaque option.
Les options de configuration disponibles incluent :
• tableName : il s'agit du nom de la table dans la base de données qui contient les crédits
d'authentification, et envers laquelle la requête d'authentification sera réalisée.
• identityColumn : il s'agit du nom de la colonne dans la table utilisée pour représenter l'identité.
La colonne d'identité doit contenir une valeur unique, comme un "username" ou une adresse
émail.
• credentialColumn : il s'agit du nom de la colonne dans la table utilisée pour représenter le

crédit. Dans le cas d'une simple authentification par identité / mot de passe, la valeur de crédit
correspond au mot de passe. Voir aussi l'option credentialTreatment.
• credentialTreatment : dans la plupart des cas, les mots de passe et autres données sensibles
sont cryptés, hachés, encodés, masqués, ou sinon traités à travers une fonction ou un
algorithme. En spécifiant un traitement paramétrable de chaîne avec cette méthode, comme
MD5(?) ou PASSWORD(?), un développeur peut appliquer un code SQL arbitraire sur les
données de crédit fournies. Comme ces fonctions sont spécifiques à chaque gestionnaire de
base de données (SGBD), vérifiez le manuel de la base de données pour vérifier la disponibilité
de ces fonctions dans votre système.
184
Zend_Auth
Comme expliqué dans l'introduction, le constructeur de Zend_Auth_Adapter_DbTable

requiert une instance
Exemple de Zend_Db_Adapter_Abstract
51. Utilisation basique qui est utilisée comme connexion
Le
à la code suivant
base de créeà laquelle
données un adaptateur pour
l'instance une base d'authentification
d'adaptateur de données en est mémoire, créetout,
liée. Avant un
schéma avecàune
la connexion tablede
la base unique,
donnée et devrait
insère une
être ligne
crée. sur laquelle nous pouvons réaliser une
requête
// Créed'authentification
une connexion plus tard. Cet
de base de exemple
données requiert
SQLite que l'extension PDO SQLite soit
en mémoire
disponible :
$dbAdapter = new Zend_Db_Adapter_Pdo_Sqlite(array('dbname' =>
':memory:'));
// Construit une requête de création de table

$sqlCreate = 'CREATE TABLE [users] ( '
. '[id] INTEGER NOT NULL PRIMARY KEY, '
. '[username] VARCHAR(50) UNIQUE NOT NULL, '
. '[password] VARCHAR(32) NULL, '
. '[real_name] VARCHAR(150) NULL)';
// Crée la table de crédits d'authentification

$dbAdapter->query($sqlCreate);
// Construit la requête pour insérer une ligne pour laquelle

// l'authentification pourra réussir
$sqlInsert = "INSERT INTO users (username, password, real_name) "
. "VALUES ('my_username', 'my_password', 'My Real Name')";
Avec
// une connexion
Insertion de base de données et des données disponibles dans la table,
des données
$dbAdapter->query($sqlInsert);
une instance de Zend_Auth_Adapter_DbTable peut être créée. Les valeurs d'options
de
// configuration
Configure une peuvent être fournies
instance avec desauparamètres
constructeurdeouconstructeur
en tant que paramètres
... aux
méthodes de réglage après l'instanciation :
$authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter,
'users',
'username',
'password');
// ... ou configure l'instance avec des méthodes de réglage

$authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
$authAdapter->setTableName('users')
A cet instant, l'instance de l'adaptateur d'authentification est prête à recevoir des requêtes
->setIdentityColumn('username')
->setCredentialColumn('password');
d'authentification.
// Règle les valeurs led'entrées
Dans but de réaliser une requête d'authentification, les valeurs des
des crédits
crédits requêtés sont fournies à l'adaptateur
// (en général, à partir d'un formulaire avant d'appeler la méthode authenticate() :
d'enregistrement)
$authAdapter->setIdentity('my_username')
->setCredential('my_password');
En plus
// de la disponibilité
Réalise la requêtede la méthode getIdentity()
d'authentification, pour récupérer
et sauvegarde l'objet du résultat
le résultat
$result = $authAdapter->authenticate();
d'authentification, Zend_Auth_Adapter_DbTable supporte aussi la récupération de la
// Affiche l'identité
ligne
echo de la table qui a réussi l'authentification
$result->getIdentity() . "\n\n"; :
// Affiche la ligne de résultat

print_r($authAdapter->getResultRowObject());
/* Affiche:
my_username
Array
(
[id] => 1
[username] => my_username
[password] => my_password
[real_name] => My Real Name
Puisque la ligne de la table contient la valeur de crédit, il est important de garantir ces valeurs
)
*/
contre l'accès fortuit.
185
Zend_Auth
2.2. Utilisation avancée : maintenir persistant l'objet de résultat

DbTable
Par défaut, Zend_Auth_Adapter_DbTable retourne l'identité fournie à l'objet Auth
en cas d'authentification couronnée de succès. Un autre scénario d'utilisation, où les
développeurs veulent stocker dans le mécanisme de stockage persistant du Zend_Auth
un objet d'identité contenant d'autres informations utiles, est résolu en utilisant la méthode
getResultRowObject() retournant un objet stdClass. Le petit bout de code suivant illustre
cette utilisation :
// authentifie avec Zend_Auth_Adapter_DbTable

$result = $this->_auth->authenticate($adapter);
// stocke l'identité comme objet dans lequel seulement username et

// real_name sont retournés
$storage = $this->_auth->getStorage();
$storage->write($adapter->getResultRowObject(array('username',
'real_name')));
// stocke l'identité comme objet dans lequel la colonne password

// a été omis
$storage->write($adapter->getResultRowObject(null, 'password'));
/* ... */
} else {
/* ... */
2.3. Utilisation avancée par l'exemple

Bien que le but initial de Zend_Auth (et par extension celui de
Zend_Auth_Adapter_DbTable) est principalement l'authentification et non l'autorisation (ou
contrôle d'accès), il existe quelques exemples et problèmes qui franchissent la limite des
domaines auxquels ils appartiennent. Selon la façon dont vous avez décidé d'expliquer votre
problème, il semble parfois raisonnable de résoudre ce qui pourrait ressembler à un problème
d'autorisation dans l'adaptateur d'authentification.
Ceci étant dit, Zend_Auth_Adapter_DbTable possède des mécanismes qui sont construits
de telle sorte qu'ils peuvent être démultipliés pour ajouter des contrôles supplémentaires au
moment de l'authentification pour résoudre quelques problèmes communs d'utilisateur.
// La valeur du champs "etat" d'un compte

// ne doit pas être égal à "compromis"
$adapter = new Zend_Auth_Adapter_DbTable($db,
'utilisateurs',
'login',
'password',
'MD5(?) AND etat != "compromis"');
// La valeur du champs "actif" d'un compte

// doit être égal à "TRUE"
$adapter = new Zend_Auth_Adapter_DbTable($db,
186
Zend_Auth
'utilisateurs',
'login',
'password',
'MD5(?) AND actif = "TRUE"');
Un autre scénario possible est l'implantation d'un mécanisme de "salting". "Salting" est un terme
se référant une technique qui peut fortement améliorer la sécurité de votre application. C'est
basé sur l'idée que concaténer une chaîne aléatoire à tout mot de passe rend impossible la
réussite d'une attaque de type "brute force" sur la base de données en utilisant des valeurs
préalablement hashées issues d'un dictionnaire.
Par conséquent nous devons modifier notre table pour stocker notre chaîne de "salt" aléatoire :
$sqlAlter = "ALTER TABLE [users] "

. "ADD COLUMN [password_salt] "
. "AFTER [password]";
$dbAdapter->query($sqlAlter);
Voici une méthode simple pour générer une chaîne aléatoire pour chaque utilisateur à leur
enregistrement :
for ($i = 0; $i < 50; $i++)

{
$dynamicSalt .= chr(rand(33, 126));
}
Et maintenant, construisons l'adaptateur :

$db,
'users',
'username',
'password',
"MD5(CONCAT('"
. Zend_Registry::get('staticSalt')
. "', ?, password_salt))"
);
Vous pouvez encore améliorer la sécurité en utilisant une chaîne de "salt"

statique codée en dur dans votre application. Dans le cas ou la base de données
est compromise (par exemple par une attaque de type injection SQL) mais que
votre serveur Web est intact, les données sont inutilisables par l'attaquant.
Une autre alternative est d'utiliser la méthode getDbSelect() de la classe

Zend_Auth_Adapter_DbTable après la construction de l'adaptateur. Cette méthode
retournera une instance d'objet Zend_Db_Select utilisée pour réaliser la routine
authenticate(). Il est important de noter que cette méthode retournera toujours le même
objet, que la méthode authenticate() a été appelée ou non. Cet objet ne comportera aucune
information d'identité ou de crédit puisque celles-ci sont placées dans l'objet select au moment
de authenticate().
Un exemple de situation nécessitant l'utilisation de la méthode getDbSelect() serait de vérifier

le statut d'un utilisateur, en d'autres termes pour voir si le compte d'un utilisateur est activé.
// En continuant avec l'exemple ci-dessus
187
Zend_Auth

$db,
'users',
'username',
'password',
'MD5(?)'
);
// Récupérer l'objet select (par référence)

$select = $adapter->getDbSelect();
$select->where('active = "TRUE"');
// Authentification, ceci s'assure que users.active = TRUE

$adapter->authenticate();
3. Authentification "Digest"
3.1. Introduction
L'authentification "Digest" est une méthode d'authentification HTTP qui améliore
l'authentification basique en fournissant un moyen d'authentifier sans avoir à transmettre le mot
de passe en clair sur le réseau.
Cet adaptateur permet l'authentification en utilisant un fichier texte contenant des lignes
comportant les éléments de base d'une authentification Digest :
• identifiant, tel que "utilisateur.jean"
• domaine, tel que "Zone administrative"
• hachage MD55 d'un identifiant, domaine et mot de passe, séparés par des caractères deux-
points.
Les éléments ci-dessus sont séparés par des caractères deux-points, comme dans l'exemple
suivant (dans lequel le mot de passe est "unMotdepasse") :
unUtilisateur:Un domaine:3b17d7f3a9374666e892cbce58aa724f
3.2. Spécifications
L'adaptateur d'authentification Digest, Zend_Auth_Adapter_Digest requiert plusieurs
paramètres d'entrée :
• filename : fichier utilisé pour réaliser l'authentification
• realm : domaine d'authentification Digest ("realm" en anglais)
• username : identifiant d'authentification Digest
• password : mot de passe pour l'identifiant dans le domaine
Ces paramètres doivent être définis avant l'appel de authenticate().
3.3. Identité
L'adaptateur d'authentification Digest retourne un objet Zend_Auth_Result, lequel a été
alimenté avec l'identité sous la forme d'un tableau ayant pour clés realm (domaine) et username
188
Zend_Auth
(identifiant). Les valeurs respectives associées à ces clés correspondent aux valeurs définies
avant l'appel à authenticate().
$adaptateur = new Zend_Auth_Adapter_Digest($nomFichier,

$domaine,
$identifiant,
$motdepasse);
$resultat = $adaptateur->authenticate();
$identite = $resultat->getIdentity();
print_r($identite);
/*
Array
(
[realm] => Un domaine
[username] => unUtilisateur
)
*/
4. Adaptateur d'authentification HTTP

4.1. Introduction
Zend_Auth_Adapter_Http fournit une implémentation des authentifications HTTP Basicet
Digest, au regard de la norme RFC-2617. Digest est une méthode d'authentification HTTP
basée sur Basic, mais qui augmente la sécurité en fournissant un moyen d'authentification sans
transmettre le mot de passe en clair, sur le réseau.
Caractéristiques principales :
• Support des méthodes Basic et Digest ;
• Propose tous les des schémas de challenge, le client peut répondre avec le schéma qu'il
supporte ;
• Support de l'authentification Proxy ;
• Inclus le support d'authentification de type fichier, et fournit une interface pour créer son propre
support, comme une base de données.
Il y a quelques caractéristiques de la RFC-2617 qui ne sont pas encore supportées :
• Le "Nonce tracking", mécanisme qui évite les attaques par répétitions ;
• Authentification avec vérification d'intégrité ("auth-int") ;
• En-tête HTTP "Authentication-Info".
4.2. Fonctionnement
Cette adaptateur utilise 2 sous-composants, la classe d'authentification HTTP elle-même et
des "Résolveurs." La classe d'authentification HTTP encapsule la logique de commande des
authentifications Basic et Digest. Elle utilise aussi un résolveur pour chercher les identifiants sur
un disque (fichier texte par défaut), et les analyser. Ils sont alors comparés aux valeurs envoyées
par le client pour déterminer une éventuelle correspondance.
189
Zend_Auth
4.3. Options de configuration

La classe Zend_Auth_Adapter_Http requière un tableau de configuration lors de sa
construction. Il y a plusieurs options de configuration disponibles, dont certaines requises :
Tableau 9. Liste des options de configuration
Nom Requise (?) Description

accept_schemes Oui Détermine les schémas
d'authentification que
l'adaptateur va accepter du
client. Ce doit être une liste
séparée par des espaces,
contenant 'basic' et / ou
'digest'.
realm Oui Fournit le nom de
l'authentification ("realm") ;
chaque nom d'utilisateur
doit être unique, par nom
d'authentification.
digest_domains Oui lorsque accept_schemes Liste d'URI, séparées
contient "digest" d'espace, pour lesquelles
la même information
d'authentification est valide.
Les URI peuvent pointer vers
différents serveurs.
nonce_timeout Oui lorsque accept_schemes Nombre de seconde pour
contient "digest" la validité du jeton
d'authentification. Voyez les
notes ci-dessous.
proxy_auth Non Désactivé par défaut. Activez
le pour effectuer une
authentification via un Proxy.
L'implémentation actuelle du nonce_timeout a des effets intéressants. Ce

paramètre doit déterminer le temps de validité d'un jeton, autrement dit : le temps
d'acceptation d'un client. Par exemple, une valeur de 3600 aura pour effet de
commander à l'adaptateur le rappel des informations d'identification du client,
toutes les heures. Ce comportement sera changé lorsque le paramètre "nonce
tracking" sera supporté.
4.4. Résolveurs
Le travail du résolveur consiste à récupérer un nom d'utilisateur ("username") et un nom
d'authentification ("realm") et retourner des identifiants. L'authentification Basic s'attend à
recevoir une version encodée Base64 du mot de passe ("password"). L'authentification Digest,
elle, attend un hash du "username", du "realm", et du "password" (séparés par des deux-points).
Actuellement le seul algorithme de hash supporté est MD5.
Zend_Auth_Adapter_Http se fie a des objets implémentant

Zend_Auth_Adapter_Http_Resolver_Interface. Une classe de résolution de fichier
190
Zend_Auth
texte est inclue avec cet adaptateur, mais n'importe quelle classe peut être écrite, grâce à
l'interface.
4.4.1. Résolveur fichiers

Cette classe est très simple. Son constructeur ne prend qu'un paramètre qui définit le nom du
fichier cible. Un accesseur existe aussi. Sa méthode resolve() traverse le fichier texte à la
recherche de la ligne qui correspond au "username" et au "realm". La syntaxe est similaire aux
fichiers htpasswd d'Apache :
<username>:<realm>:<credentials>\n
Chaque ligne se décompose en 3 champs - "username", "realm", et "credentials" - séparés par

des deux-points. Le résolveur ne fait que retourner la valeur de "credentials". Ainsi, avec Basic
cette valeur devra être le mot de passe en clair de l'utilisateur identifié par "username". En mode
Digest, la valeur MD5 de toute la chaîne "username:realm:password" (avec les deux-points).
Pour créer des résolveurs de fichiers séparés, utilisez :
$path = 'files/passwd.txt';
$resolver = new Zend_Auth_Adapter_Http_Resolver_File($path);
ou
$path = 'files/passwd.txt';
$resolver = new Zend_Auth_Adapter_Http_Resolver_File();
$resolver->setFile($path);
Si le chemin donné n'est pas lisible, une exception est envoyée.
4.5. Usage général :

Tout d'abord, créez un tableau de configuration avec les options requises :
$config = array(
'accept_schemes' => 'basic digest',
'realm' => 'My Web Site',
'digest_domains' => '/members_only /my_account',
'nonce_timeout' => 3600,
);
Ce tableau va permettre d'accepter les modes Basic ou Digest et demandera une authentification
pour les zones du site situées sous /members_only et /my_account. La valeur du "real" est
en général affichée par le navigateur dans la boite de dialogue. Le paramètre nonce_timeout,
fonctionne comme expliqué plus haut.
Ensuite, créez un objet de Zend_Auth_Adapter_Http :
$adapter = new Zend_Auth_Adapter_Http($config);
Comme nous supportons les 2 modes Basic et Digest, nous avons besoin de deux résolveurs
différents :
$basicResolver = new Zend_Auth_Adapter_Http_Resolver_File();

$basicResolver->setFile('files/basicPasswd.txt');
$digestResolver = new Zend_Auth_Adapter_Http_Resolver_File();

$digestResolver->setFile('files/digestPasswd.txt');
191
Zend_Auth
$adapter->setBasicResolver($basicResolver);
$adapter->setDigestResolver($digestResolver);
Enfin, nous procédons à la demande d'authentification. L'adaptateur a besoin de deux objets

"Request" et "Response" :
assert($request instanceof Zend_Controller_Request_Http);

assert($response instanceof Zend_Controller_Response_Http);
$adapter->setRequest($request);
$adapter->setResponse($response);
$result = $adapter->authenticate();
if (!$result->isValid()) {
// Mauvais username/password, ou action annulée
}
5. LDAP Authentication
5.1. Introduction
Zend_Auth_Adapter_Ldap supports web application authentication with LDAP services. Its
features include username and domain name canonicalization, multi-domain authentication, and
failover capabilities. It has been tested to work with Microsoft Active Directory and OpenLDAP,
but it should also work with other LDAP service providers.
This documentation includes a guide on using Zend_Auth_Adapter_Ldap, an exploration of

its API, an outline of the various available options, diagnostic information for troubleshooting
authentication problems, and example options for both Active Directory and OpenLDAP servers.
5.2. Usage
To incorporate Zend_Auth_Adapter_Ldap authentication into your application quickly, even
if you're not using Zend_Controller, the meat of your code should look something like the
following:
$username = $this->_request->getParam('username');
$password = $this->_request->getParam('password');
$config = new Zend_Config_Ini('../application/config/config.ini',

'production');
$log_path = $config->ldap->log_path;
$options = $config->ldap->toArray();
unset($options['log_path']);
$adapter = new Zend_Auth_Adapter_Ldap($options, $username,

$password);
$result = $auth->authenticate($adapter);
if ($log_path) {
$messages = $result->getMessages();
$logger = new Zend_Log();
192
Zend_Auth
$logger->addWriter(new Zend_Log_Writer_Stream($log_path));
$filter = new Zend_Log_Filter_Priority(Zend_Log::DEBUG);
$logger->addFilter($filter);
foreach ($messages as $i => $message) {

if ($i-- > 1) { // $messages[2] and up are log messages
$message = str_replace("\n", "\n ", $message);
$logger->log("Ldap: $i: $message", Zend_Log::DEBUG);
}
}
}
Of course, the logging code is optional, but it is highly recommended that you use a logger.
Zend_Auth_Adapter_Ldap will record just about every bit of information anyone could want
in $messages (more below), which is a nice feature in itself for something that has a history of
being notoriously difficult to debug.
The Zend_Config_Ini code is used above to load the adapter options. It is also optional. A
regular array would work equally well. The following is an example application/config/
config.ini file that has options for two separate servers. With multiple sets of server options
the adapter will try each, in order, until the credentials are successfully authenticated. The names
of the servers (e.g., 'server1' and 'server2') are largely arbitrary. For details regarding the options
array, see the Server Options section below. Note that Zend_Config_Ini requires that any
values with "equals" characters (=) will need to be quoted (like the DNs shown below).
[production]
ldap.log_path = /tmp/ldap.log
; Typical options for OpenLDAP

ldap.server1.host = s0.foo.net
ldap.server1.accountDomainName = foo.net
ldap.server1.accountDomainNameShort = FOO
ldap.server1.accountCanonicalForm = 3
ldap.server1.username = "CN=user1,DC=foo,DC=net"
ldap.server1.password = pass1
ldap.server1.baseDn = "OU=Sales,DC=foo,DC=net"
ldap.server1.bindRequiresDn = true
; Typical options for Active Directory

ldap.server2.host = dc1.w.net
ldap.server2.useStartTls = true
ldap.server2.accountDomainName = w.net
ldap.server2.accountDomainNameShort = W
ldap.server2.accountCanonicalForm = 3
ldap.server2.baseDn = "CN=Users,DC=w,DC=net"
The above configuration will instruct Zend_Auth_Adapter_Ldap to attempt to authenticate

users with the OpenLDAP server s0.foo.net first. If the authentication fails for any reason,
the AD server dc1.w.net will be tried.
With servers in different domains, this configuration illustrates multi-domain authentication. You
can also have multiple servers in the same domain to provide redundancy.
Note that in this case, even though OpenLDAP has no need for the short NetBIOS style domain
name used by Windows, we provide it here for name canonicalization purposes (described in
the Username Canonicalization section below).
193
Zend_Auth
5.3. The API

The Zend_Auth_Adapter_Ldap constructor accepts three parameters.
The $options parameter is required and must be an array containing one or more sets of
options. Note that it is an array of arrays of Zend_Ldap options. Even if you will be using only
one LDAP server, the options must still be within another array.
Below is print_r() output of an example options parameter containing two sets of server
options for LDAP servers s0.foo.net and dc1.w.net (the same options as the above INI
representation):
Array
(
[server2] => Array
(
[host] => dc1.w.net
[useStartTls] => 1
[accountDomainName] => w.net
[accountDomainNameShort] => W
[accountCanonicalForm] => 3
[baseDn] => CN=Users,DC=w,DC=net
)
[server1] => Array

(
[host] => s0.foo.net
[accountDomainName] => foo.net
[accountDomainNameShort] => FOO
[accountCanonicalForm] => 3
[username] => CN=user1,DC=foo,DC=net
[password] => pass1
[baseDn] => OU=Sales,DC=foo,DC=net
[bindRequiresDn] => 1
)
The information provided in each set of options above is different mainly because AD does not
require a username be in DN form when binding (see the bindRequiresDn option in the Server
Options section below), which means we can omit a number of options associated with retrieving
the DN for a username being authenticated.
What is a Distinguished Name?

A DN or "distinguished name" is a string that represents the path to an object
within the LDAP directory. Each comma-separated component is an attribute
and value representing a node. The components are evaluated in reverse. For
example, the user account CN=Bob Carter,CN=Users,DC=w,DC=net is located
directly within the CN=Users,DC=w,DC=net container. This structure is best
explored with an LDAP browser like the ADSI Edit MMC snap-in for Active
Directory or phpLDAPadmin.
The names of servers (e.g. 'server1' and 'server2' shown above) are largely arbitrary, but for the
sake of using Zend_Config, the identifiers should be present (as opposed to being numeric
indexes) and should not contain any special characters used by the associated file formats (e.g.
the '.' INI property separator, '&' for XML entity references, etc).
194
Zend_Auth
With multiple sets of server options, the adapter can authenticate users in multiple domains and
provide failover so that if one server is not available, another will be queried.
The Gory Details: What Happens in the Authenticate Method?
When the authenticate() method is called, the adapter iterates over each
set of server options, sets them on the internal Zend_Ldap instance, and
calls the Zend_Ldap::bind() method with the username and password being
authenticated. The Zend_Ldap class checks to see if the username is qualified
with a domain (e.g., has a domain component like alice@foo.net or FOO
\alice). If a domain is present, but does not match either of the server's
domain names (foo.net or FOO), a special exception is thrown and caught
by Zend_Auth_Adapter_Ldap that causes that server to be ignored and the
next set of server options is selected. If a domain does match, or if the user
did not supply a qualified username, Zend_Ldap proceeds to try to bind with
the supplied credentials. if the bind is not successful, Zend_Ldap throws a
Zend_Ldap_Exception which is caught by Zend_Auth_Adapter_Ldap and
the next set of server options is tried. If the bind is successful, the iteration
stops, and the adapter's authenticate() method returns a successful result.
If all server options have been tried without success, the authentication fails,
and authenticate() returns a failure result with error messages from the last
iteration.
The username and password parameters of the Zend_Auth_Adapter_Ldap constructor

represent the credentials being authenticated (i.e., the credentials supplied by the user through
your HTML login form). Alternatively, they may also be set with the setUsername() and
setPassword() methods.
5.4. Server Options

Each set of server options in the context of Zend_Auth_Adapter_Ldap consists of the
following options, which are passed, largely unmodified, to Zend_Ldap::setOptions():
Tableau 10. Server Options
Name Description
host The hostname of LDAP server that these
options represent. This option is required.
port The port on which the LDAP server is listening.
If useSsl is TRUE, the default port value is 636.
If useSsl is FALSE, the default port value is 389.
useStartTls Whether or not the LDAP client should
use TLS (aka SSLv2) encrypted transport.
A value of TRUE is strongly favored in
production environments to prevent passwords
from be transmitted in clear text. The default
value is FALSE, as servers frequently require
that a certificate be installed separately
after installation. The useSsl and useStartTls
options are mutually exclusive. The useStartTls
option should be favored over useSsl but not all
servers support this newer mechanism.
195
Zend_Auth
Name Description
useSsl Whether or not the LDAP client should use
SSL encrypted transport. The useSsl and
useStartTls options are mutually exclusive, but
useStartTls should be favored if the server
and LDAP client library support it. This value
also changes the default port value (see port
description above).
username The DN of the account used to perform
account DN lookups. LDAP servers that
require the username to be in DN form
when performing the "bind" require this option.
Meaning, if bindRequiresDn is TRUE, this
option is required. This account does not need
to be a privileged account; an account with
read-only access to objects under the baseDn
is all that is necessary (and preferred based on
the Principle of Least Privilege).
password The password of the account used to perform
account DN lookups. If this option is not
supplied, the LDAP client will attempt an
"anonymous bind" when performing account
DN lookups.
bindRequiresDn Some LDAP servers require that the username
used to bind be in DN form like CN=Alice
Baker,OU=Sales,DC=foo,DC=net (basically all
servers except AD). If this option is TRUE, this
instructs Zend_Ldap to automatically retrieve
the DN corresponding to the username being
authenticated, if it is not already in DN form,
and then re-bind with the proper DN. The
default value is FALSE. Currently only Microsoft
Active Directory Server (ADS) is known not
to require usernames to be in DN form when
binding, and therefore this option may be
FALSE with AD (and it should be, as retrieving
the DN requires an extra round trip to the
server). Otherwise, this option must be set
to TRUE (e.g. for OpenLDAP). This option
also controls the default acountFilterFormat
used when searching for accounts. See the
accountFilterFormat option.
baseDn The DN under which all accounts being
authenticated are located. This option is
required. if you are uncertain about the
correct baseDn value, it should be sufficient
to derive it from the user's DNS domain
using DC= components. For example, if the
user's principal name is alice@foo.net,
a baseDn of DC=foo,DC=net should
work. A more precise location (e.g.,
196
Zend_Auth
Name Description
OU=Sales,DC=foo,DC=net) will be more
efficient, however.
accountCanonicalForm A value of 2, 3 or 4 indicating the form to
which account names should be canonicalized
after successful authentication. Values are
as follows: 2 for traditional username style
names (e.g., alice), 3 for backslash-style
names (e.g., FOO\alice) or 4 for principal
style usernames (e.g., alice@foo.net). The
default value is 4 (e.g., alice@foo.net). For
example, with a value of 3, the identity returned
by Zend_Auth_Result::getIdentity()
(and Zend_Auth::getIdentity(), if
Zend_Auth was used) will always be FOO
\alice, regardless of what form Alice
supplied, whether it be alice, alice@foo.net,
FOO\alice, FoO\aLicE, foo.net\alice,
etc. See the Account Name Canonicalization
section in the Zend_Ldap documentation for
details. Note that when using multiple sets
of server options it is recommended, but not
required, that the same accountCanonicalForm
be used with all server options so that the
resulting usernames are always canonicalized
to the same form (e.g., if you canonicalize
to EXAMPLE\username with an AD server
but to username@example.com with an
OpenLDAP server, that may be awkward for
the application's high-level logic).
accountDomainName The FQDN domain name for which the
target LDAP server is an authority (e.g.,
example.com). This option is used to
canonicalize names so that the username
supplied by the user can be converted
as necessary for binding. It is also
used to determine if the server is an
authority for the supplied username (e.g., if
accountDomainName is foo.net and the user
supplies bob@bar.net, the server will not be
queried, and a failure will result). This option is
not required, but if it is not supplied, usernames
in principal name form (e.g., alice@foo.net)
are not supported. It is strongly recommended
that you supply this option, as there are many
use-cases that require generating the principal
name form.
accountDomainNameShort The 'short' domain for which the target
LDAP server is an authority (e.g., FOO).
Note that there is a 1:1 mapping
between the accountDomainName and
accountDomainNameShort. This option should
197
Zend_Auth
Name Description
be used to specify the NetBIOS domain
name for Windows networks, but may also be
used by non-AD servers (e.g., for consistency
when multiple sets of server options with
the backslash style accountCanonicalForm).
This option is not required but if it is not
supplied, usernames in backslash form (e.g.,
FOO\alice) are not supported.
accountFilterFormat The LDAP search filter used to search for
accounts. This string is a printf()-style
expression that must contain one '%s' to
accomodate the username. The default value
is '(&(objectClass=user)(sAMAccountName=
%s))', unless bindRequiresDn is set to
TRUE, in which case the default is
'(&(objectClass=posixAccount)(uid=%s))'. For
example, if for some reason you wanted
to use bindRequiresDn = true with AD
you would need to set accountFilterFormat
= '(&(objectClass=user)(sAMAccountName=
%s))'.
optReferrals If set to TRUE, this option indicates to the LDAP
client that referrals should be followed. The
default value is FALSE.
If you enable useStartTls = TRUE or useSsl = TRUE you may find that the LDAP
client generates an error claiming that it cannot validate the server's certificate.
Assuming the PHP LDAP extension is ultimately linked to the OpenLDAP
client libraries, to resolve this issue you can set "TLS_REQCERT never" in
the OpenLDAP client ldap.conf (and restart the web server) to indicate to
the OpenLDAP client library that you trust the server. Alternatively, if you are
concerned that the server could be spoofed, you can export the LDAP server's
root certificate and put it on the web server so that the OpenLDAP client can
validate the server's identity.
5.5. Collecting Debugging Messages

Zend_Auth_Adapter_Ldap collects debugging information within its authenticate()
method. This information is stored in the Zend_Auth_Result object as messages. The array
returned by Zend_Auth_Result::getMessages() is described as follows
Tableau 11. Debugging Messages

Messages Array Index Description
Index 0 A generic, user-friendly message that is
suitable for displaying to users (e.g.,
"Invalid credentials"). If the authentication is
successful, this string is empty.
Index 1 A more detailed error message that is not
suitable to be displayed to users but should
be logged for the benefit of server operators.
198
Zend_Auth
Messages Array Index Description

If the authentication is successful, this string is
empty.
Indexes 2 and higher All log messages in order starting at index 2.
In practice, index 0 should be displayed to the user (e.g., using the FlashMessenger helper),
index 1 should be logged and, if debugging information is being collected, indexes 2 and higher
could be logged as well (although the final message always includes the string from index 1).
5.6. Common Options for Specific Servers

5.6.1. Options for Active Directory
For ADS, the following options are noteworthy:
Tableau 12. Options for Active Directory

Name Additional Notes
host As with all servers, this option is required.
useStartTls For the sake of security, this should be TRUE
if the server has the necessary certificate
installed.
useSsl Possibly used as an alternative to useStartTls
(see above).
baseDn As with all servers, this option is
required. By default AD places all user
accounts under the Users container (e.g.,
CN=Users,DC=foo,DC=net), but the default is
not common in larger organizations. Ask your
AD administrator what the best DN for accounts
for your application would be.
accountCanonicalForm You almost certainly want this to be 3 for
backslash style names (e.g., FOO\alice),
which are most familiar to Windows users.
You should not use the unqualified form 2
(e.g., alice), as this may grant access to your
application to users with the same username
in other trusted domains (e.g., BAR\alice and
FOO\alice will be treated as the same user).
(See also note below.)
accountDomainName This is required with AD unless
accountCanonicalForm 2 is used, which, again,
is discouraged.
accountDomainNameShort The NetBIOS name of the domain that users
are in and for which the AD server is an
authority. This is required if the backslash style
accountCanonicalForm is used.
Technically there should be no danger of accidental cross-domain authentication

with the current Zend_Auth_Adapter_Ldap implementation, since server
199
Zend_Auth
domains are explicitly checked, but this may not be true of a future
implementation that discovers the domain at runtime, or if an alternative adapter
is used (e.g., Kerberos). In general, account name ambiguity is known to be the
source of security issues, so always try to use qualified account names.
5.6.2. Options for OpenLDAP
For OpenLDAP or a generic LDAP server using a typical posixAccount style schema, the
following options are noteworthy:
Tableau 13. Options for OpenLDAP
Name Additional Notes

host As with all servers, this option is required.
useStartTls For the sake of security, this should be TRUE
if the server has the necessary certificate
installed.
useSsl Possibly used as an alternative to useStartTls
(see above).
username Required and must be a DN, as OpenLDAP
requires that usernames be in DN form when
performing a bind. Try to use an unprivileged
account.
password The password corresponding to the username
above, but this may be omitted if the LDAP
server permits an anonymous binding to query
user accounts.
bindRequiresDn Required and must be TRUE, as OpenLDAP
requires that usernames be in DN form when
performing a bind.
baseDn As with all servers, this option is required and
indicates the DN under which all accounts
being authenticated are located.
accountCanonicalForm Optional, but the default value is 4 (principal
style names like alice@foo.net), which may
not be ideal if your users are used to backslash
style names (e.g., FOO\alice). For backslash
style names use value 3.
accountDomainName Required unless you're using
accountCanonicalForm 2, which is not
recommended.
accountDomainNameShort If AD is not also being used, this value is not
required. Otherwise, if accountCanonicalForm
3 is used, this option is required and should
be a short name that corresponds adequately
to the accountDomainName (e.g., if your
accountDomainName is foo.net, a good
accountDomainNameShort value might be
FOO).
200
Zend_Auth
6. Authentification OpenID
6.1. Introduction
Zend_Auth_Adapter_OpenId permet l'authentification à travers un serveur distant OpenID.
Une telle authentification attend que l'utilisateur fournisse à l'application Web son identifiant
OpenID. L'utilisateur est alors redirigé vers un fournisseur de services OpenID, afin de s'identifier
en rapport avec l'application Web utilisée. Un mot de passe ou un autre procédé est utilisé, et
celui-ci n'est jamais connu de l'application Web originale.
L'identité OpenID est juste une URI qui pointe vers une page avec des informations décrivant
le serveur à utiliser et des informations sur l'utilisateur. Pour plus d'informations, consultez le
site officiel OpenID.
La classe Zend_Auth_Adapter_OpenId utilise Zend_OpenId_Consumer qui sert à gérer le

protocole OpenID.
Zend_OpenId utilise l'extension GMP, si disponible. L'utilisation de

l'extension GMP est recommandée pour améliorer les performances de
Zend_Auth_Adapter_OpenId.
6.2. Spécifications
Comme toute autre classe adaptateur de Zend_Auth, Zend_Auth_Adapter_OpenId
implémente Zend_Auth_Adapter_Interface, qui définit une seule méthode :
authenticate(). Elle est utilisée pour l'authentification elle-même, une fois que l'objet est
prêt. La préparation d'un objet OpenID nécessite quelques options à passer à Zend_OpenId.
A la différence des autres adaptateurs Zend_Auth, l'adaptateur

Zend_Auth_Adapter_OpenId utilise une authentification sur un serveur
externe à l'application, et nécessitera donc deux requêtes HTTP. Ainsi
Zend_Auth_Adapter_OpenId::authenticate() devra être appelée deux fois : d'abord
pour rediriger l'utilisateur vers le serveur OpenID (rien ne sera donc retourné par la méthode),
qui lui-même redirigera l'utilisateur vers l'application, où un deuxième appel de méthode
Zend_Auth_Adapter_OpenId::authenticate() vérifiera la signature et complétera le
processus. Un objet Zend_Auth_Result sera alors cette fois-ci retourné.
L'exemple suivant montre l'utilisation de Zend_Auth_Adapter_OpenId.

Zend_Auth_Adapter_OpenId::authenticate() est appelée deux fois. La première fois
juste après avoir envoyé le formulaire HTML, lorsque $_POST['openid_action'] vaut
"login", et la deuxième fois après la redirection HTTP du serveur OpenID vers l'application,
lorsque $_GET['openid_mode'] ou $_POST['openid_mode'] existe.
<?php
$status = "";
if ((isset($_POST['openid_action']) &&
$_POST['openid_action'] == "login" &&
!empty($_POST['openid_identifier'])) ||
isset($_GET['openid_mode']) ||
isset($_POST['openid_mode'])) {
$result = $auth->authenticate(
new Zend_Auth_Adapter_OpenId(@$_POST['openid_identifier']));
201
Zend_Auth
$status = "You are logged-in as "

. $auth->getIdentity()
. "<br>\n";
} else {
$auth->clearIdentity();
foreach ($result->getMessages() as $message) {
$status .= "$message<br>\n";
}
}
} else if ($auth->hasIdentity()) {
if (isset($_POST['openid_action']) &&
$_POST['openid_action'] == "logout") {
$auth->clearIdentity();
} else {
$status = "You are logged-in as "
. $auth->getIdentity()
. "<br>\n";
}
}
?>
<html><body>
<?php echo htmlspecialchars($status);?>
<form method="post"><fieldset>
<legend>OpenID Login</legend>
<input type="text" name="openid_identifier" value="">

<input type="submit" name="openid_action" value="login">
<input type="submit" name="openid_action" value="logout">
</fieldset></form></body></html>
Il est possible de personnaliser le processus, pour par exemple demander une redirection
du serveur OpenID vers l'application, sur une page différente de la première. Ceci
peut être fait avec des objets personnalisés Zend_OpenId_Consumer_Storage ou
Zend_Controller_Response. Vous pouvez aussi utiliser le procédé "Simple Registration"
pour récupérer les informations au sujet de l'utilisateur, en provenance du serveur
OpenID. Toutes ces possibilités sont écrites et détaillées dans le chapitre concernant
Zend_OpenId_Consumer.
202
Zend_Barcode
1. Introduction
Zend_Barcode fournit une manière générique de générer des code-barres. Le composant
Zend_Barcode est divisé en deux sous-composants : les objets code-barres et les générateurs
de rendu. Les objets permettent de créer les code-barres indépendamment du support de rendu.
Les générateurs de rendu vous permettent de tracer les code-barres en fonction sur le support.
2. Création de code-barres avec la classe Zend_Barcode

2.1. Utilisation de la fabrique Zend_Barcode::factory
Zend_Barcode possède une méthode de fabrique pour créer une instance d'un générateur
de rendu qui étend Zend_Barcode_Renderer_RendererAbstract. Ce méthode accepte 5
arguments.
1. Le nom du format de code-barres (ex. "code39") (obligatoire)
2. Le nom du générateur de rendu (ex. "image") (obligatoire)
3. Les options de l'objet code-barres (un tableau ou un objet Zend_Config) (optionnel)
4. Les options du générateur de rendu (un tableau ou un objet Zend_Config) (optionnel)
5. Booléen indiquant si le générateur automatique d'erreur est activé. Si une exception intervient,
l'objet code-barres fourni sera remplacé par un objet représentant l'erreur (optionnel par défaut
vaut TRUE)
Exemple 52. Récupérer un générateur de rendu avec Zend_Barcode::factory()
Zend_Barcode::factory() instancie un objet code-barres et un générateur de rendu

et les lie ensemble. Dans le premier exemple, nous allons utiliser le type de code-barres
Code39 avec le générateur de rendu Image.
// Seul le texte à écrire est obligatoire

$barcodeOptions = array('text' => 'ZEND-FRAMEWORK');
// Pas d'options requises
$rendererOptions = array();
$renderer = Zend_Barcode::factory(
'code39', 'image', $barcodeOptions, $rendererOptions
);
203
Zend_Barcode
Exemple 53. Utiliser Zend_Barcode::factory() avec des objets Zend_Config
Vous pouvez fournir un objet Zend_Config à la fabrique afin de créer les objets souhaités.
L'exemple suivant est fonctionnellement équivalent au précédent.
// En utilisant seulement un objet Zend_Config

$config = new Zend_Config(array(
'barcode' => 'code39',
'barcodeParams' => array('text' => 'ZEND-FRAMEWORK'),
'renderer' => 'image',
'rendererParams' => array('imageType' => 'gif'),
));
$renderer = Zend_Barcode::factory($config);
2.2. Tracer un code-barres

Quand vous dessiner un code-barres, vous récupérez la ressource dans laquelle le code-barres
est tracée. Pour ensuite tracer le code-barres, vous pouvez appeler la méthode draw() du
générateur de rendu ou simplement utiliser la méthode proxy fournie par Zend_Barcode.
Exemple 54. Tracer un code-barres avec l'objet générateur de rendu

// Tracé du code-barres dans une nouvelle image
$imageResource = Zend_Barcode::factory(
)->draw();
Exemple 55. Trace un code-barres avec Zend_Barcode::draw()

// Tracé du code-barres dans une nouvelle image
$imageResource = Zend_Barcode::draw(
);
2.3. Générer le rendu d'un code-barres

Quand vous générez un code-barres, vous dessinez le code-barres, vous envoyez les entêtes
et vous envoyez la ressource (par exemple vers un navigateur). Pour rendre un code-barres,
vous pouvez appeler la méthode render() du générateur de rendu ou simplement utiliser la
méthode proxy fournie par Zend_Barcode.
204
Zend_Barcode
Exemple 56. Effectuer le rendu d'un code-barres avec l'objet générateur de rendu

// Tracé du code-barres dans une nouvelle image,
// envoi des entêtes et de l'image
Zend_Barcode::factory(
)->render();
Ceci générera ce code-barres :
Exemple 57. Effectuer le rendu d'un code-barres avec Zend_Barcode::render()

// Tracé du code-barres dans une nouvelle image,
// envoi des entêtes et de l'image
Zend_Barcode::render(
);
Ceci générera le même code-barres que l'exemple précédent.
3. Zend_Barcode Objects
Barcode objects allow you to generate barcodes independently of the rendering support. After
generation, you can retrieve the barcode as an array of drawing instructions that you can provide
to a renderer.
Objects have a large number of options. Most of them are common to all objects. These options
can be set in four ways:
• As an array or a Zend_Config object passed to the constructor.
• As an array passed to the setOptions() method.
• As a Zend_Config object passed to the setConfig() method.
• Via individual setters for each configuration type.
205
Zend_Barcode
Exemple 58. Different ways to parameterize a barcode object
$options = array('text' => 'ZEND-FRAMEWORK', 'barHeight' => 40);
// Case 1: constructor
$barcode = new Zend_Barcode_Object_Code39($options);
// Case 2: setOptions()
$barcode = new Zend_Barcode_Object_Code39();
$barcode->setOptions($options);
// Case 3: setConfig()
$config = new Zend_Config($options);
$barcode->setConfig($config);
// Case 4: individual setters

$barcode->setText('ZEND-FRAMEWORK')
->setBarHeight(40);
3.1. Common Options

In the following list, the values have no units; we will use the term "unit." For example, the
default value of the "thin bar" is "1 unit". The real units depend on the rendering support (see
the renderers documentation for more information). Setters are each named by uppercasing
the initial letter of the option and prefixing the name with "set" (e.g. "barHeight" becomes
"setBarHeight"). All options have a corresponding getter prefixed with "get" (e.g. "getBarHeight").
Available options are:
Tableau 14. Common Options
Option Data Type Default Value Description

barcodeNamespace String Namespace of the
Zend_Barcode_Object
barcode; for example,
if you need to extend
the embedding objects
barHeight Integer 50 Height of the bars
barThickWidth Integer 3 Width of the thick bar
barThinWidth Integer 1 Width of the thin
factor Integer 1 Factor by which to
multiply bar widths and
font sizes
foreColor Integer 0 (black) Color of the bar and the
text. Could be provided
as an integer or as
a HTML value (e.g.
"#333333")
backgroundColor Integer or String 16777125 (white) Color of the
background. Could be
provided as an integer
or as a HTML value
(e.g. "#333333")
206
Zend_Barcode

reverseColor Boolean FALSE Allow switching the
color of the bar and the
background
orientation Integer 0 Orientation of the
barcode
font String or Integer NULL Font path to a TTF font
or a number between
1 and 5 if using image
generation with GD
(internal fonts)
fontSize Integer 10 Size of the font
(not applicable with
numeric fonts)
withBorder Boolean FALSE Draw a border around
the barcode and the
quiet zones
drawText Boolean TRUE Set if the text is
displayed below the
barcode
stretchText Boolean FALSE Specify if the text is
stretched all along the
barcode
withChecksum Boolean FALSE Indicate whether or
not the checksum is
automatically added to
the barcode
withChecksumInText Boolean FALSE Indicate whether or
not the checksum is
displayed in the textual
representation
text String NULL The text to represent
as a barcode
3.1.1. Particular case of static setBarcodeFont()

You can set a commont font for all your objects by using the static method
Zend_Barcode_Object::setBarcodeFont(). This value can be always be overridden for
individual objects by using the setFont() method.
// In your bootstrap:
Zend_Barcode_Object::setBarcodeFont('my_font.ttf');
// Later in your code:

'code39',
'pdf',
array('text' => 'ZEND-FRAMEWORK')
); // will use 'my_font.ttf'
// or:
207
Zend_Barcode
'code39',
'image',
array(
'text' => 'ZEND-FRAMEWORK',
'font' => 3
)
); // will use the 3rd GD internal font
3.2. Common Additional Getters
Tableau 15. Common Getters
Getter Data Type Description

getType() String Return the name of
the barcode class without
the namespace (e.g.
Zend_Barcode_Object_Code39
returns simply "code39")
getRawText() String Return the original text
provided to the object
getTextToDisplay() String Return the text to display,
including, if activated, the
checksum value
getQuietZone() Integer Return the size of the space
needed before and after the
barcode without any drawing
getInstructions() Array Return drawing instructions as
an array.
getHeight($recalculate Integer Return the height of the
= false) barcode calculated after
possible rotation
getWidth($recalculate Integer Return the width of the barcode
= false) calculated after possible
rotation
Integer
getOffsetTop($recalculate Return the position of the top
= false) of the barcode calculated after
possible rotation
Integer
getOffsetLeft($recalculate Return the position of the left
= false) of the barcode calculated after
possible rotation
3.3. Description of shipped barcodes

You will find below detailed information about all barcode types shipped by default with Zend
Framework.
208
Zend_Barcode
3.3.1. Zend_Barcode_Object_Error
This barcode is a special case. It is internally used to automatically render an exception caught
by the Zend_Barcode component.
3.3.2. Zend_Barcode_Object_Code25
• Name: Code 25 (or Code 2 of 5 or Code 25 Industrial)
• Allowed characters: '0123456789'
• Checksum: optional (modulo 10)
• Length: variable
There are no particular options for this barcode.
3.3.3. Zend_Barcode_Object_Code25interleaved
This barcode extends Zend_Barcode_Object_Code25 (Code 2 of 5), and has the same
particulars and options, and adds the following:
• Name: Code 2 of 5 Interleaved
• Length: variable (always even number of characters)
Available options include:
Tableau 16. Zend_Barcode_Object_Code25interleaved Options

withBearerBars Boolean FALSE Draw a thick bar at the
top and the bottom of
the barcode.
209
Zend_Barcode
If the number of characters is not even,

Zend_Barcode_Object_Code25interleaved will automatically prepend
the missing zero to the barcode text.
3.3.4. Zend_Barcode_Object_Ean2
This barcode extends Zend_Barcode_Object_Ean5 (EAN 5), and has the same particulars
and options, and adds the following:
• Name: EAN-2
• Checksum: only use internally but not displayed
• Length: 2 characters
If the number of characters is lower than 2, Zend_Barcode_Object_Ean2 will

automatically prepend the missing zero to the barcode text.
• Name: EAN-5
• Checksum: only use internally but not displayed
• Length: 5 characters

210
Zend_Barcode
• Name: EAN-8
• Checksum: mandatory (modulo 10)
• Length: 8 characters (including checksum)

• Name: EAN-13
If the number of characters is lower than 13, Zend_Barcode_Object_Ean13

will automatically prepend the missing zero to the barcode text.
3.3.8. Zend_Barcode_Object_Code39
• Name: Code 39
211
Zend_Barcode
• Allowed characters: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ -.$/+%'
• Length: variable
Zend_Barcode_Object_Code39 will automatically add the start and stop

characters ('*') for you.
3.3.9. Zend_Barcode_Object_Identcode
This barcode extends Zend_Barcode_Object_Code25interleaved (Code 2 of 5

Interleaved), and inherits some of its capabilities; it also has a few particulars of its own.
• Name: Identcode (Deutsche Post Identcode)
• Checksum: mandatory (modulo 10 different from Code25)
If the number of characters is lower than 12,

Zend_Barcode_Object_Identcode will automatically prepend missing zeros
to the barcode text.
3.3.10. Zend_Barcode_Object_Itf14
This barcode extends Zend_Barcode_Object_Code25interleaved (Code 2 of 5

Interleaved), and inherits some of its capabilities; it also has a few particulars of its own.
• Name: ITF-14
212
Zend_Barcode
If the number of characters is lower than 14, Zend_Barcode_Object_Itf14

will automatically prepend missing zeros to the barcode text.
3.3.11. Zend_Barcode_Object_Leitcode
This barcode extends Zend_Barcode_Object_Identcode (Deutsche Post Identcode), and

inherits some of its capabilities; it also has a few particulars of its own.
• Name: Leitcode (Deutsche Post Leitcode)
• Checksum: mandatory (modulo 10 different from Code25)
If

Zend Framework 1-10-x FR

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Zend Framework 1-10-x FR

Titre original :

Transféré par

Droits d'auteur :

Formats disponibles

Guide de

Zend Framework 1.10.x

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2. Create Your Project

2.1. Install Zend Framework

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

2.2. Create Your Project

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

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

2.3. The Bootstrap

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap

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

2.5. Action Controllers

The default IndexController is as follows:

class IndexController extends Zend_Controller_Action

public function init()

public function indexAction()

And the default ErrorController is as follows:

class ErrorController extends Zend_Controller_Action

public function errorAction()

// 404 error -- controller or action not found

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

; Add to [production] section:

The final INI file should look as follows:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap

; Add to [production] section: