golang melaksanakan redis

Redis ialah pangkalan data storan nilai kunci berprestasi tinggi yang sangat popular dan digunakan secara meluas dalam caching, baris gilir mesej, storan data dan senario lain. Artikel ini akan memperkenalkan cara menggunakan bahasa Go untuk melaksanakan pangkalan data Redis yang mudah.

Struktur data Redis

Redis ialah pangkalan data storan nilai kunci, di mana kedua-dua kunci dan nilai boleh terdiri daripada pelbagai jenis data. Redis menyokong lima jenis data asas:

1. String: Jenis data paling asas bagi Redis adalah selamat binari, bermakna ia boleh mengandungi sebarang data jenis ini. Panjang data maksimum ialah 512 MB.
2. Senarai: Jenis senarai ialah senarai terpaut berganda Setiap nod mengandungi rentetan, membenarkan operasi seperti menggantung, mengalih dan muncul di kedua-dua hujung senarai.
3. Set: Jenis set ialah koleksi tidak tertib yang mengandungi rentetan unik dan tidak berulang.
4. Jadual cincang (Cincang): Jenis jadual cincang ialah jadual cincang tidak tersusun dengan medan rentetan dan nilai yang sepadan Medan rentetan adalah unik dan digunakan untuk menyimpan pasangan nilai kunci.
5. Set Tempahan (ZSet): Jenis set tersusun ialah set tak tertib yang mengandungi ahli unik, bukan pendua dan skor tertib yang dikaitkan dengan setiap ahli.

Antara jenis data di atas, rentetan, senarai, jadual cincang dan set tersusun ialah jenis yang paling biasa digunakan.

Berbeza daripada pangkalan data lain, Redis menggunakan model satu benang atas sebab prestasi dan menggunakan sejumlah besar memori, memerlukan data ditulis ke cakera dengan kerap.

Arahan Redis

Arahan Redis (Perintah) ialah mesej yang dihantar oleh klien ke pelayan Redis Ia biasanya dalam format teks biasa dan menggunakan
sebagai pembatas antara arahan dan parameter simbol . Setiap arahan terdiri daripada satu atau lebih parameter, di mana parameter pertama ialah nama arahan. Arahan Redis boleh digunakan untuk mengendalikan data dalam pangkalan data Redis, seperti membaca dan menulis data, mencipta dan memadam kunci, dsb.

Berikut ialah contoh beberapa arahan yang biasa digunakan:

1. SET: Tetapkan pasangan nilai kunci.

   set key value

2. DAPATKAN: Dapatkan nilai kunci yang ditentukan.

   get key

3. INCR: Naikkan nilai kunci yang ditentukan sebanyak 1.

   incr key

4. DECR: Kurangkan nilai kunci yang ditentukan sebanyak 1.

   decr key

5. TAMAT TEMPOH: Tetapkan masa tamat tempoh kunci.

   expire key seconds

Melaksanakan pangkalan data Redis

Untuk melaksanakan pangkalan data Redis, kita perlu mencipta lima jenis struktur data: rentetan, senarai , Set, jadual cincang dan set diisih. Kami juga perlu melaksanakan pelayan Redis supaya ia boleh menerima arahan klien dan memprosesnya.

Pertama, kita perlu mentakrifkan struktur pangkalan data Redis, yang boleh menyimpan semua pasangan nilai kunci dan mengandungi lima jenis struktur data:

type RedisDB struct {
   StringData map[string]string
   ListData map[string][]string
   SetData map[string]map[string]bool
   HashData map[string]map[string]string
   ZsetData map[string]map[string]float64
}

Seterusnya, kami mentakrifkan pemprosesan kaedah arahan Redis . Kita boleh menggunakan pernyataan suis untuk menulis pernyataan kes bagi setiap nama arahan, dan kemudian menghantar kepada kaedah yang sepadan berdasarkan nama arahan dan parameter, contohnya:

