SET myKey "myValue"

GET myKey

DEL myKey

INCR mycounter

DECR mycounter

// 商品信息緩存鍵的生成
func generateProductCacheKey(productID string) string {
    return "product:" + productID
}

// 將商品信息存儲到Redis緩存中
func cacheProductInfo(productID string, productInfo map[string]interface{}) {
    cacheKey := generateProductCacheKey(productID)
    // 序列化商品信息為JSON格式
    productJSON, _ := json.Marshal(productInfo)
    // 將序列化后的商品信息存儲到Redis
    rdb.Set(ctx, cacheKey, string(productJSON), 0) // 0表示永不過期，實際使用時可以設(shè)置過期時間
}

// 從Redis緩存中獲取商品信息
func getProductInfoFromCache(productID string) (map[string]interface{}, error) {
    cacheKey := generateProductCacheKey(productID)
    // 從Redis獲取商品信息
    productJSON, err := rdb.Get(ctx, cacheKey).Result()
    if err != nil {
        return nil, err
    }
    // 反序列化JSON格式的商品信息
    var productInfo map[string]interface{}
    json.Unmarshal([]byte(productJSON), &productInfo)
    return productInfo, nil
}

// 當(dāng)商品信息更新時，同步更新Redis緩存
func updateProductInfoAndCache(productID string, newProductInfo map[string]interface{}) {
    // 更新數(shù)據(jù)庫中的商品信息

    // 更新Redis緩存中的商品信息
    cacheProductInfo(productID, newProductInfo)
}

// recordArticleView 記錄文章的瀏覽次數(shù)
func recordArticleView(articleID string) {
    // 使用Redis的INCR命令原子性地遞增文章的瀏覽次數(shù)
    result, err := redisClient.Incr(ctx, articleID).Result()
    if err != nil {
        // 如果發(fā)生錯誤，記錄錯誤日志
        log.Printf("Error incrementing view count for article %s: %v", articleID, err)
        return
    }
    // 可選：記錄瀏覽次數(shù)到日志或進行其他業(yè)務(wù)處理
    fmt.Printf("Article %s has been viewed %d times\n", articleID, result)
}

// getArticleViewCount 從Redis獲取文章的瀏覽次數(shù)
func getArticleViewCount(articleID string) (int, error) {
    // 從Redis獲取文章的瀏覽次數(shù)
    viewCount, err := redisClient.Get(ctx, articleID).Result()
    if err != nil {
        if err == redis.Nil {
            // 如果文章ID在Redis中不存在，可以認為瀏覽次數(shù)為0
            return 0, nil
        } else {
            // 如果發(fā)生錯誤，記錄錯誤日志
            log.Printf("Error getting view count for article %s: %v", articleID, err)
            return 0, err
        }
    }
    // 將瀏覽次數(shù)從字符串轉(zhuǎn)換為整數(shù)
    count, err := strconv.Atoi(viewCount)
    if err != nil {
        log.Printf("Error converting view count to integer for article %s: %v", articleID, err)
        return 0, err
    }
    return count, nil
}

// renderArticlePage 渲染文章頁面，并顯示瀏覽次數(shù)
func renderArticlePage(articleID string) {
    // 在渲染文章頁面之前，記錄瀏覽次數(shù)
    recordArticleView(articleID)

    // 獲取文章瀏覽次數(shù)
    viewCount, err := getArticleViewCount(articleID)
    if err != nil {
        // 處理錯誤，例如設(shè)置瀏覽次數(shù)為0或跳過錯誤
        viewCount = 0
    }
}

// 偽代碼：在分布式系統(tǒng)中實現(xiàn)分布式鎖的功能

