Caching ist essentiell, um eine hohe Performance und Skalierbarkeit zu erreichen. Die Implementierung der richtigen Caching-Strategie bereits in der Entwicklungsphase ist entscheidend, um verzögerte APIs und träge Seitenladezeiten zu vermeiden. Laravel ist eines der beliebtesten PHP-Frameworks, daher ist die Implementierung der optimalen Laravel-Caching-Strategie unabdingbar für ein besseres Nutzererlebnis und einen größeren Geschäftserfolg.

In diesem Artikel werden wir Strategien für die Implementierung und Manipulation von Caching in Laravel erkunden. Du lernst, wie Laravel Caching funktioniert, verschiedene Laravel Caching Abfragen und wie du Caching in Laravel Apps handhaben kannst.

Du wirst mehr von diesem Artikel haben, wenn du bereits ein Grundwissen über die folgenden Punkte hast:

Lass uns eintauchen!

Warum ist Caching wichtig?

Mit dem jüngsten Boom im Internetgeschäft haben verschiedene Unternehmen Statistiken, die zeigen, wie sich die Ladezeit einer Webseite und eine niedrige Performance ohne Caching stark auf SEO, Nutzerengagement und Conversion-Raten auswirken können. Und das beginnt mit einer exzellenten Caching-Strategie.

Eine Online-Studie fand heraus: „1 Sekunde Ladeverzögerung würde Amazon 1,6 Milliarden Dollar Umsatz pro Jahr kosten.“

Eine andere Google-Studie berichtet: „Unsere Forschung zeigt, dass, wenn die Suchergebnisse auch nur um einen Bruchteil einer Sekunde verlangsamt werden, die Leute weniger suchen (ernsthaft: Eine Verzögerung von 400ms führt zu einem Rückgang des Suchvolumens um 0,44 Prozent). Und diese Ungeduld ist nicht nur auf die Suche beschränkt: Vier von fünf Internetnutzern klicken weg, wenn ein Video beim Laden stockt.“

Eine kleine Trägheit bei der Ladezeit deiner Webseite kann sich massiv auf die Erfahrung deiner Nutzer auswirken und zu einem großen Verlust führen.

Was ist Laravel Caching?

Laravel bietet eine robuste und einfach zu bedienende Implementierung von Caching und verschiedenen Caching Backends. Mit Laravel Cache kannst du effizient und effektiv zwischen vielen Caching-Engines wechseln, ohne Code zu schreiben.

Die Konfiguration des Laravel-Caches findest du im Ordner config/cache.php, wobei du wahrscheinlich nur die .env-Datei benötigst, um zwischen verschiedenen Cache-Backends zu wechseln.

Laravel Cache bietet auch viele praktische Methoden, die wir nutzen können, um verschiedene Caching-Strategien zu implementieren.

Caching ist ein essentieller Teil des Softwareentwicklungsprozesses für jeden, der mehr Wert auf hohe Performance und Skalierbarkeit legt. 📈 Tauche hier in alles ein, was du über Laravel Caching wissen musst 🚀Click to Tweet

Laravel Cache-Treiber und Vergleiche

Laravel Cache bietet großartige Caching Backends und Treiber. Abhängig von deinem Anwendungsfall kannst du zwischen ihnen wechseln, um die Performance und Ladezeit deiner Anwendung zu verbessern.

Abgesehen davon bietet Laravel Cache auch eine nahtlose Möglichkeit, ein benutzerdefiniertes Backend zu erstellen und es mit Laravel Cache zu verwenden, aber nur, wenn die Liste unten nicht zu deinem Anwendungsfall passt.

Wir werden als nächstes über die Liste aller Backends sprechen, die von Laravel Cache bereitgestellt werden.

1. Datei

Der File-Treiber ist das Standard-Backend, das vom Laravel-Cache verwendet wird, wenn kein Treiber in der .env-Datei angegeben ist.

