laravel responsecache Télécharger - laravel responsecache Téléchargement du code source

Ce package Laravel peut mettre en cache une réponse entière. Par défaut, il mettra en cache toutes les demandes d'obtention réussies qui renvoient du contenu textuel (tel que HTML et JSON) pendant une semaine. Cela pourrait potentiellement accélérer considérablement la réponse.

Ainsi, la première fois qu'une demande arrive dans le package, la réponse sera enregistrée avant de l'envoyer aux utilisateurs. Lorsque la même demande revient, nous ne parcourons pas l'intégralité de l'application, mais répondons simplement avec la réponse enregistrée.

Êtes-vous un apprenant visuel? Ensuite, regardez cette vidéo qui explique comment utiliser laravel-responsecache et comment il fonctionne sous le capot.

Soutenez-nous

Nous investissons beaucoup de ressources dans la création des meilleurs packages open source de leur catégorie. Vous pouvez nous soutenir en achetant l'un de nos produits payants.

Nous apprécions grandement que vous nous envoyiez une carte postale de votre ville natale, mentionnant le(s) forfait(s) que vous utilisez. Vous trouverez notre adresse sur notre page contact. Nous publions toutes les cartes postales reçues sur notre mur virtuel de cartes postales.

Installation

Si vous utilisez PHP 7, installez la v6.x de ce package.

Vous pouvez installer le package via composer :

composer require spatie/laravel-responsecache

Le package s’enregistrera automatiquement.

Vous pouvez publier le fichier de configuration avec :

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

Voici le contenu du fichier de configuration publié :

 // 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,
];

Et enfin, vous devez installer les middlewares fournis SpatieResponseCacheMiddlewaresCacheResponse::class et SpatieResponseCacheMiddlewaresDoNotCacheResponse .

Pour Laravel 11.x et versions ultérieures :

Ajoutez les définitions de middleware à l'application d'amorçage.

 // bootstrap / app . php


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

    . . .

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

Pour Laravel 10.x et versions antérieures :

Ajoutez les définitions de middleware au noyau http.

 // app / Http / Kernel . php

. . .

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

...

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

Usage

Utilisation de base

Par défaut, le package mettra en cache toutes les requêtes GET réussies pendant une semaine. Les utilisateurs connectés auront chacun leur propre cache distinct. Si ce comportement est ce dont vous avez besoin, vous avez terminé : l’installation de ResponseCacheServiceProvider était suffisante.

Vider le cache

Manuellement

L'intégralité du cache peut être effacée avec :

ResponseCache:: clear ();

Cela effacera tout du cache spécifié dans le fichier de configuration.

Utiliser une commande de console

La même chose peut être accomplie en émettant cette commande artisanale :

php artisan responsecache:clear

Utiliser des événements de modèle

Vous pouvez exploiter les événements du modèle pour vider le cache chaque fois qu'un modèle est enregistré ou supprimé. Voici un exemple.

 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 ();
        });
    }
}

Oublier un ou plusieurs URI spécifiques

Vous pouvez oublier des URI spécifiques avec :

 // 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 ' );

La méthode ResponseCache::forget ne fonctionne que lorsque vous n'utilisez pas de cacheNameSuffix dans votre profil de cache, utilisez ResponseCache::selectCachedItems pour gérer cacheNameSuffix .

Oublier une sélection d'éléments mis en cache

Vous pouvez utiliser ResponseCache::selectCachedItems() pour spécifier quels éléments mis en cache doivent être oubliés.

 // 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 ();

Le cacheNameSuffix dépend de votre profil de cache. Par défaut, il s'agit de l'ID utilisateur ou d'une chaîne vide si elle n'est pas authentifiée.

Empêcher la mise en cache d'une requête

Les requêtes peuvent être ignorées à l’aide du middleware doNotCacheResponse . Ce middleware peut être attribué aux routes et aux contrôleurs.

En utilisant le middleware, notre itinéraire pourrait être exempté de la mise en cache.

 // app / Http / routes . php

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

Alternativement, vous pouvez ajouter le middleware à un contrôleur :

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

Contourner volontairement le cache

