Menggunakan Redis dalam Go: Panduan Lengkap

Dengan perkembangan pesat Internet dan aplikasi mudah alih, pemprosesan data telah menjadi bahagian yang amat diperlukan dalam aplikasi moden. Teknologi caching pangkalan data menjadi semakin penting, dan Redis menjadi semakin popular sebagai aplikasi dalam memori berprestasi tinggi. Dalam artikel ini, kami akan membentangkan tutorial komprehensif tentang menggunakan Redis dalam bahasa Go.

1. Persediaan

Sebelum mula menggunakan Redis, kita perlu memasang dan memulakan pelayan Redis. Ini dilakukan dengan memuat turun Redis dan menjalankan arahan pelayan Redis. Sebaik sahaja kami menjalankan Redis dan pelayan dimulakan, kami akan dapat beroperasi dengan Redis.

2. Menggunakan Klien Go Redis

Dalam bahasa Go, terdapat banyak perpustakaan klien Redis tersedia untuk menyambung dan berkomunikasi dengan pelayan Redis. Di sini kami memilih salah satu perpustakaan pelanggan Go Redis yang paling popular - go-redis.

Muat turun dan pasang go-redis:

go get github.com/go-redis/redis

3. Operasi asas

Sambung ke pelayan Redis:

import (
    "fmt"
    "github.com/go-redis/redis"
)

func main() {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379", // Redis 服务器地址
        Password: "",               // Redis 密码
        DB:       0,                // Redis 数据库
    })

    pong, err := client.Ping().Result()
    fmt.Println(pong, err)
}

Output: PONG <nil>

Dalam contoh ini, kami mewujudkan sambungan Redis dan ping untuk memeriksa sama ada sambungan itu normal.

Tetapkan dan dapatkan pasangan nilai kunci dalam Redis:

err := client.Set("key", "value", 0).Err()
if err != nil {
    panic(err)
}

val, err := client.Get("key").Result()
if err != nil {
    panic(err)
}
fmt.Println("key", val)

Output: key value

Dalam contoh ini, kami menggunakan perintah SET untuk menetapkan kunci masuk Pasangan nilai redis, dan kemudian gunakan perintah GET untuk mendapatkan semula pasangan nilai kunci.

4. Operasi Terperinci

Terdapat banyak arahan lanjutan dalam Redis untuk operasi yang lebih kompleks. Di bawah ini kami akan memperkenalkan beberapa arahan lanjutan yang biasa digunakan.

4.1 Terbit/Langgan

Redis menyediakan mod terbitkan/langgan yang boleh digunakan untuk menghantar mesej kepada berbilang pelanggan. Dalam contoh ini, kami akan mencipta dua pelanggan, satu yang melanggan saluran foo dan satu yang menerbitkan mesej ke saluran foo.

import (
    "fmt"
    "github.com/go-redis/redis"
)

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

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

    pubsub := client2.Subscribe("foo")
    _, err := pubsub.Receive()
    if err != nil {
        panic(err)
    }

    err = client1.Publish("foo", "hello world").Err()
    if err != nil {
        panic(err)
    }

    msg, err := pubsub.ReceiveMessage()
    if err != nil {
        panic(err)
    }

    fmt.Println(msg.Channel, msg.Payload)
}

Output: foo hello world

Dalam contoh ini, kami menggunakan perintah PUBLISH untuk menerbitkan mesej ke saluran foo dan menggunakan perintah SUBSCRIBE untuk melanggan saluran untuk menerima mesej. Apabila kami menerbitkan mesej, kami akan menerimanya dalam pelanggan yang melanggan kami.

4.2 Transaksi

Redis menyediakan fungsi transaksi untuk mengendalikan situasi di mana berbilang operasi perlu dilakukan secara serentak. Kita boleh menggunakan arahan berikut untuk membuat transaksi dan menambah berbilang arahan Redis pada transaksi.

import (
    "fmt"
    "github.com/go-redis/redis"
)

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

    err := client.Watch(func(tx *redis.Tx) error {
        _, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
            pipe.Set("key1", "hello")
            pipe.Set("key2", "world")
            return nil
        })
        if err != nil {
            return err
        }

        val1, err := tx.Get("key1").Result()
        if err != nil {
            return err
        }
        fmt.Println("key1", val1)

        val2, err := tx.Get("key2").Result()
        if err != nil {
            return err
        }
        fmt.Println("key2", val2)

        return nil
    }, "key1", "key2")

    if err != nil {
        panic(err)
    }
}

Output: key1 hello key2 world

Dalam contoh ini, kami mencipta transaksi menggunakan perintah WATCH dan menambah dua perintah SET pada transaksi. Kami kemudian cuba membaca kedua-dua kekunci untuk memastikan operasi SET berjaya. Jika operasi SET gagal, keseluruhan transaksi dibatalkan.

5. Kesimpulan

Dalam artikel ini, kami telah memperkenalkan cara menggunakan perpustakaan klien Redis go-redis dalam bahasa Go untuk menyambung dan mengendalikan pelayan Redis. Kami mempelajari tentang operasi asas dan lanjutan Redis seperti menetapkan dan mendapatkan pasangan nilai kunci, mod terbitkan/langganan dan transaksi. Dengan menggunakan teknologi ini, kami boleh membina aplikasi berprestasi tinggi dan berskala dengan mudah.

Atas ialah kandungan terperinci Menggunakan Redis dalam Go: Panduan Lengkap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!