refactoring cache and db references.

framework/base/Module.php

@@ -411,7 +411,7 @@ abstract class Module extends Component
 	 * array(
 	 *     'comment' => array(
 	 *         'class' => 'app\modules\CommentModule',
-	 *         'connectionID' => 'db',
+	 *         'db' => 'db',
 	 *     ),
 	 *     'booking' => array(
 	 *         'class' => 'app\modules\BookingModule',
@@ -521,7 +521,7 @@ abstract class Module extends Component
 	 *     ),
 	 *     'cache' => array(
 	 *         'class' => 'yii\caching\DbCache',
-	 *         'connectionID' => 'db',
+	 *         'db' => 'db',
 	 *     ),
 	 * )
 	 * ~~~

framework/caching/DbCache.php

@@ -7,6 +7,7 @@
 
 namespace yii\caching;
 
+use Yii;
 use yii\base\InvalidConfigException;
 use yii\db\Connection;
 use yii\db\Query;
@@ -14,30 +15,20 @@ use yii\db\Query;
 /**
  * DbCache implements a cache application component by storing cached data in a database.
  *
- * DbCache stores cache data in a DB table whose name is specified via [[cacheTableName]].
+ * By default, DbCache stores session data in a DB table named 'tbl_cache'. This table
- * For MySQL database, the table should be created beforehand as follows :
+ * must be pre-created. The table name can be changed by setting [[cacheTable]].
- *
- * ~~~
- * CREATE TABLE tbl_cache (
- *     id char(128) NOT NULL,
- *     expire int(11) DEFAULT NULL,
- *     data LONGBLOB,
- *     PRIMARY KEY (id),
- *     KEY expire (expire)
- * );
- * ~~~
- *
- * You should replace `LONGBLOB` as follows if you are using a different DBMS:
- *
- * - PostgreSQL: `BYTEA`
- * - SQLite, SQL server, Oracle: `BLOB`
- *
- * DbCache connects to the database via the DB connection specified in [[connectionID]]
- * which must refer to a valid DB application component.
  *
  * Please refer to [[Cache]] for common cache operations that are supported by DbCache.
  *
- * @property Connection $db The DB connection instance.
+ * The following example shows how you can configure the application to use DbCache:
+ *
+ * ~~~
+ * 'cache' => array(
+ *     'class' => 'yii\caching\DbCache',
+ *     // 'db' => 'mydb',
+ *     // 'cacheTable' => 'my_cache',
+ * )
+ * ~~~
  *
  * @author Qiang Xue <qiang.xue@gmail.com>
  * @since 2.0
@@ -45,50 +36,56 @@ use yii\db\Query;
 class DbCache extends Cache
 {
 	/**
-	 * @var string the ID of the [[Connection|DB connection]] application component. Defaults to 'db'.
+	 * @var Connection|string the DB connection object or the application component ID of the DB connection.
+	 * After the DbCache object is created, if you want to change this property, you should only assign it
+	 * with a DB connection object.
 	 */
-	public $connectionID = 'db';
+	public $db = 'db';
 	/**
-	 * @var string name of the DB table to store cache content. Defaults to 'tbl_cache'.
+	 * @var string name of the DB table to store cache content.
-	 * The table must be created before using this cache component.
+	 * The table should be pre-created as follows:
+	 *
+	 * ~~~
+	 * CREATE TABLE tbl_cache (
+	 *     id char(128) NOT NULL PRIMARY KEY,
+	 *     expire int(11),
+	 *     data BLOB
+	 * );
+	 * ~~~
+	 *
+	 * where 'BLOB' refers to the BLOB-type of your preferred DBMS. Below are the BLOB type
+	 * that can be used for some popular DBMS:
+	 *
+	 * - MySQL: LONGBLOB
+	 * - PostgreSQL: BYTEA
+	 * - MSSQL: BLOB
+	 *
+	 * When using DbCache in a production server, we recommend you create a DB index for the 'expire'
+	 * column in the cache table to improve the performance.
 	 */
-	public $cacheTableName = 'tbl_cache';
+	public $cacheTable = 'tbl_cache';
 	/**
 	 * @var integer the probability (parts per million) that garbage collection (GC) should be performed
-	 * when storing a piece of data in the cache. Defaults to 10, meaning 0.001% chance.
+	 * when storing a piece of data in the cache. Defaults to 100, meaning 0.01% chance.
 	 * This number should be between 0 and 1000000. A value 0 meaning no GC will be performed at all.
 	 **/
 	public $gcProbability = 100;
-	/**
+
-	 * @var Connection the DB connection instance
-	 */
-	private $_db;
 
 	/**
-	 * Returns the DB connection instance used for caching purpose.
+	 * Initializes the DbCache component.
-	 * @return Connection the DB connection instance
+	 * This method will initialize the [[db]] property to make sure it refers to a valid DB connection.
-	 * @throws InvalidConfigException if [[connectionID]] does not point to a valid application component.
+	 * @throws InvalidConfigException if [[db]] is invalid.
 	 */
