FragmentCache.php 5.06 KB
Newer Older
resurtm committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\widgets;

use Yii;
use yii\base\Widget;
use yii\caching\Cache;
use yii\caching\Dependency;

/**
 * @author Qiang Xue <qiang.xue@gmail.com>
 * @since 2.0
 */
class FragmentCache extends Widget
{
	/**
	 * @var Cache|string the cache object or the application component ID of the cache object.
	 * After the FragmentCache object is created, if you want to change this property,
	 * you should only assign it with a cache object.
	 */
	public $cache = 'cache';
	/**
	 * @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 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' => 'yii\caching\DbDependency',
	 *     'sql' => 'SELECT MAX(lastModified) FROM Post',
	 * )
	 * ~~~
	 *
	 * 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 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 $variations;
	/**
	 * @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 $enabled = true;
	/**
	 * @var array a list of placeholders for embedding dynamic contents. This property
	 * is used internally to implement the content caching feature. Do not modify it.
	 */
	public $dynamicPlaceholders;

	/**
	 * Initializes the FragmentCache object.
	 */
	public function init()
	{
		parent::init();

		if (!$this->enabled) {
			$this->cache = null;
		} elseif (is_string($this->cache)) {
			$this->cache = Yii::$app->getComponent($this->cache);
		}

		if ($this->getCachedContent() === false) {
			$this->view->cacheStack[] = $this;
			ob_start();
			ob_implicit_flush(false);
		}
	}

	/**
	 * Marks the end of content to be cached.
	 * Content displayed before this method call and after {@link init()}
	 * will be captured and saved in cache.
	 * This method does nothing if valid content is already found in cache.
	 */
	public function run()
	{
		if (($content = $this->getCachedContent()) !== false) {
			echo $content;
		} elseif ($this->cache instanceof Cache) {
			$content = ob_get_clean();
			array_pop($this->view->cacheStack);
			if (is_array($this->dependency)) {
				$this->dependency = Yii::createObject($this->dependency);
			}
			$data = array($content, $this->dynamicPlaceholders);
			$this->cache->set($this->calculateKey(), $data, $this->duration, $this->dependency);

			if (empty($this->view->cacheStack) && !empty($this->dynamicPlaceholders)) {
				$content = $this->updateDynamicContent($content, $this->dynamicPlaceholders);
			}
			echo $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) {
			$this->_content = false;
			if ($this->cache instanceof Cache) {
				$key = $this->calculateKey();
				$data = $this->cache->get($key);
				if (is_array($data) && count($data) === 2) {
					list ($content, $placeholders) = $data;
					if (is_array($placeholders) && count($placeholders) > 0) {
						if (empty($this->view->cacheStack)) {
							// outermost cache: replace placeholder with dynamic content
							$content = $this->updateDynamicContent($content, $placeholders);
						}
						foreach ($placeholders as $name => $statements) {
							$this->view->addDynamicPlaceholder($name, $statements);
						}
					}
					$this->_content = $content;
				}
			}
		}
		return $this->_content;
	}

	protected function updateDynamicContent($content, $placeholders)
	{
		foreach ($placeholders as $name => $statements) {
			$placeholders[$name] = $this->view->evaluateDynamicContent($statements);
		}
		return strtr($content, $placeholders);
	}

	/**
	 * Generates a unique key used for storing the content in cache.
	 * The key generated depends on both [[id]] and [[variations]].
	 * @return mixed a valid cache key
	 */
	protected function calculateKey()
	{
		$factors = array(__CLASS__, $this->getId());
		if (is_array($this->variations)) {
			foreach ($this->variations as $factor) {
				$factors[] = $factor;
			}
		}
		return $factors;
	}
}