This meant 2 things for me:

• The solution needed to be able to take on existing models with minimum effort, and a strong convention
• I wanted to see in the controller if I was caching or not, and have an easy way of of toggling between the two in debugging.

If you were to build an application from scratch, and you knew exactly which data sources to cache, you might want to integrate the caching into your model, but in my case I'm iterating over the code base over and over again, refactoring and improving in small steps on a constant basis, and this is where I feel the approach was perfect.

class BaseModelCache {
  private $object = null;
  private $cache = null;
  private $__objectMethods = null;
  
  public function __construct($object) {
    $backendName = 'File';
    $frontendName = 'Class';

    $frontendOptions = array(
      'lifetime' => 1800,
    );

    $backendOptions = array(
      'cache_dir' => '/my/cache/dir/',
    );

    $this->object = $object;
    // for initialization you can call $this->_getObjectMethods() here

    $frontendOptions['cached_entity'] = $object;

    try {
      Zend_Loader::loadClass('Zend_Cache');
      $this->cache = Zend_Cache::factory($frontendName, $backendName, $frontendOptions, $backendOptions);     
    } catch(Exception $e) {
      throw($e);
    }
  }
  
  public function __call($method, $args) {
    $class_methods = $this->_getObjectMethods();

    if(in_array($method , $class_methods)) {
        $caller = Array($this->cache, $method);
        return call_user_func_array($caller, $args);
    }

    throw new Exception( " Method " . $method . " does not exist in this class " . get_class($class ) . "." );
  }

  /**
   * returns object methods
   * @return array
   */
  protected function _getObjectMethods()
  {
    if ($this->__objectMethods === null && $this->object !== null)
    {
      $class = get_class($this->object);
      $this->__objectMethods = get_class_methods($class);
    }
    return $this->__objectMethods;
  }
}

