Go-Redis
Redis ist ein In-Memory-Datenspeicher. In diesem Artikel wird die Verwendung von Redis mit Go vorgestellt.
Installation
Zuerst muss der Redis-Client installiert werden.
bash
go get github.com/redis/go-redis/v9Verbindung herstellen
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
val, err := rdb.Ping(ctx).Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("Ping:", val)
}String-Operationen
go
package main
import (
"context"
"fmt"
"log"
"time"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// Set
err := rdb.Set(ctx, "key", "value", 0).Err()
if err != nil {
log.Fatal(err)
}
// Get
val, err := rdb.Get(ctx, "key").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("key:", val)
// Set mit Ablaufzeit
err = rdb.Set(ctx, "key2", "value2", 10*time.Second).Err()
if err != nil {
log.Fatal(err)
}
// Get und Del
err = rdb.Del(ctx, "key").Err()
if err != nil {
log.Fatal(err)
}
}Hash-Operationen
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// HSet
err := rdb.HSet(ctx, "user:1", "name", "Alice").Err()
if err != nil {
log.Fatal(err)
}
rdb.HSet(ctx, "user:1", "age", 25)
// HGet
name, err := rdb.HGet(ctx, "user:1", "name").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("name:", name)
// HGetAll
val, err := rdb.HGetAll(ctx, "user:1").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("user:1:", val)
// HDel
err = rdb.HDel(ctx, "user:1", "age").Err()
if err != nil {
log.Fatal(err)
}
}List-Operationen
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// LPush
err := rdb.LPush(ctx, "mylist", "a", "b", "c").Err()
if err != nil {
log.Fatal(err)
}
// RPush
err = rdb.RPush(ctx, "mylist", "d", "e").Err()
if err != nil {
log.Fatal(err)
}
// LRange
val, err := rdb.LRange(ctx, "mylist", 0, -1).Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("mylist:", val)
// LPop
val2, err := rdb.LPop(ctx, "mylist").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("LPop:", val2)
// RPop
val3, err := rdb.RPop(ctx, "mylist").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("RPop:", val3)
}Set-Operationen
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// SAdd
err := rdb.SAdd(ctx, "myset", "a", "b", "c").Err()
if err != nil {
log.Fatal(err)
}
// SMembers
val, err := rdb.SMembers(ctx, "myset").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("myset:", val)
// SIsMember
ok, err := rdb.SIsMember(ctx, "myset", "a").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("SIsMember a:", ok)
// SRem
err = rdb.SRem(ctx, "myset", "b").Err()
if err != nil {
log.Fatal(err)
}
}Sorted Set-Operationen
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// ZAdd
err := rdb.ZAdd(ctx, "myzset", redis.Z{
Score: 1,
Member: "one",
}).Err()
if err != nil {
log.Fatal(err)
}
rdb.ZAdd(ctx, "myzset", redis.Z{Score: 2, Member: "two"})
rdb.ZAdd(ctx, "myzset", redis.Z{Score: 3, Member: "three"})
// ZRange
val, err := rdb.ZRange(ctx, "myzset", 0, -1).Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("ZRange:", val)
// ZRangeWithScores
val2, err := rdb.ZRangeWithScores(ctx, "myzset", 0, -1).Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("ZRangeWithScores:", val2)
// ZRem
err = rdb.ZRem(ctx, "myzset", "two").Err()
if err != nil {
log.Fatal(err)
}
}Pub/Sub
go
package main
import (
"context"
"fmt"
"log"
"time"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// Publisher
go func() {
time.Sleep(100 * time.Millisecond)
err := rdb.Publish(ctx, "channel", "hello").Err()
if err != nil {
log.Fatal(err)
}
}()
// Subscriber
pubsub := rdb.Subscribe(ctx, "channel")
ch := pubsub.Channel()
msg := <-ch
fmt.Println("Empfangen:", msg.Payload)
pubsub.Close()
}Transaktionen
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// Transaktion mit Pipeline
err := rdb.Watch(ctx, func(tx *redis.Tx) error {
_, err := tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
pipe.Set(ctx, "key1", "value1", 0)
pipe.Set(ctx, "key2", "value2", 0)
return nil
})
return err
})
if err != nil {
log.Fatal(err)
}
fmt.Println("Transaktion erfolgreich!")
}Lua-Skript
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// Lua-Skript registrieren
script := redis.NewScript(`
redis.call("SET", KEYS[1], ARGV[1])
return redis.call("GET", KEYS[1])
`)
// Skript ausführen
val, err := script.Run(ctx, rdb, []string{"key"}, "value").Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("Lua-Ergebnis:", val)
}Connection Pool
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
PoolSize: 100, // Connection Pool Größe
})
val, err := rdb.Ping(ctx).Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("Ping:", val)
// Connection schließen
defer rdb.Close()
}Redis Cluster
go
package main
import (
"context"
"fmt"
"log"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClusterClient(&redis.ClusterOptions{
Addrs: []string{
"localhost:7000",
"localhost:7001",
"localhost:7002",
},
})
val, err := rdb.Ping(ctx).Result()
if err != nil {
log.Fatal(err)
}
fmt.Println("Cluster Ping:", val)
defer rdb.Close()
}