Das File-Backend wurde entwickelt, um die gecachten Daten in einer verschlüsselten Datei zu speichern, die sich unter storage/framework/ befindet. Laravel erstellt eine verschlüsselte Datei mit den Daten und dem Cache-Schlüssel, wenn neue Daten gecached werden. Das gleiche passiert, wenn der Benutzer versucht, den Inhalt abzurufen. Laravel Cache durchsucht den Ordner nach dem angegebenen Schlüssel und gibt, wenn gefunden, den Inhalt zurück.

Obwohl das Dateibackend einwandfrei funktioniert und Zeit beim Installieren und Konfigurieren von externen Treibern spart, kann es auch perfekt für die Entwicklung sein. Es ist schneller als der direkte Zugriff auf die Daten vom Datenbankserver.

Um den File-Treiber zu nutzen, füge den folgenden Code zu deiner .env Datei hinzu:

CACHE_DRIVER=file

2. Array

Der Array-Treiber ist ein perfektes Caching-Backend für die Durchführung von automatisierten Tests und lässt sich einfach mit Github Actions, Jenkins, etc. konfigurieren.

Das Array Backend speichert die gecachten Daten in einem Array in PHP und erfordert keine Installation oder Konfiguration von Treibern. Es funktioniert perfekt für automatisierte Tests und ist ein bisschen schneller als das File Cache Backend.

Um den Array-Treiber zu verwenden, füge den folgenden Code zu deiner .env-Datei hinzu:

CACHE_DRIVER=array

3. Datenbank

Wenn du den Datenbanktreiber verwendest, werden die Daten für den aktuellen PHP-Prozess im Speicher gehalten. Daher musst du eine Datenbanktabelle erstellen, um die gecachten Daten zu speichern. Zusätzlich verbessert das Datenbank-Caching die Skalierbarkeit, indem es die Arbeitslast der Abfragen vom Backend auf mehrere Frontends verteilt.

Du kannst diesen Artisan-Befehl – php artisan cache:table – ausführen, um das vom Datenbanktreiber benötigte Datenbankschema automatisch zu generieren.

Der Datenbanktreiber wird hauptsächlich in Situationen verwendet, in denen du jede beliebige Software auf deiner Hosting Plattform installieren kannst.

Nehmen wir an, du verwendest einen kostenlosen Host Plan mit begrenzten Optionen. In diesem Fall würden wir vorschlagen, dass du dich an den Dateitreiber hältst, da der Datenbanktreiber in den meisten Fällen der schwächste Punkt deiner Anwendung ist und es keine gute Idee ist, mehr Daten in diesen Engpass zu schieben.

Um den Datenbanktreiber zu verwenden, füge den folgenden Code zu deiner .env Datei hinzu:

CACHE_DRIVER=database

4. Redis

Der Redis-Treiber nutzt die In-Memory-basierte Caching-Technologie namens Redis. Obwohl es im Vergleich zu den anderen oben besprochenen Cache-Treibern sehr schnell ist, erfordert es die Installation und Konfiguration einer externen Technologie.

Um den Redis-Treiber zu verwenden, füge den folgenden Code zu deiner .env-Datei hinzu:

CACHE_DRIVER=redis

5. Memcached

Memcached ist bekanntlich der beliebteste In-Memory-basierte Cache-Speicher. Wenn dich ein bisschen zusätzliche Serverwartung nicht stört (du musst zusätzliche Dienste installieren und warten), sind die speicherbasierten Cache-Treiber Memcached eine gute Option.

Um den Memcached-Treiber zu verwenden, muss das Memcached PECL-Paket installiert werden.

Um den Memcached-Treiber zu verwenden, füge den folgenden Code zu deiner .env-Datei hinzu.

CACHE_DRIVER=memcached 

Der beste Cache-Treiber und die Leistung des Cache-Treibers hängen vom Anwendungsfall deines Projekts und der Menge der abzurufenden Daten ab.

Laravel Cache Verwendung und Methoden

Laravel Cache bietet viele wertvolle Methoden, um viele Caching-Strategien zu implementieren.

Im Folgenden werden wir die verschiedenen Methoden auflisten und erklären (kategorisiert nach ihrem Anwendungsfall):

  1. put()
  2. get()
  3. many()
  4. putMany()
  5. increment()
  6. decrement()
  7. forever()
  8. forget()
  9. flush()
  10. remember()
  11. rememberForever()