So you do not have to call the same methods again and again, because the information about the existing class methods never change within the runtime. But if so (maybe you have a dynamic linking plugin object, you can return the get_class_methods() result instead of setting the internal $__objectMethods - maybe per param flag for the method.

A really nice solution, but not applicable in my projects.

If you're looking to create a more granular caching/uncaching, that gives you control over what you delete record by record, you might want to have a look into the use of tags. Zend_Cache_Class has a function called setTagsArray(), and the clear() also takes tags as an optional parameter.

class Test extends BaseModel
{
    private $_hoho = NULL;

    public function __construct($hoho)
    {
        $this->_hoho = $hoho;
        parent::__construct();
    }

    public function foo($bar)
    {
        return $this->_hoho . '_' . $bar;
    }
}

$test = new Test('test1');
echo $test->cache->foo('teststring');

$test = new Test('test2');
echo $test->cache->foo('teststring');

-----

will return:
_teststring
_teststring

and not:
test1_teststring
test2_teststring

I can work around, when setting cachedEntityLabel by myself, but this property of the Zend_Cache_Frontend_Class is set to private. So how would you cache objects with different constructor params?

here is my proposal, I got already some properties from my config object. this will work, but i didn't wrote any unit tests, yet. please feel free to contact me:

abstract class BaseModel
{
    public $cache;

    public function __construct($frontendOptions = array(), $backendOptions = array())
    {
        $this->cache = new BaseModelCache($this, $frontendOptions, $backendOptions);
    }

    public function setCacheSuffix($suffix)
    {
        $this->cache->setCacheSuffix($suffix);
    }

    public function clean($mode = 'all', $tags = array())
    {
        $this->cache->clean($mode, $tags);
    }

    public function setTagsArray($tags = array())
    {
        $this->cache->setTagsArray($tags);
    }

    public function setPriority($priority)
    {
        $this->cache->setPriority($priority);
    }

    public function setLifetime($lifetime = false)
    {
        $this->cache->setLifetime($lifetime);
    }

}

class BaseModelCache
{
    protected $_object = null;
    protected $_cache = null;

    protected $_cacheByDefault = NULL;
    protected $_objectMethods = null;
    protected $_frontendOptions = array();
    protected $_backendOptions = array();
    protected $_backendName = NULL;
    protected $_defaultCacheIdPrefix = '';
    protected $_lifetime = NULL;

    /**
     * the constructor
     *
     * @param mixed $object
     */
    public function __construct ($object, $frontendOptions = array(), $backendOptios = array())
    {
        if (!Zend_Registry::isRegistered('Zend_Config'))
        {
            throw new Project_Exception('Zend_Config is not registered in Zend_Registry.');
        }

        $this->_object = $object;

        $this->_cacheByDefault = Zend_Registry::get('Zend_Config')->caching->cache_by_default;
        $this->_defaultCacheIdPrefix = Zend_Registry::get('Zend_Config')->caching->default_cache_id_prefix;
        $this->_lifetime = Zend_Registry::get('Zend_Config')->caching->lifetime;
        $this->_backendName = Zend_Registry::get('Zend_Config')->caching->backendName;

        $this->setFrontendOptions($frontendOptions)
             ->setBackendOptions($backendOptios);

        try
        {
            $this->_cache = Zend_Cache::factory('Class', $this->_backendName, $this->_frontendOptions, $this->_backendOptions);
        }
        catch (Zend_Cache_Exception $e)
        {
            throw ($e);
        }
        return $this;
    }

    /**
     * the main method, calls the models from cache
     *
     * @param $method
     * @param $args
     * @return unknown
     */
    public function __call ($method, $args)
    {
        $class_methods = $this->_getObjectMethods();
        if (in_array($method, $class_methods))
        {
            $caller = array($this->_cache , $method);
            return call_user_func_array($caller, $args);
        }
        throw new Exception("Method " . $method . " does not exist in this class " . get_class($class) . ".");
    }

    /**
     * returns object methods
     * @return array
     */
    protected function _getObjectMethods ()
    {
        if ($this->_objectMethods === null && $this->_object !== null)
        {
            $class = get_class($this->_object);
            $this->_objectMethods = get_class_methods($class);
        }
        return $this->_objectMethods;
    }


    /**
     * sets the FrontendOptions for the Cache Frontend
     *
     * @param array $frontendOptions
     * @return BaseModelCache
     */
    protected function setFrontendOptions($frontendOptions)
    {
        if (is_array($frontendOptions))
        {
            if (!isset($frontendOptions['cache_id_prefix']))
            {
                $frontendOptions['cache_id_prefix'] = $this->_defaultCacheIdPrefix;
            }
            if (!isset($frontendOptions['lifetime']))
            {
                $frontendOptions['lifetime'] = $this->_lifetime;
            }
            if (!isset($frontendOptions['cached_entity']))
            {
                $frontendOptions['cached_entity'] = $this->_object;
            }
            $this->_frontendOptions = $frontendOptions;
        }
        else
        {
            throw new Zend_Cache_Exception('frontendOptions must be an array.');
        }
        return $this;

    }

    /**
     * sets the BackendOptions for the Cache Backend
     *
     * @param array $backendOptions
     * @return BaseModelCache
     */
    protected function setBackendOptions($backendOptions)
    {
        if (is_array($backendOptions))
        {
            if (!in_array('cache_dir', $backendOptions) && $this->_backendName = 'File')
            {
                $backendOptions['cache_dir'] = APP_PATH . Zend_Registry::get('Zend_Config')->caching->cache_dir;
            }
            $this->_backendOptions = $backendOptions;
        }
        else
        {
            throw new Zend_Cache_Exception('backendOptions must be an array.');
        }
        return $this;
    }

    public function setCacheSuffix($suffix)
    {
        if (!is_string($suffix))
        {
            throw new Exception('Cache Suffix must be a string');
        }
        $cachePrefix = Zend_Registry::get('Zend_Config')->caching->default_cache_id_prefix;
        $this->_cache->setOption('cache_id_prefix', $cachePrefix . $suffix . '_');
    }

    public function clean($mode = 'all', $tags = array())
    {
        $this->_cache->clean($mode, $tags);
    }

    public function setTagsArray($tags = array())
    {
        $this->_cache->setTagsArray($tags);
    }

    public function setPriority($priority)
    {
        $this->_cache->setPriority($priority);
    }

    public function setLifetime($lifetime = false)
    {
        $this->_cache->setLifetime($lifetime);
    }
}

class Test extends BaseModel
{

    private $_hoho = NULL;

    public function __construct($hoho)
    {
        $this->_hoho = $hoho;
        parent::__construct();

    }

    public function foo($bar)
    {
        for ($i = 0; $i < 1000000; $i++)
        {
        }
        return $this->_hoho . '_' . $bar;
    }
}

$a = new Test('hey');
$a->setCacheSuffix('hey');
echo 'non-cached: '.$a->foo('hh') . '';
echo 'cached: '.$a->cache->foo('hh') .'';

$b = new aTest('wiki');
$b->setCacheSuffix('wiki');
echo 'non-cached: '.$b->foo('hh'). '';
echo 'cached: '.$b->cache->foo('hh'). '';

you can create the suffix dynamically, but i would prefer not to do so. The Problem is that sometimes you give an object to the constructor and then you have to serialize the whole object to create a cache suffix, and that is too much, i guess. It seems to be better, when you create the suffix manually.

By the way, I made a mistake in the code above. the BaseModel.php won't need the setCacheSuffix, clean, setTagsArray, setPriority & setLifetime methods, because the cache property is public, so you can call it like this:

$a = new Test('foo');
$a->cache->setCacheSuffix('foo');
$a->cache->foo('teststring');

this will work, but serializing big and heavy objects like Zend_Date f.e. will take a lot of time.

But, if you like, you can use this:

class aTest extends BaseModel
{
   public function __construct($hoho)
   {
       $this->_hoho = $hoho;
       $args = func_get_args();
       parent::__construct(array(), array(), $args);
   }
}

abstract class BaseModel
{
    public $cache;

    public function __construct($frontendOptions = array(), $backendOptions = array(), $childParams = array())
    {
        $this->cache = new BaseModelCache($this, $frontendOptions, $backendOptions);
        $this->cache->setCacheSuffix(md5(serialize($childParams)));
    }

}

Adding public function 'cache' to an existing model wolud be much simpler than extending.

class MyModel extend aBaseModelObject
{
  public function doSomething()
  {
    return 'resultFromComplexDatabaseQuery';
  }
	
  public function cache()
  {
    return new BaseModelCache($this);
  }
}

Just played around with this the last couple hours.

Its nice but not perfekt. eg. you cant use findParentRow or getDependentRowset when the Zend_Db_Table_Row is cached.

You can get around this by using a own Zend_Db_Table_Row class which overrides setTable. (you can not just set "setTable" couse you loose the _tableClass property, and this is checked in setTable.

If you got around this you fall into your next problem. The ID which is generated by "Zend_Cache_Frontend_Class::_makeId" dont take the contents of the object in account. so if you loop through a rowset and use findDependentRowset in this loop, it will always return the same contents, because the ID generated for it is always the same.

For replication here are the classes I used:

class Cwd_Db_Cache {
 // see comment by Robert Kummer 
 // http://www.contentwithstyle.co.uk/content/a-caching-pattern-for-models#comment-5876
}

forgot to add the (quick & dirty) test case: The setTable call is neccessary if the row object cames from cache. (trying to figure out a way to do this automaticly)

$m_event = new EventModel();
$events = $m_event->cache->fetchAll(array("status='1'","deleted='0'"),'createdate desc',10,0);
echo "<ul>";
foreach($events as $event){
	echo "<li>".$event->event_id."</li>";	    			
	$event->setTable($m_event);    			
	$acts = $event->cache->findDependentRowset('ActModel');
	echo "<ul>";
	foreach($acts as $act){
		echo "<li>".$act->act_id."</li>";
	}	    		
	echo "</ul>";	    		
}
echo "</ul>";     

Is the ID problem similar to what Sascha-Oliver described? Maybe when I have spare time, I will have a ponder and see what I can come up with ...

With the version of Sascha-Oliver i was able to get around this. but its not a very beautiful solution.

The nice thing about it, it doesnt matter whats in the cache and what is fetched from the db. all combinations are working.

$m_event = new EventModel();
$m_act = new ActModel();
$events = $m_event->cache->fetchAll(array("status='1'","deleted='0'"),'createdate desc',10,0);
echo "<ul>";
foreach($events as $event){
	echo "<li>".$event->event_id."</li>";	    			
	$event->setTable($m_event);
	$event->cache->setCacheSuffix('eventid_'.$event->event_id);
	
	$acts = $event->cache->findDependentRowset('ActModel');
	echo "<ul>";
	foreach($acts as $act){	    			
		$act->setTable($m_act);
		$act->cache->setCacheSuffix('actid_'.$act->act_id);
		$foo = $act->cache->findParentRow('EventModel');
		echo "<li>".$act->act_id." (".$foo->event_id.")</li>";
	}	    		
	echo "</ul>"; 	    		
}
echo "</ul>";

You can find the classes at http://svn.cwd.at/cwd/trunk/Cwd/