laravel responsecache herunterladen - laravel responsecache Quellcode herunterladen

Dieses Laravel-Paket kann eine gesamte Antwort zwischenspeichern. Standardmäßig werden alle erfolgreichen Get-Anfragen, die textbasierte Inhalte (z. B. HTML und JSON) zurückgeben, eine Woche lang zwischengespeichert. Dies könnte die Reaktion möglicherweise erheblich beschleunigen.

Wenn also zum ersten Mal eine Anfrage im Paket eingeht, wird die Antwort gespeichert, bevor sie an die Benutzer gesendet wird. Wenn dieselbe Anfrage erneut eingeht, gehen wir nicht die gesamte Bewerbung durch, sondern antworten nur mit der gespeicherten Antwort.

Sind Sie ein visueller Lerner? Dann schauen Sie sich dieses Video an, das zeigt, wie Sie Laravel-Responsecache verwenden können und wie es unter der Haube funktioniert.

Unterstützen Sie uns

Wir investieren viele Ressourcen in die Erstellung erstklassiger Open-Source-Pakete. Sie können uns unterstützen, indem Sie eines unserer kostenpflichtigen Produkte kaufen.

Wir freuen uns sehr, dass Sie uns eine Postkarte aus Ihrer Heimatstadt schicken und erwähnen, welches unserer Pakete Sie verwenden. Unsere Adresse finden Sie auf unserer Kontaktseite. Wir veröffentlichen alle erhaltenen Postkarten auf unserer virtuellen Postkartenwand.

Installation

Wenn Sie PHP 7 verwenden, installieren Sie v6.x dieses Pakets.

Sie können das Paket über Composer installieren:

composer require spatie/laravel-responsecache

Das Paket registriert sich automatisch.

Sie können die Konfigurationsdatei veröffentlichen mit:

php artisan vendor:publish --tag= " responsecache-config "

Dies ist der Inhalt der veröffentlichten Konfigurationsdatei:

 // config / responsecache . php

return [
    / *
     * Determine if the response cache middleware should be enabled .
     * /
    ' enabled ' => env ( ' RESPONSE_CACHE_ENABLED ' , true ),

    / *
     *  The given class will determinate if a request should be cached . The
     *  default class will cache all successful GET - requests .
     *
     *  You can provide your own class given that it implements the
     *  CacheProfile interface .
     * /
    ' cache_profile ' => Spatie  ResponseCache  CacheProfiles CacheAllSuccessfulGetRequests::class,

    / *
     *  Optionally , you can specify a header that will force a cache bypass .
     *  This can be useful to monitor the performance of your application .
     * /
    ' cache_bypass_header ' => [
        ' name ' => env ( ' CACHE_BYPASS_HEADER_NAME ' , null ),
        ' value ' => env ( ' CACHE_BYPASS_HEADER_VALUE ' , null ),
    ],

    / *
     * When using the default CacheRequestFilter this setting controls the
     * default number of seconds responses must be cached .
     * /
    ' cache_lifetime_in_seconds ' => env ( ' RESPONSE_CACHE_LIFETIME ' , 60 * 60 * 24 * 7 ),

    / *
     * This setting determines if a http header named with the cache time
     * should be added to a cached response . This can be handy when
     * debugging .
     * /
    ' add_cache_time_header ' => env ( ' APP_DEBUG ' , true ),

    / *
     * This setting determines the name of the http header that contains
     * the time at which the response was cached
     * /
    ' cache_time_header_name ' => env ( ' RESPONSE_CACHE_HEADER_NAME ' , ' laravel-responsecache ' ),

    / *
     * This setting determines if a http header named with the cache age
     * should be added to a cached response . This can be handy when
     * debugging .
     * ONLY works when "add_cache_time_header" is also active !
     * /
    ' add_cache_age_header ' => env ( ' RESPONSE_CACHE_AGE_HEADER ' , false ),

    / *
     * This setting determines the name of the http header that contains
     * the age of cache
     * /
    ' cache_age_header_name ' => env ( ' RESPONSE_CACHE_AGE_HEADER_NAME ' , ' laravel-responsecache-age ' ),

    / *
     * Here you may define the cache store that should be used to store
     * requests . This can be the name of any store that is
     * configured in app / config / cache . php
     * /
    ' cache_store ' => env ( ' RESPONSE_CACHE_DRIVER ' , ' file ' ),

    / *
     * Here you may define replacers that dynamically replace content from the response .
     * Each replacer must implement the Replacer interface .
     * /
    ' replacers ' => [
         Spatie  ResponseCache  Replacers CsrfTokenReplacer::class,
    ],

    / *
     * If the cache driver you configured supports tags , you may specify a tag name
     * here . All responses will be tagged . When clearing the responsecache only
     * items with that tag will be flushed .
     *
     * You may use a string or an array here .
     * /
    ' cache_tag ' => '' ,

    / *
     * This class is responsible for generating a hash for a request . This hash
     * is used to look up an cached response .
     * /
    ' hasher ' =>  Spatie  ResponseCache  Hasher DefaultHasher::class,

    / *
     * This class is responsible for serializing responses .
     * /
    ' serializer ' =>  Spatie  ResponseCache  Serializers DefaultSerializer::class,
];

