Redis

Redis adalah database penyimpanan key-value (Key-Value) open source yang ditulis dalam bahasa ANSI C, mematuhi protokol BSD, mendukung jaringan, berbasis memori, terdistribusi, dan persistensi opsional. Redis menyediakan API untuk berbagai bahasa, dapat digunakan sebagai database NoSQL, juga dapat berfungsi sebagai penyimpanan cache berkecepatan tinggi, dan mendukung antrian pesan sederhana.

Artikel ini hanya menjelaskan cara menggunakan driver Go untuk mengoperasikan database Redis, tanpa menjelaskan Redis itu sendiri.

Dokumentasi resmi: Golang Redis client (uptrace.dev)

Repositori resmi: go-redis/redis: Type-safe Redis client for Golang (github.com)

Instalasi

Ada banyak driver untuk Redis, dan yang digunakan dalam artikel ini adalah github.com/go-redis/redis.

Jika versi Redis yang Anda gunakan adalah 6

go get github.com/go-redis/redis/v8

Jika versi Redis yang Anda gunakan adalah 7

go get github.com/go-redis/redis/v9

Memulai Cepat

import (
   "fmt"
   "log"
   "testing"

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

func TestQuickStart(t *testing.T) {
   // Membuat klien koneksi Redis
   redisClient := redis.NewClient(&redis.Options{
      Addr:     "192.168.48.134:6379",
      Password: "123456",
      DB:       0, // Menggunakan DB default
   })

   // Menetapkan pasangan key-value, 0 berarti tidak pernah kedaluwarsa
   redisClient.Set("hello", "world", 0)

   // Membaca nilai
   result, err := redisClient.Get("hello").Result()
   if err == redis.Nil {
      fmt.Println("key tidak ada")
   } else if err != nil {
      log.Panic(err)
   }
   fmt.Println(result)
}

Konfigurasi Koneksi

type Options struct {
  // Tipe jaringan tcp atau unix.
  // Default adalah tcp.
  Network string
  // Alamat redis, format host:port
  Addr string

    // Dialer membuat koneksi jaringan baru dan memiliki prioritas lebih tinggi daripada opsi Network dan Addr
  // Network and Addr options.
  Dialer func() (net.Conn, error)

  // Fungsi ini akan dipanggil saat membuat koneksi redis baru
  OnConnect func(*Conn) error

  // Kata sandi redis, dapat kosong jika server redis tidak mengaturnya.
  Password string

  // Database redis, dimulai dari 0, default adalah 0, dapat tidak diatur
  DB int

  // Jumlah maksimum percobaan ulang saat operasi redis gagal, default 0.
  MaxRetries int

  // Interval waktu percobaan ulang minimum.
  // Default adalah 8ms ; -1 berarti menonaktifkan.
  MinRetryBackoff time.Duration

  // Interval waktu percobaan ulang maksimum
  // Default adalah 512ms; -1 berarti menonaktifkan.
  MaxRetryBackoff time.Duration

  // Waktu tunggu koneksi redis baru.
  // Default adalah 5 detik.
  DialTimeout time.Duration

  // Waktu tunggu baca socket
  // Default 3 detik.
  ReadTimeout time.Duration

  // Waktu tunggu tulis socket
  WriteTimeout time.Duration

  // Jumlah maksimum koneksi dalam pool koneksi redis.
  // Ukuran pool default sama dengan jumlah cpu * 10
  PoolSize int

  // Jumlah minimum koneksi idle dalam pool koneksi redis.
  MinIdleConns int

  // Waktu hidup maksimum koneksi redis, default tidak akan menutup koneksi yang sudah usang.
  MaxConnAge time.Duration

  // Setelah Anda mendapatkan koneksi dari pool koneksi redis, berapa lama pool akan menunggu koneksi yang diambil tersebut.
  // Default adalah menunggu ReadTimeout + 1 detik.
  PoolTimeout time.Duration

  // Berapa lama pool koneksi redis akan menutup koneksi idle.
  // Default adalah 5 menit. -1 berarti menonaktifkan opsi konfigurasi ini
  IdleTimeout time.Duration

  // Berapa lama sekali memeriksa koneksi idle
  // Default adalah 1 menit. -1 berarti menonaktifkan deteksi koneksi idle
  IdleCheckFrequency time.Duration

  // Pengaturan read-only, jika diatur ke true, pada instance node saat ini, redis hanya dapat melakukan kueri cache dan tidak dapat memperbarui.
  readOnly bool

    // Konfigurasi TLS
  TLSConfig *tls.Config
}

Membuat Koneksi

// Membuat klien koneksi Redis
redisClient := redis.NewClient(&redis.Options{
    Addr:     "192.168.48.134:6379",
    Password: "123456",
    DB:       0, // Menggunakan DB default
})

Menutup Koneksi

Driver memelihara pool koneksi di dalamnya, tidak perlu menutup koneksi setiap kali melakukan operasi.

defer redisClient.Close()

Driver Redis ini hampir menutup semua operasi, perintah Redis dan nama metode berkorespondensi satu sama lain. Pada dasarnya,只要 mengetahui cara menggunakan perintah Redis, metode driver yang sesuai juga hampir dapat digunakan.

Perintah Redis: Manual Perintah Redis

Operasi Dasar

Menghapus key

redisClient.Set("name", "jack", 0)
fmt.Println(redisClient.Del("name").Result())

Waktu kedaluwarsa

redisClient.Set("name", "jack", 0)
// Mengatur waktu kedaluwarsa
redisClient.Expire("name", time.Second*2)
fmt.Println(redisClient.Get("name").Val())
time.Sleep(time.Second * 3)
fmt.Println(redisClient.Get("name").Val())

Membatalkan waktu kedaluwarsa

redisClient.Set("name", "jack", 2)
// Membatalkan waktu kedaluwarsa
redisClient.Persist("name")
time.Sleep(time.Second * 2)
fmt.Println(redisClient.Get("name"))

Kueri waktu kedaluwarsa

fmt.Println(redisClient.TTL("name"))
fmt.Println(redisClient.PTTL("name"))

Mengganti nama

redisClient.Rename("name", "newName")

Kueri tipe

redisClient.Type("name")

Scan

fmt.Println(redisClient.Scan(0, "", 4))

String

Simpan dan ambil sederhana

redisClient.Set("token", "abcefghijklmn", 0)
fmt.Println(redisClient.Get("token").Val())

Simpan dan ambil batch

redisClient.MSet("cookie", "12345", "token", "abcefg")
fmt.Println(redisClient.MGet("cookie", "token").Val())

Tambah dan kurangi angka

redisClient.Set("age", "1", 0)
// Tambah otomatis
redisClient.Incr("age")
fmt.Println(redisClient.Get("age").Val())
// Kurangi otomatis
redisClient.Decr("age")
fmt.Println(redisClient.Get("age").Val())

Tabel Hash

Operasi baca dan tulis

// Menetapkan satu per satu
redisClient.HSet("map", "name", "jack")
// Menetapkan batch
redisClient.HMSet("map", map[string]interface{}{"a": "b", "c": "d", "e": "f"})
// Mengakses satu per satu
fmt.Println(redisClient.HGet("map", "a").Val())
// Mengakses batch
fmt.Println(redisClient.HMGet("map", "a", "b").Val())
// Mendapatkan seluruh map
fmt.Println(redisClient.HGetAll("map").Val())

Output

b
[b <nil>]
map[a:b c:d e:f name:jack]

Menghapus key

// Menghapus satu bidang dari map
redisClient.HDel("map", "a")

Menentukan apakah key ada

// Menentukan apakah bidang ada
redisClient.HExists("map", "a")

Mendapatkan semua key

// Mendapatkan semua key dari map
redisClient.HKeys("map")

Mendapatkan panjang tabel hash

// Mendapatkan panjang map
redisClient.HLen("map")

Menelusuri pasangan key-value tabel hash

// Menelusuri pasangan key-value dalam map
redisClient.HScan("map", 0, "", 1)

List

Memodifikasi elemen

// Menambahkan dari kiri
redisClient.LPush("list", "a", "b", "c", "d", "e")
// Menambahkan dari kanan
redisClient.RPush("list", "g", "i", "a")
// Menyisipkan nilai di depan nilai referensi
redisClient.LInsertBefore("list", "a", "aa")
// Menyisipkan nilai di belakang nilai referensi
redisClient.LInsertAfter("list", "a", "gg")
// Menetapkan nilai elemen dengan indeks yang ditentukan
redisClient.LSet("list", 0, "head")

Mengakses panjang

// Mengakses panjang list
redisClient.LLen("list")

Mengakses elemen

// Pop elemen dari kiri
redisClient.LPop("list")
// Pop elemen dari kanan
redisClient.RPop("list")
// Mengakses elemen dengan indeks yang ditentukan
redisClient.LIndex("list", 1)
// Mengakses elemen dalam rentang yang ditentukan
redisClient.LRange("list", 0, 1)

Menghapus elemen

// Menghapus elemen yang ditentukan
redisClient.LRem("list", 0, "a")
// Menghapus elemen dalam rentang yang ditentukan
redisClient.LTrim("list", 0, 1)
// Menyimpan elemen dalam rentang yang ditentukan
redisClient.LTrim("list", 0, 1)

Set

Menambahkan elemen

// Menambahkan elemen ke dalam set
redisClient.SAdd("set", "a", "b", "c")
redisClient.SAdd("set2", "c", "d", "e")

Mengakses elemen set

// Mendapatkan semua anggota dalam set
redisClient.SMembers("set")
// Menentukan apakah elemen termasuk dalam set ini
redisClient.SIsMember("set", "a")
// Mengembalikan count elemen secara acak
redisClient.SRandMemberN("set", 1)
// Mendapatkan jumlah elemen dalam set
redisClient.SCard("set")

Operasi set

// Mengembalikan selisih dari set yang diberikan
redisClient.SDiff("set", "set2")
// Menyimpan selisih dari set yang diberikan dalam hasil set, mengembalikan panjang hasil set
redisClient.SDiffStore("store", "set", "se2")
// Mengembalikan irisan dari set yang diberikan
redisClient.SInter("set", "set2")
// Menyimpan irisan dari set yang diberikan dalam hasil set, mengembalikan panjang hasil set
redisClient.SInterStore("store", "set", "set2")
// Mengembalikan gabungan dari set yang diberikan
redisClient.SUnion("set", "set2")
// Menyimpan gabungan dari set yang diberikan dalam hasil set, mengembalikan panjang hasil set
redisClient.SUnionStore("store", "set", "store")

Menghapus elemen

// Pop dan hapus elemen tersebut
redisClient.SPop("set")
// Pop dan hapus N elemen
redisClient.SPopN("set", 2)

Memindahkan elemen

// Memindahkan elemen yang ditentukan dari set sumber ke set target
redisClient.SMove("set", "set2", "a")

Menghapus elemen

// Menghapus elemen yang ditentukan
redisClient.SRem("set", "a", "b")

Menelusuri

// Menelusuri set
redisClient.SScan("set", 0, "", 2)

Sorted Set

Menambahkan elemen

// Menambahkan elemen ke sorted set
redisClient.ZAdd("ss", redis.Z{
   Score:  1,
   Member: "a",
}, redis.Z{
   Score:  2,
   Member: "b",
})

Peringkat elemen

// Mengembalikan peringkat elemen dalam sorted set, diurutkan dari rendah ke tinggi
redisClient.ZRank("ss", "1")
// Mengembalikan peringkat elemen dalam sorted set, diurutkan dari tinggi ke rendah
redisClient.ZRevRank("ss", "1")

Mengakses elemen

// Mengembalikan jumlah anggota antara min dan max
redisClient.ZCount("ss", "1", "2")

// Mengembalikan bobot elemen
redisClient.ZScore("ss", "a")

// Mengembalikan elemen dalam rentang yang ditentukan
redisClient.ZRange("ss", 1, 2)
// Mengembalikan semua anggota antara min dan max
redisClient.ZRangeByScore("ss", redis.ZRangeBy{
   Min:    "1",
   Max:    "2",
   Offset: 0,
   Count:  1,
})

Memodifikasi bobot

// Menambahkan bobot yang sesuai ke elemen yang sesuai
redisClient.ZIncr("ss", redis.Z{
   Score:  2,
   Member: "b",
})

Menghapus elemen

// Menghapus elemen yang ditentukan
redisClient.ZRem("ss", "a")
// Menghapus elemen dalam rentang peringkat yang ditentukan
redisClient.ZRemRangeByRank("ss", 1, 2)
// Menghapus elemen dalam rentang bobot antara min dan max
redisClient.ZRemRangeByScore("ss", "1", "2")

Skrip

// Memuat skrip, mengembalikan nilai sha
redisClient.ScriptLoad("return 0")
// Menjalankan skrip berdasarkan nilai sha
redisClient.EvalSha("sha", []string{}, "")
// Menjalankan skrip secara langsung
redisClient.Eval("return 0", []string{}, "")
// Membersihkan cache skrip
redisClient.ScriptFlush()
// Menghentikan skrip yang sedang berjalan
redisClient.ScriptKill()
// Memverifikasi apakah skrip dengan nilai hash yang sesuai ada
redisClient.ScriptExists("")

Publish Subscribe

// Mengirim pesan ke channel yang ditentukan
redisClient.Publish("channel", "message")
// Berlangganan channel yang ditentukan
redisClient.Subscribe("channel")
// Melihat status langganan
redisClient.PubSubNumSub("channel")