So erstellen Sie eine Caching-Ebene für Ihre Laravel-API

Angenommen, Sie erstellen eine API zur Bereitstellung einiger Daten und stellen fest, dass GET-Antworten recht langsam sind. Sie haben versucht, Ihre Abfragen zu optimieren und Ihre Datenbanktabellen nach häufig abgefragten Spalten zu indizieren, erhalten aber immer noch nicht die gewünschten Antwortzeiten. Der nächste Schritt besteht darin, eine Caching-Ebene für Ihre API zu schreiben. „Caching-Schicht“ ist hier nur ein schicker Begriff für eine Middleware, die erfolgreiche Antworten in einem schnell abrufbaren Speicher speichert. z.B. Redis, Memcached usw., dann prüft jede weitere Anfrage an die API, ob die Daten im Store verfügbar sind und stellt die Antwort bereit.

Voraussetzungen

• Laravel
• Redis

Bevor wir beginnen

Ich gehe davon aus, dass Sie, wenn Sie hier angekommen sind, wissen, wie man eine Laravel-App erstellt. Sie sollten außerdem entweder über eine lokale oder eine Cloud-Redis-Instanz verfügen, mit der Sie eine Verbindung herstellen können. Wenn Sie Docker lokal haben, können Sie meine Compose-Datei hier kopieren. Eine Anleitung zum Herstellen einer Verbindung zum Redis-Cache-Treiber finden Sie hier.

Erstellen unserer Dummy-Daten

Damit wir sehen können, dass unsere Caching-Ebene wie erwartet funktioniert. Natürlich benötigen wir einige Daten. Nehmen wir an, wir haben ein Modell namens Post. Deshalb werde ich einige Beiträge erstellen und auch einige komplexe Filter hinzufügen, die datenbankintensiv sein können, und dann können wir sie durch Zwischenspeichern optimieren.

Jetzt beginnen wir mit dem Schreiben unserer Middleware:

Wir erstellen unser Middleware-Skelett durch Ausführen

php artisan make:middleware CacheLayer

Dann registrieren Sie es in Ihrer app/Http/Kernel.php unter der API-Middleware-Gruppe wie folgt:

    protected $middlewareGroups = [
        'api' => [
            CacheLayer::class,
        ],
    ];

Aber wenn Sie Laravel 11 ausführen, registrieren Sie es in Ihrer Bootstrap/app.php

->withMiddleware(function (Middleware $middleware) {
        $middleware->api(append: [
            \App\Http\Middleware\CacheLayer::class,
        ]);
    })

Caching-Terminologien

• Cache-Treffer: Tritt auf, wenn angeforderte Daten im Cache gefunden werden.
• Cache-Fehler: Tritt auf, wenn die angeforderten Daten nicht im Cache gefunden werden.
• Cache Flush: Löschen der gespeicherten Daten im Cache, damit dieser mit neuen Daten wieder aufgefüllt werden kann.
• Cache-Tags: Dies ist eine einzigartige Funktion von Redis. Cache-Tags sind eine Funktion zum Gruppieren zusammengehöriger Elemente im Cache, wodurch es einfacher wird, zusammengehörige Daten gleichzeitig zu verwalten und ungültig zu machen.
• Time to Live (TTL): Dies bezieht sich auf die Zeitspanne, die ein zwischengespeichertes Objekt gültig bleibt, bevor es abläuft. Ein häufiges Missverständnis ist die Annahme, dass jedes Mal, wenn auf ein Objekt aus dem Cache zugegriffen wird (ein Cache-Treffer), seine Ablaufzeit zurückgesetzt wird. Dies ist jedoch nicht wahr. Wenn die TTL beispielsweise auf 5 Minuten eingestellt ist, läuft das zwischengespeicherte Objekt nach 5 Minuten ab, unabhängig davon, wie oft innerhalb dieses Zeitraums darauf zugegriffen wird. Nach Ablauf der 5 Minuten führt die nächste Anfrage für dieses Objekt dazu, dass ein neuer Eintrag im Cache erstellt wird.

Berechnen eines eindeutigen Cache-Schlüssels

