Descargar laravel responsecache - Descarga del código fuente laravel responsecache

Este paquete de Laravel puede almacenar en caché una respuesta completa. De forma predeterminada, almacenará en caché todas las solicitudes de obtención exitosas que devuelvan contenido basado en texto (como html y json) durante una semana. Potencialmente, esto podría acelerar la respuesta considerablemente.

Entonces, la primera vez que llegue una solicitud al paquete se guardará la respuesta antes de enviarla a los usuarios. Cuando vuelve a recibir la misma solicitud, no revisamos toda la solicitud, sino que simplemente respondemos con la respuesta guardada.

¿Eres un aprendiz visual? Luego mire este video que explica cómo puede usar laravel-responsecache y cómo funciona internamente.

Apóyanos

Invertimos muchos recursos en la creación de los mejores paquetes de código abierto. Puedes apoyarnos comprando uno de nuestros productos pagos.

Apreciamos mucho que nos envíe una postal desde su ciudad natal, mencionando cuál de nuestros paquetes está utilizando. Encontrarás nuestra dirección en nuestra página de contacto. Publicamos todas las postales recibidas en nuestro muro virtual de postales.

Instalación

Si está utilizando PHP 7, instale la versión 6.x de este paquete.

Puede instalar el paquete a través del compositor:

composer require spatie/laravel-responsecache

El paquete se registrará automáticamente.

Puede publicar el archivo de configuración con:

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

Este es el contenido del archivo de configuración publicado:

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

Y finalmente debe instalar los middlewares proporcionados SpatieResponseCacheMiddlewaresCacheResponse::class y SpatieResponseCacheMiddlewaresDoNotCacheResponse .

Para laravel 11.x y posteriores:

Agregue las definiciones de middleware a la aplicación de arranque.

 // bootstrap / app . php


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

    . . .

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

Para laravel 10.x y versiones anteriores:

Agregue las definiciones de middleware al kernel http.

 // app / Http / Kernel . php

. . .

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

...

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

Uso

Uso básico

De forma predeterminada, el paquete almacenará en caché todas las solicitudes GET exitosas durante una semana. Los usuarios que hayan iniciado sesión tendrán cada uno su propio caché independiente. Si este comportamiento es lo que necesita, ya está: instalar ResponseCacheServiceProvider fue suficiente.

Borrar el caché

A mano

Todo el caché se puede borrar con:

ResponseCache:: clear ();

Esto borrará todo del almacén de caché especificado en el archivo de configuración.

Usando un comando de consola

Lo mismo se puede lograr emitiendo este comando artesanal:

php artisan responsecache:clear

Usando eventos modelo

Puede aprovechar los eventos del modelo para borrar el caché cada vez que se guarda o elimina un modelo. He aquí un ejemplo.

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

Olvidar uno o varios URI específicos

Puedes olvidar URI específicos con:

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

El método ResponseCache::forget solo funciona cuando no estás usando cacheNameSuffix en tu perfil de caché; usa ResponseCache::selectCachedItems para tratar con cacheNameSuffix .

Olvidar una selección de elementos almacenados en caché

Puede utilizar ResponseCache::selectCachedItems() para especificar qué elementos almacenados en caché deben olvidarse.

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

El cacheNameSuffix depende de su perfil de caché; de forma predeterminada, es el ID de usuario o una cadena vacía si no está autenticado.

Evitar que una solicitud se almacene en caché

Las solicitudes se pueden ignorar utilizando el middleware doNotCacheResponse . Este middleware se puede asignar a rutas y controladores.

Usando el middleware nuestra ruta podría estar exenta de ser almacenada en caché.

 // app / Http / routes . php

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

Alternativamente, puedes agregar el middleware a un controlador:

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

Omitir intencionalmente el caché