Cache speichern

Neue Daten im Cache zu speichern ist sehr einfach, indem du die verschiedenen Methoden verwendest, die jeweils mehrere Anwendungsfälle haben.

1. Cache::put()

Diese Methode akzeptiert drei Schlüsselparameter, die Dauer und die Daten, die gecacht werden sollen.

Lass uns einen Blick darauf werfen, wie man Cache::put() benutzt:

Cache::put(key, data, duration)

$post = Post::find(1);

Cache::put('post_1', $post, 20);

Der obige Code wird den Beitrag mit dem eindeutigen Key für 20 Sekunden zwischenspeichern.

2. Cache::putMany()

Diese Methode speichert ein Array von Daten im Cache auf einmal mit der gleichen Dauer. Sie akzeptiert zwei Parameter, nämlich data und seconds.

Lass uns einen Blick darauf werfen, wie man Cache::putMany() benutzt:

Cache::putMany(data, duration) // syntax

$posts = Post::all();

Cache::putMany($posts, 20);
3. Cache::remember()

Diese Methode ist eine weitere hervorragende Möglichkeit, die Cache Aside Strategie zu implementieren. Die Methode Cache::remember() akzeptiert drei Parameter, einen Key, Seconds und eine Closure, die verwendet wird, um Daten aus der Datenbank zu holen, wenn sie nicht gefunden werden.

Lass uns einen Blick darauf werfen, wie man Cache::remember() benutzt:

Cache::remember(key, duration, closure) // syntax

Cache::remember('posts', 20, function(){
  return Post::all();
});

Laravel Cache hat auch die Methode Cache::rememberForever(), die den Parameter seconds nicht akzeptiert und die Daten für immer speichert.

4. Cache::forever()

Diese Methode speichert Daten im Cache Server für immer, ohne eine Dauer anzugeben. Du kannst es mit dem folgenden Code implementieren:

Cache::forever(key, data)

$post = Post::find(1);

Cache::forever('post_1', $post);

Cache Daten abrufen

Die Methoden in dieser Kategorie rufen Daten aus dem Cache ab. Einige dieser Methoden können sich unterschiedlich verhalten, je nachdem ob die Daten gefunden werden oder nicht.

1. Cache::get()

Diese Methode holt Daten vom Cache-Server mit einem bestimmten Key. Du kannst ein Element abrufen, indem du den folgenden Code verwendest:

Cache::get(key) // syntax

$posts = Cache::get('posts');
2. Cache::many()

Diese Methode ist ähnlich zu Cache::putMany(). Sie wird verwendet, um ein Array von gecachten Daten auf einmal abzurufen, indem ein Array der gecachten Schlüssel verwendet wird. Du kannst ein Array des Caches mit folgendem Code abrufen:

Cache::many(keys) // syntax

const $keys = [
  'posts',
  'post_1',
  'post_2'
];

$posts = Cache::many($keys);
3. Cache::remember()

Du kannst diese Methode auch verwenden, um gecachte Daten abzurufen, indem du den Cache-Server mit dem angegebenen Schlüssel überprüfst. Wenn die Daten im Cache gespeichert sind, wird es sie abrufen. Andernfalls wird es die Daten vom Datenbankserver abrufen und im Cache speichern. Diese Methode ist die gleiche wie die Cache::rememberForever() Methode mit nur einem zusätzlichen Sekunden Parameter in der Cache::remember() Methode.

Elemente aus dem Cache entfernen

Die Methoden unter dieser Kategorie werden verwendet, um Elemente aus dem Cache zu entfernen, gruppiert nach Funktionalität.

1. Cache::forget()

Diese Methode entfernt ein einzelnes Element aus dem Cache mit einem angegebenen Schlüsselparameter:

Cache::forget('key');
2. Cache::flush()

Diese Methode löscht alle Cache-Engines. Sie löscht alle Elemente, die irgendwo im Cache gespeichert sind:

Cache::flush();

Incrementing or Decrementing Cache Values