Cache-Treiber sind also ein Schlüsselwertspeicher. Sie haben also einen Schlüssel, dann ist der Wert Ihr JSON. Sie benötigen also einen eindeutigen Cache-Schlüssel, um Ressourcen zu identifizieren. Ein eindeutiger Cache-Schlüssel hilft auch bei der Cache-Ungültigmachung, d. h. dem Entfernen von Cache-Elementen, wenn eine neue Ressource erstellt/aktualisiert wird. Mein Ansatz zur Cache-Schlüsselgenerierung besteht darin, die Anforderungs-URL, die Abfrageparameter und den Text in ein Objekt umzuwandeln. Dann serialisieren Sie es in einen String. Fügen Sie dies Ihrer Cache-Middleware hinzu:

class CacheLayer 
{
    public function handle(Request $request, Closure $next): Response
    {
    }

    private function getCacheKey(Request $request): string
    {
        $routeParameters = ! empty($request->route()->parameters) ? $request->route()->parameters : [auth()->user()->id];
        $allParameters = array_merge($request->all(), $routeParameters);
        $this->recursiveSort($allParameters);

        return $request->url() . json_encode($allParameters);
    }

    private function recursiveSort(&$array): void
    {
        foreach ($array as &$value) {
            if (is_array($value)) {
                $this->recursiveSort($value);
            }
        }

        ksort($array);
    }
}

Lassen Sie uns den Code Zeile für Zeile durchgehen.

• Zuerst prüfen wir, ob die Anforderungsparameter übereinstimmen. Wir wollen nicht den gleichen Cache-Schlüssel für /users/1/posts und /users/2/posts berechnen.
• Und wenn es keine übereinstimmenden Parameter gibt, übergeben wir die Benutzer-ID. Dieser Teil ist optional. Wenn Sie Routen wie /user haben, werden Details für den aktuell authentifizierten Benutzer zurückgegeben. Es ist sinnvoll, die Benutzer-ID im Cache-Schlüssel zu übergeben. Wenn nicht, können Sie es einfach zu einem leeren Array ([]) machen.
• Dann erhalten wir alle Abfrageparameter und führen sie mit den Anforderungsparametern zusammen
• Dann sortieren wir die Parameter. Dieser Sortierschritt ist deshalb so wichtig, weil wir beispielsweise für /posts?page=1&limit=20 und /posts?limit=20&page=1 dieselben Daten zurückgeben können. Unabhängig von der Reihenfolge der Parameter geben wir also immer noch denselben Cache-Schlüssel zurück.

Ausgenommen Routen

Abhängig von der Art der Anwendung, die Sie erstellen. Es wird einige GET-Routen geben, die Sie nicht zwischenspeichern möchten. Deshalb erstellen wir eine Konstante mit der Regex, die diesen Routen entspricht. Das sieht so aus:

 private const EXCLUDED_URLS = [
    '~^api/v1/posts/[0-9a-zA-Z]+/comments(\?.*)?$~i'
'
];

In diesem Fall stimmt dieser reguläre Ausdruck mit allen Kommentaren eines Beitrags überein.

TTL konfigurieren

Fügen Sie dazu einfach diesen Eintrag zu Ihrer config/cache.php hinzu

  'ttl' => now()->addMinutes(5),

Schreiben unserer Middleware

Jetzt haben wir alle vorbereitenden Schritte festgelegt und können unseren Middleware-Code schreiben:

public function handle(Request $request, Closure $next): Response
    {
        if ('GET' !== $method) {
           return $next($request);
        }

        foreach (self::EXCLUDED_URLS as $pattern) {
            if (preg_match($pattern, $request->getRequestUri())) {
                return $next($request);
            }
        }

        $cacheKey = $this->getCacheKey($request);

        $exception = null;

        $response = cache()
            ->tags([$request->url()])
            ->remember(
                key: $cacheKey,
                ttl: config('cache.ttl'),
                callback: function () use ($next, $request, &$exception) {
                    $res = $next($request);

                    if (property_exists($res, 'exception') && null !== $res->exception) {
                        $exception = $res;

                        return null;
                    }

                    return $res;
                }
            );

        return $exception ?? $response;
    }

