Share
Heute zeige ich Ihnen die Symfony Cache-Komponente, eine einfache Möglichkeit, Ihren PHP-Anwendungen Caching hinzuzufügen. Dadurch wird die Gesamtleistung Ihrer Anwendung verbessert, indem die Ladezeit der Seite reduziert wird.
Mit der Symfony Cache-Komponente können Sie das Caching in Ihren PHP-Anwendungen einrichten. Die Komponente selbst ist sehr einfach zu installieren und zu konfigurieren und ermöglicht einen schnellen Einstieg. Außerdem bietet es eine Vielzahl von Adaptern zur Auswahl, wie in der folgenden Liste dargestellt:
Beim Zwischenspeichern mit der Symfony Cache-Komponente gibt es einige Begriffe, mit denen Sie sich vertraut machen sollten.
Zunächst einmal die Cache-Element bezieht sich auf den Inhalt, der gespeichert wird. Jedes Element wird als Schlüsselwertpaar gespeichert. Die Cache-Elemente werden vom verwaltet Cache-Pool, welche gruppiert sie logisch. Tatsächlich müssen Sie den Cache-Pool verwenden, um die Cache-Werte zu bearbeiten. Endlich ist es das Cache-Adapter Das macht alles, was schwer ist, um Gegenstände in der Cache-Backend.
In diesem Artikel erfahren Sie, wie Sie die Leistungsfähigkeit der Symfony Cache-Komponente entfalten können. Wie üblich beginnen wir mit der Installation und Konfiguration. Anschließend werden wir in der zweiten Hälfte des Artikels einige Beispiele aus der Praxis untersuchen.
In diesem Abschnitt installieren wir die Cache-Komponente. Ich gehe davon aus, dass Sie Composer bereits in Ihrem System installiert haben. Sie benötigen ihn, um die bei Packagist verfügbare Cache-Komponente zu installieren.
Nachdem Sie Composer installiert haben, installieren Sie die Cache-Komponente mit dem folgenden Befehl.
$ composer erfordert Symfony / Cache
Das hätte einen schaffen sollen composer.json Datei, die so aussehen sollte:
"required": "symfony / cache": "^ 4.1"
Das ist alles für die Installation, aber wie sollen Sie es Ihrer Anwendung hinzufügen? Es ist nur eine Frage der Einbeziehung der autoload.php Datei, die von Composer in Ihrer Anwendung erstellt wurde, wie im folgenden Snippet gezeigt.
In diesem Abschnitt wird ein Beispiel beschrieben, in dem gezeigt wird, wie Sie die Cache-Komponente in Ihren Anwendungen zum Zwischenspeichern von Inhalten verwenden können.
Beginnen wir mit dem Erstellen des index.php Datei mit folgendem Inhalt.
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"; // lösche alle Elemente $ cachePool-> clear (); if (! $ cachePool-> hasItem ('demo_string')) echo "Der Cache-Eintrag demo_string wurde erfolgreich gelöscht! \ n"; // 2. speichere Array-Werte $ demoOne = $ cachePool-> getItem ('demo_array'); if (! $ demoOne-> isHit ()) $ demoOne-> set (array ("eins", "zwei", "drei")); $ cachePool-> save ($ demoOne); if ($ cachePool-> hasItem ('demo_array')) $ demoOne = $ cachePool-> getItem ('demo_array'); var_dump ($ demoOne-> get ()); Echo "\ n"; // bestimmtes Element löschen $ cachePool-> deleteItem ('demo_array'); if (! $ cachePool-> hasItem ('demo_array')) echo "Der Cache-Eintrag demo_array wurde erfolgreich gelöscht! \ n"; // 3. Ablauf für Elemente setzen $ foo = $ cachePool-> getItem ('foo'); if (! $ foo-> isHit ()) $ foo-> set ('bar'); $ foo-> verfällt nach (30); $ cachePool-> save ($ foo); if ($ cachePool-> hasItem ('foo')) $ foo = $ cachePool-> getItem ('foo'); echo $ foo-> get (); Echo "\ n"; Schlaf (60); if ($ cachePool-> hasItem ('foo')) $ foo = $ cachePool-> getItem ('foo'); echo $ foo-> get (); Echo "\ n"; else echo "Cache-Element ist abgelaufen! \ n"; Gehen wir durch die Hauptteile der index.php Datei, um ihren Zweck zu verstehen.
Wie bereits erwähnt, werden zwischengespeicherte Elemente in einem Cache-Pool gespeichert. Darüber hinaus wird jeder Cache-Pool von einem bestimmten Cache-Back-End und Adapter unterstützt. Wenn Sie beispielsweise Elemente im Dateisystemcache speichern möchten, müssen Sie den Cache-Pool des Dateisystemadapters initialisieren.
$ cachePool = new FilesystemAdapter (", 0," cache ");Sie können drei optionale Argumente für die angeben Dateisystemadapter Objekt:
Da wir den Cache-Pool bereits erstellt haben, können wir ihn zum Speichern von Cache-Elementen verwenden.
Erstens verwenden wir die getItem Methode zum Abrufen des Cache-Elements mit der demo_string Schlüssel. Als nächstes benutzen wir die isHit Methode, um zu überprüfen, ob der von uns gesuchte Wert bereits im Cache-Element vorhanden ist $ demoString.
$ demoString = $ cachePool-> getItem ('demo_string'); if (! $ demoString-> isHit ()) $ demoString-> set ('Hello World!'); $ cachePool-> save ($ demoString); Da dies das erste Mal ist, holen wir die demo_string Cache-Element, das isHit Methode sollte zurückkehren falsch. Als nächstes benutzen wir die einstellen Methode der $ demoString Objekt, um den Cache-Wert festzulegen. Zum Schluss speichern wir das $ demoString Artikel in die $ cachePool Cache-Pool mit der sparen Methode.
Nachdem wir das Objekt im Cache gespeichert haben, sehen wir uns an, wie wir es aus dem Cache holen können.
if ($ cachePool-> hasItem ('demo_string')) $ demoString = $ cachePool-> getItem ('demo_string'); echo $ demoString-> get (); Echo "\ n"; Hier benutzen wir die hasItem Methode, um das Vorhandensein des Cache-Elements im Cache-Pool zu prüfen, bevor er abgerufen wird.
Lassen Sie uns als Nächstes alle Cache-Elemente aus dem Cache-Pool löschen:
$ cachePool-> clear ();
Im vorherigen Abschnitt haben wir erläutert, wie grundlegende Werte im Cache-Pool gespeichert werden. Das Speichern von Array-Werten ist ähnlich, wie Sie im folgenden Beispiel sehen können.
$ demoOne = $ cachePool-> getItem ('demo_array'); if (! $ demoOne-> isHit ()) $ demoOne-> set (array ("eins", "zwei", "drei")); $ cachePool-> save ($ demoOne); if ($ cachePool-> hasItem ('demo_array')) $ demoOne = $ cachePool-> getItem ('demo_array'); var_dump ($ demoOne-> get ()); Echo "\ n"; Wie Sie sehen, können wir das Cache-Element genauso wie einen String mit einem Array-Wert setzen.
Lassen Sie uns als Nächstes das bestimmte Cache-Element aus dem Cache-Pool löschen.
$ cachePool-> deleteItem ('demo_array');Hier benutzen wir die Element löschen Methode zum Löschen der demo_array Element aus dem Cache-Pool.
Bisher haben wir Elemente ohne Ablaufdatum im Pool zwischengespeichert. Normalerweise möchten Sie jedoch keine Elemente dauerhaft im Cache speichern. Beispielsweise möchten Sie möglicherweise Cache-Elemente regelmäßig aktualisieren, sodass Sie einen Mechanismus benötigen, der abgelaufene Cache-Elemente löscht.
In diesem Abschnitt wird erläutert, wie Elemente im Cache zusammen mit einem Ablaufdatum gespeichert werden.
$ foo = $ cachePool-> getItem ('foo'); if (! $ foo-> isHit ()) $ foo-> set ('bar'); $ foo-> verfällt nach (30); $ cachePool-> save ($ foo); Wie Sie im obigen Snippet sehen können, können Sie die erlischtAfter Methode, um ein Verfallsdatum für das zwischengespeicherte Element festzulegen. Sie können im ersten Argument des Befehls die Anzahl der Sekunden angeben, für die Sie ein Element im Cache speichern möchten erlischtAfter Methode.
In unserem Beispiel verwenden wir die schlafen Methode, um zu testen, ob das zwischengespeicherte Element noch im Cache-Pool verfügbar ist.
if ($ cachePool-> hasItem ('foo')) $ foo = $ cachePool-> getItem ('foo'); echo $ foo-> get (); Echo "\ n"; Schlaf (60); if ($ cachePool-> hasItem ('foo')) $ foo = $ cachePool-> getItem ('foo'); echo $ foo-> get (); Echo "\ n"; else echo "Cache-Element ist abgelaufen! \ n"; Probieren Sie es aus, um zu sehen, wie es funktioniert!
Heute haben wir uns kurz mit der Symfony Cache-Komponente beschäftigt, mit der Sie das Caching in Ihren PHP-Anwendungen einrichten können. Es unterstützt auch eine Vielzahl von Caching-Adaptern, die zusammen die Flexibilität bei der Auswahl des Backends bieten, das Sie verwenden möchten.
Fühlen Sie sich frei, Ihre Gedanken und Fragen mit dem untenstehenden Formular auszudrücken.
