Data Persistent Storage

forever können Daten dauerhaft im Cache gespeichert werden. Da diese Daten nicht ablaufen, müssen sie manuell über die forget-Methode aus dem Cache gelöscht werden:

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

{tip} Wenn Sie den Memcached-Treiber verwenden, wenn die zwischengespeicherten Daten das Speicherlimit erreichen , „Permanent gespeicherte Daten können gelöscht werden.“

Daten aus dem Cache löschen

Sie können diese mit der Methode forget aus dem Cache löschen Daten:

Cache::forget('key');

Sie können auch eine Null- oder eine negative TTL angeben Wert zum Löschen dieser Daten:

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

Sie können die Methode flush verwenden, um alle Caches zu löschen:

Cache::flush();

{Hinweis} Die Methode zum Löschen des Caches berücksichtigt nicht den Cache Präfix und wird Der gesamte Inhalt im Cache wird gelöscht. Bitte überlegen Sie daher sorgfältig, ob Sie den mit anderen Anwendungen gemeinsam genutzten Cache löschen.

Atomic Lock

{note} Um diese Funktion nutzen zu können, muss Ihre Anwendung verwenden memcached, dynamodb oder redis Der Cache-Treiber dient als Standard-Cache-Treiber für Ihre Anwendung. Darüber hinaus müssen alle Server mit demselben zentralen Cache-Server kommunizieren.

Atomsperren ermöglichen Operationen auf verteilten Sperren, ohne sich Gedanken über die Rennbedingungen machen zu müssen. Beispielsweise verwendet Laravel Forge atomare Sperren, um sicherzustellen, dass jeweils nur eine Remote-Aufgabe auf einem Server ausgeführt wird. Mit der Methode Cache::lock können Sie Sperren erstellen und verwalten: Die Methode

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

get kann auch eine Schließung erhalten. Nachdem der Abschluss ausgeführt wurde, gibt Laravel die Sperre automatisch frei:

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

Wenn die Sperre zum Zeitpunkt Ihrer Anfrage nicht verfügbar ist, können Sie Laravel so steuern, dass es eine bestimmte Anzahl von Sekunden wartet. Wenn die Sperre nicht innerhalb des angegebenen Zeitlimits erworben werden kann, wird IlluminateContractsCacheLockTimeoutException ausgegeben:

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秒后获取的锁...
   });

Sperren prozessübergreifend verwalten

Manchmal möchten Sie die Sperre in einem anderen erwerben verarbeiten und in einem anderen Prozess freigeben. Sie könnten beispielsweise während einer Webanforderung eine Sperre erwerben und die Sperre aufheben, wenn der durch diese Anforderung ausgelöste Warteschlangenjob endet. In diesem Fall sollten Sie den „Besitzer-Token“ des Sperrbereichs an den Warteschlangenjob übergeben, damit der Job die Sperre mit dem angegebenen Token erneut instanziieren kann:

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

Wenn Sie dies tun möchten, ohne den aktuellen Wert zu berücksichtigen lock Um die Sperre ohne den Eigentümer aufzuheben, können Sie forceRelease verwenden Methode:

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

Cache-Hilfsfunktion

Zusätzlich zur Verwendung des Cache Fassaden- oder Cache-Vertrags können Sie auch die globale Hilfsfunktion cache verwenden, um Cache-Daten abzurufen und zu speichern. Wenn die Funktion cache nur einen Zeichenfolgenparameter empfängt, gibt sie den Wert zurück, der dem angegebenen Schlüssel entspricht:

$value = cache('key');

Wenn Sie der Funktion einen Satz Schlüssel-Wert-Paare und eine Ablaufzeit bereitstellen, wird dies der Fall sein Daten für eine bestimmte Zeit zwischenspeichern:

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

Wenn die Funktion cache ohne Argumente aufgerufen wird, gibt sie ein IlluminateContractsCacheFactory zurück Implementierte Instanzen, mit denen Sie andere Caching-Methoden aufrufen können:

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

{tip} Wenn Sie in Ihren Tests die globale Hilfsfunktion cache verwenden, können Sie die Methode Cache::shouldReceive genau wie den Test verwenden Fassade.

Cache-Tag