// 嘗試獲取分布式鎖
func tryGetDistributedLock(lockKey string, val string, expireTime int) bool {
    // 使用SET命令結(jié)合NX和PX參數(shù)嘗試獲取鎖
    // NX表示如果key不存在則可以設(shè)置成功
    // PX指定鎖的超時時間（毫秒）
    // 這里的val是一個隨機值，用于在釋放鎖時驗證鎖是否屬于當(dāng)前進程
    result, err := redisClient.SetNX(ctx, lockKey, val, time.Duration(expireTime)*time.Millisecond).Result()
    if err != nil {
        // 記錄錯誤，例如：日志記錄
        log.Printf("Error trying to get distributed lock for key %s: %v", lockKey, err)
        return false
    }
    // 如果result為1，則表示獲取鎖成功，result為0表示鎖已被其他進程持有
    return result == 1
}

// 釋放分布式鎖
func releaseDistributedLock(lockKey string, val string) {
    // 使用Lua腳本來確保釋放鎖的操作是原子性的
    script := `
        if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
        else
            return 0
        end
    `
    // 執(zhí)行Lua腳本
    result, err := redisClient.Eval(ctx, script, []string{lockKey}, val).Result()
    if err != nil {
        // 記錄錯誤
        log.Printf("Error releasing distributed lock for key %s: %v", lockKey, err)
    }
    // 如果result為1，則表示鎖被成功釋放，如果為0，則表示鎖可能已經(jīng)釋放或不屬于當(dāng)前進程
    if result == int64(0) {
        log.Printf("Failed to release the lock, it might have been released by others or expired")
    }
}

// 執(zhí)行業(yè)務(wù)邏輯，使用分布式鎖來保證業(yè)務(wù)邏輯的原子性
func executeBusinessLogic(lockKey string) {
    val := generateRandomValue() // 生成一個隨機值，作為鎖的值
    if tryGetDistributedLock(lockKey, val, 30000) { // 嘗試獲取鎖，30秒超時
        defer releaseDistributedLock(lockKey, val) // 無論業(yè)務(wù)邏輯是否成功執(zhí)行，都釋放鎖
        // 執(zhí)行具體的業(yè)務(wù)邏輯
        // ...
    } else {
        // 未能獲取鎖，處理重試邏輯或返回錯誤
        // ...
    }
}

// generateRandomValue 生成一個隨機值作為鎖的唯一標(biāo)識
func generateRandomValue() string {
    return strconv.FormatInt(time.Now().UnixNano(), 10)
}

// 偽代碼：API限流器
func rateLimiter(apiKey string, threshold int, timeWindow int) bool {
    currentCount, err := redisClient.Incr(ctx, apiKey).Result()
    if err != nil {
        log.Printf("Error incrementing API key %s: %v", apiKey, err)
        return false
    }

    // 如果當(dāng)前計數(shù)超過閾值，則拒絕請求
    if currentCount > threshold {
        return false
    }

    // 重置計數(shù)器的過期時間
    _, err = redisClient.Expire(ctx, apiKey, timeWindow).Result()
    if err != nil {
        log.Printf("Error resetting expire time for API key %s: %v", apiKey, err)
        return false
    }

    return true
}

// 在API處理函數(shù)中調(diào)用限流器
func handleAPIRequest(apiKey string) {
    if rateLimiter(apiKey, 100, 1) { // 限流閾值設(shè)為100，時間窗口為1秒
        // 處理API請求
    } else {
        // 限流，返回錯誤或提示信息
    }
}

// 偽代碼：用戶登錄并存儲session
func userLogin(username string, password string) (string, error) {
    // 驗證用戶名和密碼

    // 創(chuàng)建session ID
    sessionID := generateSessionID()

    // 序列化用戶信息
    userInfo := map[string]string{"username": username}
    serializedInfo, err := json.Marshal(userInfo)
    if err != nil {
        // 處理錯誤
        return "", err
    }

    // 存儲session信息到Redis，設(shè)置過期時間
    err = redisClient.Set(ctx, sessionID, string(serializedInfo), time.Duration(30)*time.Minute).Err()
    if err != nil {
        // 處理錯誤
        return "", err
    }

    return sessionID, nil
}

