<!-- EN-Revision: 12150 -->
<sect1 id="zend.http.client.advanced">
    <title>Zend_Http_Client - Utilisation avancée</title>

    <sect2 id="zend.http.client.redirections">
        <title>Redirections HTTP</title>

        <para>Par défaut, <classname>Zend_Http_Client</classname> gère automatiquement les redirections HTTP, et suivra jusqu'à 5
        redirections. Ce comportement peut être modifié en changeant le paramètre de configuration
        "maxredirects".</para>

        <para>Conformément à la RFC HTTP/1.1, les codes réponse HTTP 301 et 302 doivent être traités par le client en
        envoyant à nouveau la même requête à l'adresse spécifiée - en utilisant la même méthode de requête. Cependant,
        la plupart des clients ne réagissent pas correctement et redirige toujours via une requête GET. Par défaut,
        <classname>Zend_Http_Client</classname> agit de même - Lors d'une redirection basée sur la réception d'un code 301 ou 302,
        tous les paramètres GET et POST sont remis à zéro, et une requête GET est envoyée à la nouvelle adresse. Ce
        comportement peut être modifié en positionnant le paramètre de configuration "strictredirects" à
        <code>TRUE</code> : <example id="zend.http.client.redirections.example-1">
                <title>Forcer des redirections conformes au RFC 2616 lors de la réception d'un code statut 301 and
                302</title>

                <programlisting role="php"><![CDATA[
// Redirections strictes
$client->setConfig(array('strictredirects' => true)

// Redirections non strictes
$client->setConfig(array('strictredirects' => false)
]]></programlisting>
            </example></para>

        <para>Il est toujours possible d'obtenir le nombre de redirections effectuées après l'envoi d'une requête en
        invoquant la méthode getRedirectionsCount().</para>
    </sect2>

    <sect2 id="zend.http.client.cookies">
        <title>Ajout de cookies et gestion de leur persistance</title>

        <para><classname>Zend_Http_Client</classname> fournit une interface simple afin d'ajouter des cookies à une requête de
        manière à ce qu'aucune modification directe de l'en-tête ne soit nécessaire. Ceci est réalisé via la méthode
        <code>setCookie()</code>. Cette méthode peut être utilisée de plusieurs manières : <example
                id="zend.http.client.cookies.example-1">
                <title>Définition de cookies via setCookie()</title>

                <programlisting role="php"><![CDATA[
// Simple et facile : en fournissant un nom de cookie et une valeur
$client->setCookie('parfum', 'pépites de chocolat');

// en fournissant directement une chaîne de cookie encodée (nom=valeur)
// Notez que la valeur doit être déjà encodée au format URL
$client->setCookie('parfum=p%C3%A9pites%20de%20chocolat');

// En fournissant un objet Zend_Http_Cookie
$cookie =
    Zend_Http_Cookie::fromString('parfum=p%C3%A9pites%20de%20chocolat');
$client->setCookie($cookie);
]]></programlisting>
            </example> Pour plus d'information sur les objets <classname>Zend_Http_Cookie</classname>, voir <xref
        linkend="zend.http.cookies" />.</para>

        <para><classname>Zend_Http_Client</classname> permet également la persistance des cookies - ce qui permet au client de
        stocker tous les cookies reçus et transmis, et de les retransmettre automatiquement lors des requêtes suivantes.
        Cela se révèle très utile lorsqu'il est nécessaire de s'identifier sur un site donné (et de recevoir ainsi un
        cookie de session) avant de pouvoir envoyer d'autres requêtes. <example id="zend.http.client.cookies.example-2">
                <title>Activer la persistance des cookies</title>

                <programlisting role="php"><![CDATA[
// Pour activer la persistance des cookies,
// définissez un Magasin de cookie "Cookie Jar"
$client->setCookieJar();

// Première requête : s'identifier et démarrer une session
$client->setUri('http://exemple.com/login.php');
$client->setParameterPost('user', 'h4x0r');
$client->setParameterPost('password', '1337');
$client->request('POST');

// Le magasin de cookies stocke automatiquement les
// cookies transmis dans la réponse, un cookie de session par exemple

// Maintenant nous pouvons envoyer notre requête suivante
// les cookies stockés seront transmis automatiquement.
$client->setUri('http://exemple.com/lire_actualite_membres.php');
$client->request('GET');
]]></programlisting>
            </example> Pour plus d'information sur la classe <classname>Zend_Http_CookieJar</classname>, voir <xref
        linkend="zend.http.cookies.cookiejar" />.</para>
    </sect2>

    <sect2 id="zend.http.client.custom_headers">
        <title>Définir des en-têtes personnalisés</title>

        <para>Il est possible de définir des en-têtes personnalisés en utilisant la méthode <code>setHeaders()</code>.
        Cette méthode est très versatile et peut être utilisée de diverses manières comme le montre l'exemple suivant :
        <example id="zend.http.client.custom_headers.example-1">
                <title>Définir un en-tête personnalisé unique</title>

                <programlisting role="php"><![CDATA[
// Définition d'un en-tête unique,
// écrasant toute valeur précédemment définie
$client->setHeaders('Host', 'www.exemple.com');

// La même chose d'une autre manière
$client->setHeaders('Host: www.example.com');

// Définition de plusieurs valeurs pour le même en-tête
// (surtout utile pour les en-têtes de cookies)
$client->setHeaders('Cookie', array(
    'PHPSESSID=1234567890abcdef1234567890abcdef',
    'language=fr'
));
]]></programlisting>
            </example></para>

        <para><code>setHeader()</code> peut aussi être facilement utilisé pour définir des en-têtes multiples en un seul
        appel, en fournissant un tableau d'en-têtes comme paramètre unique : <example
                id="zend.http.client.custom_headers.example-2">
                <title>Définition de plusieurs en-têtes personnalisés</title>

                <programlisting role="php"><![CDATA[
// Définition de plusieurs en-têtes,
// écrasant toute valeur précédemment définie
$client->setHeaders(array(
    'Host' => 'www.exemple.com',
    'Accept-encoding' => 'gzip,deflate',
    'X-Powered-By' => 'Zend Framework'));

// Le tableau peut contenir uniquement des valeurs
$client->setHeaders(array(
    'Host: www.exemple.com',
    'Accept-encoding: gzip,deflate',
    'X-Powered-By: Zend Framework'));
]]></programlisting>
            </example></para>
    </sect2>

    <sect2 id="zend.http.client.file_uploads">
        <title>Envoi de fichiers</title>

        <para>Il est possible d'envoyer des fichiers au travers d'HTTP en utilisant la méthode
        <code>setFileUpload</code>. Cette méthode attend un nom de fichier comme premier paramètre, un nom de formulaire
        comme second paramètre, et, en option, des données comme troisième paramètre. Si le troisième paramètre est
        <code>null</code>, la valeur du premier paramètre est supposée être un fichier sur le disque dur et
        <classname>Zend_Http_Client</classname> essaiera de lire ce fichier et de l'envoyer. Sinon la valeur du premier paramètre
        sera envoyée comme nom du fichier mais il n'est pas nécessaire que le fichier existe sur le disque dur. Le
        deuxième paramètre est toujours requis, et est équivalent à l'attribut "name" d'une balise &lt;input&gt;, si le
        fichier devait être envoyé à partir d'un formulaire HTML. Un quatrième paramètre optionnel fournit le type du
        fichier. S'il n'est pas spécifié et que <classname>Zend_Http_Client</classname> lit le fichier à partir du disque dur, la
        fonction mime_content_type sera utilisée pour tenter de définir, si possible, le type du fichier. Dans tous les
        cas, le type MIME par défaut sera 'application/octet-stream'. <example
                id="zend.http.client.file_uploads.example-1">
                <title>Utilisation de setFileUpload pour envoyer des fichiers</title>

                <programlisting role="php"><![CDATA[
// Envoi de données arbitraires comme fichier
$texte = 'ceci est un texte ordinaire';
$client->setFileUpload('du_texte.txt', 'upload', $texte, 'text/plain');

// envoi d'un fichier existant
$client->setFileUpload('/tmp/Backup.tar.gz', 'bufile');

// envoi des fichiers
$client->request('POST');
]]></programlisting>
            </example> Dans le premier exemple, la variable $texte est envoyée et sera disponible dans
        <code>$_FILES['upload']</code> côté serveur. Dans le second exemple, le fichier existant
        "<filename>/tmp/Backup.tar.gz</filename>" est envoyé au serveur et sera disponible dans
        <code>$_FILES['bufile']</code>. Son type sera défini automatiquement si possible. Sinon, le type sera défini
        comme "application/octet-stream".</para>

        <note>
            <title>Envoi de fichiers</title>

            <para>Lors de l'envoi de fichiers, le type de la requête HTTP est automatiquement défini comme
            "multipart/form-data". Gardez à l'esprit que vous devez utiliser la méthode POST ou la méthode PUT pour
            envoyer des fichiers. La plupart des serveurs ignoreront le corps de la requête si vous utilisez une autre
            méthode.</para>
        </note>
    </sect2>

    <sect2 id="zend.http.client.raw_post_data">
        <title>Envoyer des données brutes via POST</title>

        <para>Vous pouvez utiliser <classname>Zend_Http_Client</classname> pour envoyer des données brutes via POST en utilisant
        la méthode <code>setRawData()</code>. Cette méthode accepte deux paramètres : le premier contient les données à
        transmettre dans le corps de la requête. Le deuxième paramètre, optionnel, contient le type des données. Bien
        que ce paramètre soit optionnel, vous devriez normalement le définir avant l'envoi de la requête, soit via
        setRawData() ou via la méthode <code>setEncType()</code>. <example id="zend.http.client.raw_post_data.example-1">
                <title>Envoi de données brutes via POST</title>

                <programlisting role="php"><![CDATA[
$xml = '<book>' .
       '  <title>Islands in the Stream</title>' .
       '  <author>Ernest Hemingway</author>' .
       '  <year>1970</year>' .
       '</book>';

$client->setRawData($xml, 'text/xml')->request('POST');

// Une autre manière de faire la même chose :
$client->setRawData($xml)->setEncType('text/xml')->request('POST');
]]></programlisting>
            </example> Les données seront disponible côté serveur via la variable PHP <code>$HTTP_RAW_POST_DATA</code>
        ou via le flux php://input.</para>

        <note>
            <title>Utiliser des données brutes POST</title>

            <para>Définir des données brutes POST pour une requête écrasera tout autre paramètre POST ou envoi de
            fichiers. Il est recommandé de ne pas utiliser les deux conjointement. Gardez à l'esprit que la plupart des
            serveurs ignoreront le corps de la requête si celle-ci n'utilise pas la méthode POST.</para>
        </note>
    </sect2>

    <sect2 id="zend.http.client.http_authentication">
        <title>Authentification HTTP</title>

        <para>Actuellement, <classname>Zend_Http_Client</classname> propose uniquement l'authentification HTTP "basic". Cette
        fonctionnalité est utilisée via la méthode <code>setAuth()</code>. Celle-ci accepte trois paramètres : le nom
        d'utilisateur, le mot de passe et un type d'authentification optionnel. Comme mentionné, seule
        l'authentification "basic" est actuellement implémentée (l'ajout de l'authentification "digest" est planifié).
        <example id="zend.http.client.http_authentication.example-1">
                <title>Définir nom d'utilisateur et mot de passe pour l'authentification HTTP</title>

                <programlisting role="php"><![CDATA[
// Utilisation de l'authentification 'basic'
$client->setAuth('shahar',
                 'monMotdePasse!',
                 Zend_Http_Client::AUTH_BASIC);

// L'authentification 'basic' étant le comportement par défaut,
// on peut aussi écrire ceci :
$client->setAuth('shahar', 'monMotdePasse!');
]]></programlisting>
            </example></para>
    </sect2>

    <sect2 id="zend.http.client.multiple_requests">
        <title>Envoyer plusieurs requêtes avec le même client</title>

        <para><classname>Zend_Http_Client</classname> a été également conçu spécifiquement pour gérer plusieurs requêtes
        consécutives avec la même instance. Ceci est utile dans les cas ou le script nécessite d'accéder à des données
        en provenance de divers emplacements ou, par exemple, lors de l'accès à des ressources HTTP nécessitant une
        authentification préalable.</para>

        <para>Lorsqu'on génère plusieurs requêtes vers le même hôte, il est chaudement recommandé d'activer la variable
        de configuration "keepalive". De cette manière, si le serveur supporte le mode de connexion "keep-alive", la
        connexion au serveur sera fermée après l'exécution de toutes les requêtes et la destruction de l'instance. Ceci
        permet d'éviter au serveur d'ouvrir et de fermer de multiples connexions TCP.</para>

        <para>Lorsqu'on génère plusieurs requêtes avec le même client, mais qu'on souhaite s'assurer que tous les
        paramètres spécifiques de chacune des requêtes sont effacés, on peut utiliser la méthode
        <code>resetParameters()</code>. Ceci permet de supprimer tous les paramètres GET et POST, le contenu des
        requêtes et les en-têtes spécifiques de manière à ce qu'ils ne soient pas réutilisés lors de la requête
        suivante.</para>

        <note>
            <title>Réinitialiser les paramètres</title>

            <para>Notez que les en-têtes spécifiques non liés à la requête ne sont pas réinitialisés quand la méthode
            <code>resetParameters</code> est invoquée. En fait, seuls les en-têtes "Content-length" et "Content-type"
            sont supprimés. Ceci permet de définir une seule fois les en-têtes comme "Accept-language" ou
            "Accept-encoding".</para>
        </note>

        <para>Une autre fonctionnalité spécifique aux requêtes consécutives est l'objet Magasin de Cookies ("Cookie
        Jar"). Il permet de sauver automatiquement les cookies définis par le serveur lors de la première requête et de
        les renvoyer de manière transparente lors de chacune des requêtes suivantes. Ceci permet, par exemple, de passer
        une étape d'authentification avant d'envoyer d'autres requêtes.</para>

        <para>Si votre application nécessite une requête d'authentification par utilisateur, et que d'autres requêtes
        peuvent être effectuées via plusieurs scripts différents, il peut se révéler pratique de stocker le Magasin de
        cookies dans la session utilisateur. De cette manière, il sera possible de ne s'identifier qu'une seule fois par
        session.</para>

        <example id="zend.http.client.multiple_requests.example-1">
            <title>Exécuter plusieurs requêtes avec un seul client</title>

            <programlisting role="php"><![CDATA[
// D'abord, instancier le client
$client =
    new Zend_Http_Client('http://www.exemple.com/obtientdonnees.php',
                         array('keepalive' => true));

// Disposons-nous du cookie de session ?
if (isset($_SESSION['cookiejar']) &&
    $_SESSION['cookiejar'] instanceof Zend_Http_CookieJar)) {

    $client->setCookieJar($_SESSION['cookiejar']);
} else {
    // Sinon, Identifions-nous et stockons le cookie
    $client->setCookieJar();
    $client->setUri('http://www.exemple.com/connexion.php');
    $client->setParameterPost(array(
        'user' => 'shahar',
        'pass' => 'secret'
    ));
    $client->request(Zend_Http_Client::POST);

    // Maintenant, effaçons les paramètres et définissons l'URI
    // à sa valeur originale (notez que les cookies envoyés par le
    // serveur sont stockés dans le magasin de cookies)
    $client->resetParameters();
    $client->setUri('http://www.exemple.com/obtientdonnees.php');
}

$reponse = $client->request(Zend_Http_Client::GET);

// Stockons les cookies dans la session pour la page suivante
$_SESSION['cookiejar'] = $client->getCookieJar();
]]></programlisting>
        </example>
    </sect2>
</sect1>