php/yii2
1
0
Fork 0
mirror of https://github.com/yiisoft/yii2.git synced 2025-08-26 06:15:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

FragmentCache WIP

Browse Source
This commit is contained in:
Qiang Xue
2013-03-25 14:27:15 -04:00
parent 379e48a4c6
commit 392b293d33
9 changed files with 146 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
framework/widgets/FragmentCache.php
View File

@ -7,7 +7,11 @@
namespace yii\widgets;
use Yii;
use yii\base\InvalidConfigException;
use yii\base\Widget;
use yii\caching\Cache;
use yii\caching\Dependency;
/**
* @author Qiang Xue <qiang.xue@gmail.com>
@ -15,82 +19,48 @@ use yii\base\Widget;
*/
class FragmentCache extends Widget
{
/**
* Prefix to the keys for storing cached data
*/
const CACHE_KEY_PREFIX = 'Yii.COutputCache.';
/**
* @var string the ID of the cache application component. Defaults to 'cache' (the primary cache application component.)
*/
public $cacheID = 'cache';
/**
* @var integer number of seconds that the data can remain in cache. Defaults to 60 seconds.
* If it is 0, existing cached content would be removed from the cache.
* If it is a negative value, the cache will be disabled (any existing cached content will
* remain in the cache.)
*
* Note, if cache dependency changes or cache space is limited,
* the data may be purged out of cache earlier.
* @var integer number of seconds that the data can remain valid in cache.
* Use 0 to indicate that the cached data will never expire.
*/
public $duration = 60;
/**
* @var mixed the dependency that the cached content depends on.
* This can be either an object implementing {@link ICacheDependency} interface or an array
* specifying the configuration of the dependency object. For example,
* <pre>
* @var array|Dependency the dependency that the cached content depends on.
* This can be either a [[Dependency]] object or a configuration array for creating the dependency object.
* For example,
*
* ~~~
* array(
* 'class'=>'CDbCacheDependency',
* 'sql'=>'SELECT MAX(lastModified) FROM Post',
* 'class' => 'yii\caching\DbDependency',
* 'sql' => 'SELECT MAX(lastModified) FROM Post',
* )
* </pre>
* ~~~
*
* would make the output cache depends on the last modified time of all posts.
* If any post has its modification time changed, the cached content would be invalidated.
*/
public $dependency;
/**
* @var boolean whether the content being cached should be differentiated according to route.
* A route consists of the requested controller ID and action ID.
* Defaults to true.
* @var array list of factors that would cause the variation of the content being cached.
* Each factor is a string representing a variation (e.g. the language, a GET parameter).
* The following variation setting will cause the content to be cached in different versions
* according to the current application language:
*
* ~~~
* array(
* Yii::$app->language,
* )
*/
public $varyByRoute = true;
public $variations;
/**
* @var boolean whether the content being cached should be differentiated according to user's language.
* A language is retrieved via Yii::app()->language.
* Defaults to false.
* @since 1.1.14
* @var boolean whether to enable the fragment cache. You may use this property to turn on and off
* the fragment cache according to specific setting (e.g. enable fragment cache only for GET requests).
*/
public $varyByLanguage = false;
/**
* @var array list of GET parameters that should participate in cache key calculation.
* By setting this property, the output cache will use different cached data
* for each different set of GET parameter values.
*/
public $varyByParam;
/**
* @var string a PHP expression whose result is used in the cache key calculation.
* By setting this property, the output cache will use different cached data
* for each different expression result.
* The expression can also be a valid PHP callback,
* including class method name (array(ClassName/Object, MethodName)),
* or anonymous function (PHP 5.3.0+). The function/method signature should be as follows:
* <pre>
* function foo($cache) { ... }
* </pre>
* where $cache refers to the output cache component.
*/
public $varyByExpression;
/**
* @var array list of request types (e.g. GET, POST) for which the cache should be enabled only.
* Defaults to null, meaning all request types.
*/
public $requestTypes;
private $_key;
private $_cache;
private $_contentCached;
private $_content;
private $_actions;
public $enabled = true;
/**
* Marks the start of content to be cached.
@ -100,10 +70,7 @@ class FragmentCache extends Widget
*/
public function init()
{
if ($this->getIsContentCached()) {
$this->replayActions();
} elseif ($this->_cache !== null) {
$this->getController()->getCachingStack()->push($this);
if ($this->getCachedContent() === false && $this->getCache() !== null) {
ob_start();
ob_implicit_flush(false);
}
@ -117,178 +84,89 @@ class FragmentCache extends Widget
*/
public function run()
{
if ($this->getIsContentCached()) {
if ($this->getController()->isCachingStackEmpty()) {
echo $this->getController()->processDynamicOutput($this->_content);
} else {
echo $this->_content;
}
} elseif ($this->_cache !== null) {
$this->_content = ob_get_clean();
$this->getController()->getCachingStack()->pop();
$data = array($this->_content, $this->_actions);
if (($content = $this->getCachedContent()) !== false) {
echo $content;
} elseif (($cache = $this->getCache()) !== false) {
$content = ob_get_clean();
if (is_array($this->dependency)) {
$this->dependency = Yii::createComponent($this->dependency);
$this->dependency = Yii::createObject($this->dependency);
}
$this->_cache->set($this->getCacheKey(), $data, $this->duration, $this->dependency);
$cache->set($this->calculateKey(), $content, $this->duration, $this->dependency);
echo $content;
}
}
if ($this->getController()->isCachingStackEmpty()) {
echo $this->getController()->processDynamicOutput($this->_content);
/**
* @var string|boolean the cached content. False if the content is not cached.
*/
private $_content;
/**
* Returns the cached content if available.
* @return string|boolean the cached content. False is returned if valid content is not found in the cache.
*/
public function getCachedContent()
{
if ($this->_content === null) {
if (($cache = $this->getCache()) !== null) {
$key = $this->calculateKey();
$this->_content = $cache->get($key);
} else {
echo $this->_content;
$this->_content = false;
}
}
return $this->_content;
}
/**
* @return boolean whether the content can be found from cache
* Generates a unique key used for storing the content in cache.
* The key generated depends on both [[id]] and [[variations]].
* @return string a valid cache key
*/
public function getIsContentCached()
protected function calculateKey()
{
if ($this->_contentCached !== null) {
return $this->_contentCached;
} else {
return $this->_contentCached = $this->checkContentCache();
}
}
/**
* Looks for content in cache.
* @return boolean whether the content is found in cache.
*/
protected function checkContentCache()
{
if ((empty($this->requestTypes) || in_array(Yii::app()->getRequest()->getRequestType(), $this->requestTypes))
&& ($this->_cache = $this->getCache()) !== null
) {
if ($this->duration > 0 && ($data = $this->_cache->get($this->getCacheKey())) !== false) {
$this->_content = $data[0];
$this->_actions = $data[1];
return true;
}
if ($this->duration == 0) {
$this->_cache->delete($this->getCacheKey());
}
if ($this->duration <= 0) {
$this->_cache = null;
$factors = array(__CLASS__, $this->getId());
if (is_array($this->variations)) {
foreach ($this->variations as $factor) {
$factors[] = $factor;
}
}
return false;
return $this->getCache()->buildKey($factors);
}
/**
* @return ICache the cache used for caching the content.
* @var Cache
*/
protected function getCache()
{
return Yii::app()->getComponent($this->cacheID);
}
private $_cache;
/**
* Caclulates the base cache key.
* The calculated key will be further variated in {@link getCacheKey}.
* Derived classes may override this method if more variations are needed.
* @return string basic cache key without variations
* Returns the cache instance used for storing content.
* @return Cache the cache instance. Null is returned if the cache component is not available
* or [[enabled]] is false.
* @throws InvalidConfigException if [[cacheID]] does not point to a valid application component.
*/
protected function getBaseCacheKey()
public function getCache()
{
return self::CACHE_KEY_PREFIX . $this->getId() . '.';
}
/**
* Calculates the cache key.
* The key is calculated based on {@link getBaseCacheKey} and other factors, including
* {@link varyByRoute}, {@link varyByParam}, {@link varyBySession} and {@link varyByLanguage}.
* @return string cache key
*/
protected function getCacheKey()
{
if ($this->_key !== null) {
return $this->_key;
} else {
$key = $this->getBaseCacheKey() . '.';
if ($this->varyByRoute) {
$controller = $this->getController();
$key .= $controller->getUniqueId() . '/';
if (($action = $controller->getAction()) !== null) {
$key .= $action->getId();
}
}
$key .= '.';
if ($this->varyBySession) {
$key .= Yii::app()->getSession()->getSessionID();
}
$key .= '.';
if (is_array($this->varyByParam) && isset($this->varyByParam[0])) {
$params = array();
foreach ($this->varyByParam as $name) {
if (isset($_GET[$name])) {
$params[$name] = $_GET[$name];
} else {
$params[$name] = '';
}
}
$key .= serialize($params);
}
$key .= '.';
if ($this->varyByExpression !== null) {
$key .= $this->evaluateExpression($this->varyByExpression);
}
$key .= '.';
if ($this->varyByLanguage) {
$key .= Yii::app()->language;
}
$key .= '.';
return $this->_key = $key;
if (!$this->enabled) {
return null;
}
}
/**
* Records a method call when this output cache is in effect.
* When the content is served from the output cache, the recorded
* method will be re-invoked.
* @param string $context a property name of the controller. The property should refer to an object
* whose method is being recorded. If empty it means the controller itself.
* @param string $method the method name
* @param array $params parameters passed to the method
*/
public function recordAction($context, $method, $params)
{
$this->_actions[] = array($context, $method, $params);
}
/**
* Replays the recorded method calls.
*/
protected function replayActions()
{
if (empty($this->_actions)) {
return;
}
$controller = $this->getController();
$cs = Yii::app()->getClientScript();
foreach ($this->_actions as $action) {
if ($action[0] === 'clientScript') {
$object = $cs;
} elseif ($action[0] === '') {
$object = $controller;
if ($this->_cache === null) {
$cache = Yii::$app->getComponent($this->cacheID);
if ($cache instanceof Cache) {
$this->_cache = $cache;
} else {
$object = $controller->{$action[0]};
}
if (method_exists($object, $action[1])) {
call_user_func_array(array($object, $action[1]), $action[2]);
} elseif ($action[0] === '' && function_exists($action[1])) {
call_user_func_array($action[1], $action[2]);
} else {
throw new CException(Yii::t('yii', 'Unable to replay the action "{object}.{method}". The method does not exist.',
array('object' => $action[0],
'method' => $action[1])));
throw new InvalidConfigException('FragmentCache::cacheID must refer to the ID of a cache application component.');
}
}
return $this->_cache;
}
/**
* Sets the cache instance used by the session component.
* @param Cache $value the cache instance
*/
public function setCache($value)
{
$this->_cache = $value;
}
}