Il est possible de contourner le cache de manière délibérée et sécurisée et de garantir que vous recevez toujours une nouvelle réponse. Cela peut être utile si vous souhaitez profiler un point de terminaison ou si vous devez déboguer une réponse. Dans tous les cas, tout ce que vous avez à faire est de remplir les variables d'environnement CACHE_BYPASS_HEADER_NAME et CACHE_BYPASS_HEADER_VALUE , puis d'utiliser cet en-tête personnalisé lors de l'exécution des requêtes.

Création d'un profil de cache personnalisé

Pour déterminer quelles requêtes doivent être mises en cache et pendant combien de temps, une classe de profil de cache est utilisée. La classe par défaut qui gère ces questions est SpatieResponseCacheCacheProfilesCacheAllSuccessfulGetRequests .

Vous pouvez créer votre propre classe de profil de cache en implémentant l'interface SpatieResponseCacheCacheProfilesCacheProfile . Jetons un coup d'œil à l'interface :

 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 );
}

Mise en cache d'itinéraires spécifiques

Au lieu d’enregistrer globalement le middleware cacheResponse , vous pouvez également l’enregistrer en tant que middleware de route.

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

Lorsque vous utilisez le middleware de routes, vous pouvez spécifier le nombre de secondes pendant lesquelles ces routes doivent être mises en cache :

 // 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 ' );

Utiliser des balises

Si le pilote de cache que vous avez configuré prend en charge les balises, vous pouvez spécifier une liste de balises lors de l'application du middleware.

 // 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 ' );

Supprimer le contenu balisé

Vous pouvez effacer les réponses auxquelles une balise ou une liste de balises est attribuée. Par exemple, cette instruction supprimerait les routes '/test3' et '/test4' ci-dessus :

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

En revanche, cette instruction supprimerait uniquement la route '/test2' :

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

Notez que cela utilise la fonctionnalité de balises de cache intégrée de Laravel, ce qui signifie que les routes peuvent également être effacées de la manière habituelle :

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

Événements

Il existe plusieurs événements que vous pouvez utiliser pour surveiller et déboguer la mise en cache des réponses dans votre application.

RéponseCacheHit

SpatieResponseCacheEventsResponseCacheHit

Cet événement est déclenché lorsqu'une requête passe via le middleware ResponseCache et qu'une réponse mise en cache a été trouvée et renvoyée.

Cache manqué

SpatieResponseCacheEventsCacheMissed

Cet événement est déclenché lorsqu'une requête passe via le middleware ResponseCache mais qu'aucune réponse mise en cache n'a été trouvée ou renvoyée.

ClearingResponseCache et ClearedResponseCache

SpatieResponseCacheEventsClearingResponseCache

SpatieResponseCacheEventsClearedResponseCache

Ces événements sont déclenchés respectivement lorsque le responsecache:clear est démarré et terminé.

Création d'un remplaçant

Pour remplacer le contenu mis en cache par du contenu dynamique, vous pouvez créer un remplaçant. Par défaut, nous ajoutons un CsrfTokenReplacer dans le fichier de configuration.

Vous pouvez créer vos propres remplaçants en implémentant l'interface SpatieResponseCacheReplacersReplacer . Jetons un coup d'œil à l'interface :

 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 ;
}

Ensuite vous pouvez définir votre remplaçant dans le fichier de configuration responsecache.php :

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

Personnalisation du sérialiseur

Un sérialiseur est chargé de sérialiser une réponse afin qu'elle puisse être stockée dans le cache. Il est également responsable de la reconstruction de la réponse à partir du cache.

Le sérialiseur par défaut SpatieResponseCacheSerializerDefaultSerializer fonctionnera dans la plupart des cas.

Si vous avez des besoins particuliers en matière de sérialisation, vous pouvez spécifier un sérialiseur personnalisé dans la clé serializer du fichier de configuration. Toute classe qui implémente SpatieResponseCacheSerializersSerializer peut être utilisée. Voici à quoi ressemble cette interface :

 namespace Spatie  ResponseCache  Serializers ;

use Symfony  Component  HttpFoundation  Response ;

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

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

Essai

Vous pouvez exécuter les tests avec :

composer test

Alternatives

Barry Vd. Heuvel a créé un package qui met en cache les réponses en exploitant HttpCache.
Joseph Silber a créé Laravel Page Cache qui peut écrire son cache sur le disque et laisser Nginx les lire, donc PHP n'a même plus besoin de démarrer.