Unduhan laravel responsecache - unduhan kode sumber laravel responsecache

Paket Laravel ini dapat menyimpan seluruh respons dalam cache. Secara default, ini akan menyimpan semua permintaan yang berhasil yang mengembalikan konten berbasis teks (seperti html dan json) selama seminggu. Hal ini berpotensi mempercepat respons secara signifikan.

Jadi pertama kali permintaan masuk dalam paket akan menyimpan responsnya sebelum mengirimkannya ke pengguna. Ketika permintaan yang sama masuk lagi, kami tidak akan memeriksa keseluruhan aplikasi namun hanya merespons dengan respons yang disimpan.

Apakah Anda seorang pembelajar visual? Kemudian tonton video ini yang membahas bagaimana Anda dapat menggunakan laravel-responsecache dan cara kerjanya.

Dukung kami

Kami menginvestasikan banyak sumber daya untuk menciptakan paket sumber terbuka terbaik di kelasnya. Anda dapat mendukung kami dengan membeli salah satu produk berbayar kami.

Kami sangat menghargai Anda mengirimi kami kartu pos dari kota asal Anda, yang menyebutkan paket kami mana yang Anda gunakan. Anda akan menemukan alamat kami di halaman kontak kami. Kami mempublikasikan semua kartu pos yang diterima di dinding kartu pos virtual kami.

Instalasi

Jika Anda menggunakan PHP 7, instal v6.x paket ini.

Anda dapat menginstal paket melalui composer:

composer require spatie/laravel-responsecache

Paket akan otomatis mendaftar sendiri.

Anda dapat mempublikasikan file konfigurasi dengan:

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

Ini adalah isi file konfigurasi yang dipublikasikan:

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

Dan terakhir Anda harus menginstal middleware yang disediakan SpatieResponseCacheMiddlewaresCacheResponse::class dan SpatieResponseCacheMiddlewaresDoNotCacheResponse .

Untuk laravel 11.x dan yang lebih baru:

Tambahkan definisi middleware ke aplikasi bootstrap.

 // bootstrap / app . php


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

    . . .

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

Untuk laravel 10.x dan sebelumnya:

Tambahkan definisi middleware ke kernel http.

 // app / Http / Kernel . php

. . .

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

...

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

Penggunaan

Penggunaan dasar

Secara default, paket akan menyimpan semua permintaan GET yang berhasil dalam cache selama seminggu. Setiap pengguna yang masuk akan memiliki cache tersendiri. Jika perilaku ini yang Anda perlukan, Anda sudah selesai: menginstal ResponseCacheServiceProvider sudah cukup.

Menghapus cache

Secara manual

Seluruh cache dapat dibersihkan dengan:

ResponseCache:: clear ();

Ini akan menghapus semuanya dari penyimpanan cache yang ditentukan dalam file konfigurasi.

Menggunakan perintah konsol

Hal yang sama dapat dilakukan dengan mengeluarkan perintah artisan ini:

php artisan responsecache:clear

Menggunakan peristiwa model

Anda dapat memanfaatkan peristiwa model untuk menghapus cache setiap kali model disimpan atau dihapus. Berikut ini contohnya.

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

Lupakan satu atau beberapa URI tertentu

Anda dapat melupakan URI tertentu dengan:

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

Metode ResponseCache::forget hanya berfungsi ketika Anda tidak menggunakan cacheNameSuffix di profil cache Anda, gunakan ResponseCache::selectCachedItems untuk menangani cacheNameSuffix .

Melupakan pilihan item yang di-cache

Anda dapat menggunakan ResponseCache::selectCachedItems() untuk menentukan item cache mana yang harus dilupakan.

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

cacheNameSuffix bergantung pada profil cache Anda, secara default adalah ID pengguna atau string kosong jika tidak diautentikasi.

Mencegah permintaan di-cache

Permintaan dapat diabaikan dengan menggunakan middleware doNotCacheResponse . Middleware ini dapat ditugaskan ke rute dan pengontrol.

Dengan menggunakan middleware, rute kami dapat dikecualikan dari cache.

 // app / Http / routes . php

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

Alternatifnya, Anda dapat menambahkan middleware ke pengontrol:

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

Sengaja melewati cache

