: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
* CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
* Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
* @copyright Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
* @link https://cakephp.org CakePHP(tm) Project
* @license https://opensource.org/licenses/mit-license.php MIT License
use Cake\Cache\Engine\NullEngine;
use Cake\Core\ObjectRegistry;
use Cake\Core\StaticConfigTrait;
use InvalidArgumentException;
* Cache provides a consistent interface to Caching in your application. It allows you
* to use several different Cache engines, without coupling your application to a specific
* implementation. It also allows you to change out cache storage or configuration without effecting
* the rest of your application.
* ### Configuring Cache engines
* You can configure Cache engines in your application's `Config/cache.php` file.
* A sample configuration would be:
* Cache::config('shared', [
* 'className' => 'Cake\Cache\Engine\ApcuEngine',
* This would configure an APCu cache engine to the 'shared' alias. You could then read and write
* to that cache alias by using it for the `$config` parameter in the various Cache methods.
* In general all Cache operations are supported by all cache engines.
* However, Cache::increment() and Cache::decrement() are not supported by File caching.
* There are 7 built-in caching engines:
* - `ApcuEngine` - Uses the APCu object cache, one of the fastest caching engines.
* - `ArrayEngine` - Uses only memory to store all data, not actually a persistent engine.
* Can be useful in test or CLI environment.
* - `FileEngine` - Uses simple files to store content. Poor performance, but good for
* storing large objects, or things that are not IO sensitive. Well suited to development
* as it is an easy cache to inspect and manually flush.
* - `MemcacheEngine` - Uses the PECL::Memcache extension and Memcached for storage.
* Fast reads/writes, and benefits from memcache being distributed.
* - `RedisEngine` - Uses redis and php-redis extension to store cache data.
* - `WincacheEngine` - Uses Windows Cache Extension for PHP. Supports wincache 1.1.0 and higher.
* This engine is recommended to people deploying on windows with IIS.
* - `XcacheEngine` - Uses the Xcache extension, an alternative to APCu.
* See Cache engine documentation for expected configuration keys.
* @see config/app.php for configuration settings
* An array mapping url schemes to fully qualified caching engine
protected static $_dsnClassMap = [
'array' => 'Cake\Cache\Engine\ArrayEngine',
'apc' => 'Cake\Cache\Engine\ApcuEngine', // @deprecated Since 3.6. Use apcu instead.
'apcu' => 'Cake\Cache\Engine\ApcuEngine',
'file' => 'Cake\Cache\Engine\FileEngine',
'memcached' => 'Cake\Cache\Engine\MemcachedEngine',
'null' => 'Cake\Cache\Engine\NullEngine',
'redis' => 'Cake\Cache\Engine\RedisEngine',
'wincache' => 'Cake\Cache\Engine\WincacheEngine',
'xcache' => 'Cake\Cache\Engine\XcacheEngine',
* Flag for tracking whether or not caching is enabled.
protected static $_enabled = true;
* Group to Config mapping
protected static $_groups = [];
* Cache Registry used for creating and using cache adapters.
* @var \Cake\Core\ObjectRegistry
protected static $_registry;
* Returns the Cache Registry instance used for creating and using cache adapters.
* @return \Cake\Core\ObjectRegistry
public static function getRegistry()
if (!static::$_registry) {
static::$_registry = new CacheRegistry();
return static::$_registry;
* Sets the Cache Registry instance used for creating and using cache adapters.
* Also allows for injecting of a new registry instance.
* @param \Cake\Core\ObjectRegistry $registry Injectable registry object.
public static function setRegistry(ObjectRegistry $registry)
static::$_registry = $registry;
* Returns the Cache Registry instance used for creating and using cache adapters.
* Also allows for injecting of a new registry instance.
* @param \Cake\Core\ObjectRegistry|null $registry Injectable registry object.
* @return \Cake\Core\ObjectRegistry
* @deprecated Deprecated since 3.5. Use getRegistry() and setRegistry() instead.
public static function registry(ObjectRegistry $registry = null)
deprecationWarning('Use Cache::getRegistry() and Cache::setRegistry() instead.');
static::setRegistry($registry);
return static::getRegistry();
* Finds and builds the instance of the required engine class.
* @param string $name Name of the config array that needs an engine instance built
* @throws \InvalidArgumentException When a cache engine cannot be created.
protected static function _buildEngine($name)
$registry = static::getRegistry();
if (empty(static::$_config[$name]['className'])) {
throw new InvalidArgumentException(
sprintf('The "%s" cache configuration does not exist.', $name)
$config = static::$_config[$name];
$registry->load($name, $config);
} catch (RuntimeException $e) {
if (!array_key_exists('fallback', $config)) {
$registry->set($name, new NullEngine());
trigger_error($e->getMessage(), E_USER_WARNING);
if ($config['fallback'] === false) {
if ($config['fallback'] === $name) {
throw new InvalidArgumentException(sprintf('"%s" cache configuration cannot fallback to itself.', $name), null, $e);
$fallbackEngine = clone static::engine($config['fallback']);
$newConfig = $config + ['groups' => [], 'prefix' => null];
$fallbackEngine->setConfig('groups', $newConfig['groups'], false);
if ($newConfig['prefix']) {
$fallbackEngine->setConfig('prefix', $newConfig['prefix'], false);
$registry->set($name, $fallbackEngine);
if ($config['className'] instanceof CacheEngine) {
$config = $config['className']->getConfig();
if (!empty($config['groups'])) {
foreach ($config['groups'] as $group) {
static::$_groups[$group][] = $name;
static::$_groups[$group] = array_unique(static::$_groups[$group]);
sort(static::$_groups[$group]);
* Fetch the engine attached to a specific configuration name.
* If the cache engine & configuration are missing an error will be
* @param string $config The configuration name you want an engine for.
* @return \Cake\Cache\CacheEngine When caching is disabled a null engine will be returned.
* @deprecated 3.7.0 Use Cache::pool() instead. In 4.0 all cache engines will implement the
* PSR16 interface and this method does not return objects implementing that interface.
public static function engine($config)
if (!static::$_enabled) {
$registry = static::getRegistry();
if (isset($registry->{$config})) {
return $registry->{$config};
static::_buildEngine($config);
return $registry->{$config};
* Get a SimpleCacheEngine object for the named cache pool.
* @param string $config The name of the configured cache backend.
* @return \Cake\Cache\SimpleCacheEngine
public static function pool($config)
return new SimpleCacheEngine(static::engine($config));
* Permanently remove all expired and deleted data
* @param string $config [optional] The config name you wish to have garbage collected. Defaults to 'default'
* @param int|null $expires [optional] An expires timestamp. Defaults to NULL
* @deprecated 3.7.0 Will be removed in 4.0
public static function gc($config = 'default', $expires = null)
$engine = static::engine($config);
* Write data for key into cache.
* Writing to the active cache config:
* Cache::write('cached_data', $data);
* Writing to a specific cache config:
* Cache::write('cached_data', $data, 'long_term');
* @param string $key Identifier for the data
* @param mixed $value Data to be cached - anything except a resource
* @param string $config Optional string configuration name to write to. Defaults to 'default'
* @return bool True if the data was successfully cached, false on failure
public static function write($key, $value, $config = 'default')
if (is_resource($value)) {
$backend = static::pool($config);
$success = $backend->set($key, $value);
if ($success === false && $value !== '') {
"%s cache was unable to write '%s' to %s cache",
* Write data for many keys into cache.
* Writing to the active cache config:
* Cache::writeMany(['cached_data_1' => 'data 1', 'cached_data_2' => 'data 2']);
* Writing to a specific cache config:
* Cache::writeMany(['cached_data_1' => 'data 1', 'cached_data_2' => 'data 2'], 'long_term');
* @param array $data An array of data to be stored in the cache
* @param string $config Optional string configuration name to write to. Defaults to 'default'
* @return array of bools for each key provided, indicating true for success or false for fail
* @throws \RuntimeException
public static function writeMany($data, $config = 'default')
$engine = static::engine($config);
$return = $engine->writeMany($data);
foreach ($return as $key => $success) {
if ($success === false && $data[$key] !== '') {
throw new RuntimeException(sprintf(
'%s cache was unable to write \'%s\' to %s cache',
* Read a key from the cache.
* Reading from the active cache configuration.
* Cache::read('my_data');
* Reading from a specific cache configuration.
* Cache::read('my_data', 'long_term');
* @param string $key Identifier for the data
* @param string $config optional name of the configuration to use. Defaults to 'default'
* @return mixed The cached data, or false if the data doesn't exist, has expired, or if there was an error fetching it
public static function read($key, $config = 'default')
// TODO In 4.x this needs to change to use pool()
$engine = static::engine($config);
return $engine->read($key);
* Read multiple keys from the cache.
* Reading multiple keys from the active cache configuration.
* Cache::readMany(['my_data_1', 'my_data_2]);
* Reading from a specific cache configuration.
* Cache::readMany(['my_data_1', 'my_data_2], 'long_term');
* @param array $keys an array of keys to fetch from the cache
* @param string $config optional name of the configuration to use. Defaults to 'default'
* @return array An array containing, for each of the given $keys, the cached data or false if cached data could not be
public static function readMany($keys, $config = 'default')
// In 4.x this needs to change to use pool()
$engine = static::engine($config);
return $engine->readMany($keys);
* Increment a number under the key and return incremented value.
* @param string $key Identifier for the data
* @param int $offset How much to add
* @param string $config Optional string configuration name. Defaults to 'default'
* @return int|false New value, or false if the data doesn't exist, is not integer,
* or if there was an error fetching it.
public static function increment($key, $offset = 1, $config = 'default')
$engine = static::pool($config);
if (!is_int($offset) || $offset < 0) {
return $engine->increment($key, $offset);
* Decrement a number under the key and return decremented value.
* @param string $key Identifier for the data
* @param int $offset How much to subtract
* @param string $config Optional string configuration name. Defaults to 'default'
* @return int|false New value, or false if the data doesn't exist, is not integer,
* or if there was an error fetching it
public static function decrement($key, $offset = 1, $config = 'default')
$engine = static::pool($config);
if (!is_int($offset) || $offset < 0) {
return $engine->decrement($key, $offset);
* Delete a key from the cache.
* Deleting from the active cache configuration.
* Cache::delete('my_data');
* Deleting from a specific cache configuration.
* Cache::delete('my_data', 'long_term');
* @param string $key Identifier for the data
* @param string $config name of the configuration to use. Defaults to 'default'
* @return bool True if the value was successfully deleted, false if it didn't exist or couldn't be removed
public static function delete($key, $config = 'default')
$backend = static::pool($config);
return $backend->delete($key);
* Delete many keys from the cache.
* Deleting multiple keys from the active cache configuration.
* Cache::deleteMany(['my_data_1', 'my_data_2']);
* Deleting from a specific cache configuration.
* Cache::deleteMany(['my_data_1', 'my_data_2], 'long_term');
* @param array $keys Array of cache keys to be deleted
* @param string $config name of the configuration to use. Defaults to 'default'
* @return array of boolean values that are true if the value was successfully deleted,
* false if it didn't exist or couldn't be removed.
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
