Implementierung von lokalem Caching mit Golangs Web-Framework Buffalo Framework

Lokales Caching ist eine häufig verwendete Technologie in der Webentwicklung, die die Leistung und Verfügbarkeit von Webanwendungen verbessern kann. Während des Entwicklungsprozesses müssen wir häufig bestimmte Frameworks verwenden, um lokales Caching zu implementieren. In diesem Artikel werde ich vorstellen, wie man das Web-Framework Buffalo von Golang verwendet, um lokales Caching zu implementieren.

Das Buffalo-Framework ist ein Web-Framework, das auf der Grundlage der Golang-Sprache entwickelt wurde. Im Buffalo-Framework können wir problemlos lokales Caching implementieren, was die Leistung von Webanwendungen erheblich verbessern kann. Im Folgenden werde ich vorstellen, wie das Buffalo-Framework zur Implementierung von lokalem Caching verwendet wird.

Schritt 1: Erstellen Sie eine neue Buffalo-Anwendung

Um das Buffalo-Framework zur Implementierung von lokalem Caching zu verwenden, müssen wir zunächst eine neue Buffalo-Anwendung erstellen. Mit dem folgenden Befehl können wir eine neue Buffalo-App erstellen:

$ buffalo new myapp

Dadurch wird eine neue Buffalo-App mit dem Namen myapp erstellt. myapp的新Buffalo应用程序。

第二步：添加gorilla / mux依赖关系

我们将使用gorilla / mux作为我们的HTTP路由器。为此，我们需要添加gorilla / mux的依赖项。我们可以通过在go.mod文件中添加以下行来实现：

require github.com/gorilla/mux v1.8.0

然后运行以下命令来下载依赖项：

$ go mod download

第三步：创建一个缓存控制器

我们需要创建一个缓存控制器来处理所有请求。我们可以创建一个名为CacheController的新文件，并添加以下代码：

package actions

import (
    "net/http"
    "time"

    "github.com/gorilla/mux"
    "github.com/gobuffalo/buffalo"
    "github.com/gobuffalo/buffalo/cache"
)

func CacheController() buffalo.Handler {
    // create a map to store the cache entries
    var cacheEntries = make(map[string]cache.Store)

    return func(c buffalo.Context) error {
        // get the current route
        route := c.Value("current_route").(mux.RouteMatch)

        // get the cache entry name
        cacheKey := route.Route.GetName()

        // check if the cache entry exists
        if cacheEntry, ok := cacheEntries[cacheKey]; ok {
            // if it does, get the value from the cache
            cachedValue, err := cacheEntry.Get(c.Request().URL.String())
            if err == nil {
                // if there's no error, return the value from the cache
                return c.Render(http.StatusOK, r.JSON(cachedValue))
            }
        }

        // if the cache entry doesn't exist or there was an error getting
        // the value from the cache, run the handler and cache the result
        h := route.Route.GetHandler()
        res := h(c)
        cacheStore := cache.NewCache(time.Minute * 1)
        cacheStore.Add(c.Request().URL.String(), res.Body.String())

        cacheEntries[cacheKey] = cacheStore

        return res
    }
}

在这个控制器中，我们使用了gorilla / mux的mux.RouteMatch结构，来获取当前的路由信息和名称。然后我们使用Buffalo的cache包来实现缓存。当我们检查缓存时，我们首先检查路由是否存在于我们的缓存map中，然后检查缓存中是否存在与请求URL的匹配项。如果存在匹配项，则返回缓存的值，否则运行处理程序并将结果缓存起来。

第四步：在路由器中使用缓存控制器

现在我们可以在路由器中使用缓存控制器了。我们只需要在路由器的中间件中添加CacheController

Schritt 2: Gorilla/Mux-Abhängigkeit hinzufügen

Wir werden Gorilla/Mux als unseren HTTP-Router verwenden. Dazu müssen wir die Abhängigkeit von Gorilla/Mux hinzufügen. Wir können dies tun, indem wir die folgende Zeile in die Datei go.mod einfügen:

func (a *App) cacheRoutes() {
    r := a.Router

    r.Use(func(next buffalo.Handler) buffalo.Handler {
        return func(c buffalo.Context) error {
            c.Set("start_time", time.Now())
            return next(c)
        }
    })

    r.Use(CacheController())
}

Dann führen Sie den folgenden Befehl aus, um die Abhängigkeiten herunterzuladen:

$ buffalo dev

Schritt 3: Erstellen Sie einen Cache-Controller

Wir brauchen Erstellen Sie einen Cache-Controller, um alle Anfragen zu verarbeiten. Wir können eine neue Datei namens CacheController erstellen und den folgenden Code hinzufügen:

$ curl http://localhost:3000/api/v1/items

In diesem Controller verwenden wir die mux.RouteMatch-Struktur von Gorilla/Mux, um das aktuelle Routing zu erhalten Informationen und Name. Dann verwenden wir das cache-Paket von Buffalo, um Caching zu implementieren. Wenn wir den Cache überprüfen, prüfen wir zunächst, ob die Route in unserer Cache-Karte vorhanden ist, und prüfen dann, ob im Cache eine Übereinstimmung mit der Anforderungs-URL vorhanden ist. Bei einer Übereinstimmung wird der zwischengespeicherte Wert zurückgegeben, andernfalls wird der Handler ausgeführt und das Ergebnis zwischengespeichert.

Schritt 4: Den Cache-Controller im Router verwenden

Jetzt können wir den Cache-Controller im Router verwenden. Wir müssen lediglich den Controller CacheController in der Middleware des Routers hinzufügen. Wir können diesen Prozess mit dem folgenden Code implementieren: 🎜rrreee🎜 In diesem Beispiel fügen wir auch eine Startzeit-Middleware hinzu, um die Dauer und Leistung der Anfrage aufzuzeichnen. 🎜🎜Schritt 5: Cache testen🎜🎜Jetzt können wir testen, ob unser Cache ordnungsgemäß funktioniert. Wir können die Buffalo-Anwendung mit dem folgenden Befehl starten: 🎜rrreee🎜 Dann können wir Tools wie Curl verwenden, um unseren Cache zu testen. Zum Beispiel: 🎜rrreee🎜 Wir können diesen Befehl mehrmals ausführen, um den Cache zu testen. Beim ersten Durchlauf wird der Cache gefüllt und beim zweiten und den folgenden Durchläufen werden die zwischengespeicherten Werte zurückgegeben. 🎜🎜Fazit🎜🎜In diesem Artikel haben wir vorgestellt, wie Sie das Buffalo-Framework verwenden, um lokales Caching zu implementieren. Das Buffalo-Framework ist für die Entwicklung von Webanwendungen sehr nützlich, da es viele häufige Aufgaben und Vorgänge vereinfacht. Durch die Verwendung des Buffalo-Frameworks und einiger anderer Abhängigkeiten wie Gorilla/Mux und dem Cache-Paket von Buffalo können wir problemlos lokales Caching implementieren und die Leistung und Verfügbarkeit unserer Webanwendungen verbessern. 🎜

Das obige ist der detaillierte Inhalt vonImplementierung von lokalem Caching mit Golangs Web-Framework Buffalo Framework. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!