Du kannst die Werte eines Integer-Wertes, der in deinem Cache gespeichert ist, anpassen, indem du die Methoden increment und decrement verwendest:

Cache::increment('key');

Cache::increment('key', $amount);

Cache::decrement('key');

Cache::decrement('key', $amount);

Laravel Cache hat viele tolle Methoden, die wir hier nicht besprochen haben, aber die oben genannten Methoden sind beliebt. Einen Überblick über alle Methoden kannst du dir in der offiziellen Laravel Cache Dokumentation verschaffen.

Cache-Befehle erklärt

Laravel stellt Befehle zur Verfügung, um die Arbeit mit dem Laravel Cache einfach und schnell zu machen. Im Folgenden findest du eine Liste aller Befehle und ihrer Funktionalitäten.

Laravel Cache löschen

Dieser Befehl wird verwendet, um den Laravel Cache zu löschen, bevor er überhaupt abläuft, indem du das Terminal/die Konsole benutzt. Zum Beispiel kannst du den folgenden Befehl ausführen:

php artisan cache:clear

Route-Cache löschen

Dieser Befehl wird verwendet, um den Routen-Cache deiner Laravel-Anwendung zu löschen. Führe zum Beispiel den folgenden Befehl aus, um deinen Routen-Cache zu löschen:

php artisan config:cache

Kompilierte View-Dateien löschen

Dieser Befehl wird verwendet, um die kompilierten View-Dateien deiner Laravel-Anwendung zu löschen. Du kannst es mit dem folgenden Befehl erreichen:

php artisan view:clear

Datenbank Tabelle

Wenn du den Datenbanktreiber verwendest, musst du ein Datenbankschema namens Cache erstellen, um die Cachedaten zu speichern. Du kannst auch den Artisan Befehl verwenden, um eine Migration mit dem richtigen Schema zu erzeugen:

php artisan cache:table

Laravel Caching-Strategien

Abhängig von deinem Anwendungsfall und deiner Datenstruktur stehen dir wahrscheinlich mehrere verschiedene Cache-Strategien zur Verfügung. Du kannst sogar eine eigene Strategie erstellen, die deinen Bedürfnissen entspricht. Im Folgenden gehen wir auf die Liste der beliebtesten Caching-Strategien ein, die du in deinem Laravel-Projekt implementieren kannst.

Info

Kinsta ermöglicht es dir, Laravel für deine Produkte einzusetzen, auch wenn es von unserem Team nicht offiziell unterstützt wird.

writeThrough

Bei der writeThrough-Strategie sitzt der Cache-Server zwischen den Anfragen und dem Datenbankserver, so dass jede Schreiboperation durch den Cache-Server geht, bevor sie zum Datenbankserver geht. Somit ist die writeThrough Caching Strategie ähnlich wie die readThrough Strategie.

Du kannst diese Strategie mit dem Laravel Cache mit folgendem Code implementieren:

public function writeThrough($key, $data, $minutes) {
    $cacheData = Cache::put($key, $data, $minutes)

    // Database Server is called from(after) the Cache Server.
    $this->storeToDB($cachedData)
    return $cacheData
}

private function storeToDB($data){
    Database::create($data)
    return true
}

writeBack (writeBehind)

Diese Strategie ist eine fortgeschrittene Art, die writeThrough Strategie zu implementieren, indem die Verzögerung der Schreiboperationen hinzugefügt wird.

Du kannst dies auch die writeBehind Strategie nennen, wegen der zeitlichen Verzögerung, die auf dem Cache Server angewendet wird, bevor die Daten auf den Datenbankserver geschrieben werden.

Du kannst diese Strategie mit dem Laravel Cache mit dem folgenden Code implementieren:

$durationToFlush = 1; // (in minute)
 $tempDataToFlush = [];

  public function writeBack($key, $data, $minutes){
    return $this->writeThrough($key, $data, $minutes);
  }

  public function writeThrough($key, $data, $minutes) {
      $cacheData = Cache::put($key, $data, $minutes);
      $this->storeForUpdates($cacheData);
      return $cacheData;
  }