-	public function getDb()
+	public function init()
 	{
-		if ($this->_db === null) {
+		parent::init();
-			$db = \Yii::$app->getComponent($this->connectionID);
+		if (is_string($this->db)) {
-			if ($db instanceof Connection) {
+			$this->db = Yii::$app->getComponent($this->db);
-				$this->_db = $db;
-			} else {
-				throw new InvalidConfigException("DbCache::connectionID must refer to the ID of a DB application component.");
-			}
 		}
-		return $this->_db;
+		if (!$this->db instanceof Connection) {
+			throw new InvalidConfigException("DbCache::db must be either a DB connection instance or the application component ID of a DB connection.");
 		}
-
-	/**
-	 * Sets the DB connection used by the cache component.
-	 * @param Connection $value the DB connection instance
-	 */
-	public function setDb($value)
-	{
-		$this->_db = $value;
 	}
 
 	/**
@@ -101,17 +98,16 @@ class DbCache extends Cache
 	{
 		$query = new Query;
 		$query->select(array('data'))
-			->from($this->cacheTableName)
+			->from($this->cacheTable)
 			->where('id = :id AND (expire = 0 OR expire >' . time() . ')', array(':id' => $key));
-		$db = $this->getDb();
+		if ($this->db->enableQueryCache) {
-		if ($db->enableQueryCache) {
 			// temporarily disable and re-enable query caching
-			$db->enableQueryCache = false;
+			$this->db->enableQueryCache = false;
-			$result = $query->createCommand($db)->queryScalar();
+			$result = $query->createCommand($this->db)->queryScalar();
-			$db->enableQueryCache = true;
+			$this->db->enableQueryCache = true;
 			return $result;
 		} else {
-			return $query->createCommand($db)->queryScalar();
+			return $query->createCommand($this->db)->queryScalar();
 		}
 	}
 
@@ -127,17 +123,16 @@ class DbCache extends Cache
 		}
 		$query = new Query;
 		$query->select(array('id', 'data'))
-			->from($this->cacheTableName)
+			->from($this->cacheTable)
 			->where(array('id' => $keys))
 			->andWhere('(expire = 0 OR expire > ' . time() . ')');
 
-		$db = $this->getDb();
+		if ($this->db->enableQueryCache) {
-		if ($db->enableQueryCache) {
+			$this->db->enableQueryCache = false;
-			$db->enableQueryCache = false;
+			$rows = $query->createCommand($this->db)->queryAll();
-			$rows = $query->createCommand($db)->queryAll();
+			$this->db->enableQueryCache = true;
-			$db->enableQueryCache = true;
 		} else {
-			$rows = $query->createCommand($db)->queryAll();
+			$rows = $query->createCommand($this->db)->queryAll();
 		}
 
 		$results = array();
@@ -161,13 +156,13 @@ class DbCache extends Cache
 	 */
 	protected function setValue($key, $value, $expire)
 	{
-		$command = $this->getDb()->createCommand();
+		$command = $this->db->createCommand()
-		$command->update($this->cacheTableName, array(
+			->update($this->cacheTable, array(
 				'expire' => $expire > 0 ? $expire + time() : 0,
 				'data' => array($value, \PDO::PARAM_LOB),
 			), array(
 				'id' => $key,
-		));;
+			));
 
 		if ($command->execute()) {
 			$this->gc();
@@ -196,14 +191,13 @@ class DbCache extends Cache
 			$expire = 0;
 		}
 
-		$command = $this->getDb()->createCommand();
+		try {
-		$command->insert($this->cacheTableName, array(
+			$this->db->createCommand()
+				->insert($this->cacheTable, array(
 					'id' => $key,
 					'expire' => $expire,
 					'data' => array($value, \PDO::PARAM_LOB),
-		));
+				))->execute();
-		try {
-			$command->execute();
 			return true;
 		} catch (\Exception $e) {
 			return false;
@@ -218,8 +212,9 @@ class DbCache extends Cache
 	 */
 	protected function deleteValue($key)
 	{
-		$command = $this->getDb()->createCommand();
+		$this->db->createCommand()
-		$command->delete($this->cacheTableName, array('id' => $key))->execute();
+			->delete($this->cacheTable, array('id' => $key))
+			->execute();
 		return true;
 	}
 
@@ -231,8 +226,9 @@ class DbCache extends Cache
 	public function gc($force = false)
 	{
 		if ($force || mt_rand(0, 1000000) < $this->gcProbability) {
-			$command = $this->getDb()->createCommand();
+			$this->db->createCommand()
-			$command->delete($this->cacheTableName, 'expire > 0 AND expire < ' . time())->execute();
+				->delete($this->cacheTable, 'expire > 0 AND expire < ' . time())
+				->execute();
 		}
 	}
 
@@ -243,8 +239,9 @@ class DbCache extends Cache
 	 */
 	protected function flushValues()
 	{
-		$command = $this->getDb()->createCommand();
+		$this->db->createCommand()
-		$command->delete($this->cacheTableName)->execute();
+			->delete($this->cacheTable)
+			->execute();
 		return true;
 	}
 }

framework/caching/DbDependency.php

@@ -23,9 +23,9 @@ use yii\db\Connection;
 class DbDependency extends Dependency
 {
 	/**
-	 * @var string the ID of the [[Connection|DB connection]] application component. Defaults to 'db'.
+	 * @var string the application component ID of the DB connection.
 	 */
-	public $connectionID = 'db';
+	public $db = 'db';
 	/**
 	 * @var string the SQL query whose result is used to determine if the dependency has been changed.
 	 * Only the first row of the query result will be used.
@@ -50,24 +50,17 @@ class DbDependency extends Dependency
 	}
 
 	/**
-	 * PHP sleep magic method.
-	 * This method ensures that the database instance is set null because it contains resource handles.
-	 * @return array
-	 */
-	public function __sleep()
-	{
-		$this->_db = null;
-		return array_keys((array)$this);
-	}
-
-	/**
 	 * Generates the data needed to determine if dependency has been changed.
 	 * This method returns the value of the global state.
 	 * @return mixed the data needed to determine if dependency has been changed.
 	 */
 	protected function generateDependencyData()
 	{
-		$db = $this->getDb();
+		$db = Yii::$app->getComponent($this->db);
+		if (!$db instanceof Connection) {
+			throw new InvalidConfigException("DbDependency::db must be the application component ID of a DB connection.");
+		}
+
 		if ($db->enableQueryCache) {
 			// temporarily disable and re-enable query caching
 			$db->enableQueryCache = false;
@@ -78,36 +71,4 @@ class DbDependency extends Dependency
 		}
 		return $result;
 	}
-
-	/**
-	 * @var Connection the DB connection instance
-	 */
-	private $_db;
-
-	/**
-	 * Returns the DB connection instance used for caching purpose.
-	 * @return Connection the DB connection instance
-	 * @throws InvalidConfigException if [[connectionID]] does not point to a valid application component.
-	 */
-	public function getDb()
-	{
-		if ($this->_db === null) {
-			$db = Yii::$app->getComponent($this->connectionID);
-			if ($db instanceof Connection) {
-				$this->_db = $db;
-			} else {
-				throw new InvalidConfigException("DbCacheDependency::connectionID must refer to the ID of a DB application component.");
-			}
-		}
-		return $this->_db;
-	}
-
-	/**
-	 * Sets the DB connection used by the cache component.
-	 * @param Connection $value the DB connection instance
-	 */
-	public function setDb($value)
-	{
-		$this->_db = $value;
-	}
 }

framework/console/Controller.php

@@ -135,9 +135,13 @@ class Controller extends \yii\base\Controller
 
 	/**
 	 * Returns the names of the global options for this command.
-	 * A global option requires the existence of a global member variable whose
+	 * A global option requires the existence of a public member variable whose
 	 * name is the option name.
 	 * Child classes may override this method to specify possible global options.
+	 *
+	 * Note that the values setting via global options are not available
+	 * until [[beforeAction()]] is being called.
+	 *
 	 * @return array the names of the global options for this command.
 	 */
 	public function globalOptions()

framework/console/controllers/MigrateController.php

@@ -26,9 +26,10 @@ use yii\helpers\ArrayHelper;
  * This command provides support for tracking the migration history, upgrading
  * or downloading with migrations, and creating new migration skeletons.
  *
- * The migration history is stored in a database table named as [[migrationTable]].
+ * The migration history is stored in a database table named
- * The table will be automatically created the first this command is executed.
+ * as [[migrationTable]]. The table will be automatically created the first time
- * You may also manually create it with the following structure:
+ * this command is executed, if it does not exist. You may also manually
+ * create it as follows:
  *
  * ~~~
  * CREATE TABLE tbl_migration (
@@ -74,11 +75,6 @@ class MigrateController extends Controller
 	 */
 	public $migrationTable = 'tbl_migration';
 	/**
-	 * @var string the component ID that specifies the database connection for
-	 * storing migration information.
-	 */
-	public $connectionID = 'db';
-	/**
 	 * @var string the template file for generating new migrations.
 	 * This can be either a path alias (e.g. "@app/migrations/template.php")
 	 * or a file path.
@@ -89,10 +85,10 @@ class MigrateController extends Controller
 	 */
 	public $interactive = true;
 	/**
-	 * @var Connection the DB connection used for storing migration history.
+	 * @var Connection|string the DB connection object or the application
-	 * @see connectionID
+	 * component ID of the DB connection.
 	 */
-	public $db;
+	public $db = 'db';
 
 	/**
 	 * Returns the names of the global options for this command.
@@ -100,7 +96,7 @@ class MigrateController extends Controller
 	 */
 	public function globalOptions()
 	{
-		return array('migrationPath', 'migrationTable', 'connectionID', 'templateFile', 'interactive');
+		return array('migrationPath', 'migrationTable', 'db', 'templateFile', 'interactive');
 	}
 
 	/**
@@ -119,9 +115,11 @@ class MigrateController extends Controller
 			}
 			$this->migrationPath = $path;
 
-			$this->db = Yii::$app->getComponent($this->connectionID);
+			if (is_string($this->db)) {
+				$this->db = Yii::$app->getComponent($this->db);
+			}
 			if (!$this->db instanceof Connection) {
-				throw new Exception("Invalid DB connection \"{$this->connectionID}\".");
+				throw new Exception("The 'db' option must refer to the application component ID of a DB connection.");
 			}
 
 			$version = Yii::getVersion();
@@ -277,7 +275,7 @@ class MigrateController extends Controller
 	}
 
 	/**
-	 * Upgrades or downgrades till the specified version of migration.
+	 * Upgrades or downgrades till the specified version.
 	 *
 	 * This command will first revert the specified migrations, and then apply
 	 * them again. For example,
@@ -564,25 +562,6 @@ class MigrateController extends Controller
 		));
 	}
 
-
-	/**
-	 * @return Connection the database connection that is used to store the migration history.
-	 * @throws Exception if the database connection ID is invalid.
-	 */
-	protected function getDb()
-	{
-		if ($this->db !== null) {
-			return $this->db;
-		} else {
-			$this->db = Yii::$app->getComponent($this->connectionID);
-			if ($this->db instanceof Connection) {
-				return $this->db;
-			} else {
-				throw new Exception("Invalid DB connection: {$this->connectionID}.");
-			}
-		}
-	}
-
 	/**
 	 * Returns the migration history.
 	 * @param integer $limit the maximum number of records in the history to be returned

framework/db/Command.php

@@ -7,7 +7,9 @@
 
 namespace yii\db;
 
+use Yii;
 use yii\base\NotSupportedException;
+use yii\caching\Cache;
 
 /**
  * Command represents a SQL statement to be executed against a database.
@@ -132,7 +134,7 @@ class Command extends \yii\base\Component
 			try {
 				$this->pdoStatement = $this->db->pdo->prepare($sql);
 			} catch (\Exception $e) {
-				\Yii::error($e->getMessage() . "\nFailed to prepare SQL: $sql", __CLASS__);
+				Yii::error($e->getMessage() . "\nFailed to prepare SQL: $sql", __CLASS__);
 				$errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
 				throw new Exception($e->getMessage(), $errorInfo, (int)$e->getCode());
 			}
@@ -264,7 +266,7 @@ class Command extends \yii\base\Component
 			$paramLog = "\nParameters: " . var_export($this->_params, true);
 		}
 
-		\Yii::trace("Executing SQL: {$sql}{$paramLog}", __CLASS__);
+		Yii::trace("Executing SQL: {$sql}{$paramLog}", __CLASS__);
 
 		if ($sql == '') {
 			return 0;
@@ -272,7 +274,7 @@ class Command extends \yii\base\Component
 
 		try {
 			if ($this->db->enableProfiling) {
-				\Yii::beginProfile(__METHOD__ . "($sql)", __CLASS__);
+				Yii::beginProfile(__METHOD__ . "($sql)", __CLASS__);
 			}
 
 			$this->prepare();
@@ -280,16 +282,16 @@ class Command extends \yii\base\Component
 			$n = $this->pdoStatement->rowCount();
 
 			if ($this->db->enableProfiling) {
-				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
+				Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
 			}
 			return $n;
 		} catch (\Exception $e) {
 			if ($this->db->enableProfiling) {
-				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
+				Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
 			}
 			$message = $e->getMessage();
 
-			\Yii::error("$message\nFailed to execute SQL: {$sql}{$paramLog}", __CLASS__);
+			Yii::error("$message\nFailed to execute SQL: {$sql}{$paramLog}", __CLASS__);
 
 			$errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
 			throw new Exception($message, $errorInfo, (int)$e->getCode());
@@ -381,14 +383,14 @@ class Command extends \yii\base\Component
 			$paramLog = "\nParameters: " . var_export($this->_params, true);
 		}
 
-		\Yii::trace("Querying SQL: {$sql}{$paramLog}", __CLASS__);
+		Yii::trace("Querying SQL: {$sql}{$paramLog}", __CLASS__);
 
 		/** @var $cache \yii\caching\Cache */
 		if ($db->enableQueryCache && $method !== '') {
-			$cache = \Yii::$app->getComponent($db->queryCacheID);
+			$cache = is_string($db->queryCache) ? Yii::$app->getComponent($db->queryCache) : $db->queryCache;
 		}
 
-		if (isset($cache)) {
+		if (isset($cache) && $cache instanceof Cache) {
 			$cacheKey = $cache->buildKey(array(
 				__CLASS__,
 				$db->dsn,
@@ -397,14 +399,14 @@ class Command extends \yii\base\Component
 				$paramLog,
 			));
 			if (($result = $cache->get($cacheKey)) !== false) {
-				\Yii::trace('Query result found in cache', __CLASS__);
+				Yii::trace('Query result served from cache', __CLASS__);
 				return $result;
 			}
 		}
 
 		try {
 			if ($db->enableProfiling) {
-				\Yii::beginProfile(__METHOD__ . "($sql)", __CLASS__);
+				Yii::beginProfile(__METHOD__ . "($sql)", __CLASS__);
 			}
 
 			$this->prepare();
@@ -421,21 +423,21 @@ class Command extends \yii\base\Component
 			}
 
 			if ($db->enableProfiling) {
-				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
+				Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
 			}
 
-			if (isset($cache, $cacheKey)) {
+			if (isset($cache, $cacheKey) && $cache instanceof Cache) {
 				$cache->set($cacheKey, $result, $db->queryCacheDuration, $db->queryCacheDependency);
-				\Yii::trace('Saved query result in cache', __CLASS__);
+				Yii::trace('Saved query result in cache', __CLASS__);
 			}
 
 			return $result;
 		} catch (\Exception $e) {
 			if ($db->enableProfiling) {
-				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
+				Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
 			}
 			$message = $e->getMessage();
-			\Yii::error("$message\nCommand::$method() failed: {$sql}{$paramLog}", __CLASS__);
+			Yii::error("$message\nCommand::$method() failed: {$sql}{$paramLog}", __CLASS__);
 			$errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
 			throw new Exception($message, $errorInfo, (int)$e->getCode());
 		}

framework/db/Connection.php

@@ -10,6 +10,7 @@ namespace yii\db;
 use yii\base\Component;
 use yii\base\InvalidConfigException;
 use yii\base\NotSupportedException;
+use yii\caching\Cache;
 
 /**
  * Connection represents a connection to a database via [PDO](http://www.php.net/manual/en/ref.pdo.php).
@@ -136,10 +137,10 @@ class Connection extends Component
 	/**
 	 * @var boolean whether to enable schema caching.
 	 * Note that in order to enable truly schema caching, a valid cache component as specified
-	 * by [[schemaCacheID]] must be enabled and [[enableSchemaCache]] must be set true.
+	 * by [[schemaCache]] must be enabled and [[enableSchemaCache]] must be set true.
 	 * @see schemaCacheDuration
 	 * @see schemaCacheExclude
-	 * @see schemaCacheID
+	 * @see schemaCache
 	 */
 	public $enableSchemaCache = false;
 	/**
@@ -155,20 +156,20 @@ class Connection extends Component
 	 */
 	public $schemaCacheExclude = array();
 	/**
-	 * @var string the ID of the cache application component that is used to cache the table metadata.
+	 * @var Cache|string the cache object or the ID of the cache application component that
-	 * Defaults to 'cache'.
+	 * is used to cache the table metadata.
 	 * @see enableSchemaCache
 	 */
-	public $schemaCacheID = 'cache';
+	public $schemaCache = 'cache';
 	/**
 	 * @var boolean whether to enable query caching.
 	 * Note that in order to enable query caching, a valid cache component as specified
-	 * by [[queryCacheID]] must be enabled and [[enableQueryCache]] must be set true.
+	 * by [[queryCache]] must be enabled and [[enableQueryCache]] must be set true.
 	 *
 	 * Methods [[beginCache()]] and [[endCache()]] can be used as shortcuts to turn on
 	 * and off query caching on the fly.
 	 * @see queryCacheDuration
-	 * @see queryCacheID
+	 * @see queryCache
 	 * @see queryCacheDependency
 	 * @see beginCache()
 	 * @see endCache()
@@ -176,7 +177,7 @@ class Connection extends Component
 	public $enableQueryCache = false;
 	/**
 	 * @var integer number of seconds that query results can remain valid in cache.
-	 * Defaults to 3600, meaning one hour.
+	 * Defaults to 3600, meaning 3600 seconds, or one hour.
 	 * Use 0 to indicate that the cached data will never expire.
 	 * @see enableQueryCache
 	 */
@@ -188,11 +189,11 @@ class Connection extends Component
 	 */
 	public $queryCacheDependency;
 	/**
-	 * @var string the ID of the cache application component that is used for query caching.
+	 * @var Cache|string the cache object or the ID of the cache application component
-	 * Defaults to 'cache'.
+	 * that is used for query caching.
 	 * @see enableQueryCache
 	 */
-	public $queryCacheID = 'cache';
+	public $queryCache = 'cache';
 	/**
 	 * @var string the charset used for database connection. The property is only used
 	 * for MySQL and PostgreSQL databases. Defaults to null, meaning using default charset
@@ -290,7 +291,7 @@ class Connection extends Component
 	 * This method is provided as a shortcut to setting two properties that are related
 	 * with query caching: [[queryCacheDuration]] and [[queryCacheDependency]].
 	 * @param integer $duration the number of seconds that query results may remain valid in cache.
-	 * See [[queryCacheDuration]] for more details.
+	 * If not set, it will use the value of [[queryCacheDuration]]. See [[queryCacheDuration]] for more details.
 	 * @param \yii\caching\Dependency $dependency the dependency for the cached query result.
 	 * See [[queryCacheDependency]] for more details.
 	 */

framework/db/Schema.php

@@ -7,6 +7,7 @@
 
 namespace yii\db;
 
+use Yii;
 use yii\base\NotSupportedException;
 use yii\base\InvalidCallException;
 use yii\caching\Cache;
@@ -84,8 +85,10 @@ abstract class Schema extends \yii\base\Object
 		$db = $this->db;
 		$realName = $this->getRealTableName($name);
 
+		if ($db->enableSchemaCache && !in_array($name, $db->schemaCacheExclude, true)) {
 			/** @var $cache Cache */
-		if ($db->enableSchemaCache && ($cache = \Yii::$app->getComponent($db->schemaCacheID)) !== null && !in_array($name, $db->schemaCacheExclude, true)) {
+			$cache = is_string($db->schemaCache) ? Yii::$app->getComponent($db->schemaCache) : $db->schemaCache;
+			if ($cache instanceof Cache) {
 				$key = $this->getCacheKey($cache, $name);
 				if ($refresh || ($table = $cache->get($key)) === false) {
 					$table = $this->loadTableSchema($realName);
@@ -93,12 +96,10 @@ abstract class Schema extends \yii\base\Object
 						$cache->set($key, $table, $db->schemaCacheDuration);
 					}
 				}
-			$this->_tables[$name] = $table;
+				return $this->_tables[$name] = $table;
-		} else {
-			$this->_tables[$name] = $table = $this->loadTableSchema($realName);
 			}
-
+		}
-		return $table;
+		return $this->_tables[$name] = $table = $this->loadTableSchema($realName);
 	}
 
 	/**
@@ -173,8 +174,9 @@ abstract class Schema extends \yii\base\Object
 	 */
 	public function refresh()
 	{
-		/** @var $cache \yii\caching\Cache */
+		/** @var $cache Cache */
-		if ($this->db->enableSchemaCache && ($cache = \Yii::$app->getComponent($this->db->schemaCacheID)) !== null) {
+		$cache = is_string($this->db->schemaCache) ? Yii::$app->getComponent($this->db->schemaCache) : $this->db->schemaCache;
+		if ($this->db->enableSchemaCache && $cache instanceof Cache) {
 			foreach ($this->_tables as $name => $table) {
 				$cache->delete($this->getCacheKey($cache, $name));
 			}

framework/logging/DbTarget.php

@@ -7,16 +7,15 @@
 
 namespace yii\logging;
 
+use Yii;
 use yii\db\Connection;
 use yii\base\InvalidConfigException;
 
 /**
  * DbTarget stores log messages in a database table.
  *
- * By default, DbTarget will use the database specified by [[connectionID]] and save
+ * By default, DbTarget stores the log messages in a DB table named 'tbl_log'. This table
- * messages into a table named by [[tableName]]. Please refer to [[tableName]] for the required
+ * must be pre-created. The table name can be changed by setting [[logTable]].
- * table structure. Note that this table must be created beforehand. Otherwise an exception
- * will be thrown when DbTarget is saving messages into DB.
  *
  * @author Qiang Xue <qiang.xue@gmail.com>
  * @since 2.0
@@ -24,20 +23,18 @@ use yii\base\InvalidConfigException;
 class DbTarget extends Target
 {
 	/**
-	 * @var string the ID of [[Connection]] application component.
+	 * @var Connection|string the DB connection object or the application component ID of the DB connection.
-	 * Defaults to 'db'. Please make sure that your database contains a table
+	 * After the DbTarget object is created, if you want to change this property, you should only assign it
-	 * whose name is as specified in [[tableName]] and has the required table structure.
+	 * with a DB connection object.
-	 * @see tableName
 	 */
-	public $connectionID = 'db';
+	public $db = 'db';
 	/**
-	 * @var string the name of the DB table that stores log messages. Defaults to 'tbl_log'.
+	 * @var string name of the DB table to store cache content.
-	 *
+	 * The table should be pre-created as follows:
-	 * The DB table should have the following structure:
 	 *
 	 * ~~~
 	 * CREATE TABLE tbl_log (
-	 *	   id       INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
+	 *	   id       BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
 	 *	   level    INTEGER,
 	 *	   category VARCHAR(255),
 	 *	   log_time INTEGER,
@@ -48,42 +45,29 @@ class DbTarget extends Target
 	 * ~~~
 	 *
 	 * Note that the 'id' column must be created as an auto-incremental column.
-	 * The above SQL shows the syntax of MySQL. If you are using other DBMS, you need
+	 * The above SQL uses the MySQL syntax. If you are using other DBMS, you need
 	 * to adjust it accordingly. For example, in PostgreSQL, it should be `id SERIAL PRIMARY KEY`.
 	 *
 	 * The indexes declared above are not required. They are mainly used to improve the performance
 	 * of some queries about message levels and categories. Depending on your actual needs, you may
-	 * want to create additional indexes (e.g. index on log_time).
+	 * want to create additional indexes (e.g. index on `log_time`).
 	 */
-	public $tableName = 'tbl_log';
+	public $logTable = 'tbl_log';
-
-	private $_db;
 
 	/**
-	 * Returns the DB connection used for saving log messages.
+	 * Initializes the DbTarget component.
-	 * @return Connection the DB connection instance
+	 * This method will initialize the [[db]] property to make sure it refers to a valid DB connection.
-	 * @throws InvalidConfigException if [[connectionID]] does not point to a valid application component.
+	 * @throws InvalidConfigException if [[db]] is invalid.
 	 */
-	public function getDb()
+	public function init()
 	{
-		if ($this->_db === null) {
+		parent::init();
-			$db = \Yii::$app->getComponent($this->connectionID);
+		if (is_string($this->db)) {
-			if ($db instanceof Connection) {
+			$this->db = Yii::$app->getComponent($this->db);
-				$this->_db = $db;
-			} else {
-				throw new InvalidConfigException("DbTarget::connectionID must refer to the ID of a DB application component.");
 		}
+		if (!$this->db instanceof Connection) {
+			throw new InvalidConfigException("DbTarget::db must be either a DB connection instance or the application component ID of a DB connection.");
 		}
-		return $this->_db;
-	}
-
-	/**
-	 * Sets the DB connection used by the cache component.
-	 * @param Connection $value the DB connection instance
-	 */
-	public function setDb($value)
-	{
-		$this->_db = $value;
 	}
 
 	/**
@@ -93,10 +77,9 @@ class DbTarget extends Target
 	 */
 	public function export($messages)
 	{
-		$db = $this->getDb();
+		$tableName = $this->db->quoteTableName($this->logTable);
-		$tableName = $db->quoteTableName($this->tableName);
 		$sql = "INSERT INTO $tableName (level, category, log_time, message) VALUES (:level, :category, :log_time, :message)";
-		$command = $db->createCommand($sql);
+		$command = $this->db->createCommand($sql);
 		foreach ($messages as $message) {
 			$command->bindValues(array(
 				':level' => $message[1],

framework/web/CacheSession.php

@@ -15,7 +15,7 @@ use yii\base\InvalidConfigException;
  * CacheSession implements a session component using cache as storage medium.
  *
  * The cache being used can be any cache application component.
- * The ID of the cache application component is specified via [[cacheID]], which defaults to 'cache'.
+ * The ID of the cache application component is specified via [[cache]], which defaults to 'cache'.
  *
  * Beware, by definition cache storage are volatile, which means the data stored on them
  * may be swapped out and get lost. Therefore, you must make sure the cache used by this component
@@ -27,14 +27,27 @@ use yii\base\InvalidConfigException;
 class CacheSession extends Session
 {
 	/**
-	 * @var string the ID of the cache application component. Defaults to 'cache' (the primary cache application component.)
+	 * @var Cache|string the cache object or the application component ID of the cache object.
+	 * The session data will be stored using this cache object.
+	 *
+	 * After the CacheSession object is created, if you want to change this property,
+	 * you should only assign it with a cache object.
 	 */
-	public $cacheID = 'cache';
+	public $cache = 'cache';
 
 	/**
-	 * @var Cache the cache component
+	 * Initializes the application component.
 	 */
-	private $_cache;
+	public function init()
+	{
+		parent::init();
+		if (is_string($this->cache)) {
+			$this->cache = Yii::$app->getComponent($this->cache);
+		}
+		if (!$this->cache instanceof Cache) {
+			throw new InvalidConfigException('CacheSession::cache must refer to the application component ID of a cache object.');
+		}
+	}
 
 	/**
 	 * Returns a value indicating whether to use custom session storage.
@@ -47,33 +60,6 @@ class CacheSession extends Session
 	}
 
 	/**
-	 * Returns the cache instance used for storing session data.
-	 * @return Cache the cache instance
-	 * @throws InvalidConfigException if [[cacheID]] does not point to a valid application component.
-	 */
-	public function getCache()
-	{
-		if ($this->_cache === null) {
-			$cache = Yii::$app->getComponent($this->cacheID);
-			if ($cache instanceof Cache) {
-				$this->_cache = $cache;
-			} else {
-				throw new InvalidConfigException('CacheSession::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;
-	}
-
-	/**
 	 * Session read handler.
 	 * Do not call this method directly.
 	 * @param string $id session ID
@@ -81,7 +67,7 @@ class CacheSession extends Session
 	 */
 	public function readSession($id)
 	{
-		$data = $this->getCache()->get($this->calculateKey($id));
+		$data = $this->cache->get($this->calculateKey($id));
 		return $data === false ? '' : $data;
 	}
 
@@ -94,7 +80,7 @@ class CacheSession extends Session
 	 */
 	public function writeSession($id, $data)
 	{
-		return $this->getCache()->set($this->calculateKey($id), $data, $this->getTimeout());
+		return $this->cache->set($this->calculateKey($id), $data, $this->getTimeout());
 	}
 
 	/**
@@ -105,7 +91,7 @@ class CacheSession extends Session
 	 */
 	public function destroySession($id)
 	{
-		return $this->getCache()->delete($this->calculateKey($id));
+		return $this->cache->delete($this->calculateKey($id));
 	}
 
 	/**
@@ -115,6 +101,6 @@ class CacheSession extends Session
 	 */
 	protected function calculateKey($id)
 	{
-		return $this->getCache()->buildKey(array(__CLASS__, $id));
+		return $this->cache->buildKey(array(__CLASS__, $id));
 	}
 }

framework/web/DbSession.php

@@ -15,24 +15,45 @@ use yii\base\InvalidConfigException;
 /**
  * DbSession extends [[Session]] by using database as session data storage.
  *
- * DbSession uses a DB application component to perform DB operations. The ID of the DB application
- * component is specified via [[connectionID]] which defaults to 'db'.
- *
  * By default, DbSession stores session data in a DB table named 'tbl_session'. This table
- * must be pre-created. The table name can be changed by setting [[sessionTableName]].
+ * must be pre-created. The table name can be changed by setting [[sessionTable]].
- * The table should have the following structure:
+ * 
+ * The following example shows how you can configure the application to use DbSession:
+ * 
+ * ~~~
+ * 'session' => array(
+ *     'class' => 'yii\web\DbSession',
+ *     // 'db' => 'mydb',
+ *     // 'sessionTable' => 'my_session',
+ * )
+ * ~~~
+ *
+ * @author Qiang Xue <qiang.xue@gmail.com>
+ * @since 2.0
+ */
+class DbSession extends Session
+{
+	/**
+	 * @var Connection|string the DB connection object or the application component ID of the DB connection.
+	 * After the DbSession object is created, if you want to change this property, you should only assign it
+	 * with a DB connection object.
+	 */
+	public $db = 'db';
+	/**
+	 * @var string the name of the DB table that stores the session data.
+	 * The table should be pre-created as follows:
 	 *
 	 * ~~~
 	 * CREATE TABLE tbl_session
 	 * (
- *     id CHAR(32) PRIMARY KEY,
+	 *     id CHAR(40) NOT NULL PRIMARY KEY,
 	 *     expire INTEGER,
 	 *     data BLOB
 	 * )
 	 * ~~~
 	 *
- * where 'BLOB' refers to the BLOB-type of your preferred database. Below are the BLOB type
+	 * where 'BLOB' refers to the BLOB-type of your preferred DBMS. Below are the BLOB type
- * that can be used for some popular databases:
+	 * that can be used for some popular DBMS:
 	 *
 	 * - MySQL: LONGBLOB
 	 * - PostgreSQL: BYTEA
@@ -40,33 +61,24 @@ use yii\base\InvalidConfigException;
 	 *
 	 * When using DbSession in a production server, we recommend you create a DB index for the 'expire'
 	 * column in the session table to improve the performance.
- *
- * @author Qiang Xue <qiang.xue@gmail.com>
- * @since 2.0
- */
-class DbSession extends Session
-{
-	/**
-	 * @var string the ID of a {@link CDbConnection} application component. If not set, a SQLite database
-	 * will be automatically created and used. The SQLite database file is
-	 * is <code>protected/runtime/session-YiiVersion.db</code>.
-	 */
-	public $connectionID;
-	/**
-	 * @var string the name of the DB table to store session content.
-	 * Note, if {@link autoCreateSessionTable} is false and you want to create the DB table manually by yourself,
-	 * you need to make sure the DB table is of the following structure:
-	 * <pre>
-	 * (id CHAR(32) PRIMARY KEY, expire INTEGER, data BLOB)
-	 * </pre>
-	 * @see autoCreateSessionTable
 	 */
-	public $sessionTableName = 'tbl_session';
+	public $sessionTable = 'tbl_session';
+
 	/**
-	 * @var Connection the DB connection instance
+	 * Initializes the DbSession component.
+	 * This method will initialize the [[db]] property to make sure it refers to a valid DB connection.
+	 * @throws InvalidConfigException if [[db]] is invalid.
 	 */
-	private $_db;
+	public function init()
-
+	{
+		parent::init();
+		if (is_string($this->db)) {
+			$this->db = Yii::$app->getComponent($this->db);
+		}
+		if (!$this->db instanceof Connection) {
+			throw new InvalidConfigException("DbSession::db must be either a DB connection instance or the application component ID of a DB connection.");
+		}		
+	}
 
 	/**
 	 * Returns a value indicating whether to use custom session storage.
@@ -94,25 +106,27 @@ class DbSession extends Session
 
 		parent::regenerateID(false);
 		$newID = session_id();
-		$db = $this->getDb();
 
 		$query = new Query;
-		$row = $query->from($this->sessionTableName)
+		$row = $query->from($this->sessionTable)
 			->where(array('id' => $oldID))
-			->createCommand($db)
+			->createCommand($this->db)
 			->queryRow();
 		if ($row !== false) {
 			if ($deleteOldSession) {
-				$db->createCommand()->update($this->sessionTableName, array(
+				$this->db->createCommand()
-					'id' => $newID
+					->update($this->sessionTable, array('id' => $newID), array('id' => $oldID))
-				), array('id' => $oldID))->execute();
+					->execute();
 			} else {
 				$row['id'] = $newID;
-				$db->createCommand()->insert($this->sessionTableName, $row)->execute();
+				$this->db->createCommand()
+					->insert($this->sessionTable, $row)
+					->execute();
 			}
 		} else {
 			// shouldn't reach here normally
-			$db->createCommand()->insert($this->sessionTableName, array(
+			$this->db->createCommand()
+				->insert($this->sessionTable, array(
 					'id' => $newID,
 					'expire' => time() + $this->getTimeout(),
 				))->execute();
@@ -120,33 +134,6 @@ class DbSession extends Session
 	}
 
 	/**
-	 * Returns the DB connection instance used for storing session data.
-	 * @return Connection the DB connection instance
-	 * @throws InvalidConfigException if [[connectionID]] does not point to a valid application component.
-	 */
-	public function getDb()
-	{
-		if ($this->_db === null) {
-			$db = Yii::$app->getComponent($this->connectionID);
-			if ($db instanceof Connection) {
-				$this->_db = $db;
-			} else {
-				throw new InvalidConfigException("DbSession::connectionID must refer to the ID of a DB application component.");
-			}
-		}
-		return $this->_db;
-	}
-
-	/**
-	 * Sets the DB connection used by the session component.
-	 * @param Connection $value the DB connection instance
-	 */
-	public function setDb($value)
-	{
-		$this->_db = $value;
-	}
-
-	/**
 	 * Session read handler.
 	 * Do not call this method directly.
 	 * @param string $id session ID
@@ -156,9 +143,9 @@ class DbSession extends Session
 	{
 		$query = new Query;
 		$data = $query->select(array('data'))
-			->from($this->sessionTableName)
+			->from($this->sessionTable)
 			->where('expire>:expire AND id=:id', array(':expire' => time(), ':id' => $id))
-			->createCommand($this->getDb())
+			->createCommand($this->db)
 			->queryScalar();
 		return $data === false ? '' : $data;
 	}
@@ -176,24 +163,23 @@ class DbSession extends Session
 		// http://us.php.net/manual/en/function.session-set-save-handler.php
 		try {
 			$expire = time() + $this->getTimeout();
-			$db = $this->getDb();
 			$query = new Query;
 			$exists = $query->select(array('id'))
-				->from($this->sessionTableName)
+				->from($this->sessionTable)
 				->where(array('id' => $id))
-				->createCommand($db)
+				->createCommand($this->db)
 				->queryScalar();
 			if ($exists === false) {
-				$db->createCommand()->insert($this->sessionTableName, array(
+				$this->db->createCommand()
+					->insert($this->sessionTable, array(
 						'id' => $id,
 						'data' => $data,
 						'expire' => $expire,
 					))->execute();
 			} else {
-				$db->createCommand()->update($this->sessionTableName, array(
+				$this->db->createCommand()
-					'data' => $data,
+					->update($this->sessionTable, array('data' => $data, 'expire' => $expire), array('id' => $id))
-					'expire' => $expire
+					->execute();
-				), array('id' => $id))->execute();
 			}
 		} catch (\Exception $e) {
 			if (YII_DEBUG) {
@@ -213,8 +199,8 @@ class DbSession extends Session
 	 */
 	public function destroySession($id)
 	{
-		$this->getDb()->createCommand()
+		$this->db->createCommand()
-			->delete($this->sessionTableName, array('id' => $id))
+			->delete($this->sessionTable, array('id' => $id))
 			->execute();
 		return true;
 	}
@@ -227,8 +213,8 @@ class DbSession extends Session
 	 */
 	public function gcSession($maxLifetime)
 	{
-		$this->getDb()->createCommand()
+		$this->db->createCommand()
-			->delete($this->sessionTableName, 'expire<:expire', array(':expire' => time()))
+			->delete($this->sessionTable, 'expire<:expire', array(':expire' => time()))
 			->execute();
 		return true;
 	}

framework/web/PageCache.php

@@ -29,11 +29,10 @@ class PageCache extends ActionFilter
 	 * If not set, the view registered with the application will be used.
 	 */
 	public $view;
-
 	/**
-	 * @var string the ID of the cache application component. Defaults to 'cache' (the primary cache application component.)
+	 * @var string the application component ID of the [[\yii\caching\Cache|cache]] object.
 	 */
-	public $cacheID = 'cache';
+	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.
@@ -91,7 +90,7 @@ class PageCache extends ActionFilter
 	public function beforeAction($action)
 	{
 		$properties = array();
-		foreach (array('cacheID', 'duration', 'dependency', 'variations', 'enabled') as $name) {
+		foreach (array('cache', 'duration', 'dependency', 'variations', 'enabled') as $name) {
 			$properties[$name] = $this->$name;
 		}
 		$id = $this->varyByRoute ? $action->getUniqueId() : __CLASS__;

framework/web/UrlManager.php

@@ -9,6 +9,7 @@ namespace yii\web;
 
 use Yii;
 use yii\base\Component;
+use yii\caching\Cache;
 
 /**
  * UrlManager handles HTTP request parsing and creation of URLs based on a set of rules.
@@ -49,11 +50,14 @@ class UrlManager extends Component
 	 */
 	public $routeVar = 'r';
 	/**
-	 * @var string the ID of the cache component that is used to cache the parsed URL rules.
+	 * @var Cache|string the cache object or the application component ID of the cache object.
-	 * Defaults to 'cache' which refers to the primary cache component registered with the application.
+	 * Compiled URL rules will be cached through this cache object, if it is available.
-	 * Set this property to false if you do not want to cache the URL rules.
+	 *
+	 * After the UrlManager object is created, if you want to change this property,
+	 * you should only assign it with a cache object.
+	 * Set this property to null if you do not want to cache the URL rules.
 	 */
-	public $cacheID = 'cache';
+	public $cache = 'cache';
 	/**
 	 * @var string the default class name for creating URL rule instances
 	 * when it is not specified in [[rules]].
@@ -65,11 +69,14 @@ class UrlManager extends Component
 
 
 	/**
-	 * Initializes the application component.
+	 * Initializes UrlManager.
 	 */
 	public function init()
 	{
 		parent::init();
+		if (is_string($this->cache)) {
+			$this->cache = Yii::$app->getComponent($this->cache);
+		}
 		$this->compileRules();
 	}
 
@@ -81,13 +88,10 @@ class UrlManager extends Component
 		if (!$this->enablePrettyUrl || $this->rules === array()) {
 			return;
 		}
-		/**
+		if ($this->cache instanceof Cache) {
-		 * @var $cache \yii\caching\Cache
+			$key = $this->cache->buildKey(__CLASS__);
-		 */
-		if ($this->cacheID !== false && ($cache = Yii::$app->getComponent($this->cacheID)) !== null) {
-			$key = $cache->buildKey(__CLASS__);
 			$hash = md5(json_encode($this->rules));
-			if (($data = $cache->get($key)) !== false && isset($data[1]) && $data[1] === $hash) {
+			if (($data = $this->cache->get($key)) !== false && isset($data[1]) && $data[1] === $hash) {
 				$this->rules = $data[0];
 				return;
 			}
@@ -100,8 +104,8 @@ class UrlManager extends Component
 			$this->rules[$i] = Yii::createObject($rule);
 		}
 
-		if (isset($cache)) {
+		if ($this->cache instanceof Cache) {
-			$cache->set($key, array($this->rules, $hash));
+			$this->cache->set($key, array($this->rules, $hash));
 		}
 	}
 

framework/widgets/FragmentCache.php

@@ -20,9 +20,11 @@ use yii\caching\Dependency;
 class FragmentCache extends Widget
 {
 	/**
-	 * @var string the ID of the cache application component. Defaults to 'cache' (the primary cache application component.)
+	 * @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 $cacheID = 'cache';
+	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.
@@ -72,19 +74,24 @@ class FragmentCache extends Widget
 	 */
 	public $dynamicPlaceholders;
 
-
 	/**
-	 * Marks the start of content to be cached.
+	 * Initializes the FragmentCache object.
-	 * Content displayed after this method call and before {@link endCache()}
-	 * will be captured and saved in cache.
-	 * This method does nothing if valid content is already found in cache.
 	 */
 	public function init()
 	{
+		parent::init();
+
 		if ($this->view === null) {
 			$this->view = Yii::$app->getView();
 		}
-		if ($this->getCache() !== null && $this->getCachedContent() === false) {
+
+		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);
@@ -101,14 +108,14 @@ class FragmentCache extends Widget
 	{
 		if (($content = $this->getCachedContent()) !== false) {
 			echo $content;
-		} elseif (($cache = $this->getCache()) !== null) {
+		} 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);
-			$cache->set($this->calculateKey(), $data, $this->duration, $this->dependency);
+			$this->cache->set($this->calculateKey(), $data, $this->duration, $this->dependency);
 
 			if ($this->view->cacheStack === array() && !empty($this->dynamicPlaceholders)) {
 				$content = $this->updateDynamicContent($content, $this->dynamicPlaceholders);
@@ -130,9 +137,9 @@ class FragmentCache extends Widget
 	{
 		if ($this->_content === null) {
 			$this->_content = false;
-			if (($cache = $this->getCache()) !== null) {
+			if ($this->cache instanceof Cache) {
 				$key = $this->calculateKey();
-				$data = $cache->get($key);
+				$data = $this->cache->get($key);
 				if (is_array($data) && count($data) === 2) {
 					list ($content, $placeholders) = $data;
 					if (is_array($placeholders) && count($placeholders) > 0) {
@@ -172,42 +179,6 @@ class FragmentCache extends Widget
 				$factors[] = $factor;
 			}
 		}
-		return $this->getCache()->buildKey($factors);
+		return $this->cache->buildKey($factors);
-	}
-
-	/**
-	 * @var Cache
-	 */
-	private $_cache;
-
-	/**
-	 * 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.
-	 */
-	public function getCache()
-	{
-		if (!$this->enabled) {
-			return null;
-		}
-		if ($this->_cache === null) {
-			$cache = Yii::$app->getComponent($this->cacheID);
-			if ($cache instanceof Cache) {
-				$this->_cache = $cache;
-			} else {
-				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;
 	}
 }

tests/unit/framework/web/UrlManagerTest.php

@@ -11,6 +11,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		// default setting with '/' as base url
 		$manager = new UrlManager(array(
 			'baseUrl' => '/',
+			'cache' => null,
 		));
 		$url = $manager->createUrl('post/view');
 		$this->assertEquals('/?r=post/view', $url);
@@ -20,6 +21,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		// default setting with '/test/' as base url
 		$manager = new UrlManager(array(
 			'baseUrl' => '/test/',
+			'cache' => null,
 		));
 		$url = $manager->createUrl('post/view', array('id' => 1, 'title' => 'sample post'));
 		$this->assertEquals('/test/?r=post/view&id=1&title=sample+post', $url);
@@ -28,18 +30,21 @@ class UrlManagerTest extends \yiiunit\TestCase
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
 			'baseUrl' => '/',
+			'cache' => null,
 		));
 		$url = $manager->createUrl('post/view', array('id' => 1, 'title' => 'sample post'));
 		$this->assertEquals('/post/view?id=1&title=sample+post', $url);
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
 			'baseUrl' => '/test/',
+			'cache' => null,
 		));
 		$url = $manager->createUrl('post/view', array('id' => 1, 'title' => 'sample post'));
 		$this->assertEquals('/test/post/view?id=1&title=sample+post', $url);
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
 			'baseUrl' => '/test/index.php',
+			'cache' => null,
 		));
 		$url = $manager->createUrl('post/view', array('id' => 1, 'title' => 'sample post'));
 		$this->assertEquals('/test/index.php/post/view?id=1&title=sample+post', $url);
@@ -49,7 +54,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		// pretty URL with rules
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
-			'cacheID' => false,
+			'cache' => null,
 			'rules' => array(
 				array(
 					'pattern' => 'post/<id>/<title>',
@@ -66,7 +71,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		// pretty URL with rules and suffix
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
-			'cacheID' => false,
+			'cache' => null,
 			'rules' => array(
 				array(
 					'pattern' => 'post/<id>/<title>',
@@ -87,6 +92,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		$manager = new UrlManager(array(
 			'baseUrl' => '/',
 			'hostInfo' => 'http://www.example.com',
+			'cache' => null,
 		));
 		$url = $manager->createAbsoluteUrl('post/view', array('id' => 1, 'title' => 'sample post'));
 		$this->assertEquals('http://www.example.com/?r=post/view&id=1&title=sample+post', $url);
@@ -94,7 +100,9 @@ class UrlManagerTest extends \yiiunit\TestCase
 
 	public function testParseRequest()
 	{
-		$manager = new UrlManager;
+		$manager = new UrlManager(array(
+			'cache' => null,
+		));
 		$request = new Request;
 
 		// default setting without 'r' param
@@ -115,6 +123,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		// pretty URL without rules
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
+			'cache' => null,
 		));
 		// empty pathinfo
 		$request->pathInfo = '';
@@ -136,7 +145,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		// pretty URL rules
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
-			'cacheID' => false,
+			'cache' => null,
 			'rules' => array(
 				array(
 					'pattern' => 'post/<id>/<title>',
@@ -169,7 +178,7 @@ class UrlManagerTest extends \yiiunit\TestCase
 		$manager = new UrlManager(array(
 			'enablePrettyUrl' => true,
 			'suffix' => '.html',
-			'cacheID' => false,
+			'cache' => null,
 			'rules' => array(
 				array(
 					'pattern' => 'post/<id>/<title>',

tests/unit/framework/web/UrlRuleTest.php

@@ -10,7 +10,7 @@ class UrlRuleTest extends \yiiunit\TestCase
 {
 	public function testCreateUrl()
 	{
-		$manager = new UrlManager;
+		$manager = new UrlManager(array('cache' => null));
 		$suites = $this->getTestsForCreateUrl();
 		foreach ($suites as $i => $suite) {
 			list ($name, $config, $tests) = $suite;
@@ -25,7 +25,7 @@ class UrlRuleTest extends \yiiunit\TestCase
 
 	public function testParseRequest()
 	{
-		$manager = new UrlManager;
+		$manager = new UrlManager(array('cache' => null));
 		$request = new Request;
 		$suites = $this->getTestsForParseRequest();
 		foreach ($suites as $i => $suite) {