Witam

Szukałem ostatnio jak ładnie("Zendowo" ) zrobić cache dla wyników z bazy, jednak nic nie znalazłem.
Wpadłem na pomysł aby zrobić klasę (abstract) która będzie zarządzać całością.

Obrazowo

Klasa która zarządza cache

[PHP] pobierz, plaintext 
abstract class cacheDlaSql
{
 protected $_cache = null;
 protected $_db;
 
 public function __construct($db,$cache=null)
 {
  $this->_db = $db;
  if(isinstanceof(Zend_Cache....))
   $this->_cache = $cache;
 }
 
 protected _query(Zend_Db_Select $select, $typ = 'fetchAll')
 {
  if($_cache)
  {
   $cacheName = md5($select->assemble());
   //Jest cache
  //
  }
  else
  {
   // Brak cache
   // Normalne zapytanie
 }
 
 // Inne funkcje (kasowanie etc.)
}
[PHP] pobierz, plaintext 

Zwykła klasa

[PHP] pobierz, plaintext 
class Portal_Newsy extends cacheDlaSql
{
 public function dajMiNewsa($id)
 {
  $select = $this->_db->select()
   ->from(....);
 
  return $this->_query($select);
 }
}
[PHP] pobierz, plaintext 

Co myślicie o takim rozwiązaniu ?

Pozdrawiam

mi się wydaje że lepiej pozostać przy standardowym rozwiązaniu zenda, sam je stosuje i nigdy nie ma problemu

[PHP] pobierz, plaintext 
class Model_Newsy extends Zend_Db_Table {
 protected $_name = 'newsy';
 
 public function dajMiNewsa($id) {
     $cache = Zend_Registry::get('cache'); // tu mamy cache zdefiniowane w bootstrapie
     if ($news = $cache->load('news_'.$id)  {
         $news = $this->find($id)->current();
         $cache -> save($news, 'news_'.$id);
     }
     return $news;
 }
 
}
[PHP] pobierz, plaintext 

jeśli jednak postanowisz dalej kontynuować tworzenie własnej klasy to uwzględnij fakt że nie każde zapytanie powinno być cachowane

ja również uważam ze klasyczne użycie zend_cache jest lepsze. Kiedyś starałem się napisać obszerną klasę do cachowania wsystkiego co leciało z bazy. W praktyce zabrakło tam takiej logiki jak uwzględnienie "NOW()", "RAND()" w zapytaniach i założenie poległo.

Dużo lepiej jest cachować dane, dopiero w sytuacji gdy wymaga tego sytuacja. Zend_Cache nadaje się do tego idealnie. W momencie kiedy aplikacja pokazuje wąskie gardło, w którejś swojej części, to za nią zabieramy się, odpowiednio cachując dane. Pamiętaj żeby nie optymalizować tego, co nie sprawia problemów.

Może niejasno wyraziłem się w poprzednim poście.

Zend_Db_Table jeszcze nie używam (nie znalazłem dobrego przykładu, który by mi dokładnie wytłumaczył )

Oczywiście używam Zend_Cache, tylko chodzi mi o sposób w jaki to robie:

[PHP] pobierz, plaintext 
/**
* @category Portal
* @package Portal_News
*/
class Portal_News extends Aquila_Model_Cache_MySql implements Portal_News_Interface
{              
/**
* Zwraca informacje o konkretnym newsie
*
* @param int $newsId
* @param array $options
* @return array
*/
public function getId($newsId,array $options = array())
{
$newsId = (int)$newsId;
 
$query = $this->_db->select()
->from(array('n'=>'news'),'n_date')
->joinLeft(array('nt' => 'newstext'),'nt.n_id = n.n_id',array('nt_title','nt_text'))
->joinLeft(array('m' => 'members'),'m.m_id = n.m_id',array('m_id','m_name'))
->where('n.n_id = ?', $newsId)
->limit(1);
 
if(array_key_exists('language', $options))
$query->where('nt.l_id = ?', $options['language']);
 
return $this->_select($query,'fetchRow');
}
}
[PHP] pobierz, plaintext 

Klasa "obsługi" cache

[PHP] pobierz, plaintext 
abstract class Aquila_Model_Cache_MySql
{
/**
* @var Zend_Db_Adapter_Pdo_Abstract
*/
protected $_db;
 
/**
* @var Zend_Cache_Core
*/
protected $_cache;
 
/**
* Konstruktor
*
* @param Zend_Db_Adapter $db
* @param Zend_Cache_Adapter $cache
* @return Aquila_Model_Cache
*/
public function __construct(Zend_Db_Adapter_Pdo_Abstract $db, Zend_Cache_Core $cache = null)
{    
$this->_db = $db;
$this->_cache = $cache;
}
 
/**
* Zapytanie
*
* @param Zend_Db_Select $select
* @param string $fetchMode
* @param array $options
* @return array
*/
protected function _select(Zend_Db_Select $select, $fetchMode = 'fetchAll', array $options = array())
{
if($this->_cache)
{              
$cacheName = md5($select->assemble());
 
if($data = $this->_cache->load($cacheName))
{
return $data;
}
}
 
 
switch($fetchMode)
{
case 'fetchAssoc':
$data = $this->_db->fetchAssoc($select);
break;
 
case 'fetchCol':
$data = $this->_db->fetchCol($select);
break;
 
case 'fetchfetchOne':
$data = $this->_db->fetchOne($select);
break;
 
case 'fetchPairs':
$data = $this->_db->fetchPairs($select);
break;
 
case 'fetchRow':
$data = $this->_db->fetchRow($select);
break;
 
case 'fetchAll':
default:
$data = $this->_db->fetchAll($select);
break;
}
 
if($this->_cache)
{
$this->_cache->save($data, $cacheName);
}
 
return $data;
}
}
[PHP] pobierz, plaintext 

Jeżeli zapytanie zapisuje wynik do cache to używam funkcji _select.
Zapytania bez cache, wywołuje bezpośrednio $this->_db->fetch...()

Pozdrawiam.

Polecam przeczytać to:
http://www.contentwithstyle.co.uk/content/...tern-for-models
Ciekawy sposób dorzucenia cache do modelu.