// Stores new data to temp Array for updating
  private function storeForUpdates($data){
    $tempData = {};
    $tempData['duration'] = this.getMinutesInMilli();
    $tempData['data'] = data;
    array_push($tempDataToFlush, data);
  }

// Converts minutes to millisecond
private function getMinutesInMilli(){
  $currentDate = now();
  $futureDate = Carbon(Carbon::now()->timestamp + $this->durationToFlush * 60000)
  return $futureDate->timestamp
}

// Calls to update the Database Server.
public function updateDatabaseServer(){
  if($this->tempDataToFlush){
    foreach($this->tempDataToFlush as $index => $obj){
      if($obj->duration timestamp){
        if(Database::create($obj->data)){
            array_splice($this->tempDataToFlush, $index, 1);
        }
      }
    }
  }
}

Die writeBack-Methode ruft die writeThrough-Methode auf, die die Daten auf dem Cache-Server und einem temporären Array speichert, um sie später mit der updateDatabaseServer-Methode auf den Datenbankserver zu übertragen. Du kannst einen CronJob einrichten, um den Datenbankserver alle fünf Minuten zu aktualisieren.

writeAround

Diese Strategie erlaubt es, dass alle Schreiboperationen direkt an den Datenbankserver gehen, ohne den Cache-Server zu aktualisieren – nur während der Leseoperationen wird der Cache-Server aktualisiert.

Angenommen ein Benutzer möchte einen neuen Artikel erstellen, dann wird der Artikel direkt auf dem Datenbankserver gespeichert. Wenn der Benutzer den Inhalt des Artikels zum ersten Mal lesen möchte, wird der Artikel vom Datenbankserver abgerufen und aktualisiert den Cache-Server für nachfolgende Anfragen.

Du kannst diese Strategie mit dem Laravel Cache mit folgendem Code implementieren:

public function writeAround($data) {
    $storedData = Database::create($data);
    return $storedData;
}

public function readOperation($key, $minutes){
    $cacheData = Cache::remember($key, $minutes, function() {
      return Article::all();
    })
    return $cacheData;
}

Cache Aside (Lazy Loading)

Bei dieser Strategie wird die Datenbank beiseite gelegt und die Anwendung fordert zuerst Daten vom Cache-Server an. Dann, wenn es einen Hit gibt, werden die Daten an den Client zurückgegeben. Andernfalls, wenn es einen Miss gibt (nicht gefunden), fordert der Datenbankserver die Daten an und aktualisiert den Cache-Server für nachfolgende Anfragen.

Bist du es leid, dass der Level 1 WordPress-Hosting-Support dir keine Antworten gibt? Teste unser Weltklasse-Supportteam! Schau dir unsere Pläne an

Du kannst diese Strategie mit dem Laravel Cache mit folgendem Code umsetzen:

public function lazyLoadingStrategy($key, $minutes, $callback) {
  if (Cache::has($key)) {
      $data = Cache::get($key);
      return $data;
  } else {
      // Database Server is called outside the Cache Server.
      $data = $callback();
      Cache::set($key, $data, $minutes);
      return $data;
  }
}

Der obige Code zeigt die Implementierung der Cache Aside Strategy, was der Implementierung der Cache::remember Methode entspricht.

Read Through

Diese Strategie ist das direkte Gegenteil der Cache Aside Strategie. Bei dieser Strategie sitzt der Cache Server zwischen dem Client Request und dem Datenbank Server.

Anfragen gehen direkt an den Cache Server und der Cache Server ist dafür verantwortlich, die Daten vom Datenbankserver zu holen, wenn sie nicht im Cache Server gefunden werden.

Du kannst diese Strategie mit dem Laravel Cache mit dem folgenden Code implementieren:

public function readThrough($key, $minutes) {
      $data = Cache::find($key, $minutes);
      return $data;
}

private function find($key, $minutes){
    if(Cache::has($key);){
      return Cache::get($key);
    }

    // Database Server is called from the Cache Server.
    $DBdata = Database::find($key);
    Cache:put($key, $DBdata, $minutes);
    return $DBdata;
}

