Share
In questo articolo, esploreremo la libreria PhpFastCache, che ti consente di implementare il caching nelle tue applicazioni PHP. Pertanto, aiuta a migliorare le prestazioni generali del sito Web e i tempi di caricamento della pagina.
PhpFastCache è una libreria che semplifica l'implementazione del caching nelle tue applicazioni PHP. È una libreria facile da usare ma potente che fornisce diverse API per aiutarti a implementare una strategia di caching a tua scelta senza troppi problemi.
Non commettere l'errore di presumere che si tratta semplicemente di uno schema di memorizzazione nella cache del file system tradizionale. Infatti, PhpFastCache supporta una pletora di adattatori che ti permettono di scegliere tra back-end ad alte prestazioni come Memcache, Redis, MongoDB, CouchDB e altri.
Diamo una rapida occhiata ad alcuni degli adattatori più popolari:
Se non trovi la tua scelta di adattatore nell'elenco sopra, potresti facilmente sviluppare un driver personalizzato che si collega al sistema e funziona senza sforzo.
Oltre alla funzionalità di base, la libreria PhpFastCache fornisce anche un meccanismo di eventi che consente di rispondere a determinati eventi predefiniti. Ad esempio, quando qualcosa viene eliminato dalla cache, è possibile rilevare questo evento e aggiornare o eliminare i dati correlati.
Nelle prossime sezioni, passeremo attraverso l'installazione e la configurazione di PhpFastCache, insieme alla dimostrazione di alcuni esempi.
In questa sezione, passeremo attraverso l'installazione e la configurazione della libreria PhpFastCache. Ci sono diversi modi in cui puoi avvicinarti a questo nel tuo progetto.
Se vuoi solo scaricare il .cerniera lampo o .tar.gz versione della libreria senza troppi problemi, si potrebbe andare avanti e afferrarlo dal sito ufficiale.
D'altra parte, è possibile installarlo anche come pacchetto Composer. Questo dovrebbe essere il modo preferito in quanto rende la manutenzione e l'aggiornamento più facili in futuro. Se non hai ancora installato Composer, dovrai farlo prima.
Una volta installato Composer, andiamo avanti e prendiamo la libreria PhpFastCache usando il seguente comando.
$ compositore richiede phpfastcache / phpfastcache
Una volta completato con successo il comando, è necessario disporre della directory del fornitore, che contiene tutto il necessario per eseguire la libreria PhpFastCache. D'altra parte, se ti mancano librerie o estensioni richieste dalla libreria PhpFastCache, Composer ti chiederà di installarle prima.
Dovresti anche trovare il composer.json file che assomiglia a questo:
"require": "phpfastcache / phpfastcache": "^ 6.1"
Indipendentemente dal modo in cui hai scelto di installare la libreria PhpFastCache, l'unica cosa necessaria è includere il file autoload.php file nella tua applicazione per dare il via.
Se stai utilizzando il flusso di lavoro basato su Composer, autoload.php si trova sotto il venditore elenco.
// Includere il caricatore automatico per compositore richiede 'YOUR_APP_PATH /vendor/autoload.php';
D'altra parte, se hai scaricato il .cerniera lampo o .tar.gz pacchetto, autoload.php dovrebbe essere disponibile a src / autoload.php.
// Includi autoloader richiede 'YOUR_APP_PATH /src/autoload.php';
E con questo, è tutto pronto per iniziare il caching e ottenere i benefici della straordinaria libreria PhpFastCache. Nella prossima sezione analizzeremo un paio di esempi pratici che dimostrano come utilizzare PhpFastCache nella tua applicazione.
Ho già detto che la libreria PhpFastCache supporta vari adattatori per quanto riguarda la memorizzazione nella cache. In questa sezione, dimostrerò utilizzando il file system e gli adattatori Redis.
Vai avanti e crea il file_cache_example.php file con il seguente contenuto. Presumo che tu stia utilizzando il flusso di lavoro Composer e quindi il venditore directory è allo stesso livello di quella di file_cache_example.php. Se PhpFastCache è stato installato manualmente, è possibile modificare di conseguenza la struttura del file.
Accentsconagua
__DIR__. "/ cache"]); // Ottieni l'istanza dei file nella cache $ objFilesCache = CacheManager :: getInstance ('file'); $ key = "welcome_message"; // Prova a recuperare l'elemento memorizzato nella cache con la chiave "welcome_message" $ CachedString = $ objFilesCache-> getItem ($ key); if (is_null ($ CachedString-> get ())) // La voce memorizzata non esiste $ numberOfSeconds = 60; $ CachedString-> set ("Questo sito Web utilizza PhpFastCache!") -> expiresAfter ($ numberOfSeconds); $ ObjFilesCache-> save ($ CachedString); echo "Non ancora nella cache, lo impostiamo nella cache e proviamo a scaricarlo dalla cache!"; echo" Il valore di welcome_message: ". $ CachedString-> get (); else // La voce cache esiste echo" Già nella cache!"; echo" Il valore di welcome_message: ". $ CachedString-> get ();Passiamo attraverso questo per capire cosa significa ogni pezzo di codice. La prima cosa ovvia è includere il autoload.php file e importa lo spazio dei nomi che intendiamo utilizzare.
// Includi autoloader del compositore richiede __DIR__. '/Vendor/autoload.php'; usa phpFastCache \ CacheManager;
Quando si utilizza la cache dei file, si suppone di fornire il percorso della directory che contiene i file generati dal sistema di memorizzazione nella cache. Ed è esattamente ciò che abbiamo configurato nel seguente frammento.
// Inizializzazione della configurazione predefinita per l'adattatore "files" CacheManager :: setDefaultConfig (["percorso" => __DIR__. "/ Cache"]);
Certo, dobbiamo assicurarci che il nascondiglio la directory esiste ed è scrivibile dal server web.
Successivamente, istanziamo l'oggetto cache e proviamo a caricare l'elemento memorizzato nella cache con messaggio di benvenuto chiave.
// Ottieni l'istanza dei file nella cache $ objFilesCache = CacheManager :: getInstance ('file'); $ key = "welcome_message"; // Prova a recuperare l'elemento memorizzato nella cache con la chiave "welcome_message" $ CachedString = $ objFilesCache-> getItem ($ key);Se l'elemento non esiste nella cache, lo aggiungeremo alla cache per 60 secondi e lo visualizzeremo dalla cache. D'altra parte, se esiste nella cache, lo recupereremo!
if (is_null ($ CachedString-> get ())) // La voce memorizzata non esiste $ numberOfSeconds = 60; $ CachedString-> set ("Questo sito Web utilizza PhpFastCache!") -> expiresAfter ($ numberOfSeconds); $ ObjFilesCache-> save ($ CachedString); echo "Non ancora nella cache, lo impostiamo nella cache e proviamo a scaricarlo dalla cache!"; echo" Il valore di welcome_message: ". $ CachedString-> get (); else // La voce cache esiste echo" Già nella cache!"; echo" Il valore di welcome_message: ". $ CachedString-> get ();Era un setup abbastanza facile, no? In effetti, puoi andare avanti ed eseguire il file per verificare i risultati!
Quando lo esegui per la prima volta, dovresti vedere il seguente output:
Non ancora nella cache, lo mettiamo nella cache e proviamo a scaricarlo dalla cache! Il valore di welcome_message: questo sito Web utilizza PhpFastCache!
Nella prossima esecuzione, l'output è simile a questo:
Già nella cache! Il valore di welcome_message: questo sito Web utilizza PhpFastCache!
Quindi quello era il caching del file system a tua disposizione. Nella prossima sezione, faremo lo stesso esempio usando l'adattatore cache Redis.
Prima di andare avanti, presumo che tu abbia già installato il server Redis ed è in esecuzione sulla porta 6379, che è la porta predefinita per Redis.
Con questo set up, andiamo avanti e creare il redis_cache_example.php file con il seguente contenuto.
'127.0.0.1', "port" => 6379]); // Ottieni istanze di file cache $ objRedisCache = CacheManager :: getInstance ('redis'); $ key = "welcome_message"; // Prova a recuperare l'elemento memorizzato nella cache con la chiave "welcome_message" $ CachedString = $ objRedisCache-> getItem ($ key); if (is_null ($ CachedString-> get ())) // La voce memorizzata non esiste $ numberOfSeconds = 60; $ CachedString-> set ("Questo sito Web utilizza PhpFastCache!") -> expiresAfter ($ numberOfSeconds); $ ObjRedisCache-> save ($ CachedString); echo "Non ancora nella cache, lo impostiamo nella cache e proviamo a scaricarlo dalla cache!"; echo" Il valore di welcome_message: ". $ CachedString-> get (); else // La voce cache esiste echo" Già nella cache!"; echo" Il valore di welcome_message: ". $ CachedString-> get ();Come puoi vedere, il file è praticamente lo stesso, ad eccezione della sezione che inizializza la configurazione specifica per l'adattatore Redis.
// Inizializzazione della configurazione predefinita per l'adattatore "redis" CacheManager :: setDefaultConfig (["host" => '127.0.0.1', "port" => 6379]);
Ovviamente, è necessario modificare le impostazioni dell'host e della porta in modo che corrispondano ai propri requisiti se si sta utilizzando un server Redis diverso da localhost.
Vai avanti e avvia il redis_cache_example.php file per vedere come funziona. Puoi anche confermarlo controllando l'output nella CLI Redis.
127.0.0.1:6379> KEYS * 1) "welcome_message"
Questo è tutto ciò che serve per utilizzare l'adattatore Redis. Ti incoraggio a provare diversi adattatori e le loro opzioni!
Oggi abbiamo analizzato una delle librerie di caching più popolari per PHP-PhpFastCache. Nella prima metà dell'articolo, abbiamo discusso le nozioni di base insieme all'installazione e alla configurazione. Più avanti nell'articolo, abbiamo analizzato un paio di esempi per dimostrare i concetti di cui abbiamo discusso.
Spero che ti sia piaciuto l'articolo e che sarai motivato ad integrare la libreria PhpFastCache nei tuoi prossimi progetti. Sentiti libero di postare qualsiasi domanda e commento qui sotto!