Anda dapat dengan sengaja dan aman melewati cache dan memastikan Anda selalu menerima respons baru. Ini mungkin berguna jika Anda ingin membuat profil beberapa titik akhir atau jika Anda perlu men-debug respons. Apa pun kasusnya, yang perlu Anda lakukan hanyalah mengisi variabel lingkungan CACHE_BYPASS_HEADER_NAME dan CACHE_BYPASS_HEADER_VALUE lalu menggunakan header khusus tersebut saat menjalankan permintaan.

Membuat profil cache khusus

Untuk menentukan permintaan mana yang harus di-cache, dan berapa lama, kelas profil cache digunakan. Kelas default yang menangani pertanyaan ini adalah SpatieResponseCacheCacheProfilesCacheAllSuccessfulGetRequests .

Anda dapat membuat kelas profil cache Anda sendiri dengan mengimplementasikan antarmuka SpatieResponseCacheCacheProfilesCacheProfile . Mari kita lihat antarmukanya:

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

Menyimpan rute tertentu dalam cache

Daripada mendaftarkan middleware cacheResponse secara global, Anda juga dapat mendaftarkannya sebagai middleware rute.

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

Saat menggunakan middleware rute, Anda dapat menentukan berapa detik rute ini harus di-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 ' );

Menggunakan tag

Jika driver cache yang Anda konfigurasi mendukung tag, Anda dapat menentukan daftar tag saat menerapkan 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 ' );

Menghapus konten yang diberi tag

Anda dapat menghapus tanggapan yang diberi tag atau daftar tag. Misalnya, pernyataan ini akan menghapus rute '/test3' dan '/test4' di atas:

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

Sebaliknya, pernyataan ini hanya akan menghapus rute '/test2' :

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

Perhatikan bahwa ini menggunakan fungsionalitas tag cache bawaan Laravel, artinya rute juga dapat dibersihkan dengan cara biasa:

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

Acara

Ada beberapa peristiwa yang dapat Anda gunakan untuk memantau dan men-debug cache respons di aplikasi Anda.

ResponCacheHit

SpatieResponseCacheEventsResponseCacheHit

Peristiwa ini dipicu ketika permintaan melewati middleware ResponseCache dan respons yang di-cache ditemukan dan dikembalikan.

CacheTerlewatkan

SpatieResponseCacheEventsCacheMissed

Peristiwa ini dipicu ketika permintaan melewati middleware ResponseCache tetapi tidak ada respons cache yang ditemukan atau dikembalikan.

ClearingResponseCache dan ClearedResponseCache

SpatieResponseCacheEventsClearingResponseCache

SpatieResponseCacheEventsClearedResponseCache

Peristiwa ini dipicu masing-masing ketika responsecache:clear dimulai dan selesai.

Membuat Pengganti

Untuk mengganti konten yang di-cache dengan konten dinamis, Anda dapat membuat penggantinya. Secara default kami menambahkan CsrfTokenReplacer di file konfigurasi.

Anda dapat membuat pengganti Anda sendiri dengan mengimplementasikan antarmuka SpatieResponseCacheReplacersReplacer . Mari kita lihat antarmukanya:

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

Setelah itu Anda dapat menentukan pengganti Anda di file konfigurasi responsecache.php :

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

Menyesuaikan serializer

Serializer bertanggung jawab untuk membuat serialisasi respons sehingga dapat disimpan dalam cache. Ia juga bertanggung jawab untuk membangun kembali respons dari cache.

Serializer default SpatieResponseCacheSerializerDefaultSerializer hanya akan berfungsi dalam banyak kasus.

Jika Anda memiliki kebutuhan serialisasi khusus, Anda dapat menentukan serializer khusus di kunci serializer pada file konfigurasi. Kelas apa pun yang mengimplementasikan SpatieResponseCacheSerializersSerializer dapat digunakan. Seperti inilah tampilan antarmukanya:

 namespace Spatie  ResponseCache  Serializers ;

use Symfony  Component  HttpFoundation  Response ;

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

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

Pengujian

Anda dapat menjalankan tes dengan:

composer test

Alternatif

Barry Vd. Heuvel membuat paket yang menyimpan respons dalam cache dengan memanfaatkan HttpCache.
Joseph Silber membuat Laravel Page Cache yang dapat menulis cache-nya ke disk dan membiarkan Nginx membacanya, sehingga PHP bahkan tidak perlu memulai lagi.