func (r *RedisDB) ExecuteCommand(command []string) interface{} {
   switch strings.ToLower(command[0]) {
   case "get":
      return r.Get(command[1])
   case "set":
      r.Set(command[1], command[2])
      return "OK"
   case "del":
      r.Del(command[1:]...)
      return "OK"
   case "exists":
      return r.Exists(command[1])
   case "expire":
      r.Expire(command[1], command[2])
      return "OK"
   }
   return fmt.Sprintf("Error: unknown command %s", command[0])
}

Kita perlu melaksanakan kaedah untuk mengendalikan setiap arahan Redis. Sebagai contoh, berikut ialah pelaksanaan arahan GET:

func (r *RedisDB) Get(key string) interface{} {
   result, ok := r.StringData[key]
   if !ok {
      return nil
   }
   return result
}

Pelaksanaan arahan SET adalah seperti berikut:

func (r *RedisDB) Set(key, value string) {
   r.StringData[key] = value
}

Pelaksanaan arahan DEL adalah seperti berikut:

func (r *RedisDB) Del(keys ...string) {
   for i := range keys {
      delete(r.StringData, keys[i]) // 删除字符串
      delete(r.ListData, keys[i])   // 删除列表
      delete(r.SetData, keys[i])    // 删除集合
      delete(r.HashData, keys[i])   // 删除哈希表
      delete(r.ZsetData, keys[i])   // 删除有序集合
   }
}

Arahan EXISTS adalah seperti berikut:

func (r *RedisDB) Exists(key string) interface{} {
   _, ok1 := r.StringData[key]
   _, ok2 := r.ListData[key]
   _, ok3 := r.SetData[key]
   _, ok4 := r.HashData[key]
   _, ok5 := r.ZsetData[key]
   if ok1 || ok2 || ok3 || ok4 || ok5 {
      return true
   }
   return false
}

Akhir sekali, kami melaksanakan penghurai arahan mudah untuk pangkalan data Redis, yang menerima arahan daripada klien dan menghantarnya kepada kaedah pemprosesan arahan pangkalan data untuk mendapatkan hasil. Kodnya adalah seperti berikut:

func (r *RedisDB) CommandParser(conn net.Conn) {
   defer conn.Close()
   reader := bufio.NewReader(conn)
   for {
      command, err := reader.ReadString('
')
      if err != nil {
         return
      }
      command = strings.TrimRight(command, "
")
      if len(command) == 0 {
         continue
      }

      args := strings.Split(command, " ")
      result := r.ExecuteCommand(args)
      data, _ := json.Marshal(result)
      conn.Write(data)
      conn.Write([]byte("
"))
   }
}

Dengan cara ini, kami telah melaksanakan pangkalan data Redis yang mudah.

Uji pangkalan data Redis

Kami boleh menggunakan telnet untuk menguji pangkalan data Redis. Mula-mula, jalankan pelayan Redis:

redis := RedisDB{
   StringData: make(map[string]string),
   ListData: make(map[string][]string),
   SetData: make(map[string]map[string]bool),
   HashData: make(map[string]map[string]string),
   ZsetData: make(map[string]map[string]float64),
}
listener, err := net.Listen("tcp", ":6379")
if err != nil {
   log.Fatal("Unable to listen on port 6379", err)
}
for {
   conn, err := listener.Accept()
   if err != nil {
      log.Println("Error accepting connection", err)
      continue
   }
   go redis.CommandParser(conn)
}

Kemudian, gunakan telnet untuk menyambung ke pelayan Redis:

telnet localhost 6379

Masukkan arahan dalam telnet untuk menguji pangkalan data Redis:

set name john
OK
get name
"john"
exists name
true
expire name 60
OK
del name
OK

Dengan cara ini, kami Berjaya melaksanakan pangkalan data Redis yang mudah. Sudah tentu, ini hanyalah pelaksanaan asas, dan pangkalan data Redis sebenar juga mengandungi banyak ciri lanjutan, seperti terbitkan/langganan, skrip Lua, urus niaga, kegigihan, pengelompokan dan banyak lagi. Tetapi versi mudah yang disediakan dalam artikel ini sudah cukup untuk anda memahami prinsip pelaksanaan asas Redis.

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