Amalan penyepaduan cache aplikasi web pembelajaran Golang

Golang ialah bahasa pengaturcaraan sumber terbuka yang dibangunkan oleh Google. Ia popular kerana fleksibiliti, kecekapan dan kebolehskalaannya, terutamanya dalam pembangunan aplikasi web. Artikel ini bertujuan untuk memperkenalkan cara mengintegrasikan caching dalam Golang untuk meningkatkan prestasi aplikasi web.

1. Maksud dan prinsip caching

Cache ialah struktur data yang digunakan untuk menyimpan data yang kerap diakses untuk meningkatkan kelajuan akses. Caching boleh menyimpan data dalam ingatan, dengan itu mempercepatkan capaian data untuk mengelakkan pembacaan yang kerap daripada cakera.

Penggunaan caching dalam aplikasi web adalah sangat biasa. Apabila aplikasi web perlu mendapatkan semula data, ia biasanya menghantar permintaan pertanyaan kepada pangkalan data. Proses menyoal pangkalan data boleh memakan masa, dan jika data yang sama perlu disoal dengan kerap, ia akan mengurangkan prestasi aplikasi web. Jika keputusan pertanyaan dicache dalam ingatan, prestasi program akan bertambah baik.

2. Caching dalam Golang

Di Golang, anda boleh menggunakan perpustakaan caching terbina dalam atau perpustakaan caching pihak ketiga untuk melaksanakan fungsi caching.

1. Pustaka caching terbina dalam

Golang menyediakan perpustakaan caching terbina dalam - sync.Map. sync.Map ialah jadual cincang selamat benang yang membenarkan membaca dan menulis serentak tanpa overhed persaingan kunci, jadi ia lebih sesuai untuk senario konkurensi tinggi.

Sangat mudah untuk melaksanakan caching menggunakan penyegerakan.Peta. Sebagai contoh, kita boleh mentakrifkan cache seperti ini:

var cache sync.Map

Kemudian, kita boleh menggunakan kaedah Muat dan Simpan untuk membaca dan menyimpan data daripada cache. Sebagai contoh, kita boleh membaca entri cache dengan kunci "foo" daripada cache seperti ini:

if value, ok := cache.Load("foo"); ok {
    fmt.Println("value is", value)
}

Kemudian, kita boleh menyimpan entri cache dengan kunci "foo" ke dalam cache seperti ini:

cache.Store("foo", "bar")

Terdapat kaedah lain dalam penyegerakan. Peta, seperti Padam, Julat, dsb., yang boleh membantu kami menyelesaikan pengurusan cache.

2. Pustaka cache pihak ketiga

Selain menggunakan sync.Map, kami juga boleh menggunakan pustaka cache pihak ketiga untuk melaksanakan caching.

Redis ialah sistem penyimpanan caching dan nilai kunci yang biasa digunakan yang sesuai untuk aplikasi web. Di Golang, terdapat banyak perpustakaan pelanggan Redis pihak ketiga yang tersedia, seperti go-redis, redigo, dsb.

Sebagai contoh, kita boleh menggunakan go-redis untuk melaksanakan caching. Mula-mula, kita perlu mentakrifkan klien Redis:

client := redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
    Password: "",
    DB: 0,
})

Kemudian, kita boleh menggunakan kaedah Set dan Dapatkan untuk menyimpan data ke dalam cache dan membaca data daripada cache:

err := client.Set(context.Background(), "foo", "bar", 0).Err()
if err != nil {
    panic(err)
}

value, err := client.Get(context.Background(), "foo").Result()
if err != nil {
    panic(err)
}
fmt.Println("value is", value)

Redis also There adalah kaedah lain, seperti Del, Exists, Expire, dsb., yang boleh membantu kami menyelesaikan pengurusan cache.

3. Amalan caching

Dalam aplikasi web, caching digunakan secara meluas dan boleh digunakan untuk fail statik, hasil pertanyaan pangkalan data, respons API dan senario lain.

Kami boleh menggunakan rangka kerja web pihak ketiga Golang untuk membina aplikasi web. Sebagai contoh, kita boleh menggunakan Gin sebagai rangka kerja web.

Berikut ialah contoh caching menggunakan Gin dan penyegerakan.Peta:

package main

import (
    "math/rand"
    "strconv"
    "sync"

    "github.com/gin-gonic/gin"
)

var cache sync.Map

func main() {
    r := gin.Default()

    r.GET("/cache/:key", func(c *gin.Context) {
        key := c.Param("key")
        if value, ok := cache.Load(key); ok {
            c.JSON(200, gin.H{
                "key": key,
                "value": value,
            })
        } else {
            value := strconv.Itoa(rand.Intn(100))
            cache.Store(key, value)
            c.JSON(200, gin.H{
                "key": key,
                "value": value,
            })
        }
    })

    r.Run()
}

Dalam contoh ini, kami mentakrifkan pembolehubah global yang dipanggil cache, iaitu penyegerakan.Peta. Apabila kami mengakses "/cache/:key", kami mula-mula mencari nilai yang sepadan dengan kunci daripada cache. Jika nilai ditemui dalam cache, kami mengembalikannya kepada pelanggan. Jika tidak, kami menggunakan rand.Intn(100) untuk menjana nombor rawak sebagai nilai dan menyimpannya dalam cache.

Apabila kita menggunakan curl untuk mengakses http://localhost:8080/cache/foo, hasilnya akan serupa dengan:

{
    "key": "foo",
    "value": "42"
}

4. Kesimpulan

Cache ialah Teknologi yang sangat penting yang boleh membantu kami meningkatkan prestasi aplikasi web. Di Golang, kami boleh menggunakan penyegerakan terbina dalam. Peta dan perpustakaan caching pihak ketiga untuk melaksanakan caching. Kami juga memperkenalkan contoh caching menggunakan Gin dan sync.Map.

Apabila kami menggunakan cache, kami perlu memberi perhatian kepada beberapa isu. Sebagai contoh, kita perlu kerap memadamkan entri cache yang telah tamat tempoh untuk mengelakkan limpahan cache. Apabila menggunakan cache luaran seperti Redis, faktor seperti kependaman rangkaian juga perlu dipertimbangkan. Dalam amalan, kita perlu mempertimbangkan pelbagai faktor untuk memilih penyelesaian caching terbaik.

Atas ialah kandungan terperinci Amalan penyepaduan cache aplikasi web pembelajaran Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!