[ZF-10089] Zend_Log
[zend.git] / documentation / manual / fr / module_specs / Zend_Cache-Frontends.xml
blob918fce2b3c14ca6343e35c35d2bd8aa1aefeac4d
1 <?xml version="1.0" encoding="utf-8"?>
2 <!-- EN-Revision: 22140 -->
3 <!-- Reviewed: no -->
4 <sect1 id="zend.cache.frontends">
5     <title>Les frontends Zend_Cache</title>
7     <sect2 id="zend.cache.frontends.core">
8         <title>Zend_Cache_Core</title>
10         <sect3 id="zend.cache.frontends.core.introduction">
11             <title>Introduction</title>
13             <para>
14                 <classname>Zend_Cache_Core</classname> est un frontend spécial parce qu'il est le
15                 coeur du module. C'est le frontend de cache générique qui est étendu par les autres
16                 classes.
17             </para>
19             <note>
20                 <para>
21                     Tous les frontends héritent de <classname>Zend_Cache_Core</classname> ainsi ses
22                     méthodes et options (décrites ci-dessous) seront aussi disponibles dans les
23                     autres frontends, cependant ils ne sont pas documentés ici.
24                 </para>
25             </note>
26         </sect3>
28         <sect3 id="zend.cache.frontends.core.options">
29             <title>Options disponibles</title>
31             <para>
32                 Ces options sont passées à la méthode de fabrique comme montrées dans les
33                 exemples précédents.
34             </para>
36             <table id="zend.cache.frontends.core.options.table">
37                 <title>Options du frontend Core</title>
39                 <tgroup cols="4">
40                     <thead>
41                         <row>
42                             <entry>Option</entry>
43                             <entry>Type de données</entry>
44                             <entry>Valeur par défaut</entry>
45                             <entry>Description</entry>
46                         </row>
47                     </thead>
48                     <tbody>
49                         <row>
50                             <entry><emphasis>caching</emphasis></entry>
51                             <entry><type>Boolean</type></entry>
52                             <entry><constant>TRUE</constant></entry>
53                             <entry>
54                                 Active / désactive le cache (peut-être très utile pour le
55                                 débogage de scripts en cache)
56                             </entry>
57                         </row>
58                         <row>
59                             <entry><emphasis>cache_id_prefix</emphasis></entry>
60                             <entry><type>String</type></entry>
61                             <entry><constant>NULL</constant></entry>
62                             <entry>
63                                 Un préfixe pour tous les ID de cache, si réglé à
64                                 <constant>NULL</constant>, aucun préfixe d'ID de cache ne sera
65                                 utilisé. Le préfixe d'ID de cache sert essentiellement à créer des
66                                 espaces de noms dans le cache, permettant à plusieurs applications
67                                 ou sites Web d'utiliser un cache partagé. Chaque application ou
68                                 site web peut utilisé un préfixe d'ID de cache différent et un
69                                 préfixe peut aussi être utilisé plusieurs fois.
70                             </entry>
71                         </row>
72                         <row>
73                             <entry><emphasis>lifetime</emphasis></entry>
74                             <entry><type>Integer</type></entry>
75                             <entry>3600</entry>
76                             <entry>
77                                 Temps de vie (en secondes) du cache, si défini à
78                                 <constant>NULL</constant>, le cache est valide indéfiniment
79                             </entry>
80                         </row>
81                         <row>
82                             <entry><emphasis>logging</emphasis></entry>
83                             <entry><type>Boolean</type></entry>
84                             <entry><constant>FALSE</constant></entry>
85                             <entry>
86                                 Si défini à <constant>TRUE</constant>, le logging par
87                                 <classname>Zend_Log</classname> est activé (mais le système sera
88                                 plus lent)
89                             </entry>
90                         </row>
91                         <row>
92                             <entry><emphasis>write_control</emphasis></entry>
93                             <entry><type>Boolean</type></entry>
94                             <entry><constant>TRUE</constant></entry>
95                             <entry>
96                                 Active / désactive le contrôle d'écriture (le cache est lu
97                                 juste après l'écriture pour détecter des entrées corrompues),
98                                 activer "writeControl" va ralentir un petit peu
99                                 l'écriture du cache, mais pas la lecture (il peut détecter des
100                                 fichiers de cache corrompus, mais ceci n'est pas un contrôle
101                                 parfait).
102                             </entry>
103                         </row>
104                         <row>
105                             <entry><emphasis>automatic_serialization</emphasis></entry>
106                             <entry><type>Boolean</type></entry>
107                             <entry><constant>FALSE</constant></entry>
108                             <entry>
109                                 Active / désactive la sérialisation automatique, il peut
110                                 être utilisé pour enregistrer directement des données qui ne sont
111                                 pas des chaînes de caractères (mais c'est plus lent).
112                             </entry>
113                         </row>
114                         <row>
115                             <entry><emphasis>automatic_cleaning_factor</emphasis></entry>
116                             <entry><type>Integer</type></entry>
117                             <entry>0</entry>
118                             <entry>
119                                 Active / désactive le nettoyage automatique ("garbage
120                                 collector"): 0 signifie aucun nettoyage automatique de cache, 1
121                                 signifie un nettoyage systématique du cache et x &gt; 1 signifie le
122                                 nettoyage aléatoire 1 fois toute les x écritures.
123                             </entry>
124                         </row>
125                         <row>
126                             <entry><emphasis>ignore_user_abort</emphasis></entry>
127                             <entry><type>Boolean</type></entry>
128                             <entry><constant>FALSE</constant></entry>
129                             <entry>
130                                 Si réglé à <constant>TRUE</constant>, le cache active le drapeau
131                                 <acronym>PHP</acronym> "ignore_user_abort" dans la méthode
132                                 <methodname>save()</methodname> pour prévenir de la corruption du
133                                 cache dans certains cas.
134                             </entry>
135                         </row>
136                     </tbody>
137                 </tgroup>
138             </table>
139         </sect3>
141         <sect3 id="zend.cache.core.examples">
142             <title>Exemples</title>
144             <para>Un exemple est donné dans le manuel, tout au début.</para>
146             <para>
147                 Si vous stocker uniquement des chaînes de caractères dans le cache (parce
148                 qu'avec l'option "automatic_serialization", il est possible de stocker
149                 des booléens), vous pouvez utiliser une construction plus compact comme&#160;:
150             </para>
152             <programlisting language="php"><![CDATA[
153 // nous avons déjà $cache
155 $id = 'myBigLoop'; // id de cache de "ce que l'on veut cacher"
157 if (!($data = $cache->load($id))) {
158     // cache absent
160     $data = '';
161     for ($i = 0; $i < 10000; $i++) {
162         $data = $data . $i;
163     }
165     $cache->save($data);
169 // [...] fait quelque chose avec $data
170 // (affichage, passage ailleurs, etc, etc)
171 ]]></programlisting>
173             <para>
174                 Si vous voulez cacher des blocs multiples ou des instances de données, l'idée
175                 reste la même&#160;:
176             </para>
178             <programlisting language="php"><![CDATA[
179 // on s'assure que l'on utilise des identifiant uniques
180 $id1 = 'foo';
181 $id2 = 'bar';
183 // block 1
184 if (!($data = $cache->load($id1))) {
185     // cache absent
187     $data = '';
188     for ($i=0;$i<10000;$i++) {
189         $data = $data . $i;
190     }
192     $cache->save($data);
195 echo($data);
197 // ceci n'est pas affecté par la mise en cache
198 echo('NEVER CACHED! ');
200 // block 2
201 if (!($data = $cache->load($id2))) {
202     // cache missed
204     $data = '';
205     for ($i=0;$i<10000;$i++) {
206         $data = $data . '!';
207     }
209     $cache->save($data);
212 echo($data);
213 ]]></programlisting>
215             <para>
216                 Si vous voulez cacher des valeurs "spéciales" (des booléens avec l'option
217                 "automatic_serialization") ou des chaînes vides, vous ne pouvez pas
218                 utiliser la construction compacte montrée ci-dessus. Vous devez tester de manière
219                 formelle l'état du cache.
220             </para>
222             <programlisting language="php"><![CDATA[
223 // La construction compacte (ne pas utiliser si vous cachez
224 // des chaînes et/ou des booléens)
225 if (!($data = $cache->load($id))) {
227     // cache absent
229     // [...] on crée $data
231     $cache->save($data);
235 // on fait qqch avec $data
237 // [...]
239 // La construction complète (fonctionne dans tous les cas)
240 if (!($cache->test($id))) {
242     // cache absent
244     // [...] on crée $data
246     $cache->save($data);
248 } else {
250     // lecture du cache
252     $data = $cache->load($id);
256 // on fait qqch avec $data
257 ]]></programlisting>
258         </sect3>
259     </sect2>
261     <sect2 id="zend.cache.frontends.output">
262         <title>Zend_Cache_Frontend_Output</title>
264         <sect3 id="zend.cache.frontends.output.introduction">
265             <title>Introduction</title>
267             <para>
268                 <classname>Zend_Cache_Frontend_Output</classname> est un frontend capturant la
269                 sortie. Il utilise la bufferisation de sortie de <acronym>PHP</acronym> pour
270                 capturer tout ce qui passe entre les méthodes <methodname>start()</methodname> et
271                 <methodname>end()</methodname>.
272             </para>
273         </sect3>
275         <sect3 id="zend.cache.frontends.output.options">
276             <title>Options disponibles</title>
278             <para>
279                 Ce frontend n'a pas d'options spécifiques autres que celles de
280                 <classname>Zend_Cache_Core</classname>.
281             </para>
282         </sect3>
284         <sect3 id="zend.cache.frontends.output.examples">
285             <title>Exemples</title>
287             <para>
288                 Un exemple est donnée dans le manuel, tout au début. Le voici avec des
289                 changements mineurs&#160;:
290             </para>
292             <programlisting language="php"><![CDATA[
293 // s'il y a un cache manquant, la bufferisation de sortie est lancée
294 if (!$cache->start('mypage')) {
296     // affiche tout comme d'habitude
297     echo 'Hello world! ';
298     echo 'This is cached ('.time().') ';
300     $cache->end(); // affiche ce qu'il y a dans le buffer
303 echo 'This is never cached ('.time().').';
304 ]]></programlisting>
306             <para>
307                 Utiliser cette forme est assez simple pour définir une mise de cache de
308                 sortie dans vos projets déjà en production, avec peu de refactorisation de
309                 code.
310             </para>
311         </sect3>
312     </sect2>
314     <sect2 id="zend.cache.frontends.function">
315         <title>Zend_Cache_Frontend_Function</title>
317         <sect3 id="zend.cache.frontends.function.introduction">
318             <title>Introduction</title>
320             <para>
321                 <classname>Zend_Cache_Frontend_Function</classname> met en cache les résultats des
322                 appels de fonction. Elle a une seule méthode principale appelée
323                 <methodname>call()</methodname> qui prend un nom de fonction et des paramètres pour
324                 l'appel dans un tableau.
325             </para>
326         </sect3>
328         <sect3 id="zend.cache.frontends.function.options">
329             <title>Options disponibles</title>
331             <table id="zend.cache.frontends.function.options.table">
332                 <title>Options du frontend Function</title>
334                 <tgroup cols="4">
335                     <thead>
336                         <row>
337                             <entry>Option</entry>
338                             <entry>Type de données</entry>
339                             <entry>Valeur par défaut</entry>
340                             <entry>Description</entry>
341                         </row>
342                     </thead>
343                     <tbody>
344                         <row>
345                             <entry><emphasis>cache_by_default</emphasis></entry>
346                             <entry><type>Boolean</type></entry>
347                             <entry><constant>TRUE</constant></entry>
348                             <entry>
349                                 si <constant>TRUE</constant>, les appels de fonction seront mis en
350                                 cache par défaut
351                             </entry>
352                         </row>
353                         <row>
354                             <entry><emphasis>cached_functions</emphasis></entry>
355                             <entry><type>Array</type></entry>
356                             <entry>''</entry>
357                             <entry>les noms de fonctions seront toujours mis en cache</entry>
358                         </row>
359                         <row>
360                             <entry><emphasis>non_cached_functions</emphasis></entry>
361                             <entry><type>Array</type></entry>
362                             <entry>''</entry>
363                             <entry>
364                                 les noms de fonctions ne doivent jamais être mis en
365                                 cache
366                             </entry>
367                         </row>
368                     </tbody>
369                 </tgroup>
370             </table>
371         </sect3>
373         <sect3 id="zend.cache.frontends.function.examples">
374             <title>Exemples</title>
376             <para>
377                 Utiliser la fonction <methodname>call()</methodname> est la même chose qu'utiliser
378                 <methodname>call_user_func_array()</methodname> en <acronym>PHP</acronym>&#160;:
379             </para>
381             <programlisting language="php"><![CDATA[
382 $cache->call('veryExpensiveFunc', $params);
384 // $params est dans un tableau par exemple, pour appeler
385 // (avec mise en cache) : veryExpensiveFunc(1, 'foo', 'bar')
386 // vous devriez utiliser
387 $cache->call('veryExpensiveFunc', array(1, 'foo', 'bar'));
388 ]]></programlisting>
390             <para>
391                 <classname>Zend_Cache_Frontend_Function</classname> est assez intelligente pour
392                 mettre en cache la valeur de retour de la fonction, ainsi que sa sortie interne.
393             </para>
395             <note>
396                 <para>
397                     Vous pouvez passer n'importe quelle fonction utilisateur à l'exception de
398                     <methodname>array()</methodname>, <methodname>echo()</methodname>,
399                     <methodname>empty()</methodname>, <methodname>eval()</methodname>,
400                     <methodname>exit()</methodname>, <methodname>isset()</methodname>,
401                     <methodname>list()</methodname>, <methodname>print()</methodname>
402                     et <methodname>unset()</methodname>.
403                 </para>
404             </note>
405         </sect3>
406     </sect2>
408     <sect2 id="zend.cache.frontends.class">
409         <title>Zend_Cache_Frontend_Class</title>
411         <sect3 id="zend.cache.frontends.class.introduction">
412             <title>Introduction</title>
414             <para>
415                 <classname>Zend_Cache_Frontend_Class</classname> est différent de
416                 <classname>Zend_Cache_Frontend_Function</classname> parce qu'elle permet de mettre
417                 en cache les objets et les méthodes statiques.
418             </para>
419         </sect3>
421         <sect3 id="zend.cache.frontends.class.options">
422             <title>Options disponibles</title>
424             <table id="zend.cache.frontends.class.options.table">
425                 <title>Options du frontend Class</title>
427                 <tgroup cols="4">
428                     <thead>
429                         <row>
430                             <entry>Option</entry>
431                             <entry>Type de données</entry>
432                             <entry>Valeur par défaut</entry>
433                             <entry>Description</entry>
434                         </row>
435                     </thead>
436                     <tbody>
437                         <row>
438                             <entry><emphasis>cached_entity</emphasis> (requis)</entry>
439                             <entry><type>Mixed</type></entry>
440                             <entry></entry>
441                             <entry>
442                                 si défini avec un nom de classe, nous allons mettre en cache
443                                 une classe abstraite et utiliser uniquement les appels
444                                 statiques&#160;; si défini avec un objet, nous allons mettre en
445                                 cache les méthodes de cet objet.
446                             </entry>
447                         </row>
448                         <row>
449                             <entry><emphasis>cache_by_default</emphasis></entry>
450                             <entry><type>Boolean</type></entry>
451                             <entry><constant>TRUE</constant></entry>
452                             <entry>
453                                 si <constant>TRUE</constant>, les appels vont être cachés par
454                                 défaut
455                             </entry>
456                         </row>
457                         <row>
458                             <entry><emphasis>cached_methods</emphasis></entry>
459                             <entry><type>Array</type></entry>
460                             <entry></entry>
461                             <entry>
462                                 les noms des méthodes qui seront toujours mis en
463                                 cache
464                             </entry>
465                         </row>
466                         <row>
467                             <entry><emphasis>non_cached_methods</emphasis></entry>
468                             <entry><type>Array</type></entry>
469                             <entry></entry>
470                             <entry>
471                                 les noms des méthodes qui ne doivent jamais être mises en
472                                 cache
473                             </entry>
474                         </row>
475                     </tbody>
476                 </tgroup>
477             </table>
478         </sect3>
480         <sect3 id="zend.cache.frontends.class.examples">
481             <title>Exemples</title>
483             <para>Par exemple, pour mettre en cache des appels statiques&#160;:</para>
485             <programlisting language="php"><![CDATA[
486 class test {
488     // Méthode statique
489     public static function foobar($param1, $param2) {
490         echo "foobar_output($param1, $param2)";
491         return "foobar_return($param1, $param2)";
492     }
496 // [...]
497 $frontendOptions = array(
498     'cached_entity' => 'test' // Le nom de la classe
500 // [...]
502 // l'appel caché
503 $res = $cache->foobar('1', '2');
504 ]]></programlisting>
506             <para>Pour mettre en cache des appels classiques aux méthodes&#160;:</para>
508             <programlisting language="php"><![CDATA[
509 class test {
511     private $_string = 'hello !';
513     public function foobar2($param1, $param2) {
514         echo($this->_string);
515         echo "foobar2_output($param1, $param2)";
516         return "foobar2_return($param1, $param2)";
517     }
521 // [...]
522 $frontendOptions = array(
523     'cached_entity' => new test() // Une instance de la classe
525 // [...]
527 // L'appel mis en cache
528 $res = $cache->foobar2('1', '2');
529 ]]></programlisting>
530         </sect3>
531     </sect2>
533     <sect2 id="zend.cache.frontends.file">
534         <title>Zend_Cache_Frontend_File</title>
536         <sect3 id="zend.cache.frontends.file.introduction">
537             <title>Introduction</title>
539             <para>
540                 <classname>Zend_Cache_Frontend_File</classname> est un frontend piloté par la
541                 modification d'un "fichier maître". C'est vraiment intéressant, par exemple, dans
542                 les problématiques de configuration ou de templates. Il est également possible
543                 d'utiliser plusieurs fichiers maîtres.
544             </para>
546             <para>
547                 Par exemple, vous avez un fichier de configuration <acronym>XML</acronym> qui est
548                 analysé par une fonction, celle-ci retourne un "objet de configuration" (comme avec
549                 <classname>Zend_Config</classname>). Avec
550                 <classname>Zend_Cache_Frontend_File</classname>, vous pouvez stocker l'objet de
551                 configuration dans le cache (pour éviter d'analyser le fichier de configuration
552                 <acronym>XML</acronym> chaque fois) mais avec une sorte de forte dépendance au
553                 fichier maître. Ainsi si le fichier <acronym>XML</acronym> de configuration est
554                 modifié, le cache est immédiatement invalide.
555             </para>
556         </sect3>
558         <sect3 id="zend.cache.frontends.file.options">
559             <title>Options disponibles</title>
561             <table id="zend.cache.frontends.file.options.table">
562                 <title>Options du frontend File</title>
564                 <tgroup cols="4">
565                     <thead>
566                         <row>
567                             <entry>Option</entry>
568                             <entry>Type de données</entry>
569                             <entry>Valeur par défaut</entry>
570                             <entry>Description</entry>
571                         </row>
572                     </thead>
573                     <tbody>
574                         <row>
575                             <entry><emphasis>master_file</emphasis> (déprécié)</entry>
576                             <entry><type>String</type></entry>
577                             <entry>''</entry>
578                             <entry>le chemin complet et le nom du fichier maître</entry>
579                         </row>
580                         <row>
581                             <entry><emphasis>master_files</emphasis></entry>
582                             <entry><type>Array</type></entry>
583                             <entry><methodname>array()</methodname></entry>
584                             <entry>un tableau de chemin complet de fichiers maîtres</entry>
585                         </row>
586                         <row>
587                             <entry><emphasis>master_files_mode</emphasis></entry>
588                             <entry><type>String</type></entry>
589                             <entry><constant>Zend_Cache_Frontend_File::MODE_OR</constant></entry>
590                             <entry>
591                                 <constant>Zend_Cache_Frontend_File::MODE_AND</constant> oU
592                                 <constant>Zend_Cache_Frontend_File::MODE_OR</constant> ; si
593                                 <constant>MODE_AND</constant>, alors tous les fichiers maîtres
594                                 doivent être modifiés pour rendre invalide le cache, si
595                                 <constant>MODE_OR</constant>, alors un seul fichier maître modifié
596                                 est nécessaire pour invalider le cache
597                             </entry>
598                         </row>
599                         <row>
600                             <entry><emphasis>ignore_missing_master_files</emphasis></entry>
601                             <entry><type>Boolean</type></entry>
602                             <entry><constant>FALSE</constant></entry>
603                             <entry>
604                                 si <constant>TRUE</constant>, l'absence de fichiers maîtres est
605                                 ignoré silencieusement (sinon une exception est levée)
606                             </entry>
607                         </row>
608                     </tbody>
609                 </tgroup>
610             </table>
611         </sect3>
613         <sect3 id="zend.cache.frontends.file.examples">
614             <title>Exemples</title>
616             <para>
617                 L'utilisation de ce frontend est la même que celle de
618                 <classname>Zend_Cache_Core</classname>. Il n'y a pas besoin d'exemple spécifique -
619                 la seule chose à faire est de définir le <emphasis>master_file</emphasis> lors de
620                 l'utilisation de la fabrique.
621             </para>
622         </sect3>
623     </sect2>
625     <sect2 id="zend.cache.frontends.page">
626         <title>Zend_Cache_Frontend_Page</title>
628         <sect3 id="zend.cache.frontends.page.introduction">
629             <title>Introduction</title>
631             <para>
632                 <classname>Zend_Cache_Frontend_Page</classname> est comme
633                 <classname>Zend_Cache_Frontend_Output</classname> mais créé pour une page complète.
634                 Il est impossible d'utiliser <classname>Zend_Cache_Frontend_Page</classname> pour
635                 mettre en cache un bloc unique.
636             </para>
638             <para>
639                 D'un autre côté, le "cache ID", est calculé automatiquement avec
640                 <varname>$_SERVER['REQUEST_URI']</varname> et (en fonction des options)
641                 <varname>$_GET</varname>, <varname>$_POST</varname>, <varname>$_SESSION</varname>,
642                 <varname>$_COOKIE</varname>, <varname>$_FILES</varname>. De plus, vous avez
643                 seulement une méthode pour appeler (<methodname>start()</methodname>) parce que
644                 l'appel à <methodname>end()</methodname> est totalement automatique lorsque la page
645                 est terminé.
646             </para>
648             <para>
649                 Pour le moment, ceci n'est pas implémenté mais nous prévoyons d'ajouter un
650                 système de condition <acronym>HTTP</acronym> pour économiser de la bande passante
651                 (le système émettra un en-tête "<acronym>HTTP</acronym> 304 Not Modified" si le
652                 cache est trouvé, et si le navigateur a déjà la bonne version).
653             </para>
655             <note>
656                 <para>
657                     Ce frontend opére en enregistrant une fonction de rappel qui doit être appelée
658                     quand le buffer de sortie qu'il utilise est nettoyé. Dans le but de fonctionner
659                     correctement, il doit être le buffer de sortie final de la requête. Pour
660                     garantir ceci, le buffer de sortie utilisé par le distributeur (Dispatcher)
661                     <emphasis>doit</emphasis> être désactivé en appelant la méthode
662                     <methodname>setParam()</methodname> de
663                     <classname>Zend_Controller_Front</classname>, par exemple
664                     <command>$front->setParam('disableOutputBuffering', true);</command> ou en
665                     ajoutant "resources.frontcontroller.params.disableOutputBuffering = true"
666                     à votre fichier d'amorçage (présumé de type <acronym>INI</acronym>) si vous
667                     utilisez <classname>Zend_Application</classname>.
668                 </para>
669             </note>
670         </sect3>
672         <sect3 id="zend.cache.frontends.page.options">
673             <title>Options disponibles</title>
675             <table id="zend.cache.frontends.page.options.table">
676                 <title>Options du frontend Page</title>
678                 <tgroup cols="4">
679                     <thead>
680                         <row>
681                             <entry>Option</entry>
682                             <entry>Type de données</entry>
683                             <entry>Valeur par défaut</entry>
684                             <entry>Description</entry>
685                         </row>
686                     </thead>
687                     <tbody>
688                         <row>
689                             <entry><emphasis>http_conditional</emphasis></entry>
690                             <entry><type>Boolean</type></entry>
691                             <entry><constant>FALSE</constant></entry>
692                             <entry>
693                                 utilisez le système "httpConditionnal" ou pas
694                                 (pas encore implémenté)
695                             </entry>
696                         </row>
697                         <row>
698                             <entry><emphasis>debug_header</emphasis></entry>
699                             <entry><type>Boolean</type></entry>
700                             <entry><constant>FALSE</constant></entry>
701                             <entry>
702                                 si <constant>TRUE</constant>, un texte de débogage est ajouté avant
703                                 chaque page de cache
704                             </entry>
705                         </row>
706                         <row>
707                             <entry><emphasis>default_options</emphasis></entry>
708                             <entry><type>Array</type></entry>
709                             <entry><methodname>array(...see below...)</methodname></entry>
710                             <entry>
711                                 un tableau associatif d'options par défaut&#160;:
712                                 <itemizedlist>
713                                     <listitem>
714                                         <para>
715                                             <emphasis>(boolean, <constant>TRUE</constant> par
716                                             défaut) cache</emphasis>&#160;:
717                                             le cache est activé si <constant>TRUE</constant>
718                                         </para>
719                                     </listitem>
720                                     <listitem>
721                                         <para>
722                                             <emphasis>(boolean, <constant>FALSE</constant> par
723                                             défaut) cache_with_get_variables</emphasis>&#160;: si
724                                             <constant>TRUE</constant>, le cache est toujours activé
725                                             même s'il y a des variables dans le tableau
726                                             <varname>$_GET</varname>
727                                         </para>
728                                     </listitem>
729                                     <listitem>
730                                         <para>
731                                             <emphasis>(boolean, <constant>FALSE</constant> par
732                                             défaut) cache_with_post_variables</emphasis>&#160;: si
733                                             <constant>TRUE</constant>, le cache est toujours activé
734                                             même s'il y a des variables dans le tableau
735                                             <varname>$_POST</varname>
736                                         </para>
737                                     </listitem>
738                                     <listitem>
739                                         <para>
740                                             <emphasis>(boolean, <constant>FALSE</constant> par
741                                             défaut) cache_with_session_variables</emphasis>&#160;:
742                                             si <constant>TRUE</constant>, le cache est toujours
743                                             activé s'il y a des variables dans le tableau
744                                             <varname>$_SESSION</varname>
745                                         </para>
746                                     </listitem>
747                                     <listitem>
748                                         <para>
749                                             <emphasis>(boolean, <constant>FALSE</constant> par
750                                             défaut) cache_with_files_variables</emphasis>&#160;: si
751                                             <constant>TRUE</constant>, le cache est toujours activé
752                                             s'il y a des variables dans le tableau
753                                             <varname>$_FILES</varname>
754                                         </para>
755                                     </listitem>
756                                     <listitem>
757                                         <para>
758                                             <emphasis>(boolean, <constant>FALSE</constant> par
759                                             défaut) cache_with_cookie_variables</emphasis>&#160;: si
760                                             <constant>TRUE</constant>, le cache est toujours activé
761                                             s'il y a des variables dans le tableau
762                                             <varname>$_COOKIE</varname>
763                                         </para>
764                                     </listitem>
765                                     <listitem>
766                                         <para>
767                                             <emphasis>(boolean, <constant>TRUE</constant> par
768                                             défaut) make_id_with_get_variables</emphasis>&#160;: si
769                                             <constant>TRUE</constant>, l'identifiant du cache sera
770                                             dépendant du contenu du tableau <varname>$_GET</varname>
771                                         </para>
772                                     </listitem>
773                                     <listitem>
774                                         <para>
775                                             <emphasis>(boolean, <constant>TRUE</constant> par
776                                             défaut) make_id_with_post_variables</emphasis>&#160;:
777                                             si <constant>TRUE</constant>, l'identifiant du cache
778                                             sera dépendant du contenu du tableau
779                                             <varname>$_POST</varname>
780                                         </para>
781                                     </listitem>
782                                     <listitem>
783                                         <para>
784                                             <emphasis>(boolean, <constant>TRUE</constant> par
785                                             défaut) make_id_with_session_variables</emphasis>&#160;:
786                                             si <constant>TRUE</constant>, l'identifiant du cache
787                                             sera dépendant du contenu du tableau
788                                             <varname>$_SESSION</varname>
789                                         </para>
790                                     </listitem>
791                                     <listitem>
792                                         <para>
793                                             <emphasis>(boolean, <constant>TRUE</constant> par
794                                             défaut) make_id_with_files_variables</emphasis>&#160;:
795                                             si <constant>TRUE</constant>, l'identifiant du cache
796                                             sera dépendant du contenu du tableau
797                                             <varname>$_FILES</varname>
798                                         </para>
799                                     </listitem>
800                                     <listitem>
801                                         <para>
802                                             <emphasis>(boolean, <constant>TRUE</constant> par
803                                             défaut) make_id_with_cookie_variables</emphasis>&#160;:
804                                             si <constant>TRUE</constant>, l'identifiant du cache
805                                             sera dépendant du contenu du tableau
806                                             <varname>$_COOKIE</varname>
807                                         </para>
808                                     </listitem>
809                                     <listitem>
810                                         <para>
811                                             <emphasis>(int, <constant>FALSE</constant> par défaut)
812                                             specific_lifetime</emphasis>&#160;: si
813                                             <constant>TRUE</constant>, la durée de vie fournie sera
814                                             utilisée pour l'expression régulière choisie
815                                         </para>
816                                     </listitem>
817                                     <listitem>
818                                         <para>
819                                             <emphasis>(array, <methodname>array()</methodname> par
820                                                 défaut) tags</emphasis>&#160;:
821                                             balises pour l'enregistrement en cache
822                                         </para>
823                                     </listitem>
824                                     <listitem>
825                                         <para>
826                                             <emphasis>(int, <constant>NULL</constant> par défaut)
827                                                 priority</emphasis>&#160;:
828                                             priorité (si le backend le supporte)
829                                         </para>
830                                     </listitem>
831                             </itemizedlist></entry>
832                         </row>
833                         <row>
834                             <entry><emphasis>regexps</emphasis></entry>
835                             <entry><type>Array</type></entry>
836                             <entry><methodname>array()</methodname></entry>
837                             <entry>
838                                 un tableau associatif pour définir les options, uniquement
839                                 pour certaines <constant>REQUEST_URI</constant>, les clés sont des
840                                 expressions régulières <acronym>PCRE</acronym>, les valeurs sont
841                                 des tableaux associatifs avec des options spécifiques pour définir
842                                 si les expressions régulières correspondent dans
843                                 <varname>$_SERVER['REQUEST_URI']</varname> (voir les options par
844                                 défaut pour la liste des options disponibles) ; si plusieurs
845                                 expressions régulières correspondent à un
846                                 <varname>$_SERVER['REQUEST_URI']</varname>, seule la dernière
847                                 sera utilisée.
848                             </entry>
849                         </row>
850                         <row>
851                             <entry><emphasis>memorize_headers</emphasis></entry>
852                             <entry><type>Array</type></entry>
853                             <entry><methodname>array()</methodname></entry>
854                             <entry>
855                                 un tableau de chaînes correspondant aux noms d'en-têtes
856                                 <acronym>HTTP</acronym>. Les en-têtes listés seront stockées avec
857                                 les données de cache et renvoyées lorsque le cache sera rappelé.
858                             </entry>
859                         </row>
860                     </tbody>
861                 </tgroup>
862             </table>
863         </sect3>
865         <sect3 id="zend.cache.frontends.page.examples">
866             <title>Exemples</title>
868             <para>
869                 L'utilisation de <classname>Zend_Cache_Frontend_Page</classname> est vraiment
870                 trivial&#160;:
871             </para>
873             <programlisting language="php"><![CDATA[
874 // [...] // require, configuration et factory
876 $cache->start();
877 // si le cache est trouvé, le résultat est envoyé au navigateur
878 // et le script s'arrête là
880 // reste de la page ...
881 ]]></programlisting>
883             <para>
884                 Un exemple plus complexe qui montre un moyen pour obtenir une gestion
885                 centralisée du cache dans un fichier d'amorçage (pour utiliser avec
886                 <classname>Zend_Controller</classname> par exemple)
887             </para>
889             <programlisting language="php"><![CDATA[
890 // vous devriez éviter de mettre trop de lignes avant la section
891 // de cache par exemple, pour des performances optimales,
892 // "require_once" ou "Zend_Loader::loadClass" devrait être
893 // après la section de cache
895 $frontendOptions = array(
896    'lifetime' => 7200,
897    'debug_header' => true, // pour le déboguage
898    'regexps' => array(
899        // met en cache la totalité d'IndexController
900        '^/$' => array('cache' => true),
902        // met en cache la totalité d'IndexController
903        '^/index/' => array('cache' => true),
905        // nous ne mettons pas en cache l'ArticleController...
906        '^/article/' => array('cache' => false),
908        // ...mais nous mettons en cache l'action "view"
909        '^/article/view/' => array(
910             // de cet ArticleController
911            'cache' => true,
913            // et nous mettons en cache même lorsqu'il y a
914            // des variables dans $_POST
915            'cache_with_post_variables' => true,
917            // (mais le cache sera dépendent du tableau $_POST)
918            'make_id_with_post_variables' => true,
919        )
920    )
922 $backendOptions = array(
923     'cache_dir' => '/tmp/'
926 // obtenir un objet Zend_Cache_Frontend_Page
927 $cache = Zend_Cache::factory('Page',
928                              'File',
929                              $frontendOptions,
930                              $backendOptions);
932 $cache->start();
933 // si nous trouvons un cache, le résultat est envoyé au navigateur,
934 // et le script s'arrête là
936 // [...] la fin du fichier de démarrage
937 // (ces lignes ne seront pas exécutées si on trouve un cache)
938 ]]></programlisting>
939         </sect3>
941         <sect3 id="zend.cache.frontends.page.cancel">
942             <title>La méthode spécifique cancel()</title>
944             <para>
945                 A cause de problèmes de design, dans certains cas (par exemple quand on
946                 utilise des codes de retour <acronym>HTTP</acronym> autres que 200), vous
947                 pouvez avoir besoin de stopper le processus de mise en cache courant. Il a donc été
948                 introduit pour ce frontend en particulier, la méthode
949                 <methodname>cancel()</methodname>.
950             </para>
952             <programlisting language="php"><![CDATA[
953 // [...] require, configuration et fabrique
955 $cache->start();
957 // [...]
959 if ($unTest) {
960     $cache->cancel();
961     // [...]
964 // [...]
965 ]]></programlisting>
966         </sect3>
967     </sect2>
969     <sect2 id="zend.cache.frontends.capture">
970         <title>Zend_Cache_Frontend_Capture</title>
972         <sect3 id="zend.cache.frontends.capture.introduction">
973             <title>Introduction</title>
975             <para>
976                 <classname>Zend_Cache_Frontend_Capture</classname> is like
977                 <classname>Zend_Cache_Frontend_Output</classname> but designed for a complete page.
978                 It's impossible to use <classname>Zend_Cache_Frontend_Capture</classname> for
979                 caching only a single block. This class is specifically designed to operate in
980                 concert only with the <classname>Zend_Cache_Backend_Static</classname> backend to
981                 assist in caching entire pages of <acronym>HTML</acronym> / <acronym>XML</acronym>
982                 or other content to a physical static file on the local filesystem.
983             </para>
985             <para>
986                 Please refer to the documentation on
987                 <classname>Zend_Cache_Backend_Static</classname> for all use cases pertaining to
988                 this class.
989             </para>
991             <note>
992                 <para>
993                     This frontend operates by registering a callback function to be called
994                     when the output buffering it uses is cleaned. In order for this to operate
995                     correctly, it must be the final output buffer in the request. To guarantee
996                     this, the output buffering used by the Dispatcher <emphasis>must</emphasis> be
997                     disabled by calling <classname>Zend_Controller_Front</classname>'s
998                     <methodname>setParam()</methodname> method, for example,
999                     <command>$front->setParam('disableOutputBuffering', true);</command> or adding
1000                     "resources.frontcontroller.params.disableOutputBuffering = true"
1001                     to your bootstrap configuration file (assumed <acronym>INI</acronym>) if using
1002                     <classname>Zend_Application</classname>.
1003                 </para>
1004             </note>
1005         </sect3>
1006      </sect2>
1007 </sect1>