documentation/manual/fr/module_specs/Zend_Http_Client-Adapters.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <!-- EN-Revision: 21815 -->
   3 <!-- Reviewed: no -->
   4 <sect1 id="zend.http.client.adapters">
   5     <title>Zend_Http_Client - Adaptateurs de connexion</title>
   6
   7     <sect2 id="zend.http.client.adapters.overview">
   8         <title>Présentation globale</title>
   9
  10         <para>
  11             <classname>Zend_Http_Client</classname> accepte des objets adaptateurs. Ces objets
  12             ont la responsabilité de soutenir la connexion vers un serveur, à savoir écrire des
  13             requêtes et lire des réponses L'adaptateur peut donc être changé, et même écrit ou
  14             réécrit pour correspondre à vos besoins, sans avoir l'obligation de toucher à toute la
  15             classe dite "client". Vous vous connectez et manipulez votre connexion toujours de la
  16             même manière quelque soit l'adaptateur situé dessous.
  17         </para>
  18
  19         <para>
  20             Actuellement, la classe cliente <classname>Zend_Http_Client</classname> est
  21             fournie avec quatre adaptateurs : <itemizedlist>
  22                     <listitem>
  23                         <para><classname>Zend_Http_Client_Adapter_Socket</classname> (défaut)</para>
  24                     </listitem>
  25
  26                     <listitem>
  27                         <para><classname>Zend_Http_Client_Adapter_Proxy</classname></para>
  28                     </listitem>
  29
  30                     <listitem>
  31                         <para><classname>Zend_Http_Client_Adapter_Curl</classname></para>
  32                     </listitem>
  33
  34                     <listitem>
  35                         <para><classname>Zend_Http_Client_Adapter_Test</classname></para>
  36                     </listitem>
  37                 </itemizedlist>
  38             </para>
  39
  40         <para>
  41             L'objet Zend_Http_Client se voit spécifié un adaptateur via son constructeur avec
  42             le tableau d'options, à l'index 'adapter'. Fournissez alors une chaîne représentant la
  43             classe d'adaptateur à utiliser (par exemple 'Zend_Http_Client_Adapter_Socket'), ou un
  44             objet directement (par exemple <code> new Zend_Http_Client_Adapter_Test</code>). Vous
  45             pouvez de même passer un adaptateur plus tard, avec la méthode
  46             <classname>Zend_Http_Client-&gt;setConfig()</classname>.
  47         </para>
  48     </sect2>
  49
  50     <sect2 id="zend.http.client.adapters.socket">
  51         <title>Adaptateur Socket</title>
  52
  53         <para>
  54             L'adaptateur par défaut est Zend_Http_Client_Adapter_Socket. Il est basé sur les
  55             fonctions <acronym>PHP</acronym> <methodname>fsockopen()</methodname> et soeurs. Il ne nécessite donc aucune extension
  56             particulière ni option de compilation de <acronym>PHP</acronym>.
  57         </para>
  58
  59         <para>
  60             L'adaptateur Socket peut être configuré avec des options, passées par
  61             <classname>Zend_Http_Client-&gt;setConfig()</classname> ou au constructeur du client.
  62             <table id="zend.http.client.adapter.socket.configuration.table">
  63                     <title>Zend_Http_Client_Adapter_Socket configuration</title>
  64
  65                     <tgroup cols="4">
  66                         <thead>
  67                             <row>
  68                                 <entry>Paramètre</entry>
  69                                 <entry>Description</entry>
  70                                 <entry>Types attendus</entry>
  71                                 <entry>Valeur par défaut</entry>
  72                             </row>
  73                         </thead>
  74
  75                         <tbody>
  76                             <row>
  77                                 <entry>persistent</entry>
  78                                 <entry>Utilise ou non les connexions <acronym>TCP</acronym> persistantes</entry>
  79                                 <entry>booléen</entry>
  80                                 <entry>false</entry>
  81                             </row>
  82
  83                             <row>
  84                                 <entry>ssltransport</entry>
  85                                 <entry>Couche de transport <acronym>SSL</acronym> ('sslv2', 'tls')</entry>
  86                                 <entry>chaîne</entry>
  87                                 <entry>ssl</entry>
  88                             </row>
  89
  90                             <row>
  91                                 <entry>sslcert</entry>
  92                                 <entry>Chemin vers le certificat <acronym>SSL</acronym> encodé <acronym>PEM</acronym></entry>
  93                                 <entry>chaîne</entry>
  94                                 <entry>null</entry>
  95                             </row>
  96
  97                             <row>
  98                                 <entry>sslpassphrase</entry>
  99                                 <entry>Phrase de passe pour le fichier de certificat <acronym>SSL</acronym></entry>
 100                                 <entry>chaîne</entry>
 101                                 <entry>null</entry>
 102                             </row>
 103                             <row>
 104                                 <entry>sslusecontext</entry>
 105                                 <entry>
 106                                     Active l'utilisation de SSL aux niveaux des connexions proxiées
 107                                     même si la connexion proxiée elle-même ne le fait pas.
 108                                 </entry>
 109                                 <entry>boolean</entry>
 110                                 <entry><constant>FALSE</constant></entry>
 111                             </row>
 112                         </tbody>
 113                     </tgroup>
 114
 115                     </table> <note>
 116                     <title>Connexions <acronym>TCP</acronym> persistantes</title>
 117
 118                 <para>
 119                     L'utilisation de connexions <acronym>TCP</acronym> persistantes peut potentiellement
 120                     accélérer vos requêtes <acronym>HTTP</acronym> mais n'a, dans la plupart des cas, qu'un petit effet
 121                     positif et peut surcharger le serveur <acronym>HTTP</acronym> auquel vous êtes connecté.
 122                 </para>
 123
 124                 <para>
 125                     Il est recommandé d'utiliser les connexions <acronym>TCP</acronym> persistantes seulement si
 126                     vous vous connectez au même serveur très fréquemment, et que vous êtes sûr que
 127                     le serveur est capable de gérer un nombre élevé de connections concurrentes.
 128                     Dans tous les cas vous êtes encouragés à tester l'effet des connections
 129                     persistantes à la fois sur l'accélération du client et sur la charge du serveur
 130                     avant d'activer cette option.
 131                 </para>
 132
 133                 <para>
 134                     De plus, quand vous utilisez des connexions persistantes, il est
 135                     recommandé d'activer l'option "Keep-Alive" décrite dans <xref
 136                     linkend="zend.http.client.configuration" />, sinon les connexions persistantes
 137                     n'auront que peu ou pas d'effet.
 138                 </para>
 139             </note> <note>
 140                 <title>HTTPS SSL Paramètres de flux</title>
 141
 142                 <para>
 143                     <code>ssltransport, sslcert</code> and <code>sslpassphrase</code> sont
 144                     seulement appropriées lors de l'utilisation d'HTTPS.
 145                 </para>
 146
 147                 <para>
 148                     Bien que les réglages par défaut du mode <acronym>SSL</acronym> fonctionneront pour la
 149                     plupart des applications, vous pourrez avoir besoin de les changer si le
 150                     serveur, auquel vous vous connectez, requière un paramétrage particulier du
 151                     client. Dans ce cas, vous devriez lire les sections sur la couche de transport
 152                     <acronym>SSL</acronym> et ses options à cette <ulink
 153                     url="http://www.php.net/manual/en/transports.php#transports.inet">adresse</ulink>.
 154                 </para>
 155                 </note>
 156             </para>
 157
 158         <example id="zend.http.client.adapters.socket.example-1">
 159             <title>Changer la couche de transport HTTPS</title>
 160
 161             <programlisting language="php"><![CDATA[
 162 // Définit des paramètres de configuration
 163 $config = array(
 164     'adapter'      => 'Zend_Http_Client_Adapter_Socket',
 165     'ssltransport' => 'tls'
 166 );
 167
 168 // Instantie un objet client
 169 $client = new Zend_Http_Client('https://www.example.com', $config);
 170
 171 // Cette requête sera envoyée vers une connexion sécurisée TLS
 172 $response = $client->request();
 173 ]]></programlisting>
 174         </example>
 175
 176         <para>
 177             Le résultat ci-dessus sera similaire à l'ouverture d'une connexion <acronym>TCP</acronym> avec la
 178             commande <acronym>PHP</acronym> suivante :
 179         </para>
 180
 181         <para><methodname>fsockopen('tls://www.example.com', 443)</methodname></para>
 182
 183         <sect3 id="zend.http.client.adapters.socket.streamcontext">
 184             <title>Customizing and accessing the Socket adapter stream context</title>
 185             <para>
 186                 Starting from Zend Framework 1.9, <classname>Zend_Http_Client_Adapter_Socket</classname>
 187                 provides direct access to the underlying <ulink url="http://php.net/manual/en/stream.contexts.php">stream context</ulink>
 188                 used to connect to the remote server. This allows the user to pass
 189                 specific options and parameters to the <acronym>TCP</acronym> stream, and to the <acronym>SSL</acronym> wrapper in
 190                 case of <acronym>HTTPS</acronym> connections.
 191             </para>
 192
 193             <para>
 194                 You can access the stream context using the following methods of <classname>Zend_Http_Client_Adapter_Socket</classname>:
 195                 <itemizedlist>
 196                     <listitem>
 197                         <para>
 198                             <firstterm><methodname>setStreamContext($context)</methodname></firstterm>
 199                             Sets the stream context to be used by the adapter. Can accept either
 200                             a stream context resource created using the
 201                             <ulink url="http://php.net/manual/en/function.stream-context-create.php"><methodname>stream_context_create()</methodname></ulink>
 202                             <acronym>PHP</acronym> function, or an array of stream context options, in the same format provided to this function.
 203                             Providing an array will create a new stream context using these options, and set it.
 204                         </para>
 205                     </listitem>
 206                     <listitem>
 207                         <para>
 208                             <firstterm><methodname>getStreamContext()</methodname></firstterm>
 209                             Get the stream context of the adapter. If no stream context was set,
 210                             will create a default stream context and return it. You can then set
 211                             or get the value of different context options using regular <acronym>PHP</acronym> stream
 212                             context functions.
 213                         </para>
 214                     </listitem>
 215                 </itemizedlist>
 216             </para>
 217             <example id="zend.http.client.adapters.socket.streamcontext.example-1">
 218             <title>Setting stream context options for the Socket adapter</title>
 219             <programlisting language="php"><![CDATA[
 220 // Array of options
 221 $options = array(
 222     'socket' => array(
 223         // Bind local socket side to a specific interface
 224         'bindto' => '10.1.2.3:50505'
 225     ),
 226     'ssl' => array(
 227         // Verify server side certificate,
 228         // do not accept invalid or self-signed SSL certificates
 229         'verify_peer' => true,
 230         'allow_self_signed' => false,
 231
 232         // Capture the peer's certificate
 233         'capture_peer_cert' => true
 234     )
 235 );
 236
 237 // Create an adapter object and attach it to the HTTP client
 238 $adapter = new Zend_Http_Client_Adapter_Socket();
 239 $client = new Zend_Http_Client();
 240 $client->setAdapter($adapter);
 241
 242 // Method 1: pass the options array to setStreamContext()
 243 $adapter->setStreamContext($options);
 244
 245 // Method 2: create a stream context and pass it to setStreamContext()
 246 $context = stream_context_create($options);
 247 $adapter->setStreamContext($context);
 248
 249 // Method 3: get the default stream context and set the options on it
 250 $context = $adapter->getStreamContext();
 251 stream_context_set_option($context, $options);
 252
 253 // Now, preform the request
 254 $response = $client->request();
 255
 256 // If everything went well, you can now access the context again
 257 $opts = stream_context_get_options($adapter->getStreamContext());
 258 echo $opts['ssl']['peer_certificate'];
 259 ]]></programlisting>
 260         </example>
 261
 262         <note>
 263             <para>
 264                 Note that you must set any stream context options before using the adapter
 265                 to preform actual requests. If no context is set before preforming <acronym>HTTP</acronym> requests
 266                 with the Socket adapter, a default stream context will be created. This context
 267                 resource could be accessed after preforming any requests using the
 268                 <methodname>getStreamContext()</methodname> method.
 269             </para>
 270         </note>
 271         </sect3>
 272     </sect2>
 273
 274     <sect2 id="zend.http.client.adapters.proxy">
 275         <title>Adaptateur Proxy</title>
 276
 277         <para>
 278             L'adaptateur Zend_Http_Client_Adapter_Proxy est identique à celui par défaut,
 279             Socket, sauf que Proxy se connectera au serveur via un serveur Proxy (mandataire). Cette
 280             utilisation peut être rencontrée pour des raisons de performances ou de sécurité.
 281         </para>
 282
 283         <para>
 284             En utilisant l'adaptateur Proxy, quelques paramètres de configuration seront
 285             nécessaires en plus du paramètre 'adapter' : <table
 286                     id="zend.http.client.adapters.proxy.table">
 287                     <title>Zend_Http_Client paramètres de configuration</title>
 288
 289                     <tgroup cols="4">
 290                         <thead>
 291                             <row>
 292                                 <entry>Paramètre</entry>
 293                                 <entry>Description</entry>
 294                                 <entry>Valeurs attendues</entry>
 295                                 <entry>Valeur par défaut</entry>
 296                             </row>
 297                         </thead>
 298
 299                         <tbody>
 300                             <row>
 301                                 <entry>proxy_host</entry>
 302                                 <entry>Adresse du serveur Proxy</entry>
 303                                 <entry>chaîne</entry>
 304                                 <entry>'proxy.myhost.com' ou '10.1.2.3'</entry>
 305                             </row>
 306
 307                             <row>
 308                                 <entry>proxy_port</entry>
 309                                 <entry>Port du serveur Proxy</entry>
 310                                 <entry>entier</entry>
 311                                 <entry>8080 (défaut) ou 81</entry>
 312                             </row>
 313
 314                             <row>
 315                                 <entry>proxy_user</entry>
 316                                 <entry>nom d'utilisateur pour le Proxy, si requis</entry>
 317                                 <entry>chaîne</entry>
 318                                 <entry>'shahar' ou '' pour aucun (défaut)</entry>
 319                             </row>
 320
 321                             <row>
 322                                 <entry>proxy_pass</entry>
 323                                 <entry>Mot de passe du Proxy, si requis</entry>
 324                                 <entry>chaîne</entry>
 325                                 <entry>'secret' ou '' pour aucun (défaut)</entry>
 326                             </row>
 327
 328                             <row>
 329                                 <entry>proxy_auth</entry>
 330                                 <entry>Type d'authentification <acronym>HTTP</acronym> du Proxy</entry>
 331                                 <entry>chaîne</entry>
 332                                 <entry>Zend_Http_Client::AUTH_BASIC (défaut)</entry>
 333                             </row>
 334                         </tbody>
 335                     </tgroup>
 336                 </table>
 337             </para>
 338
 339         <para>
 340             <code>proxy_host</code> devrait toujours être fourni. Si ça n'est pas le cas,
 341             alors le client retournera sur une connexion Socket par défaut. <code>proxy_port</code>
 342             est par défaut à "8080".
 343         </para>
 344
 345         <para>
 346             <code>proxy_user</code> et <code>proxy_pass</code> ne sont requis que si le
 347             serveur Proxy demande une authentification. Si vous remplissez ces options, alors un
 348             champ d'en-tête <acronym>HTTP</acronym> "Proxy-Authentication" sera ajouté à vos requêtes, via votre
 349             client.
 350         </para>
 351
 352         <para>
 353             <code>proxy_auth</code> définit le type d'authentification à utiliser, si le
 354             serveur Proxy demande une authentification. Actuellement, seule la méthode "basic"
 355             (<classname>Zend_Http_Client::AUTH_BASIC</classname>) est supportée.
 356         </para>
 357
 358         <example id="zend.http.client.adapters.proxy.example-1">
 359             <title>Utiliser Zend_Http_Client derrière un serveur Proxy</title>
 360
 361             <programlisting language="php"><![CDATA[
 362 // Paramètres de configuration
 363 $config = array(
 364     'adapter'    => 'Zend_Http_Client_Adapter_Proxy',
 365     'proxy_host' => 'proxy.int.zend.com',
 366     'proxy_port' => 8000,
 367     'proxy_user' => 'shahar.e',
 368     'proxy_pass' => 'bananashaped'
 369 );
 370
 371 // Crée l'objet client
 372 $client = new Zend_Http_Client('http://www.example.com', $config);
 373
 374 // utilisez l'objet client ici ...
 375 ]]></programlisting>
 376         </example>
 377
 378         <para>
 379             Comme déjà dit, si proxy_host n'est pas rempli ou défini en tant que chaîne vide,
 380             alors le client utilisera l'adaptateur Socket par défaut. Ceci est utile si le proxy est
 381             utilisé optionnellement, ou par intermittence.
 382         </para>
 383
 384         <note>
 385             <para>
 386                 Since the proxy adapter inherits from <classname>Zend_Http_Client_Adapter_Socket</classname>,
 387                 you can use the stream context access method (see <xref linkend="zend.http.client.adapters.socket.streamcontext" />)
 388                 to set stream context options on Proxy connections as demonstrated above.
 389             </para>
 390         </note>
 391     </sect2>
 392
 393     <sect2 id="zend.http.client.adapters.curl">
 394         <title>The cURL Adapter</title>
 395         <para>
 396             cURL is a standard <acronym>HTTP</acronym> client library that is distributed with many
 397             operating systems and can be used in <acronym>PHP</acronym> via the cURL extension. It
 398             offers functionality for many special cases which can occur for a <acronym>HTTP</acronym>
 399             client and make it a perfect choice for a <acronym>HTTP</acronym> adapter. It supports
 400             secure connections, proxy, all sorts of authentication mechanisms
 401             and shines in applications that move large files around between servers.
 402         </para>
 403
 404         <example id="zend.http.client.adapters.curl.example-1">
 405             <title>Setting cURL options</title>
 406             <programlisting language="php"><![CDATA[
 407 $config = array(
 408     'adapter'   => 'Zend_Http_Client_Adapter_Curl',
 409     'curloptions' => array(CURLOPT_FOLLOWLOCATION => true),
 410 );
 411 $client = new Zend_Http_Client($uri, $config);
 412 ]]></programlisting>
 413         </example>
 414
 415         <para>
 416             By default the cURL adapter is configured to behave exactly like
 417             the Socket Adapter and it also accepts the same configuration parameters
 418             as the Socket and Proxy adapters. You can also change the cURL options by either specifying
 419             the 'curloptions' key in the constructor of the adapter or by calling
 420             <methodname>setCurlOption($name, $value)</methodname>. The <varname>$name</varname> key
 421             corresponds to the CURL_* constants of the cURL extension. You can
 422             get access to the Curl handle by calling <code>$adapter->getHandle();</code>
 423         </para>
 424
 425         <example id="zend.http.client.adapters.curl.example-2">
 426             <title>Transfering Files by Handle</title>
 427
 428             <para>
 429                 You can use cURL to transfer very large files over <acronym>HTTP</acronym> by filehandle.
 430             </para>
 431
 432             <programlisting language="php"><![CDATA[
 433 $putFileSize   = filesize("filepath");
 434 $putFileHandle = fopen("filepath", "r");
 435
 436 $adapter = new Zend_Http_Client_Adapter_Curl();
 437 $client = new Zend_Http_Client();
 438 $client->setAdapter($adapter);
 439 $adapter->setConfig(array(
 440     'curloptions' => array(
 441         CURLOPT_INFILE => $putFileHandle,
 442         CURLOPT_INFILESIZE => $putFileSize
 443     )
 444 ));
 445 $client->request("PUT");
 446 ]]></programlisting>
 447         </example>
 448     </sect2>
 449
 450     <sect2 id="zend.http.client.adapters.test">
 451         <title>Adaptateur Test</title>
 452
 453         <para>
 454             Il est quelque fois difficile de tester une application qui a besoin d'une
 455             connexion <acronym>HTTP</acronym>. Par exemple, une application qui est en charge de lire un flux <acronym>RSS</acronym> aura
 456             besoin d'une connexion, qui n'est pas tout le temps disponible.
 457         </para>
 458
 459         <para>
 460             C'est pour cette raison que l'adaptateur
 461             <classname>Zend_Http_Client_Adapter_Test</classname> est présent. Vous pouvez de cette
 462             manière écrire vos applications, et lors de la phase de tests, passer votre connexion
 463             sur l'adaptateur Test (objet mock).
 464         </para>
 465
 466         <para>
 467             La classe <classname>Zend_Http_Client_Adapter_Test</classname> possède une méthode
 468             supplémentaire, <methodname>setResponse()</methodname>. Elle prend en paramètre un objet
 469             <classname>Zend_Http_Response</classname> ou une chaîne. Une fois cet objet de réponse
 470             déterminé, l'adaptateur de Test retournera toujours cette réponse, sans effectuer de
 471             réelle requête <acronym>HTTP</acronym>.
 472         </para>
 473
 474         <example id="zend.http.client.adapters.test.example-1">
 475             <title>Tester avec un objet de réponse HTTP unique</title>
 476
 477             <programlisting language="php"><![CDATA[
 478 // Création de l'adatateur et de l'objet client :
 479 $adapter = new Zend_Http_Client_Adapter_Test();
 480 $client = new Zend_Http_Client('http://www.example.com', array(
 481     'adapter' => $adapter
 482 ));
 483
 484 // Passage de l'objet de réponse
 485 $adapter->setResponse(
 486     "HTTP/1.1 200 OK"        . "\r\n" .
 487     "Content-type: text/xml" . "\r\n" .
 488                                "\r\n" .
 489     '<?xml version="1.0" encoding="UTF-8"?>' .
 490     '<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"' .
 491     '     xmlns:wfw="http://wellformedweb.org/CommentAPI/"' .
 492     '     xmlns:dc="http://purl.org/dc/elements/1.1/">' .
 493     '  <channel>' .
 494     '    <title>Premature Optimization</title>' .
 495     // etc....
 496     '</rss>');
 497
 498 $response = $client->request('GET');
 499 // ... continuez à parser $response...
 500 ]]></programlisting>
 501         </example>
 502
 503         <para>
 504             L'exemple ci dessus montre comment préconfigurer la réponse qui sera retournée
 505             lors d'une requête de votre objet client. Ainsi lors des tests, votre application
 506             continuera de se comporter normalement, elle aura tout simplement été trompée (mock).
 507             Aucune connexion <acronym>HTTP</acronym> n'est dans ce cas là nécessaire.
 508         </para>
 509
 510         <para>
 511             Quelques fois, plusieurs transactions <acronym>HTTP</acronym> peuvent être nécessaires. Une réponse
 512             peut demander une redirection, vers une autre. Dans ce cas, utiliser
 513             <methodname>setResponse()</methodname> toute seule n'est pas possible car il ne sera pas possible de
 514             spécifier les réponses suivantes, nécessaires alors à l'application.
 515         </para>
 516
 517         <example id="zend.http.client.adapters.test.example-2">
 518             <title>Tester avec plusieurs réponses HTTP</title>
 519
 520             <programlisting language="php"><![CDATA[
 521 // Création des objets adaptateur, et client
 522 $adapter = new Zend_Http_Client_Adapter_Test();
 523 $client = new Zend_Http_Client('http://www.example.com', array(
 524     'adapter' => $adapter
 525 ));
 526
 527 // Configuration de la première réponse attendue
 528 $adapter->setResponse(
 529     "HTTP/1.1 302 Found"      . "\r\n" .
 530     "Location: /"             . "\r\n" .
 531     "Content-Type: text/html" . "\r\n" .
 532                                 "\r\n" .
 533     '<html>' .
 534     '  <head><title>Moved</title></head>' .
 535     '  <body><p>This page has moved.</p></body>' .
 536     '</html>');
 537
 538 // Configuration des réponses successives
 539 $adapter->addResponse(
 540     "HTTP/1.1 200 OK"         . "\r\n" .
 541     "Content-Type: text/html" . "\r\n" .
 542                                 "\r\n" .
 543     '<html>' .
 544     '  <head><title>My Pet Store Home Page</title></head>' .
 545     '  <body><p>...</p></body>' .
 546     '</html>');
 547
 548 // l'objet $client est prêt à être testé
 549 // son comportement est déja configuré
 550 ]]></programlisting>
 551         </example>
 552
 553         <para>
 554             La méthode <methodname>setResponse()</methodname> détruit toutes les réponses dans le buffer
 555             de <classname>Zend_Http_Client_Adapter_Test</classname> et définit la première réponse
 556             qui sera retournée. La méthode <methodname>addResponse()</methodname> définit les réponses
 557             suivantes.
 558         </para>
 559
 560         <para>Les réponses seront rejouées dans leur ordre d'ajout.</para>
 561
 562         <para>
 563             Dans l'exemple ci-dessus, l'adaptateur est configuré pour un scénario de test de
 564             redirections 302. En fonction de votre application, le suivi d'une redirection peut être
 565             ou non désiré. Dans notre exemple, nous nous attendons à ce que la redirection soit
 566             suivie et nous configurons notre adaptateur de tests pour ceci. La réponse de
 567             redirection originelle (302) est définie avec la méthode <methodname>setResponse()</methodname>,
 568             quant à la réponse non redirigeante (200) suivante, elles est définie avec la méthode
 569             <methodname>addResponse()</methodname>. Lorsque votre objet client est configuré, vous pouvez
 570             l'injecter dans votre application à tester, et voir le résultat et les
 571             comportements.
 572         </para>
 573
 574         <para>
 575             If you need the adapter to fail on demand you can use
 576             <methodname>setNextRequestWillFail($flag)</methodname>. The method will cause the next
 577             call to <methodname>connect()</methodname> to throw an
 578             <classname>Zend_Http_Client_Adapter_Exception</classname> exception. This can be useful
 579             when your application caches content from an external site (in case the site goes down)
 580             and you want to test this feature.
 581         </para>
 582
 583         <example id="zend.http.client.adapters.test.example-3">
 584             <title>Forcing the adapter to fail</title>
 585
 586             <programlisting language="php"><![CDATA[
 587 // Instantiate a new adapter and client
 588 $adapter = new Zend_Http_Client_Adapter_Test();
 589 $client = new Zend_Http_Client('http://www.example.com', array(
 590     'adapter' => $adapter
 591 ));
 592
 593 // Force the next request to fail with an exception
 594 $adapter->setNextRequestWillFail(true);
 595
 596 try {
 597     // This call will result in a Zend_Http_Client_Adapter_Exception
 598     $client->request();
 599 } catch (Zend_Http_Client_Adapter_Exception $e) {
 600     // ...
 601 }
 602
 603 // Further requests will work as expected until
 604 // you call setNextRequestWillFail(true) again
 605 ]]></programlisting>
 606         </example>
 607     </sect2>
 608
 609     <sect2 id="zend.http.client.adapters.extending">
 610         <title>Créer vos propres adaptateurs de connexion</title>
 611
 612         <para>
 613             Vous pouvez créer vos propres adaptateurs, si vous avez un besoin spécial à
 614             utiliser. Par exemple, des possibilités de cache, ou des sockets persistantes.
 615         </para>
 616
 617         <para>
 618             Pour ceci, votre classe d'adaptateur doit implémenter l'interface
 619             <classname>Zend_Http_Client_Adapter_Interface</classname>. L'exemple suivant montre un
 620             squelette de classe. Toutes les méthodes publiques, ici, sont indispensables à la
 621             classe, elles sont issues de l'interface :
 622         </para>
 623
 624         <example id="zend.http.client.adapters.extending.example-1">
 625             <title>Création de votre propre adaptateur de connexion</title>
 626
 627             <programlisting language="php"><![CDATA[
 628 class MyApp_Http_Client_Adapter_BananaProtocol
 629     implements Zend_Http_Client_Adapter_Interface
 630 {
 631     /**
 632      * Définit le tableau de configuration pour cet adaptateur
 633      *
 634      * @param array $config
 635      */
 636     public function setConfig($config = array())
 637     {
 638         // Ceci change rarement, vous devriez copier l'implémentation
 639         // présente dans Zend_Http_Client_Adapter_Socket.
 640     }
 641
 642     /**
 643      * Connecte à une serveur distant
 644      *
 645      * @param string  $host
 646      * @param int     $port
 647      * @param boolean $secure
 648      */
 649     public function connect($host, $port = 80, $secure = false)
 650     {
 651         // Etablit la connexion au serveur
 652     }
 653
 654     /**
 655      * Envoie une requête au serveur
 656      *
 657      * @param string        $method
 658      * @param Zend_Uri_Http $url
 659      * @param string        $http_ver
 660      * @param array         $headers
 661      * @param string        $body
 662      * @return string Request as text
 663      */
 664     public function write($method,
 665                           $url,
 666                           $http_ver = '1.1',
 667                           $headers = array(),
 668                           $body = '')
 669     {
 670         // Envoie la requête au serveur distant. Cette fonction devrait
 671         // retourner la requête complète (en-tête et corps) as a string
 672     }
 673
 674     /**
 675      * Lit la réponse du serveur
 676      *
 677      * @return string
 678      */
 679     public function read()
 680     {
 681         // Lit la réponse du serveur distant, et la retourne sous forme
 682         // de chaine de caractères
 683     }
 684
 685     /**
 686      * Ferme la connexion avec le serveur
 687      *
 688      */
 689     public function close()
 690     {
 691         // Ferme la connexion, appelée en dernière.
 692     }
 693 }
 694
 695 // Maintenant, vous pouvez utiliser cet adaptateur :
 696 $client = new Zend_Http_Client(array(
 697     'adapter' => 'MyApp_Http_Client_Adapter_BananaProtocol'
 698 ));
 699 ]]></programlisting>
 700         </example>
 701     </sect2>
 702 </sect1>