Es posible omitir el caché de manera deliberada y segura y garantizar que siempre reciba una respuesta nueva. Esto puede resultar útil en caso de que desee crear un perfil de algún punto final o en caso de que necesite depurar una respuesta. En cualquier caso, todo lo que necesita hacer es completar las variables de entorno CACHE_BYPASS_HEADER_NAME y CACHE_BYPASS_HEADER_VALUE y luego usar ese encabezado personalizado al realizar las solicitudes.

Crear un perfil de caché personalizado

Para determinar qué solicitudes deben almacenarse en caché y durante cuánto tiempo, se utiliza una clase de perfil de caché. La clase predeterminada que maneja estas preguntas es SpatieResponseCacheCacheProfilesCacheAllSuccessfulGetRequests .

Puede crear su propia clase de perfil de caché implementando la interfaz SpatieResponseCacheCacheProfilesCacheProfile . Echemos un vistazo a la interfaz:

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

Almacenamiento en caché de rutas específicas

En lugar de registrar globalmente el middleware cacheResponse , también puede registrarlo como middleware de ruta.

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

Al utilizar el middleware de rutas, puede especificar la cantidad de segundos que estas rutas deben almacenarse en caché:

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

Usando etiquetas

Si el controlador de caché que configuró admite etiquetas, puede especificar una lista de etiquetas al aplicar el 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 ' );

Borrar contenido etiquetado

Puede borrar las respuestas a las que se les ha asignado una etiqueta o una lista de etiquetas. Por ejemplo, esta declaración eliminaría las rutas '/test3' y '/test4' anteriores:

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

Por el contrario, esta declaración eliminaría sólo la ruta '/test2' :

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

Tenga en cuenta que esto utiliza la funcionalidad de etiquetas de caché integrada de Laravel, lo que significa que las rutas también se pueden borrar de la forma habitual:

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

Eventos

Hay varios eventos que puede utilizar para monitorear y depurar el almacenamiento en caché de respuestas en su aplicación.

RespuestaCachéHit

SpatieResponseCacheEventsResponseCacheHit

Este evento se activa cuando una solicitud pasa a través del middleware ResponseCache y se encuentra y devuelve una respuesta almacenada en caché.

cachéperdida

SpatieResponseCacheEventsCacheMissed

Este evento se activa cuando una solicitud pasa a través del middleware ResponseCache pero no se encuentra ni se devuelve ninguna respuesta almacenada en caché.

ClearingResponseCache y ClearedResponseCache

SpatieResponseCacheEventsClearingResponseCache

SpatieResponseCacheEventsClearedResponseCache

Estos eventos se activan respectivamente cuando se inicia y finaliza responsecache:clear .

Crear un sustituto

Para reemplazar contenido almacenado en caché por contenido dinámico, puede crear un sustituto. De forma predeterminada agregamos un CsrfTokenReplacer en el archivo de configuración.

Puede crear sus propios sustitutos implementando la interfaz SpatieResponseCacheReplacersReplacer . Echemos un vistazo a la interfaz:

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

Luego puede definir su sustituto en el archivo de configuración responsecache.php :

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

Personalizando el serializador

Un serializador es responsable de serializar una respuesta para que pueda almacenarse en el caché. También es responsable de reconstruir la respuesta del caché.

El serializador predeterminado SpatieResponseCacheSerializerDefaultSerializer funcionará en la mayoría de los casos.

Si tiene algunas necesidades especiales de serialización, puede especificar un serializador personalizado en la clave de serializer del archivo de configuración. Se puede utilizar cualquier clase que implemente SpatieResponseCacheSerializersSerializer . Así es como se ve esa interfaz:

 namespace Spatie  ResponseCache  Serializers ;

use Symfony  Component  HttpFoundation  Response ;

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

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

Pruebas

Puedes ejecutar las pruebas con:

composer test

Alternativas

Barry Vd. Heuvel creó un paquete que almacena en caché las respuestas aprovechando HttpCache.
Joseph Silber creó Laravel Page Cache que puede escribir su caché en el disco y dejar que Nginx los lea, por lo que PHP ni siquiera tiene que iniciarse.