// 偽代碼：從請求中獲取并驗證session
func validateSession(sessionID string) (map[string]string, error) {
    // 從Redis獲取session信息
    serializedInfo, err := redisClient.Get(ctx, sessionID).Result()
    if err != nil {
        // 處理錯誤或session不存在
        return nil, err
    }

    // 反序列化用戶信息
    var userInfo map[string]string
    err = json.Unmarshal([]byte(serializedInfo), &userInfo)
    if err != nil {
        // 處理錯誤
        return nil, err
    }

    return userInfo, nil
}

// 偽代碼：生成新的session ID
func generateSessionID() string {
    return strconv.FormatInt(time.Now().UnixNano(), 36)
}

LPUSH mylist "item1"

RPUSH mylist "item2"

LPOP mylist

RPOP mylist

LRANGE mylist 0 -1

// 將新訂單添加到訂單處理隊列
func addOrderToQueue(order Order) {
    redisClient.LPUSH(ctx, "order_queue", order.ToString())
}

// 從訂單處理隊列中獲取待處理的訂單
func getNextOrder() (Order, error) {
    orderJSON, err := redisClient.RPOP(ctx, "order_queue").Result()
    if err != nil {
        return Order{}, err
    }
    var order Order
    json.Unmarshal([]byte(orderJSON), &order)
    return order, nil
}

// 訂單處理完成后，執(zhí)行后續(xù)任務(wù)
func processOrder(order Order) {
    // 處理訂單邏輯
    // ...
    // 發(fā)送確認郵件
    // ...
    // 更新庫存
    // ...
}

// 為文章點贊，更新排行榜
func likeArticle(articleID string) {
    // 假設(shè)每個文章都有一個對應(yīng)的得分List
    redisClient.INCR(ctx, "article:"+articleID+":score")
    // 可以進一步使用Sorted Set來維護更復(fù)雜的排行榜
}

// 獲取文章排行榜
func getArticleRankings() []Article {
    articles := []Article{}
    // 遍歷所有文章的得分List
    // 根據(jù)得分進行排序
    // ...
    return articles
}

SADD mySet "item1"

SREM mySet "item1"

SISMEMBER mySet "item1"

SINTER mySet myOtherSet

SUNION mySet myOtherSet

SDIFF mySet myOtherSet

// 給文章添加標(biāo)簽
func addTagToArticle(articleID string, tag string) {
    redisClient.SADD(ctx, "article:"+articleID+":tags", tag)
}

// 根據(jù)標(biāo)簽獲取文章列表
func getArticlesByTag(tag string) []string {
    return redisClient.SMEMBERS(ctx, "global:tags:"+tag).Val()
}

// 獲取文章的所有標(biāo)簽
func getTagsOfArticle(articleID string) []string {
    return redisClient.SMEMBERS(ctx, "article:"+articleID+":tags").Val()
}

// 添加好友
func addFriend(userOneID string, userTwoID string) {
    redisClient.SADD(ctx, "user:"+userOneID+":friends", userTwoID)
    redisClient.SADD(ctx, "user:"+userTwoID+":friends", userOneID)
}

// 判斷是否是好友
func isFriend(userOneID string, userTwoID string) bool {
    return redisClient.SISMEMBER(ctx, "user:"+userOneID+":friends", userTwoID).Val() == 1
}

// 獲取用戶的好友列表
func getFriendsOfUser(userID string) []string {
    return redisClient.SMEMBERS(ctx, "user:"+userID+":friends").Val()
}

ZADD mySortedSet 5.0 element1

ZRANGE mySortedSet 0 -1 WITHSCORES

ZREM mySortedSet element1

ZINCRBY mySortedSet 2.5 element1

ZCARD mySortedSet

// 更新玩家得分
func updatePlayerScore(playerID string, score float64) {
    sortedSetKey := "playerScores"
    // 添加或更新玩家得分
    rdb.ZAdd(ctx, sortedSetKey, &redis.Z{Score: score, Member: playerID})
}

// 獲取排行榜
func getLeaderboard(start int, stop int) []string {
    sortedSetKey := "playerScores"
    // 獲取排行榜數(shù)據(jù)
    leaderboard, _ := rdb.ZRangeWithScores(ctx, sortedSetKey, start, stop).Result()
    var result []string
    for _, entry := range leaderboard {
        result = append(result, fmt.Sprintf("%s: %.2f", entry.Member.(string), entry.Score))
    }
    return result
}

