Download laravel responsecache - download do código-fonte laravel responsecache

Este pacote Laravel pode armazenar em cache uma resposta inteira. Por padrão, ele armazenará em cache todas as solicitações get bem-sucedidas que retornam conteúdo baseado em texto (como HTML e JSON) por uma semana. Isso poderia acelerar consideravelmente a resposta.

Portanto, a primeira vez que uma solicitação chegar no pacote salvará a resposta antes de enviá-la aos usuários. Quando a mesma solicitação chega novamente, não percorremos todo o aplicativo, apenas respondemos com a resposta salva.

Você é um aprendiz visual? Então assista a este vídeo que aborda como você pode usar o laravel-responsecache e como ele funciona nos bastidores.

Apoie-nos

Investimos muitos recursos na criação dos melhores pacotes de código aberto. Você pode nos apoiar comprando um de nossos produtos pagos.

Agradecemos muito que você nos envie um cartão postal de sua cidade natal, mencionando qual(is) de nossos pacotes você está usando. Você encontrará nosso endereço em nossa página de contato. Publicamos todos os cartões postais recebidos em nosso mural virtual de cartões postais.

Instalação

Se você estiver usando PHP 7, instale a v6.x deste pacote.

Você pode instalar o pacote via compositor:

composer require spatie/laravel-responsecache

O pacote será registrado automaticamente.

Você pode publicar o arquivo de configuração com:

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

Este é o conteúdo do arquivo de configuração 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,
];

E finalmente você deve instalar os middlewares fornecidos SpatieResponseCacheMiddlewaresCacheResponse::class e SpatieResponseCacheMiddlewaresDoNotCacheResponse .

Para laravel 11.xe mais recente:

Adicione as definições de middleware ao aplicativo de inicialização.

 // 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 e anteriores:

Adicione as definições de middleware ao 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

Por padrão, o pacote armazenará em cache todas as solicitações GET bem-sucedidas por uma semana. Cada usuário conectado terá seu próprio cache separado. Se esse comportamento for o que você precisa, pronto: instalar o ResponseCacheServiceProvider foi suficiente.

Limpando o cache

Manualmente

Todo o cache pode ser limpo com:

ResponseCache:: clear ();

Isso limpará tudo do armazenamento de cache especificado no arquivo de configuração.

Usando um comando de console

O mesmo pode ser feito emitindo este comando artesão:

php artisan responsecache:clear

Usando eventos de modelo

Você pode aproveitar eventos de modelo para limpar o cache sempre que um modelo for salvo ou excluído. Aqui está um exemplo.

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

Esqueça um ou vários URIs específicos

Você pode esquecer URIs específicos com:

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

O método ResponseCache::forget só funciona quando você não está usando um cacheNameSuffix em seu perfil de cache, use ResponseCache::selectCachedItems para lidar com cacheNameSuffix .

Esquecendo uma seleção de itens em cache

Você pode usar ResponseCache::selectCachedItems() para especificar quais itens em cache devem ser esquecidos.

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

O cacheNameSuffix depende do seu perfil de cache, por padrão é o ID do usuário ou uma string vazia se não for autenticado.

Evitando que uma solicitação seja armazenada em cache

As solicitações podem ser ignoradas usando o middleware doNotCacheResponse . Este middleware pode ser atribuído a rotas e controladores.

Usando o middleware, nossa rota pode ficar isenta de armazenamento em cache.

 // app / Http / routes . php

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

Alternativamente, você pode adicionar o middleware a um controlador:

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

Ignorando propositalmente o cache

É possível ignorar o cache de maneira proposital e segura e garantir que você sempre receba uma resposta nova. Isso pode ser útil caso você queira criar o perfil de algum endpoint ou caso precise depurar uma resposta. De qualquer forma, tudo que você precisa fazer é preencher as variáveis de ambiente CACHE_BYPASS_HEADER_NAME e CACHE_BYPASS_HEADER_VALUE e então usar esse cabeçalho customizado ao realizar as solicitações.

Criando um perfil de cache personalizado

Para determinar quais solicitações devem ser armazenadas em cache e por quanto tempo, uma classe de perfil de cache é usada. A classe padrão que trata dessas questões é SpatieResponseCacheCacheProfilesCacheAllSuccessfulGetRequests .

Você pode criar sua própria classe de perfil de cache implementando a interface SpatieResponseCacheCacheProfilesCacheProfile . Vamos dar uma olhada na 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 );
}

Armazenando rotas específicas em cache

Em vez de registrar o middleware cacheResponse globalmente, você também pode registrá-lo como middleware de rota.

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

Ao usar o middleware de rota, você pode especificar o número de segundos que essas rotas devem ser armazenadas em 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 ' );

Usando tags

Se o driver de cache configurado suportar tags, você poderá especificar uma lista de tags ao aplicar o 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 ' );

Limpar conteúdo marcado

Você pode limpar as respostas às quais foi atribuída uma tag ou lista de tags. Por exemplo, esta instrução removeria as rotas '/test3' e '/test4' acima:

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

Por outro lado, esta instrução removeria apenas a rota '/test2' :

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

Observe que isso usa a funcionalidade de tags de cache integradas do Laravel, o que significa que as rotas também podem ser limpas da maneira usual:

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

Eventos

Existem vários eventos que você pode usar para monitorar e depurar o cache de resposta em seu aplicativo.

ResponseCacheHit

SpatieResponseCacheEventsResponseCacheHit

Este evento é disparado quando uma solicitação passa pelo middleware ResponseCache e uma resposta armazenada em cache é encontrada e retornada.

Cache perdido

SpatieResponseCacheEventsCacheMissed

Este evento é disparado quando uma solicitação passa pelo middleware ResponseCache mas nenhuma resposta armazenada em cache foi encontrada ou retornada.

ClearingResponseCache e ClearedResponseCache

SpatieResponseCacheEventsClearingResponseCache

SpatieResponseCacheEventsClearedResponseCache

Esses eventos são disparados respectivamente quando o responsecache:clear é iniciado e finalizado.

Criando um substituto

Para substituir o conteúdo armazenado em cache por conteúdo dinâmico, você pode criar um substituto. Por padrão, adicionamos um CsrfTokenReplacer no arquivo de configuração.

Você pode criar seus próprios substitutos implementando a interface SpatieResponseCacheReplacersReplacer . Vamos dar uma olhada na 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 ;
}

Depois você pode definir seu substituto no arquivo de configuração 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 o serializador

Um serializador é responsável por serializar uma resposta para que ela possa ser armazenada no cache. Também é responsável por reconstruir a resposta do cache.

O serializador padrão SpatieResponseCacheSerializerDefaultSerializer funcionará apenas na maioria dos casos.

Se você tiver alguma necessidade especial de serialização, poderá especificar um serializador personalizado na chave do serializer do arquivo de configuração. Qualquer classe que implemente SpatieResponseCacheSerializersSerializer pode ser usada. Esta é a aparência dessa interface:

 namespace Spatie  ResponseCache  Serializers ;

use Symfony  Component  HttpFoundation  Response ;

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

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

Teste

Você pode executar os testes com:

composer test

Alternativas

Barry Vd. Heuvel criou um pacote que armazena respostas em cache aproveitando o HttpCache.
Joseph Silber criou o Laravel Page Cache que pode gravar seu cache no disco e deixar o Nginx lê-los, para que o PHP nem precise mais inicializar.