{note} Cache-Tags mit file und database Cache-Treiber. Darüber hinaus erzielt ein Cache-Treiber wie memcached die beste Leistung, wenn der Cache, der mehrere Cache-Tags verwendet, auf „persistent“ eingestellt ist, wodurch alte Datensätze automatisch gelöscht werden.

Getaggte Cache-Daten schreiben

Cache-Tags ermöglichen es Ihnen, Cache-bezogene Tags zu markieren, damit diese zwischengespeichert werden Werte können später gelöscht werden. Sie können auf den Tag-Cache zugreifen, indem Sie ein geordnetes Array von Tag-Namen übergeben. Beispielsweise können wir den Cache mit der Methode put festlegen, während wir das Tag verwenden.

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

Zugriff auf markierte Cache-Daten

Um markierte Cache-Daten zu erhalten, ändern Sie bitte das gleiche. Ein geordnetes Array von Tags werden an die Methode tags übergeben und dann wird get aufgerufen Methode zum Abrufen des Schlüssels, den Sie abrufen möchten:

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

Markierte Cache-Daten entfernen

Sie können alles löschen zwischengespeicherte Daten für ein einzelnes Tag oder eine Gruppe von Tags. Die folgende Anweisung würde beispielsweise als people, authors oder beides zwischengespeichert. Daher werden sowohl Anne als auch John aus dem Cache gelöscht:

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

Im Gegensatz dazu löscht die folgende Anweisung nur den mit authors gekennzeichneten Cache, sodass Anne gelöscht wird, aber John Nein:

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

Benutzerdefinierten Cache-Treiber hinzufügen

Schreiben eines Treibers

Um einen benutzerdefinierten Cache-Treiber zu erstellen, müssen Sie zunächst den IlluminateContractsCacheStore-Vertrag implementieren. Daher sieht die Cache-Implementierung von MongoDB so aus:

<?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() {}
    }

Wir benötigen nur die MongoDB-Verbindung, um diese Methoden zu implementieren. Beispiele für die Implementierung dieser Methoden finden Sie unter IlluminateCacheMemcachedStore im Framework-Quellcode. Sobald der Vertrag abgeschlossen ist, können Sie die Registrierung des benutzerdefinierten Fahrers wie folgt abschließen.

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

{tip} Wenn Sie nicht wissen, wo Sie den Cache-Treibercode ablegen sollen, können Sie einen app-Namespace im Verzeichnis Extensions erstellen. Laravel schreibt jedoch nicht die Struktur Ihrer Bewerbung vor und es steht Ihnen frei, Ihre Bewerbung so zu organisieren, wie Sie möchten.

Treiber registrieren

Um Laravel zum Registrieren eines benutzerdefinierten Cache-Treibers zu verwenden, müssen Sie ihn registrieren in Cache Verwenden Sie die extend-Methode für die Fassade. Der Aufruf von Cache::extend kann in der AppProvidersAppServiceProvider-Methode des integrierten boot in der neuen Laravel-Anwendung erfolgen, oder Sie können Ihren eigenen Dienstanbieter erstellen, um die Erweiterung zu speichern, vergessen Sie aber nicht, sie hinzuzufügen in config/app.php Registrieren Sie den Dienstanbieter im Provider-Array:

<?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()   
      {      
        //   
       }
    }

Der erste Parameter, der an die extend-Methode übergeben wird, ist der Name des Treibers. Dies entspricht der Option config/cache.php der Konfigurationsdatei driver. Der zweite Parameter ist ein Abschluss, der eine IlluminateCacheRepository-Instanz zurückgeben soll. Dem Abschluss wird eine $app-Instanz des Servicecontainers übergeben.

Sobald Ihre Erweiterung registriert ist, müssen Sie die Option config/cache.php in der Konfigurationsdatei driver auf Ihren Erweiterungsnamen aktualisieren.

Ereignisse

Um Code bei jedem Cache-Vorgang auszuführen, können Sie vom Cache ausgelöste Ereignisse abhören. Normalerweise sollten Sie diese Ereignis-Listener in EventServiceProvider platzieren:

/**
 * 应用的事件监听器映射
 *
 * @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', 
           ],
        ];