1 <?xml version="1.0" encoding="UTF-8"?>
2 <!-- EN-Revision: 21829 -->
4 <sect1 id="zend.session.advanced_usage">
5 <title>Utilisation avancée</title>
8 Même si les exemples de l'utilisation basique sont une manière parfaitement acceptable
9 d'utiliser les sessions dans Zend Framework, il existe de bonnes pratiques à considérer.
10 Cette section détaille plus finement le traitement des sessions et présente des utilisations
11 plus avancées du composant <classname>Zend_Session</classname>.
14 <sect2 id="zend.session.advanced_usage.starting_a_session">
15 <title>Démarrer une session</title>
18 Si vous voulez que toutes les requêtes aient une session facilitée avec
19 <classname>Zend_Session</classname>, alors démarrez la session dans votre fichier
23 <example id="zend.session.advanced_usage.starting_a_session.example">
24 <title>Démarrer la session globale</title>
26 <programlisting language="php"><![CDATA[
27 Zend_Session::start();
32 En démarrant la session dans votre fichier d'amorçage, vous empêcher la
33 possibilité de démarrer votre session après l'envoi d'en-têtes à votre navigateur, ce
34 qui entraîne la levée d'une exception, et peut être une page cassée pour les visiteurs
35 de votre site. Divers usages avancés nécessitent premièrement
36 <methodname>Zend_Session::start()</methodname>. (D'autant plus sur les utilisations
41 Il existe quatre manières différentes pour démarrer une session, quand on utilise
42 <classname>Zend_Session</classname>. Deux sont mauvaises.
48 Mauvaise : n'activez pas <ulink
49 url="http://www.php.net/manual/fr/ref.session.php#ini.session.auto-start"><code>session.auto_start</code></ulink>
50 de PHP. Si vous n'avez pas la possibilité de désactiver ce réglage dans le
51 php.ini, ou que vous utilisez mod_php (ou équivalent), et que le réglage est
52 déjà activé dans le <code>php.ini</code>, alors ajoutez le code suivant à votre
53 fichier <code>.htaccess</code> (habituellement votre dossier de démarrage HTML)
54 : <programlisting language="httpd.conf"><![CDATA[
55 php_value session.auto_start 0
56 ]]></programlisting></para>
61 Mauvaise : n'utilisez pas la fonction <ulink
62 url="http://www.php.net/session_start"><methodname>session_start()</methodname></ulink>
63 directement. Si vous utilisez directement <methodname>session_start()</methodname>, et que
64 vous démarrez en utilisant <classname>Zend_Session_Namespace</classname>, une
65 exception sera levée par <methodname>Zend_Session::start()</methodname> ("session
66 has already been started"). Si vous appelez <methodname>session_start()</methodname>, après
67 avoir utilisé <classname>Zend_Session_Namespace</classname> ou démarré
68 explicitement <methodname>Zend_Session::start()</methodname>, une erreur de niveau
69 <constant>E_NOTICE</constant> sera générée, et l'appel sera ignoré.
75 Correcte : utilisez <methodname>Zend_Session::start()</methodname>. Si vous
76 voulez que toutes vos requêtes aient et utilisent les sessions, alors placez
77 cette fonction le plus tôt possible et sans condition dans votre fichier
78 d'amorçage. Les sessions ont un coût. Si certaines requêtes nécessitent les
79 sessions, mais que les autres n'en ont pas besoin, alors :
82 <itemizedlist mark="opencircle">
85 Sans conditions, réglez l'option <code>strict</code> à
86 <constant>TRUE</constant> en utilisant
87 <methodname>Zend_Session::setOptions()</methodname> dans votre fichier
94 Appelez <methodname>Zend_Session::start()</methodname>, uniquement
95 pour les requêtes qui nécessitent l'usage des sessions, avant la
96 première instanciation d'un objet
97 <methodname>Zend_Session_Namespace()</methodname>.
103 Utilisez "<code>new Zend_Session_Namespace()</code>" normalement,
104 quand nécessaire, mais faites attention que
105 <methodname>Zend_Session::start()</methodname> soit appelée
112 L'option <code>strict</code> empêche <code>new
113 Zend_Session_Namespace()</code> d'automatiquement démarrer une session en
114 utilisant <methodname>Zend_Session::start()</methodname>. Ainsi, cette option aide
115 les développeurs d'application Zend Framework universelles à imposer une
116 décision de conception afin d'empêcher l'utilisation de sessions pour certaines
117 requêtes, puisqu'une erreur sera levée en utilisant cette option et en
118 instanciant <classname>Zend_Session_Namespace</classname>, avant un appel
119 explicite de <methodname>Zend_Session::start()</methodname>. N'employez pas cette
120 option dans le code de la librairie coeur du ZF, car seuls les développeurs
121 universels peuvent faire ce choix de design. Les développeurs doivent considérer
122 avec précaution l'impact de l'utilisation de
123 <methodname>Zend_Session::setOptions()</methodname>, puisque ces options ont un
124 effet global, suite à leur correspondance avec les options sous-jacentes pour
131 Correcte : instanciez simplement
132 <methodname>Zend_Session_Namespace()</methodname> quand nécessaire, la session <acronym>PHP</acronym>
133 sous-jacente sera automatiquement démarrée. Ceci permet un usage extrêmement
134 simple qui fonctionne dans la plupart des cas. Cependant, vous êtes responsable
135 de vous assurer que le premier <code>new Zend_Session_Namespace()</code>
136 intervient <emphasis>avant</emphasis> que toute sortie (par exemple <ulink
137 url="http://www.php.net/headers_sent">en-têtes <acronym>HTTP</acronym></ulink>) ait été envoyée par
138 <acronym>PHP</acronym> au client, si vous utilisez le réglage par défaut, sessions basées sur les
139 cookies (fortement recommandé). Voir <xref
140 linkend="zend.session.global_session_management.headers_sent" /> pour plus
147 <sect2 id="zend.session.advanced_usage.locking">
148 <title>Verrouiller les espaces de noms de session</title>
151 Les espaces de noms de session peuvent être verrouillés, pour éviter tout risque
152 d'altération des données dans cet espace. Utilisez <methodname>lock()</methodname> pour attribuer à
153 un espace de nommage spécifique le mode lecture seule,<methodname>unLock()</methodname> pour
154 attribuer le mode lecture / écriture, et <methodname>isLocked()</methodname> pour tester si un
155 espace de nommage a été auparavant verrouillé. Les verrouillages sont transitoires et ne
156 persistent pas d'une requête à l'autre. Verrouiller un espace de nommage n'a pas d'effet
157 sur les méthodes de réglages des objets stockés dans cet espace, mais empêche
158 l'utilisation des méthodes de réglage de l'espace de noms destiné à détruire ou à
159 remplacer les objets stockés dans l'espace. De la même manière, verrouiller les
160 instances <classname>Zend_Session_Namespace</classname> n'empêche pas l'accès direct à
161 l'alias dans tableau de stockage <varname>$_SESSION</varname> (voir <ulink
162 url="http://www.php.net/references">PHP references</ulink>).
165 <example id="zend.session.advanced_usage.locking.example.basic">
166 <title>Verrouillage des espaces de noms de session</title>
168 <programlisting language="php"><![CDATA[
169 $userProfileNamespace =
170 new Zend_Session_Namespace('userProfileNamespace');
172 // vérrouillons une session en lecture seule
173 $userProfileNamespace->lock();
175 // dévérrouillage si déjà vérrouillé
176 if ($userProfileNamespace->isLocked()) {
177 $userProfileNamespace->unLock();
183 <sect2 id="zend.session.advanced_usage.expiration">
184 <title>Expiration d'un espace de noms</title>
187 Des limites peuvent être affectées à la durée de vie soit des espaces de noms soit
188 de clés individuelles dans cet espace. Les cas d'utilisation habituels incluent le
189 passage d'une information temporaire entre requêtes, et la diminution de l'exposition à
190 un potentiel risque de sécurité par la suppression de l'accès à des informations
191 sensibles potentielles à une certaine heure après que l'authentification ait eu lieu.
192 L'expiration peut être basée sur les secondes écoulées, ou basées sur le concept de
193 "hops", où un "hop" apparaît à chaque requête successive.
196 <example id="zend.session.advanced_usage.expiration.example">
197 <title>Exemple d'expiration</title>
199 <programlisting language="php"><![CDATA[
200 $s = new Zend_Session_Namespace('expireAll');
205 $s->setExpirationSeconds(5, 'a');
206 // expire seulement pour la clé "a" dans 5 secondes
208 // expiration de tout l'espace de nommage dans 5 "hops"
209 $s->setExpirationHops(5);
211 $s->setExpirationSeconds(60);
212 // L'espace de noms "expireAll" sera marqué "expired"
213 // soit à la première requête reçue après 60 secondes,
214 // soit dans 5 hops, en fonction de ce qui arrivera en premier.
219 Quand vous travaillez avec des données de session expirées dans la requête
220 courante, des précautions doivent être prises concernant leur utilisation. Bien que les
221 données soient retournées par référence, modifier les données expirées ne les rendra pas
222 persistantes dans la requête courante. Dans le but de remettre à zéro leur temps
223 d'expiration, transférez les données dans des variables temporaires, utilisez l'espace
224 de nommage pour les effacer, et ensuite réaffectez les clés appropriées de
229 <sect2 id="zend.session.advanced_usage.controllers">
230 <title>Encapsulation de session et Contrôleurs</title>
233 Les espaces de noms peuvent aussi être utilisés pour séparer l'accès aux sessions
234 par contrôleur afin de protéger les variables d'une quelconque contamination. Par
235 exemple, un contrôleur d'authentification pourrait garder ces données de session
236 séparées de tous les autres contrôleurs pour des raisons de sécurité.
239 <example id="zend.session.advanced_usage.controllers.example">
240 <title>Sessions nommées par contrôleur avec expiration automatique</title>
243 Le code suivant, partie d'un contrôleur destiné à afficher une question dans
244 un test, initie une variable booléenne pour représenter l'acceptation ou non d'une
245 réponse à la question soumise. Dans ce cas, l'utilisateur de l'application a 300
246 secondes pour répondre à la question affichée.
249 <programlisting language="php"><![CDATA[
250 $testSpace = new Zend_Session_Namespace('testSpace');
251 $testSpace->setExpirationSeconds(300, 'accept_answer');
252 // expire seulement cette variable
253 $testSpace->accept_answer = true;
257 Ci-dessous, le contrôleur qui analyse les réponses aux questions du test
258 détermine l'acceptation ou non d'une réponse en se basant sur le fait que
259 l'utilisateur a répondu dans le temps alloué :
262 <programlisting language="php"><![CDATA[
263 // contrôleur analysant la réponse
264 $testSpace = new Zend_Session_Namespace('testSpace');
265 if ($testSpace->accept_answer === true) {
266 // dans le temps autorisé
269 // pas dans le temps autorisé
275 <sect2 id="zend.session.advanced_usage.single_instance">
276 <title>Limiter les instances multiples par espace de noms</title>
279 Bien que <link linkend="zend.session.advanced_usage.locking">le verrouillage de
280 session</link> fournisse un bon degré de protection contre l'utilisation inattendue des
281 données dans un espace de noms, <classname>Zend_Session_Namespace</classname> offre
282 aussi la possibilité d'empêcher la création d'instances multiples correspondant à un
283 unique espace de noms.
287 Pour activer ce comportement, réglez à <constant>TRUE</constant> le second argument du
288 constructeur quand vous créez la dernière instance autorisée de
289 <classname>Zend_Session_Namespace</classname>. Tout tentative suivante d'instanciation
290 du même espace de noms entraînera la levée d'une exception.
293 <example id="zend.session.advanced_usage.single_instance.example">
294 <title>Limiter l'accès à un espace de noms à une instance unique</title>
296 <programlisting language="php"><![CDATA[
297 // créer une instance d'espace
298 $authSpaceAccessor1 = new Zend_Session_Namespace('Zend_Auth');
300 // créer une autre instance du même espace,
301 // mais désactiver toute nouvelle instance
302 $authSpaceAccessor2 = new Zend_Session_Namespace('Zend_Auth', true);
304 // créer une référence est toujours possible
305 $authSpaceAccessor3 = $authSpaceAccessor2;
307 $authSpaceAccessor1->foo = 'bar';
309 assert($authSpaceAccessor2->foo, 'bar');
312 $aNamespaceObject = new Zend_Session_Namespace('Zend_Auth');
313 } catch (Zend_Session_Exception $e) {
314 echo "Cannot instantiate this namespace "
315 . "since $authSpaceAccessor2 was created\n";
321 Le second paramètre dans le constructeur ci-dessus informe
322 <classname>Zend_Session_Namespace</classname> que toute future instance avec l'espace de
323 noms "Zend_Auth" sera refusée. Tenter de créer une instance entraînera la levée d'une
324 exception par le constructeur. Le développeur devient responsable de stocker quelque
325 part une référence à l'instance de l'objet (<varname>$authSpaceAccessor1</varname>,
326 <varname>$authSpaceAccessor2</varname>, ou <varname>$authSpaceAccessor3</varname> dans l'exemple
327 ci-dessus), si l'accès à l'espace de noms de session est nécessaire plus tard dans la
328 même requête. Par exemple, le développeur peut stocker la référence dans une variable
329 statique , ajouter la référence au <ulink
330 url="http://www.martinfowler.com/eaaCatalog/registry.html">registre</ulink> (voir <xref
331 linkend="zend.registry" />), ou sinon la rendre disponible pour les autres méthodes qui
332 peuvent avoir accès à cet espace de noms.
336 <sect2 id="zend.session.advanced_usage.arrays">
337 <title>Travailler avec les tableaux</title>
340 A cause de l'histoire de l'implémentation des méthodes magiques dans <acronym>PHP</acronym>, la
341 modification d'un tableau à l'intérieur d'un espace de noms peut ne pas fonctionner avec
342 les versions de <acronym>PHP</acronym> inférieures à 5.2.1. Si vous travaillez exclusivement avec des
343 versions de <acronym>PHP</acronym> 5.2.1 ou supérieur., alors vous pouvez passer la <link
344 linkend="zend.session.advanced_usage.objects">section suivante</link>.
347 <example id="zend.session.advanced_usage.arrays.example.modifying">
348 <title>Modifier un tableau de données avec un espace de noms de session</title>
350 <para>Le code suivant illustre le problème qui peut être reproduit :</para>
352 <programlisting language="php"><![CDATA[
353 $sessionNamespace = new Zend_Session_Namespace();
354 $sessionNamespace->array = array();
355 $sessionNamespace->array['testKey'] = 1;
356 // ne fonctionne pas comme attendu avant PHP 5.2.1
357 echo $sessionNamespace->array['testKey'];
361 <example id="zend.session.advanced_usage.arrays.example.building_prior">
362 <title>Construire les tableaux avant le stockage en session</title>
365 Si possible, évitez le problème en stockant les tableaux dans un espace de
366 noms de session seulement après que toutes les clés et les valeurs aient été
370 <programlisting language="php"><![CDATA[
371 $sessionNamespace = new Zend_Session_Namespace('Foo');
372 $sessionNamespace->array = array('a', 'b', 'c');
377 Si vous utilisez une version de <acronym>PHP</acronym> affectée et avez besoin de modifier un tableau
378 après l'avoir assigné à une clé dans l'espace de noms, vous pouvez utiliser l'une des
379 solutions suivantes :
382 <example id="zend.session.advanced_usage.arrays.example.workaround.reassign">
383 <title>Solution : réassigner un tableau modifié</title>
386 Dans le code suivant, une copie du tableau stocké est créée, modifiée, et
387 réassignée à la place d'où provenait la copie, en effaçant le tableau
391 <programlisting language="php"><![CDATA[
392 $sessionNamespace = new Zend_Session_Namespace();
394 // assigne le tableau initial
395 $sessionNamespace->array = array('fruit' => 'pomme');
398 $tmp = $sessionNamespace->array;
400 // modification de la copie
401 $tmp['fruit'] = 'poire';
403 // ré-assignation de la copie dans l'espace de noms
404 $sessionNamespace->array = $tmp;
406 echo $sessionNamespace->array['fruit']; // affiche "poire"
410 <example id="zend.session.advanced_usage.arrays.example.workaround.reference">
411 <title>Solution : stocker un tableau contenant une référence</title>
414 Autrement, stockez un tableau contenant une référence au tableau désiré, et y
415 accéder indirectement.
418 <programlisting language="php"><![CDATA[
419 $myNamespace = new Zend_Session_Namespace('myNamespace');
421 $myNamespace->someArray = array( &$a );
423 echo $myNamespace->someArray['foo']; // affiche "bar"
428 <sect2 id="zend.session.advanced_usage.objects">
429 <title>Utiliser les sessions avec des objets</title>
432 Si vous prévoyez de rendre persistant des objets dans les sessions <acronym>PHP</acronym>, pensez
433 qu'ils peuvent être <ulink
434 url="http://www.php.net/manual/fr/language.oop.serialization.php">sérialisé</ulink> pour
435 le stockage. Ainsi, tout objet persistant dans les sessions <acronym>PHP</acronym> doit être désérialisé
436 après sa récupération à partir du stockage. L'implication est que le développeur doit
437 s'assurer que les classes des objets persistants doivent avoir été définies avant que
438 l'objet ne soit désérialisé du stockage. Si aucune classe n'est définie pour l'objet
439 désérialisé, alors il devient une instance de <code>stdClass</code>.
443 <sect2 id="zend.session.advanced_usage.testing">
444 <title>Utiliser les sessions avec les tests unitaires</title>
447 Zend Framework s'appuie sur PHPUnit pour faciliter ses propres tests. Beaucoup de
448 développeurs étendent la suite des tests unitaires pour couvrir le code de leurs
449 applications. L'exception "<emphasis>Zend_Session is currently marked as
450 read-only</emphasis>" (NDT. : "Zend_Session est actuellement marquée en lecture seule")
451 est levée lors de l'exécution des tests unitaires, si une méthode d'écriture est
452 utilisée après la clôture de la session. Cependant les tests unitaires employant
453 <classname>Zend_Session</classname> requièrent une attention particulière, car la
454 fermeture (<methodname>Zend_Session::writeClose()</methodname>), ou la destruction d'une
455 session (<methodname>Zend_Session::destroy()</methodname>) empêche tout futur changement
456 ou suppression de clés dans un <classname>Zend_Session_Namespace</classname>. Ce
457 comportement est un résultat direct du mécanisme fondamental de l'extension session et
458 des fonctions <acronym>PHP</acronym> <methodname>session_destroy()</methodname> et <methodname>session_write_close()</methodname>,
459 qui n'a pas de mécanisme de marche arrière ("undo") pour faciliter le réglage/démontage
460 avec les tests unitaires.
464 Pour contourner ceci, regardez le test unitaire
465 <methodname>testSetExpirationSeconds()</methodname> dans
466 <code>tests/Zend/Session/SessionTest.php</code> et <code>SessionTestHelper.php</code>,
467 qui utilise le code <acronym>PHP</acronym> <methodname>exec()</methodname> pour charger un processus séparé. Le nouveau
468 processus simule plus précisément une seconde requête successive du navigateur. Le
469 processus séparé démarre avec une session "propre", comme n'importe quelle exécution de
470 <acronym>PHP</acronym> pour une requête Web. Ainsi, tout changement fait à <varname>$_SESSION</varname> dans le
471 processus appelant devient disponible dans le processus enfant, pourvu que le parent ait
472 fermé la session avant d'utiliser <methodname>exec()</methodname>.
475 <example id="zend.session.advanced_usage.testing.example">
476 <title>Utilisation de PHPUnit pour tester le code écrit avec Zend_Session*</title>
478 <programlisting language="php"><![CDATA[
479 // tester setExpirationSeconds()
480 require 'tests/Zend/Session/SessionTestHelper.php';
481 // voir aussi SessionTest.php dans trunk/
482 $script = 'SessionTestHelper.php';
483 $s = new Zend_Session_Namespace('espace');
486 $s->setExpirationSeconds(5);
488 Zend_Session::regenerateId();
489 $id = Zend_Session::getId();
490 session_write_close();
491 // relâche la session donc le processus suivant peut l'utiliser
492 sleep(4); // pas assez long pour les éléments expirent
493 exec($script . "expireAll $id expireAll", $result);
494 $result = $this->sortResult($result);
495 $expect = ';a === abricot;o === orange;p === pear';
496 $this->assertTrue($result === $expect,
497 "iteration over default Zend_Session namespace failed; "
498 . "expecting result === '$expect', but got '$result'");
501 // assez long pour que les éléments expirent
502 // (total de 6 secondes écoulées, avec une expiration de 5)
503 exec($script . "expireAll $id expireAll", $result);
504 $result = array_pop($result);
505 $this->assertTrue($result === '',
506 "iteration over default Zend_Session namespace failed; "
507 . "expecting result === '', but got '$result')");
508 session_start(); // redémarre artificiellement une session suspendue
510 // Ceci peut être découpé dans un test séparé, mais en réalité,
511 // si quoi que ce soit reste de la partie précédente et contamine
512 // les tests suivants, alors c'est un bug dont nous voulons avoir
514 $s = new Zend_Session_Namespace('expireGuava');
515 $s->setExpirationSeconds(5, 'g');
516 // maintenant essayons d'expirer seulement une clé dans l'espace
521 session_write_close();
522 // relâche la session donc le processus suivant peut l'utiliser
523 sleep(6); // pas assez long pour les éléments expirent
524 exec($script . "expireAll $id expireGuava", $result);
525 $result = $this->sortResult($result);
526 session_start(); // redémarre artificiellement la session suspendue
527 $this->assertTrue($result === ';p === plum',
528 "iteration over named Zend_Session namespace failed (result=$result)");