Da hast du es! Wir haben jetzt ein paar beliebte Caching-Strategien für deine nächste Laravel-Anwendung besprochen. Denke daran, dass du auch eine benutzerdefinierte Caching-Strategie verwenden kannst, die am besten zu deinen Projektanforderungen passt.

Caching des UI Teils einer Laravel App

Das Caching der UI unserer Laravel App ist ein Konzept, das als Full Page Cache FPC bekannt ist. Der Begriff bezieht sich auf den Prozess des Cachens der HTML-Antwort von einer Anwendung.

Es eignet sich hervorragend für Anwendungen, bei denen sich die dynamischen HTML-Daten nicht häufig ändern. Du kannst die HTML-Antwort zwischenspeichern, um eine schnellere Gesamtantwort und ein schnelleres Rendering des HTML zu erreichen.

Wir können FPC mit der folgenden Codezeile implementieren:

class ArticlesController extends Controller {
    public function index() {
        if ( Cache::has('articles_index') ) {
            return Cache::get('articles_index');
        } else {
            $news = News::all();
            $cachedData = view('articles.index')->with('articles', $news)->render();
            Cache::put('articles_index', $cachedData);                                         
            return $cachedData;           
        }  
    }
}

Auf den ersten Blick hast du vielleicht bemerkt, dass wir prüfen, ob die articles_index Seite bereits in unserem Cache-Server existiert. Dann geben wir die Seite zurück, indem wir sie mit Laravel’s view() und render() Methoden rendern.

Andernfalls rendern wir die Seite und speichern die Ausgabe in unserem Cache-Server für spätere Anfragen, bevor wir die gerenderte Seite an den Browser zurückgeben.

Eine Laravel App bauen

Jetzt werden wir das bisher Gelernte anwenden, indem wir ein neues Laravel Projekt erstellen und den Laravel Cache implementieren.

Wenn du Laravel noch nicht benutzt hast, kannst du dir durchlesen, was Laravel ist und einen Blick auf unsere Liste mit exzellenten Laravel-Tutorials werfen, um loszulegen.

Laravel einrichten

Als erstes werden wir eine neue Laravel Instanz mit dem folgenden Befehl erstellen. Du kannst in der offiziellen Dokumentation nachschauen, um mehr zu erfahren.

Öffne deine Konsole und navigiere zu dem Ort, an dem du deine PHP-Projekte speicherst, bevor du die unten stehenden Befehle ausführst. Stelle sicher, dass Composer installiert und richtig konfiguriert ist.

composer create-project laravel/laravel fast-blog-app

// Change directory to current Laravel installation
cd fast-blog-app

// Start Laravel development server.
php artisan serve

Konfigurieren und Seeding der Datenbank

Als nächstes werden wir unsere Datenbank einrichten, ein neues Artikelmodell erstellen und 500 gefälschte Datenpunkte zum Testen setzen.

Öffne deinen Datenbank-Client und erstelle eine neue Datenbank. Wir machen das gleiche mit dem Namen fast_blog_app_db und füllen dann unsere .env Datei mit den Datenbank Credentials:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=fast_blog_app_db
DB_USERNAME=//DB USERNAME HERE
DB_PASSWORD=//DB PASSWORD HERE

Als nächstes führen wir den folgenden Befehl aus, um die Migration und das Artikelmodell gleichzeitig zu erstellen:

php artisan make:model Article -m

Öffne die neu erstellte Migration gefunden database/migrations/xxx-create-articles-xxx.php und füge den folgenden Code ein:

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateArticlesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description');
            $table->timestamps();
        });
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('articles');
    }
}

Als nächstes führst du den folgenden Befehl aus, um einen neuen Seeder zu erstellen:

php artisan make:seeder ArticleSeeder

Öffne die neu erstellte Seeder-Datei, die du unter database/seeders/ArticleSeeder.php findest und füge den folgenden Code ein:

<?php
namespace Database\Seeders;
use App\Models\Article;
use Illuminate\Database\Seeder;
class ArticleSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        Article::factory()->count(500)->create();
    }
}

Öffne die Datei DatabaseSeeder.php im gleichen Verzeichnis und füge den folgenden Code hinzu:

