Data Permanent Storage

forever method can be used to persistently store data into the cache. Because these data do not expire, they must be manually removed from the cache via the forget method:

Cache::forever('key', 'value');

{tip} If you use the Memcached driver, when the cached data reaches the storage For a limited time, data in "persistent storage" may be deleted.

Delete the data in the cache

You can use the forget method from Delete this data from the cache:

Cache::forget('key');

You can also delete this data by providing a zero or negative TTL value:

Cache::put('key', 'value', 0);
Cache::put('key', 'value', -5);

You can use the flush method to clear all caches ：

Cache::flush();

{note} The method of clearing the cache does not consider the cache prefix and will delete all content in the cache. So please consider carefully when clearing cache shared with other applications.

Atomic Lock

{note} To use this feature, your application must Use the memcached, dynamodb or redis cache driver as the default cache driver for your application. Additionally, all servers must communicate with the same central cache server.

Atomic locks allow operations on distributed locks without worrying about race conditions. For example, Laravel Forge uses atomic locks to ensure that only one remote task is executed on a server at a time. You can create and manage locks using the Cache::lock method: The

use Illuminate\Support\Facades\Cache;
$lock = Cache::lock('foo', 10);
if ($lock->get()) {
    //获取锁定10秒...    
    $lock->release();
}

get method can also receive a closure. After the closure is executed, Laravel will automatically release the lock:

Cache::lock('foo')->get(function () {
    // 获取无限期锁并自动释放...
});

If the lock is not available at the time of your request, you can control Laravel to wait for a specified number of seconds. If the lock cannot be acquired within the specified time limit, Illuminate\Contracts\Cache\LockTimeoutException will be thrown:

use Illuminate\Contracts\Cache\LockTimeoutException;
$lock = Cache::lock('foo', 10);try {
    $lock->block(5);    
    // 等待最多5秒后获取的锁...
   } catch (LockTimeoutException $e) {
       // 无法获取锁...
   } finally {
       optional($lock)->release();
   }
Cache::lock('foo', 10)->block(5, function () {
    // 等待最多5秒后获取的锁...
   });

Manage cross-process locks

Sometimes, you want to acquire a lock in one process and release it in another process. For example, you could acquire a lock during a web request and want to release the lock when the queue job triggered by that request ends. In this case, you should pass the lock's scope "owner token" to the queue job so that the job can re-instantiate the lock with the given token:

// 控制器里面...
$podcast = Podcast::find($id);
if ($lock = Cache::lock('foo', 120)->get()) {
    ProcessPodcast::dispatch($podcast, $lock->owner());
    }
// ProcessPodcast Job 里面...
Cache::restoreLock('foo', $this->owner)->release();

If you want to do this without respecting the current lock To release the lock without the owner, you can use the forceRelease method:

Cache::lock('foo')->forceRelease();

Cache auxiliary function

In addition to using the Cache Facade or Cache contract, you can also use the global auxiliary function cache to obtain and save cache data. When the cache function only receives a string parameter, it will return the value corresponding to the given key:

$value = cache('key');

If you provide the function with a set of key-value pairs and expiration time , it will cache the data for the specified time:

cache(['key' => 'value'], $seconds);
cache(['key' => 'value'], now()->addMinutes(10));

When the cache function is called without any parameters, it returns a Illuminate\Contracts\Cache\ An instance of the Factory implementation that allows you to call other cache methods:

cache()->remember('users', $seconds, function () {
    return DB::table('users')->get();
 });

{tip} If you use the global helper function cache in your tests, you can use The Cache::shouldReceive method is like testing the Facade.

Cache tag

{note} Cache tag is not supported using file and database cache drivers. In addition, a cache driver like memcached performs best when the cache using multiple cache tags is set to "persistent", which automatically clears old records.

Write tagged cache data

Cache tags allow you to tag cache related data. So that these cached values ​​can be cleared later. You can access the cache of tags by passing in an ordered array of tag names. For example, we can set the cache using the put method while using the tag.

