What are Go and Redis caching?

Question

Accepted Answer

Go works with Redis via **client libraries** for caching and data storage.

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

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

ctx := context.Background()

// Basic operations
rdb.Set(ctx, "key", "value", 10*time.Minute)
val, err := rdb.Get(ctx, "key").Result()

// Hash
rdb.HSet(ctx, "user:1", "name", "Alice", "age", 25)
name, _ := rdb.HGet(ctx, "user:1", "name").Result()

// List
rdb.LPush(ctx, "queue", "task1", "task2")
task, _ := rdb.BRPop(ctx, 0, "queue").Result()

// Set
rdb.SAdd(ctx, "tags", "go", "redis", "cache")
tags, _ := rdb.SMembers(ctx, "tags").Result()

// Caching with fallback
func GetUser(ctx context.Context, id int) (*User, error) {
    key := fmt.Sprintf("user:%d", id)

// Try from cache
    cached, err := rdb.Get(ctx, key).Result()
    if err == nil {
        var user User
        json.Unmarshal([]byte(cached), &user)
        return &user, nil
    }

// Query DB
    user, err := db.GetUser(ctx, id)
    if err != nil {
        return nil, err
    }

// Cache it
    data, _ := json.Marshal(user)
    rdb.Set(ctx, key, data, 10*time.Minute)

return user, nil
}

// Cache-aside pattern
func CacheAside(ctx context.Context, key string, ttl time.Duration,
    fn func() (interface{}, error)) (interface{}, error) {

// Read from cache
    cached, err := rdb.Get(ctx, key).Result()
    if err == nil {
        var result interface{}
        json.Unmarshal([]byte(cached), &result)
        return result, nil
    }

// Compute
    result, err := fn()
    if err != nil {
        return nil, err
    }

// Save to cache
    data, _ := json.Marshal(result)
    rdb.Set(ctx, key, data, ttl)

return result, nil
}
```

**Patterns:** Cache-aside, Write-through, Write-behind, Pub/Sub.

Go: What are Go and Redis caching?