Implémentation de la mise en cache locale à l'aide du framework Web Buffalo de Golang

La mise en cache locale est une technologie couramment utilisée dans le développement Web, qui peut améliorer les performances et la disponibilité des applications Web. Au cours du processus de développement, nous devons souvent utiliser certains frameworks pour implémenter la mise en cache locale. Dans cet article, je vais vous présenter comment utiliser le framework Buffalo de Golang pour implémenter la mise en cache locale.

Le framework Buffalo est un framework Web développé sur la base du langage Golang. Dans le framework Buffalo, nous pouvons facilement implémenter une mise en cache locale, ce qui peut grandement améliorer les performances des applications Web. Ci-dessous, je vais vous présenter comment utiliser le framework Buffalo pour implémenter la mise en cache locale.

Étape 1 : Créer une nouvelle application Buffalo

Afin d'utiliser le framework Buffalo pour implémenter la mise en cache locale, nous devons d'abord créer une nouvelle application Buffalo. Nous pouvons créer une nouvelle application Buffalo en utilisant la commande suivante :

$ buffalo new myapp

Cela créera une nouvelle application Buffalo nommée myapp. 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

Étape 2 : Ajouter une dépendance gorilla/mux

Nous utiliserons gorilla/mux comme routeur HTTP. Pour cela, nous devons ajouter la dépendance de gorilla/mux. Nous pouvons le faire en ajoutant la ligne suivante dans le fichier go.mod :

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())
}

Ensuite, exécutez la commande suivante pour télécharger les dépendances :

$ buffalo dev

Étape 3 : Créer un contrôleur de cache

Nous avons besoin Créez un contrôleur de cache pour gérer toutes les requêtes. Nous pouvons créer un nouveau fichier appelé CacheController et ajouter le code suivant :

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

Dans ce contrôleur, nous utilisons la structure mux.RouteMatch de gorilla/mux, pour obtenir le routage actuel. informations et nom. Ensuite, nous utilisons le package cache de Buffalo pour implémenter la mise en cache. Lorsque nous vérifions le cache, nous vérifions d'abord si la route existe dans notre carte de cache, puis si une correspondance avec l'URL de la requête existe dans le cache. S'il y a une correspondance, la valeur mise en cache est renvoyée, sinon le gestionnaire est exécuté et le résultat est mis en cache.

Étape 4 : Utiliser le contrôleur de cache dans le routeur

Nous pouvons maintenant utiliser le contrôleur de cache dans le routeur. Il suffit d'ajouter le contrôleur CacheController dans le middleware du routeur. Nous pouvons implémenter ce processus en utilisant le code suivant : 🎜rrreee🎜 Dans cet exemple, nous ajoutons également un middleware d'heure de début pour enregistrer la durée et les performances de la requête. 🎜🎜Étape 5 : Testez le cache🎜🎜Nous pouvons maintenant tester si notre cache fonctionne correctement. Nous pouvons démarrer l'application Buffalo en utilisant la commande suivante : 🎜rrreee🎜 Ensuite, nous pouvons utiliser des outils comme curl pour tester notre cache. Par exemple : 🎜rrreee🎜 Nous pouvons exécuter cette commande plusieurs fois pour tester le cache. Lors de la première exécution, le cache est rempli et la deuxième exécution et les suivantes renverront les valeurs mises en cache. 🎜🎜Conclusion🎜🎜Dans cet article, nous avons présenté comment utiliser le framework Buffalo pour implémenter la mise en cache locale. Le framework Buffalo est très utile pour le développement d'applications Web car il simplifie de nombreuses tâches et opérations courantes. En utilisant le framework Buffalo et quelques autres dépendances telles que gorilla/mux et le package de cache de Buffalo, nous pouvons facilement implémenter la mise en cache locale et améliorer les performances et la disponibilité de nos applications Web. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!