Kohana_Cache
Kohana Cache provides a common interface to a variety of caching engines. Tags are supported where available natively to the cache system. Kohana Cache supports multiple instances of cache engines through a grouped singleton pattern.
Supported cache engines
Introduction to caching
Caching should be implemented with consideration. Generally, caching the result of resources is faster than reprocessing them. Choosing what, how and when to cache is vital. PHP APC is presently one of the fastest caching systems available, closely followed by Memcache. SQLite and File caching are two of the slowest cache methods, however usually faster than reprocessing a complex set of instructions.
Caching engines that use memory are considerably faster than the file based alternatives. But memory is limited whereas disk space is plentiful. If caching large datasets it is best to use file caching.
Configuration settings
Kohana Cache uses configuration groups to create cache instances. A configuration group can use any supported driver, with successive groups using the same driver type if required.
Configuration example
Below is an example of a memcache server configuration.
return array(
'memcache' => array( // Name of group
'driver' => 'memcache', // using Memcache driver
'servers' => array( // Available server definitions
array(
'host' => 'localhost',
'port' => 11211,
'persistent' => FALSE
)
),
'compression' => FALSE, // Use compression?
),
)
In cases where only one cache group is required, set Cache::$default (in your bootstrap,
or by extending Kohana_Cache class) to the name of the group, and use:
$cache = Cache::instance(); // instead of Cache::instance('memcache')
It will return the cache instance of the group it has been set in Cache::$default.
General cache group configuration settings
Below are the settings available to all types of cache driver.
| Name | Required | Description |
|---|---|---|
| driver | YES | (string) The driver type to use |
Details of the settings specific to each driver are available within the drivers documentation.
System requirements
- Kohana 3.0.x
- PHP 5.2.4 or greater
Constants
Properties
Constants
-
DEFAULT_EXPIRE
integer 3600
Properties
-
public static string $default
-
default driver to use
-
string(4) "file" -
public static Kohana_Cache $instances
-
instances
-
array(0) -
protected Config $_config
-
Default value:
array(0)
Methods
final public __clone() (defined in Kohana_Cache)
Overload the __clone() method to prevent cloning
Tags
Return Values
- void
Source Code
final public function __clone()
{
throw new Cache_Exception('Cloning of Kohana_Cache objects is forbidden');
}
public config([ mixed $key = NULL , mixed $value = NULL ] ) (defined in Kohana_Cache)
Getter and setter for the configuration. If no argument provided, the current configuration is returned. Otherwise the configuration is set to this class.
// Overwrite all configuration
$cache->config(array('driver' => 'memcache', '...'));
// Set a new configuration setting
$cache->config('servers', array(
'foo' => 'bar',
'...'
));
// Get a configuration setting
$servers = $cache->config('servers);
Parameters
- mixed $key = NULL - Key to set to array, either array or config path
- mixed $value = NULL - Value to associate with key
Return Values
- mixed
Source Code
public function config($key = NULL, $value = NULL)
{
if ($key === NULL)
return $this->_config;
if (is_array($key))
{
$this->_config = $key;
}
else
{
if ($value === NULL)
return Arr::get($this->_config, $key);
$this->_config[$key] = $value;
}
return $this;
}
abstract public delete(string $id ) (defined in Kohana_Cache)
Delete a cache entry based on id
// Delete 'foo' entry from the default group
Cache::instance()->delete('foo');
// Delete 'foo' entry from the memcache group
Cache::instance('memcache')->delete('foo')
Parameters
- string $id required - Id to remove from cache
Return Values
- boolean
Source Code
abstract public function delete($id);
abstract public delete_all() (defined in Kohana_Cache)
Delete all cache entries.
Beware of using this method when using shared memory cache systems, as it will wipe every entry within the system for all clients.
// Delete all cache entries in the default group
Cache::instance()->delete_all();
// Delete all cache entries in the memcache group
Cache::instance('memcache')->delete_all();
Return Values
- boolean
Source Code
abstract public function delete_all();
abstract public get(string $id [, string $default = NULL ] ) (defined in Kohana_Cache)
Retrieve a cached value entry by id.
// Retrieve cache entry from default group
$data = Cache::instance()->get('foo');
// Retrieve cache entry from default group and return 'bar' if miss
$data = Cache::instance()->get('foo', 'bar');
// Retrieve cache entry from memcache group
$data = Cache::instance('memcache')->get('foo');
Parameters
- string $id required - Id of cache to entry
- string $default = NULL - Default value to return if cache miss
Tags
Return Values
- mixed
Source Code
abstract public function get($id, $default = NULL);
public static instance([ string $group = NULL ] ) (defined in Kohana_Cache)
Creates a singleton of a Kohana Cache group. If no group is supplied the default cache group is used.
// Create an instance of the default group
$default_group = Cache::instance();
// Create an instance of a group
$foo_group = Cache::instance('foo');
// Access an instantiated group directly
$foo_group = Cache::$instances['default'];
Parameters
- string $group = NULL - The name of the cache group to use [Optional]
Tags
Return Values
- Cache
Source Code
public static function instance($group = NULL)
{
// If there is no group supplied, try to get it from the config
if ($group === NULL)
{
$group = Kohana::$config->load('cache.default');
}
// If there is no group supplied
if ($group === NULL)
{
// Use the default setting
$group = Cache::$default;
}
if (isset(Cache::$instances[$group]))
{
// Return the current group if initiated already
return Cache::$instances[$group];
}
$config = Kohana::$config->load('cache');
if ( ! $config->offsetExists($group))
{
throw new Cache_Exception(
'Failed to load Kohana Cache group: :group',
[':group' => $group]
);
}
$config = $config->get($group);
// Create a new cache type instance
$cache_class = 'Cache_'.ucfirst($config['driver']);
Cache::$instances[$group] = new $cache_class($config);
// Return the instance
return Cache::$instances[$group];
}
abstract public set(string $id , string $data [, integer $lifetime = integer 3600 ] ) (defined in Kohana_Cache)
Set a value to cache with id and lifetime
$data = 'bar';
// Set 'bar' to 'foo' in default group, using default expiry
Cache::instance()->set('foo', $data);
// Set 'bar' to 'foo' in default group for 30 seconds
Cache::instance()->set('foo', $data, 30);
// Set 'bar' to 'foo' in memcache group for 10 minutes
if (Cache::instance('memcache')->set('foo', $data, 600))
{
// Cache was set successfully
return
}
Parameters
- string $id required - Id of cache entry
- string $data required - Data to set to cache
- integer $lifetime = integer 3600 - Lifetime in seconds
Return Values
- boolean
Source Code
abstract public function set($id, $data, $lifetime = 3600);
protected __construct(array $config ) (defined in Kohana_Cache)
Ensures singleton pattern is observed, loads the default expiry
Parameters
- array $config required - Configuration
Source Code
protected function __construct(array $config)
{
$this->config($config);
}
protected _sanitize_id(string $id ) (defined in Kohana_Cache)
Replaces troublesome characters with underscores and adds prefix to avoid duplicates
// Sanitize a cache id
$id = $this->_sanitize_id($id);
Parameters
- string $id required - Id of cache to sanitize
Return Values
- string
Source Code
protected function _sanitize_id($id)
{
// adding cache prefix to avoid duplicates
$prefix = '';
// configuration for the specific cache group
if (isset($this->_config['prefix']) AND $this->_config['prefix'] !== NULL)
{
$prefix = $this->_config['prefix'];
}
// prefix general configuration cache
else
{
$prefix = Kohana::$config->load('cache.prefix');
}
// sha1 the id makes sure name is not too long and has not any not allowed characters
return $prefix.sha1($id);
}