// 更新商品銷量
func updateProductSales(productID string, sales int64) {
    sortedSetKey := "productSales"
    // 增加商品銷量
    rdb.ZIncrBy(ctx, sortedSetKey, float64(sales), productID)
}

// 獲取商品銷量排行
func getProductSalesRanking() []string {
    sortedSetKey := "productSales"
    // 獲取銷量排行數(shù)據(jù)
    ranking, _ := rdb.ZRangeWithScores(ctx, sortedSetKey, 0, -1).Result()
    var result []string
    for _, entry := range ranking {
        result = append(result, fmt.Sprintf("%s: %d", entry.Member.(string), int(entry.Score)))
    }
    return result
}

HSET myHash name "John Doe"

HGET myHash name

HDEL myHash name

HINCRBY myHash age 1

HGETALL myHash

// 存儲用戶信息到Redis Hash
func storeUserInfo(userID string, userInfo map[string]interface{}) {
    hashKey := "user:" + userID
    // 將用戶信息存儲到Redis的Hash中
    for field, value := range userInfo {
        rdb.HSet(ctx, hashKey, field, value)
    }
}

// 從Redis Hash獲取用戶信息
func getUserInfo(userID string) map[string]string {
    hashKey := "user:" + userID
    // 從Redis獲取用戶信息
    fields, err := rdb.HGetAll(ctx, hashKey).Result()
    if err != nil {
        // 處理錯誤
        return nil
    }
    // 將字段轉(zhuǎn)換為字符串映射
    var userInfo = make(map[string]string)
    for k, v := range fields {
        userInfo[k] = v
    }
    return userInfo
}

// 添加商品到購物車
func addToCart(cartID string, productID string, quantity int) {
    cartKey := "cart:" + cartID
    // 使用HINCRBY命令增加商品數(shù)量
    rdb.HIncrBy(ctx, cartKey, productID, int64(quantity))
}

// 獲取購物車中的商品和數(shù)量
func getCart(cartID string) map[string]int {
    cartKey := "cart:" + cartID
    // 從Redis獲取購物車內(nèi)容
    items, err := rdb.HGetAll(ctx, cartKey).Result()
    if err != nil {
        // 處理錯誤
        return nil
    }
    // 將商品ID和數(shù)量轉(zhuǎn)換為映射
    var cart map[string]int
    for productID, quantity := range items {
        cart[productID], _ = strconv.Atoi(quantity)
    }
    return cart
}

SETBIT myBitmap 100 1

GETBIT myBitmap 100

BITCOUNT myBitmap

BITOP AND resultBitmap key1 key2

// 更新玩家在線狀態(tài)
func updatePlayerStatus(playerID int, isOnline bool) {
    bitmapKey := "playerStatus"
    offset := playerID // 假設(shè)playerID可以直接用作offset
    if isOnline {
        rdb.SetBit(ctx, bitmapKey, int64(offset), 1)
    } else {
        rdb.SetBit(ctx, bitmapKey, int64(offset), 0)
    }
}

// 查詢玩家在線狀態(tài)
func checkPlayerStatus(playerID int) bool {
    bitmapKey := "playerStatus"
    offset := playerID // 假設(shè)playerID可以直接用作offset
    bitValue, err := rdb.GetBit(ctx, bitmapKey, int64(offset)).Result()
    if err != nil {
        // 處理錯誤
        return false
    }
    return bitValue == 1
}

// 為用戶設(shè)置功能訪問權(quán)限
func setFeatureAccess(userID int, hasAccess bool) {
    featureKey := "featureAccess"
    offset := userID // 假設(shè)userID可以直接用作offset
    if hasAccess {
        rdb.SetBit(ctx, featureKey, int64(offset), 1)
    } else {
        rdb.SetBit(ctx, featureKey, int64(offset), 0)
    }
}

