pertanyaan kumpulan redis golang

Redis ialah sistem storan struktur data dalam memori sumber terbuka yang menyokong pelbagai struktur data, seperti rentetan, cincang, senarai, set, dsb. Golang ialah bahasa yang cekap, ditaip kuat, disusun dengan keupayaan pemprosesan serentak yang sangat baik. Dalam pembangunan Golang, Redis ialah pilihan yang sangat baik Ia boleh menyediakan perkhidmatan storan data dan akses berprestasi tinggi, kebolehpercayaan tinggi untuk program. Artikel ini akan memperkenalkan cara melaksanakan operasi pertanyaan kelompok Redis di Golang.

1. Menyambung ke Redis

Mula-mula, anda perlu menggunakan pakej redis terbina dalam bahasa Go untuk menyambung ke Redis. Menyambung ke Redis adalah sangat mudah, hanya gunakan fungsi redis.NewClient(). Fungsi ini menyokong penghantaran dalam berbilang parameter, seperti alamat, kata laluan, pangkalan data, tamat masa sambungan, dll. pelayan redis. Berikut ialah contoh kod mudah:

import "github.com/go-redis/redis"

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

  // 测试连接
  _, err := client.Ping().Result()
  if err != nil {
    panic(err)
  }
}

Dalam contoh ini, kami mencipta contoh redis.NewClient dan menyambung ke pelayan Redis tempatan menggunakan konfigurasi lalai. Kemudian sambungan telah diuji melalui kaedah klien.Ping dan ralat telah dikendalikan.

2. Pertanyaan kelompok

Setelah sambungan Redis diwujudkan, pertanyaan kelompok boleh dilakukan. Di Golang, kita boleh menggunakan kaedah MGet dan HMGet yang disediakan oleh pakej redis untuk melaksanakan pertanyaan kelompok.

Kaedah MGet boleh digunakan untuk menanyakan berbilang nilai jenis String Ia menerima satu atau lebih parameter sebagai kunci pertanyaan dan mengembalikan tatasusunan rentetan. Berikut ialah contoh, yang menanyakan nilai threeKey dan fourKey dalam Redis:

func batchGetStringValues(client *redis.Client) []string {
  keys := []string{"threeKey", "fourKey"}
  res, err := client.MGet(keys...).Result()
  if err != nil {
    panic(err)
  }
  return res
}

Kaedah HMGet boleh digunakan untuk menanyakan berbilang nilai jenis Hash Ia menerima satu parameter sebagai kunci objek cincang pertanyaan, berbilang Parameter digunakan sebagai nama medan cincang, dan tatasusunan rentetan dikembalikan. Berikut ialah contoh, yang menanyakan nama dan medan umur user3 dan user4 dalam Redis:

func batchGetHashValues(client *redis.Client) []string {
  keys := []string{"user3", "user4"}
  fields := []string{"name", "age"}
  res, err := client.HMGet(keys, fields...).Result()
  if err != nil {
    panic(err)
  }
  return res
}

Perlu diingatkan di sini bahawa hasil yang dikembalikan oleh kaedah HMGet ialah tatasusunan jenis antara muka{}, bukan tatasusunan rentetan aksara. Jika anda perlu mendapatkan hasil pertanyaan, penukaran jenis diperlukan.

3. Pertanyaan serentak

Melalui dua kaedah di atas, kami boleh melaksanakan pertanyaan kelompok. Walau bagaimanapun, jika jumlah data yang ingin ditanya adalah besar, atau data yang ditanya tidak bersebelahan, kecekapan pertanyaan kelompok mungkin tidak tinggi. Untuk meningkatkan kecekapan pertanyaan, kami boleh menggunakan mekanisme goroutine dan saluran unik bahasa Go untuk melaksanakan pertanyaan serentak.

Pertama, tentukan struktur tugas pertanyaan:

type queryTask struct {
  key    string
  fields []string
  result chan interface{}
}

Antaranya, kunci mewakili kunci untuk disoal, medan mewakili senarai medan untuk disoal dan hasil mewakili hasil pertanyaan. Kemudian, tentukan kaedah coroutine:

func queryWorker(client *redis.Client, tasks <-chan *queryTask, wg *sync.WaitGroup) {
  defer wg.Done()
  for task := range tasks {
    result, err := client.HMGet(task.key, task.fields...).Result()
    if err != nil {
      task.result <- err
    } else {
      task.result <- result
    }
  }
}

Kaedah coroutine ini menerima tugas saluran tugas dan mengeluarkan tugas daripada saluran untuk pertanyaan. Hasil pertanyaan akan ditulis ke saluran hasil tugasan.

Akhir sekali, jana tugasan pertanyaan dan masukkan ke dalam saluran tugas:

func batchGetHashValuesConcurrent(client *redis.Client, keys []string, fields []string) []interface{} {
  tasks := make(chan *queryTask, len(keys)*len(fields))
  wg := sync.WaitGroup{}

  // 启动任务协程
  for i := 0; i < runtime.NumCPU(); i++ {
    go queryWorker(client, tasks, &wg)
  }

  // 发送任务
  for _, key := range keys {
    task := &queryTask{key, fields, make(chan interface{})}
    tasks <- task
    wg.Add(1)
  }

  // 等待查询完成
  go func() {
    wg.Wait()
    close(tasks)
  }()

  // 收集结果
  results := make([]interface{}, len(keys)*len(fields))
  var i int
  for task := range tasks {
    for _, res := range task.result {
      results[i] = res
      i++
    }
  }
  return results
}

Fungsi ini akan memulakan berbilang coroutine dan meletakkan tugasan pertanyaan ke dalam saluran secara bergilir-gilir. Kemudian, tunggu coroutine tugas menyelesaikan pertanyaan dan dapatkan hasil pertanyaan daripada saluran hasil tugasan. Akhirnya, semua hasil pertanyaan digabungkan menjadi satu keping dan dikembalikan.

Di atas ialah kaedah operasi pertanyaan kelompok dan pengoptimuman prestasi Redis di Golang. Sudah tentu, sebagai tambahan kepada kaedah di atas, kami juga boleh mencapai operasi pertanyaan kelompok yang lebih cekap melalui mekanisme seperti saluran paip dan transaksi Redis.

Atas ialah kandungan terperinci pertanyaan kumpulan redis golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!