Share
Oggi ti mostrerò il componente Symfony Cache, un modo semplice per aggiungere la cache alle tue applicazioni PHP. Ciò consente di migliorare le prestazioni generali dell'applicazione riducendo il tempo di caricamento della pagina.
Il componente Symfony Cache ti consente di configurare il caching nelle tue applicazioni PHP. Il componente stesso è molto facile da installare e configurare e consente di iniziare rapidamente. Inoltre, fornisce una varietà di adattatori tra cui scegliere, come mostrato nel seguente elenco:
Quando si tratta di fare il caching usando il componente Symfony Cache, ci sono un paio di termini con cui dovresti familiarizzare.
Per cominciare, il elemento della cache si riferisce al contenuto che è memorizzato. Ogni articolo è memorizzato come coppia chiave-valore. Gli elementi della cache sono gestiti da pool di cache, che li raggruppa logicamente. In realtà, è necessario utilizzare il pool di cache per manipolare i valori della cache. Finalmente, è il adattatore cache che fa tutto il pesante sollevamento per conservare gli oggetti nel cache back-end.
In questo articolo, esploreremo come liberare la potenza del componente Symfony Cache. Come al solito, inizieremo con l'installazione e la configurazione, quindi andremo ad esplorare alcuni esempi reali nella seconda metà dell'articolo.
In questa sezione, installeremo il componente Cache. Presumo che tu abbia già installato Composer nel tuo sistema: ne avrai bisogno per installare il componente Cache disponibile su Packagist.
Dopo aver installato Composer, andare avanti e installare il componente Cache usando il seguente comando.
$ compositore richiede symfony / cache
Questo dovrebbe aver creato un composer.json file che dovrebbe assomigliare a questo:
"require": "symfony / cache": "^ 4.1"
Questo è tutto per l'installazione, ma come dovresti aggiungerlo alla tua applicazione? È solo questione di includere il autoload.php file creato da Composer nella tua applicazione, come mostrato nello snippet seguente.
In questa sezione, vedremo un esempio che dimostra come utilizzare il componente Cache nelle applicazioni per memorizzare nella cache il contenuto.
Per cominciare, andiamo avanti e creare il index.php file con il seguente contenuto.
Accentsconagua
getItem ( 'demo_string'); if (! $ demoString-> isHit ()) $ demoString-> set ('Hello World!'); $ CachePool-> save ($ demoString); if ($ cachePool-> hasItem ('demo_string')) $ demoString = $ cachePool-> getItem ('demo_string'); echo $ demoString-> get (); echo "\ n"; // cancella tutti gli elementi $ cachePool-> clear (); if (! $ cachePool-> hasItem ('demo_string')) echo "La voce della cache demo_string è stata cancellata con successo! \ n"; // 2. memorizza i valori dell'array $ demoOne = $ cachePool-> getItem ('demo_array'); if (! $ demoOne-> isHit ()) $ demoOne-> set (array ("uno", "due", "tre")); $ CachePool-> save ($ demoOne); if ($ cachePool-> hasItem ('demo_array')) $ demoOne = $ cachePool-> getItem ('demo_array'); var_dump ($ demoOne-> get ()); echo "\ n"; // cancella l'elemento specifico $ cachePool-> deleteItem ('demo_array'); if (! $ cachePool-> hasItem ('demo_array')) echo "La voce di memoria demo_array è stata cancellata con successo! \ n"; // 3. imposta la scadenza sugli articoli $ pippo = $ cachePool-> getItem ('pippo'); if (! $ foo-> isHit ()) $ foo-> set ('bar'); $ Foo-> expiresAfter (30); $ CachePool-> save ($ foo); if ($ cachePool-> hasItem ('foo')) $ pippo = $ cachePool-> getItem ('pippo'); echo $ foo-> get (); echo "\ n"; sleep (60); if ($ cachePool-> hasItem ('foo')) $ pippo = $ cachePool-> getItem ('pippo'); echo $ foo-> get (); echo "\ n"; else echo "L'oggetto cache è scaduto! \ n"; Passiamo attraverso le parti principali del index.php file per capire il loro scopo.
Come discusso in precedenza, gli elementi memorizzati nella cache sono memorizzati in un pool di cache. Inoltre, ciascun pool di cache è supportato da uno specifico back-end e adattatore di cache. Se si desidera archiviare elementi nella cache del file system, ad esempio, è necessario inizializzare il pool di cache dell'adattatore del file system.
$ cachePool = new FilesystemAdapter (", 0," cache ");È possibile fornire tre argomenti facoltativi a FilesystemAdapter oggetto:
Poiché abbiamo già creato il pool di cache, possiamo utilizzarlo per archiviare gli elementi della cache.
Innanzitutto, usiamo il getItem metodo per recuperare l'elemento della cache con il demo_string chiave. Successivamente, usiamo il isHit metodo per verificare se il valore che stiamo cercando è già presente nell'elemento della cache $ demoString.
$ demoString = $ cachePool-> getItem ('demo_string'); if (! $ demoString-> isHit ()) $ demoString-> set ('Hello World!'); $ CachePool-> save ($ demoString); Poiché questa è la prima volta che stiamo recuperando il demo_string elemento della cache, il isHit il metodo dovrebbe tornare falso. Successivamente, usiamo il impostato metodo del $ demoString oggetto per impostare il valore della cache. Finalmente, salviamo il $ demoString elemento della cache in $ cachePool pool di cache utilizzando il salvare metodo.
Ora che abbiamo memorizzato l'elemento nella cache, vediamo come recuperarlo dalla cache.
if ($ cachePool-> hasItem ('demo_string')) $ demoString = $ cachePool-> getItem ('demo_string'); echo $ demoString-> get (); echo "\ n"; Qui, usiamo il hasItem metodo per verificare l'esistenza dell'elemento cache nel pool di cache prima di recuperarlo.
Successivamente, vediamo come eliminare tutti gli elementi della cache dal pool di cache:
$ CachePool-> clear ();
Nella sezione precedente, abbiamo discusso su come memorizzare i valori di base nel pool di cache. La memorizzazione dei valori dell'array è praticamente la stessa, come puoi vedere nel seguente esempio.
$ demoOne = $ cachePool-> getItem ('demo_array'); if (! $ demoOne-> isHit ()) $ demoOne-> set (array ("uno", "due", "tre")); $ CachePool-> save ($ demoOne); if ($ cachePool-> hasItem ('demo_array')) $ demoOne = $ cachePool-> getItem ('demo_array'); var_dump ($ demoOne-> get ()); echo "\ n"; Come puoi vedere, possiamo semplicemente impostare la cache con un valore di array, proprio come abbiamo fatto per una stringa.
Successivamente, vediamo come eliminare l'elemento di cache specifico dal pool di cache.
$ CachePool-> DeleteItem ( 'demo_array');
Qui, usiamo il cancellare l'oggetto metodo per eliminare il demo_array elemento dal pool di cache.
Finora, abbiamo messo nella cache gli articoli nel pool senza una data di scadenza. Tuttavia, in genere non si desidera memorizzare gli elementi nella cache in modo permanente. Ad esempio, è possibile aggiornare periodicamente gli elementi della cache, quindi è necessario un meccanismo che cancelli gli elementi della cache scaduti.
In questa sezione, discuteremo come conservare gli elementi nella cache insieme a una data di scadenza.
$ pippo = $ cachePool-> getItem ('pippo'); if (! $ foo-> isHit ()) $ foo-> set ('bar'); $ Foo-> expiresAfter (30); $ CachePool-> save ($ foo); Come puoi vedere nel frammento sopra, puoi usare il expiresAfter metodo per impostare una data di scadenza per l'elemento memorizzato nella cache. È possibile passare il numero di secondi in cui si desidera memorizzare nella cache un elemento per il primo argomento di expiresAfter metodo.
Nel nostro esempio, usiamo il dormire metodo per verificare se l'elemento memorizzato nella cache è ancora disponibile nel pool di cache.
if ($ cachePool-> hasItem ('foo')) $ pippo = $ cachePool-> getItem ('pippo'); echo $ foo-> get (); echo "\ n"; sleep (60); if ($ cachePool-> hasItem ('foo')) $ pippo = $ cachePool-> getItem ('pippo'); echo $ foo-> get (); echo "\ n"; else echo "L'oggetto cache è scaduto! \ n"; Vai avanti e provalo per vedere come funziona!
Oggi abbiamo dato una breve occhiata al componente Symfony Cache, che ti permette di configurare il caching nelle tue applicazioni PHP. Supporta inoltre una varietà di adattatori di memorizzazione nella cache che insieme offrono la flessibilità di scegliere il tipo di back-end che si desidera utilizzare.
Sentiti libero di esprimere i tuoi pensieri e le tue domande usando il modulo sottostante.
