Golang使用redis在 Gin 框架中集成使用 go-redis

前言

项目中需要用到数据缓存和简单的消息队列,在gin框架中集成redis,选用使用人数较多的go-redis库,做个记录;


接入步骤

在 Gin 框架中集成使用 go-redis,你需要完成以下步骤:

  1. 安装 go-redis 包:

    在终端或命令行中运行以下命令:

    go get -u github.com/go-redis/redis/v8
    
  2. 导入 go-redis 包:

    在你的代码中导入 go-redis 包:

    import "github.com/go-redis/redis/v8"
    
  3. 创建 Redis 客户端:

    在你的代码中创建一个 Redis 客户端,用于与 Redis 服务器进行通信。在创建客户端时,你需要提供 Redis 服务器的连接信息,例如服务器地址、密码等。

    var rdb *redis.Client
    
    func init() {
        rdb = redis.NewClient(&redis.Options{
            Addr:     "localhost:6379", // Redis 服务器地址
            Password: "",                // Redis 密码
            DB:       0,                 // 选择的数据库
        })
    
        // 检查 Redis 连接
        if err := rdb.Ping(context.Background()).Err(); err != nil {
            log.Fatal("Failed to connect to Redis:", err)
        }
    }
    

    注意:实际应用中,请根据你的 Redis 服务器的实际情况配置连接参数。

  4. 在 Gin 路由中使用 Redis 客户端:

    在你的 Gin 路由处理函数中,你可以使用之前创建的 Redis 客户端执行 Redis 操作。例如,你可以使用 GetSetIncr 等操作来读写数据。

    package main
    
    import (
        "context"
        "github.com/gin-gonic/gin"
        "github.com/go-redis/redis/v8"
        "log"
        "net/http"
    )
    
    var rdb *redis.Client
    
    func init() {
        // 初始化 Redis 客户端
        rdb = redis.NewClient(&redis.Options{
            Addr:     "localhost:6379",
            Password: "",
            DB:       0,
        })
    
        // 检查 Redis 连接
        if err := rdb.Ping(context.Background()).Err(); err != nil {
            log.Fatal("Failed to connect to Redis:", err)
        }
    }
    
    func main() {
        // 创建 Gin 实例
        router := gin.Default()
    
        // 定义路由
        router.GET("/", func(c *gin.Context) {
            // 在路由处理函数中使用 Redis 客户端
            value, err := rdb.Get(context.Background(), "example_key").Result()
            if err != nil {
                c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get value from Redis"})
                return
            }
    
            c.JSON(http.StatusOK, gin.H{"value": value})
        })
    
        // 启动 Gin 服务
        if err := router.Run(":8080"); err != nil {
            log.Fatal("Failed to start Gin server:", err)
        }
    }
    
  5. 因为用到列表做队列,后面对列表做了简单封装集

var (
   rdb      = &redis.Client{}
   redisCtx = context.Background()
)

//key的值

type RedisQueue struct {
   Key string
   //存储内容
   Val      interface{}
   SaveTime time.Duration
}

func init() {
   rdb = redis.NewClient(&redis.Options{
   	Addr:    “”, //redis服务器地址
   	Password: “”, //redis密码
   	DB:       0,           // 选择的数据库
   })

   // 检查连接是否成功
   pong, err := rdb.Ping(context.Background()).Result()
   if err != nil {
   	fmt.Println("Failed to connect to Redis: " + err.Error())
   }
   fmt.Println("Connected to Redis:", pong)
}

func (r *RedisQueue) ListLPush() error {
   return rdb.LPush(redisCtx, r.Key, r.Val).Err()
}

func (r *RedisQueue) ListCount() (count int64, err error) {
   count = rdb.LLen(redisCtx, r.Key).Val()
   return
}

func (r *RedisQueue) ListLPop() (string, error) {
   return rdb.LPop(redisCtx, r.Key).Result()
}

func (r *RedisQueue) ListRPush() error {
   return rdb.RPush(redisCtx, r.Key, r.Val).Err()
}

func (r *RedisQueue) ListRPop() (string, error) {
   return rdb.RPop(redisCtx, r.Key).Result()
}

func (r *RedisQueue) ListLREM() (count int64, err error) {
   return rdb.LRem(redisCtx, r.Key, -1, r.Val).Result()
}

func (r *RedisQueue) SetAdd() error {
   return rdb.SAdd(redisCtx, r.Key, r.Val).Err()
}

func (r *RedisQueue) SetKeyExist() (bool, error) {
   return rdb.SIsMember(redisCtx, r.Key, r.Val).Result()
}

func (r *RedisQueue) ListBRPOP() (string, error) {
   result, err := rdb.BRPop(redisCtx, 0, r.Key).Result()
   if err != nil {
   	fmt.Println("Failed to BLPop from message_queue:", err)
   	return "", err
   }
   // 输出数组的元素
   return result[1], err
}

在上述例子中,在路由处理函数中使用了 Redis 客户端,通过 Get 方法从 Redis 中获取了一个名为 “example_key” 的值,并将其返回给客户端。

总结

确保你的 Redis 服务器正常运行,并根据实际需求配置好连接参数。这样,你就可以在 Gin 框架中集成使用 go-redis,实现与 Redis 服务器的交互。

你可能感兴趣的:(golang,redis,gin)