// 檢查用戶是否有新功能訪問權(quán)限
func checkFeatureAccess(userID int) bool {
    featureKey := "featureAccess"
    offset := userID // 假設(shè)userID可以直接用作offset
    bitValue, err := rdb.GetBit(ctx, featureKey, int64(offset)).Result()
    if err != nil {
        // 處理錯誤
        return false
    }
    return bitValue == 1
}

PFADD myUniqueSet element1 element2

PFCOUNT myUniqueSet

PFMERGE mergedSet myUniqueSet1 myUniqueSet2

// 記錄用戶訪問
func recordUserVisit(userID string) {
    uniqueSetKey := "uniqueVisitors"
    // 向HyperLogLog中添加用戶ID
    rdb.PFAdd(ctx, uniqueSetKey, userID)
}

// 獲取唯一用戶訪問量
func getUniqueVisitorCount() int64 {
    uniqueSetKey := "uniqueVisitors"
    // 獲取HyperLogLog中的基數(shù)
    count, _ := rdb.PFCount(ctx, uniqueSetKey).Result()
    return count
}

// 記錄點擊事件
func recordClickEvent(clickID string, sourceID string) {
    sourceSetKey := "clicks:" + sourceID
    // 向?qū)?yīng)來源的HyperLogLog中添加點擊ID
    rdb.PFAdd(ctx, sourceSetKey, clickID)
}

// 合并點擊事件集合并分析用戶群體獨立性
func analyzeAudienceIndependence(sourceIDs []string) int64 {
    destKey := "mergedClicks"
    // 合并所有來源的HyperLogLog集合
    rdb.PFMerge(ctx, destKey, sourceIDs)
    // 計算合并后的基數(shù)
    count, _ := rdb.PFCount(ctx, destKey).Result()
    return count
}

GEOADD myGeoSet 116.407526 39.904030 "Beijing"

GEOPOS myGeoSet "Beijing"

GEODIST myGeoSet "Beijing" "Shanghai"

GEOHASH myGeoSet "Beijing"

GEORADIUS myGeoSet 116.407526 39.904030 500 km WITHCOORD WITHDIST WITHHASH

// 搜索附近地點
func searchNearbyPlaces(longitude float64, latitude float64, radius float64) []string {
    geoSetKey := "touristSpots"
    // 執(zhí)行GEORADIUS命令搜索附近地點
    places, _ := rdb.GeoRadius(
        ctx, geoSetKey, longitude, latitude, radius, "km",
        &redis.GeoRadiusQuery{WithCoord: true, WithDist: true, WithHash: true}).Result()
    
    var nearbyPlaces []string
    for _, place := range places {
        nearbyPlaces = append(nearbyPlaces, fmt.Sprintf("Name: %s, Distance: %.2f km", place.Member.(string), place.Dist))
    }
    return nearbyPlaces
}

// 記錄司機位置
func recordDriverPosition(driverID string, longitude float64, latitude float64) {
    geoSetKey := "drivers"
    rdb.GeoAdd(ctx, geoSetKey, &redis.GeoLocation{Longitude: longitude, Latitude: latitude, Member: driverID})
}

// 計算司機與乘客之間的距離并匹配
func matchDriverToPassenger(passengerLongitude float64, passengerLatitude float64) (string, float64) {
    driversGeoSetKey := "drivers"
    passengerGeoSetKey := "passengers"
    // 記錄乘客位置
    rdb.GeoAdd(ctx, passengerGeoSetKey, &redis.GeoLocation{Longitude: passengerLongitude, Latitude: latitude, Member: "PassengerID"})

    // 搜索最近的司機
    nearestDriver, _ := rdb.GeoRadius(
        ctx, driversGeoSetKey, passengerLongitude, passengerLatitude, 5, "km",
        &redis.GeoRadiusQuery{Count: 1, Any: true}).Result()

    if len(nearestDriver) > 0 {
        // 計算距離
        distance := nearestDriver[0].Dist
        return nearestDriver[0].Member.(string), distance
    }
    return "", 0
}