Melaksanakan caching tempatan menggunakan rangka kerja web Golang rangka kerja Buffalo

Caching tempatan ialah teknologi yang biasa digunakan dalam pembangunan web, yang boleh meningkatkan prestasi dan ketersediaan aplikasi web. Semasa proses pembangunan, kita selalunya perlu menggunakan rangka kerja tertentu untuk melaksanakan caching tempatan Dalam artikel ini, saya akan memperkenalkan cara menggunakan rangka kerja Web Golang Buffalo untuk melaksanakan caching tempatan.

Rangka kerja Buffalo ialah rangka kerja web yang dibangunkan berdasarkan bahasa Golang. Dalam rangka kerja Buffalo, kami boleh melaksanakan caching tempatan dengan mudah, yang boleh meningkatkan prestasi aplikasi web dengan banyak. Di bawah saya akan memperkenalkan cara menggunakan rangka kerja Buffalo untuk melaksanakan caching tempatan.

Langkah 1: Buat aplikasi Buffalo baharu

Untuk menggunakan rangka kerja Buffalo untuk melaksanakan caching tempatan, kita perlu mencipta aplikasi Buffalo baharu terlebih dahulu. Kita boleh mencipta aplikasi Buffalo baharu menggunakan arahan berikut:

$ buffalo new myapp

Ini akan mencipta aplikasi Buffalo baharu bernama myapp.

Langkah 2: Tambahkan pergantungan gorila/mux

Kami akan menggunakan gorila/mux sebagai penghala HTTP kami. Untuk ini, kita perlu menambah kebergantungan gorila/mux. Kita boleh melakukan ini dengan menambah baris berikut dalam fail go.mod:

require github.com/gorilla/mux v1.8.0

dan kemudian jalankan arahan berikut untuk memuat turun kebergantungan:

$ go mod download

Langkah 3: Buat pengawal cache

Kami perlu mencipta pengawal cache untuk mengendalikan semua permintaan. Kita boleh mencipta fail baharu bernama CacheController dan menambah kod berikut:

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

Dalam pengawal ini, kami menggunakan struktur mux.RouteMatch gorila/mux untuk mendapatkan maklumat dan nama penghalaan semasa. Kemudian kami menggunakan pakej cache Buffalo untuk melaksanakan caching. Apabila kami menyemak cache, kami mula-mula menyemak sama ada laluan itu wujud dalam cache kami map dan kemudian menyemak sama ada terdapat padanan dengan URL permintaan dalam cache. Jika terdapat padanan, nilai cache dikembalikan, jika tidak, pengendali dijalankan dan hasilnya dicache.

Langkah 4: Gunakan pengawal cache dalam penghala

Kini kita boleh menggunakan pengawal cache dalam penghala. Kami hanya perlu menambah pengawal CacheController dalam perisian tengah penghala. Kami boleh melaksanakan proses ini menggunakan kod berikut:

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

Dalam contoh ini, kami juga menambah perisian tengah masa mula untuk merekodkan tempoh dan prestasi permintaan.

Langkah 5: Uji cache

Kini kami boleh menguji sama ada cache kami berfungsi dengan betul. Kita boleh memulakan aplikasi Buffalo menggunakan arahan berikut:

$ buffalo dev

Kemudian kita boleh menggunakan alatan seperti curl untuk menguji cache kita. Contohnya:

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

Kita boleh menjalankan arahan ini beberapa kali untuk menguji cache. Pada larian pertama, cache diisi, dan larian kedua dan seterusnya akan mengembalikan nilai cache.

Kesimpulan

Dalam artikel ini, kami memperkenalkan cara menggunakan rangka kerja Buffalo untuk melaksanakan caching tempatan. Rangka kerja Buffalo sangat berguna untuk pembangunan aplikasi web kerana ia memudahkan banyak tugas dan operasi biasa. Dengan menggunakan rangka kerja Buffalo dan beberapa kebergantungan lain seperti gorila/mux dan pakej cache Buffalo, kami boleh melaksanakan caching tempatan dengan mudah dan meningkatkan prestasi serta ketersediaan aplikasi web kami.

Atas ialah kandungan terperinci Melaksanakan caching tempatan menggunakan rangka kerja web Golang rangka kerja Buffalo. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!