Und schließlich sollten Sie die bereitgestellten Middlewares SpatieResponseCacheMiddlewaresCacheResponse::class und SpatieResponseCacheMiddlewaresDoNotCacheResponse installieren.

Für Laravel 11.x und neuer:

Fügen Sie die Middleware-Definitionen zur Bootstrap-App hinzu.

 // bootstrap / app . php


-> withMiddleware ( function ( Middleware $ middleware ) {
    . . .
    $ middleware -> web (append: [
        ...
         Spatie  ResponseCache  Middlewares CacheResponse::class,
    ]);

    . . .

    $ middleware -> alias ([
        ...
        ' doNotCacheResponse ' =>  Spatie  ResponseCache  Middlewares DoNotCacheResponse::class,
    ]);
})

Für Laravel 10.x und früher:

Fügen Sie die Middleware-Definitionen zum http-Kernel hinzu.

 // app / Http / Kernel . php

. . .

protected $ middlewareGroups = [
   ' web ' => [
       ...
        Spatie  ResponseCache  Middlewares CacheResponse::class,
   ],

...

protected $ middlewareAliases = [
   ...
   ' doNotCacheResponse ' =>  Spatie  ResponseCache  Middlewares DoNotCacheResponse::class,
];

Verwendung

Grundlegende Verwendung

Standardmäßig speichert das Paket alle erfolgreichen GET Anfragen eine Woche lang im Cache. Angemeldete Benutzer haben jeweils ihren eigenen separaten Cache. Wenn Sie dieses Verhalten benötigen, sind Sie fertig: Die Installation des ResponseCacheServiceProvider war ausreichend.

Cache leeren

Manuell

Der gesamte Cache kann geleert werden mit:

ResponseCache:: clear ();

Dadurch wird alles aus dem in der Konfigurationsdatei angegebenen Cache-Speicher gelöscht.

Verwenden eines Konsolenbefehls

Das Gleiche kann durch Erteilen dieses Handwerkerbefehls erreicht werden:

php artisan responsecache:clear

Verwendung von Modellereignissen

Sie können Modellereignisse nutzen, um den Cache zu leeren, wenn ein Modell gespeichert oder gelöscht wird. Hier ist ein Beispiel.

 namespace App  Traits ;

use Spatie  ResponseCache  Facades  ResponseCache ;

trait ClearsResponseCache
{
    public static function bootClearsResponseCache ()
    {
        self :: created ( function () {
            ResponseCache:: clear ();
        });

        self :: updated ( function () {
            ResponseCache:: clear ();
        });

        self :: deleted ( function () {
            ResponseCache:: clear ();
        });
    }
}

Vergessen Sie einen oder mehrere spezifische URIs

Sie können bestimmte URIs vergessen mit:

 // Forget one
ResponseCache:: forget ( ' /some-uri ' );

// Forget several
ResponseCache:: forget ([ ' /some-uri ' , ' /other-uri ' ]);

// Equivalent to the example above
ResponseCache:: forget ( ' /some-uri ' , ' /other-uri ' );

Die Methode ResponseCache::forget funktioniert nur, wenn Sie kein „ cacheNameSuffix in Ihrem Cache-Profil verwenden. Verwenden Sie ResponseCache::selectCachedItems um mit cacheNameSuffix umzugehen.

Eine Auswahl zwischengespeicherter Elemente vergessen

Mit ResponseCache::selectCachedItems() können Sie angeben, welche zwischengespeicherten Elemente vergessen werden sollen.

 // forgetting all PUT responses of / some - uri
ResponseCache:: selectCachedItems ()-> withPutMethod ()-> forUrls ( ' /some-uri ' )-> forget ();

// forgetting all PUT responses of multiple endpoints
ResponseCache:: selectCachedItems ()-> withPutMethod ()-> forUrls ([ ' /some-uri ' , ' /other-uri ' ])-> forget ();

// this is equivalent to the example above
ResponseCache:: selectCachedItems ()-> withPutMethod ()-> forUrls ( ' /some-uri ' , ' /other-uri ' )-> forget ();

// forget / some - uri cached with "100" suffix ( by default suffix is user - > id or "" )
ResponseCache:: selectCachedItems ()-> usingSuffix ( ' 100 ' )-> forUrls ( ' /some-uri ' )-> forget ();

// all options combined
ResponseCache:: selectCachedItems ()
    -> withPutMethod ()
    -> withHeaders ([ ' foo ' => ' bar ' ])
    -> withCookies ([ ' cookie1 ' => ' value ' ])
    -> withParameters ([ ' param1 ' => ' value ' ])
    -> withRemoteAddress ( ' 127.0.0.1 ' )
    -> usingSuffix ( ' 100 ' ) 
    -> usingTags ( ' tag1 ' , ' tag2 ' )
    -> forUrls ( ' /some-uri ' , ' /other-uri ' )
    -> forget ();

Das cacheNameSuffix hängt von Ihrem Cache-Profil ab und ist standardmäßig die Benutzer-ID oder eine leere Zeichenfolge, wenn keine Authentifizierung erfolgt.

Verhindern, dass eine Anfrage zwischengespeichert wird

Anfragen können mithilfe der doNotCacheResponse Middleware ignoriert werden. Diese Middleware kann Routen und Controllern zugewiesen werden.

Mithilfe der Middleware könnte unsere Route von der Zwischenspeicherung ausgenommen werden.

 // app / Http / routes . php

Route:: get ( ' /auth/logout ' , [ ' middleware ' => ' doNotCacheResponse ' , ' uses ' => ' AuthController@getLogout ' ]);

Alternativ können Sie die Middleware zu einem Controller hinzufügen:

 class UserController extends Controller
{
    public function __construct ()
    {
        $ this -> middleware ( ' doNotCacheResponse ' , [ ' only ' => [ ' fooAction ' , ' barAction ' ]]);
    }
}

Gezielte Umgehung des Caches

Es ist möglich, den Cache gezielt und sicher zu umgehen und sicherzustellen, dass Sie immer eine neue Antwort erhalten. Dies kann nützlich sein, wenn Sie ein Profil für einen Endpunkt erstellen möchten oder eine Antwort debuggen müssen. In jedem Fall müssen Sie lediglich die Umgebungsvariablen CACHE_BYPASS_HEADER_NAME und CACHE_BYPASS_HEADER_VALUE füllen und dann diesen benutzerdefinierten Header beim Ausführen der Anforderungen verwenden.

Erstellen eines benutzerdefinierten Cache-Profils

Um zu bestimmen, welche Anforderungen wie lange zwischengespeichert werden sollen, wird eine Cache-Profilklasse verwendet. Die Standardklasse, die diese Fragen behandelt, ist SpatieResponseCacheCacheProfilesCacheAllSuccessfulGetRequests .

Sie können Ihre eigene Cache-Profilklasse erstellen, indem Sie die Schnittstelle SpatieResponseCacheCacheProfilesCacheProfile implementieren. Werfen wir einen Blick auf die Benutzeroberfläche:

 interface CacheProfile
{
    / *
     * Determine if the response cache middleware should be enabled .
     * /
    public function enabled ( Request $ request ): bool ;

    / *
     * Determine if the given request should be cached .
     * /
    public function shouldCacheRequest ( Request $ request ): bool ;

    / *
     * Determine if the given response should be cached .
     * /
    public function shouldCacheResponse ( Response $ response ): bool ;

    / *
     * Return the time when the cache must be invalidated .
     * /
    public function cacheRequestUntil ( Request $ request ): DateTime ;

    / * *
     * Return a string to differentiate this request from others .
     *
     * For example : if you want a different cache per user you could return the id of
     * the logged in user .
     *
     * @ param  Illuminate  Http  Request $ request
     *
     * @ return mixed
     * /
    public function useCacheNameSuffix ( Request $ request );
}

Zwischenspeichern bestimmter Routen

Anstatt die cacheResponse Middleware global zu registrieren, können Sie sie auch als Routen-Middleware registrieren.

 protected $ middlewareAliases = [
   ...
   ' cacheResponse ' =>  Spatie  ResponseCache  Middlewares CacheResponse::class,
];

Wenn Sie die Routen-Middleware verwenden, können Sie die Anzahl der Sekunden angeben, die diese Routen zwischengespeichert werden sollen:

 // cache this route for 5 minutes
Route:: get ( ' /my-special-snowflake ' , ' SnowflakeController@index ' )-> middleware ( ' cacheResponse:300 ' );

// cache all these routes for 10 minutes
Route:: group ( function () {
   Route:: get ( ' /another-special-snowflake ' , ' AnotherSnowflakeController@index ' );

   Route:: get ( ' /yet-another-special-snowflake ' , ' YetAnotherSnowflakeController@index ' );
})-> middleware ( ' cacheResponse:600 ' );

Verwenden von Tags

Wenn der von Ihnen konfigurierte Cache-Treiber Tags unterstützt, können Sie beim Anwenden der Middleware eine Liste von Tags angeben.

 // add a "foo" tag to this route with a 300 second lifetime
Route:: get ( ' /test1 ' , ' SnowflakeController@index ' )-> middleware ( ' cacheResponse:300,foo ' );

// add a "bar" tag to this route
Route:: get ( ' /test2 ' , ' SnowflakeController@index ' )-> middleware ( ' cacheResponse:bar ' );

// add both "foo" and "bar" tags to these routes
Route:: group ( function () {
   Route:: get ( ' /test3 ' , ' AnotherSnowflakeController@index ' );

   Route:: get ( ' /test4 ' , ' YetAnotherSnowflakeController@index ' );
})-> middleware ( ' cacheResponse:foo,bar ' );

Löschen getaggter Inhalte

Sie können Antworten löschen, denen ein Tag oder eine Liste von Tags zugewiesen ist. Diese Anweisung würde beispielsweise die oben genannten Routen '/test3' und '/test4' entfernen:

ResponseCache:: clear ([ ' foo ' , ' bar ' ]);

Im Gegensatz dazu würde diese Anweisung nur die Route '/test2' entfernen:

ResponseCache:: clear ([ ' bar ' ]);

Beachten Sie, dass hierbei die integrierte Cache-Tags-Funktion von Laravel verwendet wird, was bedeutet, dass Routen auch auf die übliche Weise gelöscht werden können:

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

Veranstaltungen

Es gibt mehrere Ereignisse, mit denen Sie das Antwort-Caching in Ihrer Anwendung überwachen und debuggen können.

ResponseCacheHit

SpatieResponseCacheEventsResponseCacheHit

Dieses Ereignis wird ausgelöst, wenn eine Anforderung die ResponseCache Middleware durchläuft und eine zwischengespeicherte Antwort gefunden und zurückgegeben wurde.

CacheMissed

SpatieResponseCacheEventsCacheMissed

Dieses Ereignis wird ausgelöst, wenn eine Anfrage die ResponseCache Middleware durchläuft, aber keine zwischengespeicherte Antwort gefunden oder zurückgegeben wurde.

ClearingResponseCache und ClearedResponseCache

SpatieResponseCacheEventsClearingResponseCache

SpatieResponseCacheEventsClearedResponseCache

Diese Ereignisse werden jeweils ausgelöst, wenn der responsecache:clear gestartet und beendet wird.

Einen Ersatz erstellen

Um zwischengespeicherte Inhalte durch dynamische Inhalte zu ersetzen, können Sie einen Ersatz erstellen. Standardmäßig fügen wir der Konfigurationsdatei einen CsrfTokenReplacer hinzu.

Sie können Ihre eigenen Ersetzungen erstellen, indem Sie die Schnittstelle SpatieResponseCacheReplacersReplacer implementieren. Werfen wir einen Blick auf die Benutzeroberfläche:

 interface Replacer
{
    / *
     * Prepare the initial response before it gets cached .
     *
     * For example : replace a generated csrf_token by '<csrf-token-here>' that you can
     * replace with its dynamic counterpart when the cached response is returned .
     * /
    public function prepareResponseToCache ( Response $ response ): void ;

    / *
     * Replace any data you want in the cached response before it gets
     * sent to the browser .
     *
     * For example : replace '<csrf-token-here>' by a call to csrf_token ()
     * /
    public function replaceInCachedResponse ( Response $ response ): void ;
}

Anschließend können Sie Ihren Ersatz in der Konfigurationsdatei responsecache.php definieren:

 /*
 * Here you may define replacers that dynamically replace content from the response.
 * Each replacer must implement the Replacer interface.
 */
'replacers' => [
    SpatieResponseCacheReplacersCsrfTokenReplacer::class,
],

Anpassen des Serialisierers

Ein Serialisierer ist dafür verantwortlich, eine Antwort zu serialisieren, damit sie im Cache gespeichert werden kann. Es ist auch für die Wiederherstellung der Antwort aus dem Cache verantwortlich.

Der Standard-Serializer SpatieResponseCacheSerializerDefaultSerializer funktioniert in den meisten Fällen einfach.

Wenn Sie spezielle Serialisierungsanforderungen haben, können Sie im serializer -Schlüssel der Konfigurationsdatei einen benutzerdefinierten Serializer angeben. Es kann jede Klasse verwendet werden, die SpatieResponseCacheSerializersSerializer implementiert. So sieht diese Schnittstelle aus:

 namespace Spatie  ResponseCache  Serializers ;

use Symfony  Component  HttpFoundation  Response ;

interface Serializer
{
    public function serialize ( Response $ response ): string ;

    public function unserialize ( string $ serializedResponse ): Response ;
}

Testen

Sie können die Tests ausführen mit:

composer test

Alternativen

Barry Vd. Heuvel hat ein Paket erstellt, das Antworten mithilfe von HttpCache zwischenspeichert.
Joseph Silber hat den Laravel Page Cache entwickelt, der seinen Cache auf die Festplatte schreiben und von Nginx lesen lassen kann, sodass PHP nicht einmal mehr gestartet werden muss.