نحوه اجرای حافظه پنهان Redis در Golang برای مبتدیان: یک راهنمای گام به گام (ویندوز نسخه)

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

package utils

import (
    "context"
    "crypto/tls"
    "log"

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

var (
    RedisClient *redis.Client
    Ctx         = context.Background()
)

// Initialize Redis Connection
func InitRedis() {
    RedisClient = redis.NewClient(&redis.Options{
        Addr:     "127.0.0.1:6379", // Replace with Redis host
        Password: "", // Replace with Redis password
        DB:       0,


    _, err := RedisClient.Ping(Ctx).Result()
    if err != nil {
        log.Fatalf("❌ Failed to connect to Redis: %v", err)
    }
    log.Println("✅ Redis connection established")
}

package utils

import (
    "encoding/json"
    "errors"
    "log"
    "time"
)

// CacheGet: Fetch data from Redis
func CacheGet(key string, result interface{}) (bool, error) {
    log.Printf("🔍 Checking cache for key: %s", key)

    val, err := RedisClient.Get(Ctx, key).Result()
    if err == redis.Nil {
        return false, errors.New("key does not exist") // Cache miss
    } else if err != nil {
        return false, errors.New("internal server error")
    }

    // Unmarshal JSON into result
    err = json.Unmarshal([]byte(val), result)
    if err != nil {
        return false, err
    }

    log.Printf("✅ Cache hit for key: %s", key)
    return true, nil
}

// CacheSet: Store data in Redis
func CacheSet(key string, value interface{}, expiration time.Duration) error {
    jsonData, err := json.Marshal(value)
    if err != nil {
        return err
    }

    return RedisClient.Set(Ctx, key, jsonData, expiration).Err()
}

// InvalidateCache: Delete a cached key (for updates)
func InvalidateCache(key string) error {
    err := RedisClient.Del(Ctx, key).Err()
    if err != nil {
        log.Printf("❌ Error invalidating cache for key: %s", key)
        return err
    }
    log.Printf("🗑️ Cache invalidated for key: %s", key)
    return nil
}

package services

import (
    "errors"
    "log"
    "time"
    "your_project/utils" // Import utils package
)

var cacheExpiration = 10 * time.Minute // Set cache expiration time

type Category struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func GetAllCategories() ([]Category, error) {
    var categories []Category
    cacheKey := "categories_cache"

    // 1️⃣ Check Redis cache first
    cached, err := utils.CacheGet(cacheKey, &categories)
    if err != nil {
        log.Printf("Redis CacheGet error: %v", err)
    }
    if cached {
        log.Println("✅ Categories fetched from Redis cache")
        return categories, nil
    }

    // 2️⃣ Cache miss → Fetch data from DB
    log.Println("⚠️ Cache miss: Fetching categories from DB")
    query := `SELECT id, name FROM categories`
    rows, err := utils.DB.Query(query)
    if err != nil {
        return nil, errors.New("database error")
    }
    defer rows.Close()

    for rows.Next() {
        var category Category
        if err := rows.Scan(&category.ID, &category.Name); err != nil {
            return nil, errors.New("data scan error")
        }
        categories = append(categories, category)
    }

    // 3️⃣ Store fetched data in Redis
    if err := utils.CacheSet(cacheKey, categories, cacheExpiration); err != nil {
        log.Printf("Redis CacheSet error: %v", err)
    }

    log.Println("✅ Categories cached in Redis")
    return categories, nil
}

err := utils.InvalidateCache("categories_cache")
if err != nil {
    log.Printf("Error invalidating cache: %v", err)
}

   redis-server

   redis-cli ping

   PONG

   redis-cli

   EXISTS categories_cache

   GET categories_cache