<?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        $this->call(ArticleSeeder::class);
    }
}

Als nächstes führst du den folgenden Befehl aus, um eine neue Fabrik zu erstellen:

php artisan make:factory ArticleFactory

Öffne die neu erstellte Factory-Datei, die du unter database/factories/ArticleFactory.php findest und füge den folgenden Code ein:

<?php
namespace Database\Factories;
use App\Models\Article;
use Illuminate\Database\Eloquent\Factories\Factory;
class ArticleFactory extends Factory
{
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = Article::class;
    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'title' => $this->faker->text(),
            'description' => $this->faker->paragraph(20)
        ];
    }
}

Führe nun den folgenden Befehl aus, um unser neu erstelltes Schema zu migrieren und auch unsere Fake-Daten zum Testen zu seeden:

php artisan migrate --seed

Den Artikel Controller erstellen

Als nächstes werden wir unseren Controller erstellen und unsere Routen einrichten, um unsere Anfrage zu bearbeiten und die Daten mit Hilfe des obigen Modells abzurufen.

Führe den folgenden Befehl aus, um einen neuen ArticlesController innerhalb des app/Http/Controllers Ordners zu erstellen:

php artisan make:controller ArticlesController --resource

Öffne die Datei und füge den folgenden Code in die Klasse ein:

// Returns all 500 articles with Caching
public function index() {
  return Cache::remember('articles', 60, function () {
      return Article::all();
  });
}

// Returns all 500 without Caching 
public function allWithoutCache() {
  return Article::all();
}

Danach öffnest du die api.php Datei, die sich im Ordner routes/ befindet und fügst den folgenden Code ein, um einen Endpunkt zu erstellen, den wir aufrufen können, um unsere Daten abzurufen:

Route::get('/articles', '[email protected]');

Route::get('/articles/withoutcache', '[email protected]');

Testen der Performance

Zum Schluss testen wir die Performance der Antwort unserer App mit oder ohne die Implementierung des Laravel-Caches.

Dieser Screenshot zeigt die Antwortzeit der API mit implementiertem Cache:

Laravel API Antwortzeit mit Cache.

Laravel API Antwortzeit mit Cache.

Der folgende Screenshot zeigt die Antwortzeit der API ohne implementierten Cache – beachte, dass die Antwortzeit gegenüber der gecachten Instanz um über 5.000% gestiegen ist:

Laravel API Antwortzeit ohne Cache.

Laravel API Antwortzeit ohne Cache.

Du hast ein solides Verständnis von Webentwicklung und Laravel, möchtest aber mehr über Laravel Caching erfahren und wie du es implementieren kannst? ✅ Dieser Beitrag ist für dich 👇Click to Tweet

Summary

Wir haben verschiedene Strategien für die Implementierung und Manipulation von Laravel Caching erforscht, indem wir ein neues Projekt erstellt, die Antworten und die Ergebnisse verglichen haben.

Du hast auch gelernt, wie du die verschiedenen Laravel-Caching-Treiber und -Methoden nutzen kannst. Außerdem haben wir verschiedene Caching-Strategien implementiert, damit du herausfinden kannst, welche für dich die richtige sein könnte.

Für mehr Laravel, entdecke unsere handverlesene Auswahl der besten Laravel-Tutorials. Egal ob du ein Anfänger oder ein fortgeschrittener Laravel-Entwickler bist, es ist für jeden etwas dabei!

Wenn du noch Fragen zum Laravel Caching hast, lass es uns bitte in den Kommentaren wissen.


Spare Zeit, Kosten und maximiere die Leistung deiner Seite mit:

  • Schnelle Hilfe von WordPress Hosting Experten, 24/7.
  • Cloudflare Enterprise Integration.
  • Globale Reichweite mit 28 Rechenzentren weltweit.
  • Optimierung mit unserem integrierten Application Performance Monitoring.

All das und noch viel mehr, in einem Plan ohne langfristige Verträge, betreute Migrationen und eine 30-Tage-Geld-zurück-Garantie. Schau Dir hier unsere Pakete an oder sprich mit dem Vertrieb, um den richtigen Tarif für dich zu finden.