• First we skip caching for non-GET requests and Excluded urls.
• Then we use the cache helper, tag that cache entry by the request url.
• we use the remember method to store that cache entry. then we call the other handlers down the stack by doing $next($request). we check for exceptions. and then either return the exception or response.

Cache Invalidation

When new resources are created/updated, we have to clear the cache, so users can see new data. and to do this we will tweak our middleware code a bit. so in the part where we check the request method we add this:

if ('GET' !== $method) {
    $response = $next($request);

    if ($response->isSuccessful()) {
        $tag = $request->url();

        if ('PATCH' === $method || 'DELETE' === $method) {
            $tag = mb_substr($tag, 0, mb_strrpos($tag, '/'));
        }

        cache()->tags([$tag])->flush();
    }

    return $response;
}

So what this code is doing is flushing the cache for non-GET requests. Then for PATCH and Delete requests we are stripping the {id}. so for example if the request url is PATCH /users/1/posts/2 . We are stripping the last id leaving /users/1/posts. this way when we update a post, we clear the cache of all a users posts. so the user can see fresh data.

Now with this we are done with the CacheLayer implementation. Lets test it

Testing our Cache

Let's say we want to retrieve all a users posts, that has links, media and sort it by likes and recently created. the url for that kind of request according to the json:api spec will look like: /posts?filter[links]=1&filter[media]=1&sort=-created_at,-likes. on a posts table of 1.2 million records the response time is: ~800ms

and after adding our cache middleware we get a response time of 41ms

Great success!

Optimizations

Another optional step is to compress the json payload we store on redis. JSON is not the most memory-efficient format, so what we can do is use zlib compression to compress the json before storing and decompress before sending to the client.
the code for that will look like:

$response = cache()
            ->tags([$request->url()])
            ->remember(
                key: $cacheKey,
                ttl: config('cache.ttl'),
                callback: function () use ($next, $request, &$exception) {
                    $res = $next($request);

                    if (property_exists($res, 'exception') && null !== $res->exception) {
                        $exception = $res;

                        return null;
                    }

                    return gzcompress($res->getContent());
                }
            );

        return $exception ?? response(gzuncompress($response));

The full code for this looks like:

getMethod();

        if ('GET' !== $method) {
            $response = $next($request);

            if ($response->isSuccessful()) {
                $tag = $request->url();

                if ('PATCH' === $method || 'DELETE' === $method) {
                    $tag = mb_substr($tag, 0, mb_strrpos($tag, '/'));
                }

                cache()->tags([$tag])->flush();
            }

            return $response;
        }

        foreach (self::EXCLUDED_URLS as $pattern) {
            if (preg_match($pattern, $request->getRequestUri())) {
                return $next($request);
            }
        }

        $cacheKey = $this->getCacheKey($request);

        $exception = null;

        $response = cache()
            ->tags([$request->url()])
            ->remember(
                key: $cacheKey,
                ttl: config('cache.ttl'),
                callback: function () use ($next, $request, &$exception) {
                    $res = $next($request);

                    if (property_exists($res, 'exception') && null !== $res->exception) {
                        $exception = $res;

                        return null;
                    }

                    return gzcompress($res->getContent());
                }
            );

        return $exception ?? response(gzuncompress($response));
    }

    private function getCacheKey(Request $request): string
    {
        $routeParameters = ! empty($request->route()->parameters) ? $request->route()->parameters : [auth()->user()->id];
        $allParameters = array_merge($request->all(), $routeParameters);
        $this->recursiveSort($allParameters);

        return $request->url() . json_encode($allParameters);
    }

    private function recursiveSort(&$array): void
    {
        foreach ($array as &$value) {
            if (is_array($value)) {
                $this->recursiveSort($value);
            }
        }

        ksort($array);
    }
}

Summary

This is all I have for you today on caching, Happy building and drop any questions, commments and improvements in the comments!

Das obige ist der detaillierte Inhalt vonSo erstellen Sie eine Caching-Ebene für Ihre Laravel-API. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!