Comment implémenter Memcached avec PDO

Question

Dois-je modifier chaque requête de mon application pour pouvoir utiliser Memcached?

J'utilise cette classe de DB à partir d'un tutoriel AOP:

class DB { 

private static $host; 
private static $dbName; 
private static $user; 
private static $password; 

/*** Declare instance ***/ 
private static $instance = NULL; 

/** 
* 
* the constructor is set to private so 
* so nobody can create a new instance using new 
* 
*/ 
private function __construct() {} 

/** 
* 
* Return DB instance or create intitial connection 
* @return object (PDO) 
* @access public 
* 
*/ 
public static function getInstance() { 

    if (!self::$instance){ 
     self::$instance = new PDO("mysql:host=".self::$host.";dbname=".self::$dbName, self::$user, self::$password); 
     self::$instance-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
    } 
    return self::$instance; 
} 

/** 
* 
* Like the constructor, we make __clone private 
* so nobody can clone the instance 
* 
*/ 
private function __clone(){} 

} /*** end of class ***/ 

est-il un bon moyen facile de le modifier pour incorporer Memcached?

Answer 1

Tout d'abord je re la structure de votre classe pour étendre la classe AOP comme ceci:

class Database extends PDO 
{ 
    /** 
    * 
    * the constructor is set to private so 
    * so nobody can create a new instance using new 
    * 
    */ 
    private static $Instance; 
    public $Cache = null; 

    public function Instance() 
    { 
     if(self::$Instance === null) 
     { 
      self::$Instance = new Database; 
      self::$Instance->Cache = new Memcached; 
     } 
     return self::$Instance; 
    } 

    public function __construct() 
    { 
     parent::__construct("Connection;String"); 
     $this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('DBStatement', array(&$this))); 
    } 
} 

---

class DBStatement extends PDOStatement 
{ 
    public $db; 

    protected function __construct(&$db) 
    { 
     $this->db =& $db; 
    } 
    /* 
     * PDO Methods! 
    */ 

    public function rowCount() 
    { 
        return $this->foundRows; 
    } 

     public function execute($array = null) 
    { 
         if ($array === null) 
         { 
             $result = parent::execute(); 
         }else 
     { 
            $result = parent :: execute($array); 
        } 
     return $result; 
    } 
} 

Ensuite, les méthodes seraient surchargée comme l'exemple dans la DBStatement de classe ci-dessus, exécuter . Chaque méthode qui renvoie un ensemble de résultats vous obligerait md5 la requête à créer un hachage unique pour cette requête, vous vérifieriez ensuite si elle existe dans le cache, si c'est le cas, vous reviendriez à la place, sinon exécuter une nouvelle requête pour extraire les résultats, puis les stocker dans le cache avant de les renvoyer