Cache::tags(['people', 'artists'])->put('John', $john, $seconds);
Cache::tags(['people', 'authors'])->put('Anne', $anne, $seconds);

Access marked cache data

To obtain a marked cache data, please change the same Pass an ordered array of tags to the tags method, then call the get method to get the key you want to retrieve:

$john = Cache::tags(['people', 'artists'])->get('John');
$anne = Cache::tags(['people', 'authors'])->get('Anne');

Remove marked cache data

You can clear all cached data with a single mark or a group of marks. For example, the following statement would be cached as people, authors, or both. Therefore, both Anne and John will be deleted from the cache:

Cache::tags(['people', 'authors'])->flush();

In contrast, the following statement will only delete the cache marked authors , so Anne will be deleted, but John will not:

Cache::tags('authors')->flush();

increase Custom cache driver

Writing Driver

To create a custom cache driver, you first need to implement the Illuminate\Contracts\Cache\Store contract. Therefore, MongoDB's cache implementation will look like this:

<?php
    namespace App\Extensions;
    use Illuminate\Contracts\Cache\Store;
    class MongoStore implements Store{ 
       public function get($key) {}    
       public function many(array $keys);    
       public function put($key, $value, $seconds) {}    
       public function putMany(array $values, $seconds);    
       public function increment($key, $value = 1) {}    
       public function decrement($key, $value = 1) {}    
       public function forever($key, $value) {}    
       public function forget($key) {}    
       public function flush() {}    
       public function getPrefix() {}
    }

We only need the MongoDB connection to implement these methods. For examples of how to implement these methods, see Illuminate\Cache\MemcachedStore in the framework source code. Once the contract is completed, you can complete the registration of the custom driver as follows.

Cache::extend('mongo', function ($app) {
    return Cache::repository(new MongoStore);
  });

{tip} If you don't know where to put the cache driver code, you can create an Extensions namespace in the app directory. However, Laravel does not dictate the structure of your application and you are free to organize your application however you like.

Register driver

To use Laravel to register a custom cache driver, you must Cache Use the extend method on the Facade. The call to Cache::extend can be done in the boot method of App\Providers\AppServiceProvider that comes with the new Laravel application, or you can also You can create your own service provider to store extensions, but don't forget to register the service provider in the provider array of config/app.php:

<?php
    namespace App\Providers;use App\Extensions\MongoStore;
    use Illuminate\Support\Facades\Cache;
    use Illuminate\Support\ServiceProvider;
    class CacheServiceProvider extends ServiceProvider{   
     /**
     * 执行服务的注册后引导。
     *
     * @return void
     */   
       public function boot()   
        {      
          Cache::extend('mongo', function ($app) {     
                 return Cache::repository(new MongoStore);        
             });   
          }   
     /**
     * 在容器中注册绑定。
     *
     * @return void
     */    
     public function register()   
      {      
        //   
       }
    }

is passed to extend The first parameter of the method is the name of the driver. This will correspond to the driver option of the config/cache.php configuration file. The second parameter is a closure that should return an instance of Illuminate\Cache\Repository. The closure will be passed an $app instance of the service container.

Once your extension is registered, you need to update the driver option in the config/cache.php configuration file to your extension name.

Events

To execute code on every cache operation, you can listen to events triggered by the cache. Typically, you should place these event listeners in EventServiceProvider:

/**
 * 应用的事件监听器映射
 *
 * @var array
 */
 protected $listen = [
     'Illuminate\Cache\Events\CacheHit' => [   
          'App\Listeners\LogCacheHit',   
         ],    
     'Illuminate\Cache\Events\CacheMissed' => [     
        'App\Listeners\LogCacheMissed',  
         ],    
     'Illuminate\Cache\Events\KeyForgotten' => [    
         'App\Listeners\LogKeyForgotten',  
          ],   
      'Illuminate\Cache\Events\KeyWritten' => [ 
          'App\Listeners\LogKeyWritten', 
           ],
        ];