Un adaptateur Zend_Auth est utilisé pour authentifier en utilisant un service d'authentification, tél que LDAP, RDBMS ou un stockage basé sur des fichiers. Les différents adaptateurs possèdent vraisemblablement des options et des comportements très divers. Cependant, quelques méthodes de base leur sont communes. Par exemple, le fait d'accepter des éléments d'authentification (incluant une identité prétendue), d'authentifier et de retourner un résultat sont des éléments communs aux adapateurs Zend_Auth.

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

L'exemple suivant est un adaptateur d'authentification qui requiert un identifiant et un mot de passe. D'autres détails, tel que la manière d'interroger le service d'authentification, ont été omis par souci de clarté :

<?php
require_once 'Zend/Auth/Adapter/Interface.php';

class MonAdaptateurAuth implements Zend_Auth_Adapter_Interface
{
    /**
     * Définition de l'identifiant et du mot de passe pour authentification
     *
     * @return void
     */
    public function __construct($identifiant, $motdepasse)
    {
        // ...
    }

    /**
     * Réalise une tentative d'authentification
     *
     * @throws Zend_Auth_Adapter_Exception si l'authentification ne peut pas être réalisée
     * @return Zend_Auth_Result
     */
    public function authenticate()
    {
        // ...
    }
}

Comme indiqué dans le bloc de documentation, authenticate() doit retourner une instance de Zend_Auth_Result (ou d'une classe derivée de Zend_Auth_Result). Si pour quelque raison que ce soit, la requête d'authentification ne peut pas être réalisée, authenticate() lancera une exception dérivée de Zend_Auth_Adapter_Exception.

Les adaptateurs Zend_Auth retournent une instance de Zend_Auth_Result via authenticate() de manière à présenter les résultats d'une tentative d'authentification. Les adaptateurs alimentent l'objet Zend_Auth_Result lors de sa construction, de manière à ce que les trois méthodes suivantes fournissent un lot de base d'opérations communes aux résultats des adaptateurs Zend_Auth :

Authentifier une requête qui contient des paramètres d'authentification est utiles en soi, mais il est également important de permettre le maintient de l'identité authentifiée sans avoir à présenter ces paramètres d'authentification à chaque requête.

HTTP est un protocole sans état, cependant, des techniques telles que les cookies ou les sessions ont été développées de manière à faciliter le maintien d'un contexte lors de multiples requêtes dans les applications web. Zend_Session est utilisé par Zend_Auth pour fournir un stockage persistant de l'identité, après une authentification réussie, via les sessions PHP.

Après une authentification réussis, Zend_Auth::authenticate() conserve l'identité résultant de l'authentification dans un stockage persistant. Par défaut, Zend_Auth utilise une classe de stockage basée sur Zend_Session. La classe de stockage peut être changée en fournissant un objet de stockage différent à Zend_Auth::setStorage().

Si la persistance automatique de l'identité n'est pas souhaitable dans un cas particulier, alors le développeur peut renoncer à utiliser la classe Zend_Auth et préférer utiliser directement une classe adaptateur.

Deux manières d'utiliser les adaptateurs Zend_Auth sont fournies

L'exemple suivant illustre la manière d'utiliser un adaptateur Zend_Auth de manière indirecte via l'utilisation de la classe Zend_Auth :

<?php
// Obtention d'une référence au l'instance Singleton de Zend_Auth
require_once 'Zend/Auth.php';
$auth = Zend_Auth::getInstance();

// Définition de l'adaptateur d'authentication
$authAdaptateur = new MonAdaptateurAuth($identifiant, $motdepasse);

// Tentative d'authentification et stockage du résultat
$resultat = $auth->authenticate($authAdaptateur);

if (!$resultat->isValid()) {
    // échec de l'authentication ; afficher pourquoi 
    foreach ($resultat->getMessages() as $message) {
        echo "$message\n";
    }
} else {
    // Authentication réussie ; l'identité ($identifiant) est stockée dans la session
    // $resultat->getIdentity() === $auth->getIdentity()
    // $resultat->getIdentity() === $identifiant
}

Une fois la tentative d'authentification réalisée, tél que montré ci-dessus, il est très simple de vérifier si une identité correctement authentifiée existe :

<?php
$auth = Zend_Auth::getInstance();
if ($auth->hasIdentity()) {
    // l'identité existe ; on la récupère
    $identite = $auth->getIdentity();
}

Pour retirer une identité du stockage persistant, utilisez simplement la méthode clearIdentity(). A utiliser typiquement pour implémenter une opération de déconnexion d'une application :

<?php
Zend_Auth::getInstance()->clearIdentity();

Quand l'utilisation automatique du stockage persistant n'est pas appropriée, le développeur peut simplement contourner l'utilisation de la classe Zend_Auth en utilisant directement une classe adaptateur. L'usage direct d'une classe adaptateur implique de configurer et préparer l'objet de l'adaptateur et d'appeler ensuite sa méthode authenticate(). Les détails spécifiques à un adaptateur sont décrits dans la documentation de chacun d'entre-eux. L'exemple suivant utilise directement MonAdaptateurAuth :

<?php
// Définition de l'adaptateur d'authentification
$authAdaptateur = new MonAdaptateurAuth($identifiant, $motdepasse);

// Tentative d'authentification, stockage du résultat
$resultat = $authAdaptateur->authenticate();

if (!$resultat->isValid()) {
    // échec de l'authentication ; afficher pourquoi 
    foreach ($resultat->getMessages() as $message) {
        echo "$message\n";
    }
} else {
    // Authentification réussie
    // $resultat->getIdentity() === $identifiant
}