GO 操作redis

GolangRedis基础命令和数据结构操作示例
最新推荐文章于 2025-05-24 03:04:29 发布
原创 最新推荐文章于 2025-05-24 03:04:29 发布 · 193 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang

一.基本命令

1.SET,GET
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   err := client.Set("hello", "world", 0).Err()
   if err != nil {
      panic(err)
   }
   val, err := client.Get("hello").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println("val", val)
}
2.SETNX
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   err := client.SetNX("name", "lisus", 0).Err()
   if err != nil {
      panic(err)
   }
   value, err := client.Get("name").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println("value:", value)
}

二.hash命令

1.HSET,HGET
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   err := client.HSet("user_1", "username", "tizi365").Err()
   if err != nil {
      panic(err)
   }
   username, err := client.HGet("user_1", "username").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(username)
}
2.HGETALL,HINCRBY,HKEYS,HLENS
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   data, err := client.HGetAll("user_1").Result()
   if err != nil {
      panic(err)
   }
   for field, val := range data {
      fmt.Println(field, val)
   }
   count, err := client.HIncrBy("user_1", "count", 2).Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(count)
​
   keys, err := client.HKeys("user_1").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(keys)
​
   size, err := client.HLen("user_1").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(size)
​
}
3.HMSet,HExists,HDel
package main
​
import "github.com/go-redis/redis"
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   data := make(map[string]interface{})
   data["id"] = 2
   data["username"] = "lisus"
​
   //一次性保存多个hash字段值
   err := client.HMSet("user_2", data).Err()
   if err != nil {
      panic(err)
   }
    
   // 检测id字段是否存在
    err := client.HExists("key", "id").Err()
    if err != nil {
        panic(err)
    }
}
​
​

三.list用法

Redis列表是简单的字符串列表，列表是有序的，列表中的元素可以重复。
​
可以添加一个元素到列表的头部（左边）或者尾部（右边）
​
golang redis list数据操作常用函数：
​
LPush - 从列表左边插入数据
LPushX - 跟LPush的区别是，仅当列表存在的时候才插入数据
RPop - 从列表的右边删除第一个数据，并返回删除的数据
RPush - 从列表右边插入数据
RPushX - 跟RPush的区别是，仅当列表存在的时候才插入数据
LPop - 从列表左边删除第一个数据，并返回删除的数据
LLen - 返回列表的大小
LRange - 返回列表的一个范围内的数据，也可以返回全部数据
LRem - 删除列表中的数据
LIndex - 根据索引坐标，查询列表中的数据
LInsert - 在指定位置插入数据LPUSH
1.LPush,LPushX
package main
​
import "github.com/go-redis/redis"
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   err := client.LPush("sale_number", 1, 2, 3, 4, 5, 6, 7, 8).Err()
   if err != nil {
      panic(err)
   }
}
2.RPop,RPush,5.RPushX,LPop
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   val, err := client.RPop("sale_number").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(val)
   //插入一个数据
   client.RPush("sale_number", 9)
   val, err = client.LPop("sale_number").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(val)
}
3.LLen,LRange,LRem
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   val, err := client.LIndex("sale_number", 5).Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(val)
​
   vals, err := client.LRange("keys", 0, -1).Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(vals)
​
   dels, err := client.LRem("sale_number", 1, 100).Result()
   if err != nil {
      panic(
          err)
   }
   fmt.Println(dels)
​
}

四.集合set的用法

1.SADD,SCard,SIsMember
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   err := client.SAdd("num1", 100).Err()
   if err != nil {
      panic(err)
   }
   client.SAdd("num1", 100, 200, 300)
​
   size, _ := client.SCard("num1").Result()
   fmt.Println(size)
​
   //判断元素是否在集合中
   ok, _ := client.SIsMember("num1", 100).Result()
   if ok {
      fmt.Println("集合包含指定元素")
   }
}
2.SMembers,SRem,SPop,SPopN
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   es, _ := client.SMembers("num1").Result()
   fmt.Println(es)
​
   // 随机返回集合中的一个元素，并且删除这个元素
   val, _ := client.SPop("num1").Result()
   fmt.Println(val)
   client.SRem("num1", 100)
​
   vals, _ := client.SPopN("num1", 5).Result()
   fmt.Println(vals)
}

五.有序集合

1.ZADD,ZCARD,ZCOUNT
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   err := client.ZAdd("zaddr", redis.Z{
      2.5,
      "tizi",
   }).Err()
   if err != nil {
      panic(err)
   }
​
   size, _ := client.ZCard("zaddr").Result()
   fmt.Println(size)
​
   count, _ := client.ZCount("zaddr", "1", "5").Result()
   fmt.Println(count)
}
2.ZRANGE,ZIncrBy
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   client.ZIncrBy("znum1", 2, "5")
​
   vals, err := client.ZRange("znum1", 0, -1).Result()
   if err != nil {
      panic(err)
   }
   for _, val := range vals {
      fmt.Println(val)
   }
}
3.ZRangeByScore
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
func main() {
   InitClient()
   op := redis.ZRangeBy{
      Min:    "2",  //最小分数
      Max:    "10", //最大分数
      Offset: 0,    //类似sql的limit, 表示开始偏移量
      Count:  5,    //一次返回多少数据
   }
   vals, err := client.ZRangeByScore("znum1", op).Result()
   if err != nil {
      panic(err)
   }
   for _, val := range vals {
      fmt.Println(val)
   }
}
4.ZRangeByScoreWithScores
func main() {
   InitClient()
   op := redis.ZRangeBy{
      Min:    "2",  //最小分数
      Max:    "10", //最大分数
      Offset: 0,    //类似sql的limit, 表示开始偏移量
      Count:  5,    //一次返回多少数据
   }
   vals, err := client.ZRangeByScoreWithScores("znum1", op).Result()
   if err != nil {
      panic(err)
   }
   for _, val := range vals {
      fmt.Println(val.Member)
      fmt.Println(val.Score)
   }
}
5.ZRem,ZRemRangeByRank
func main() {
   InitClient()
   client.ZRem("zddr", "test2")
}
func main() {
    InitClient()
    client.ZRemRangeByRank("zaddr", 0, 2)
}
6.ZSCORE
func main() {
   InitClient()
   score, _ := client.ZScore("zaddr", "test2").Result()
   fmt.Println(score)
}
7.ZRank
func main() {
   InitClient()
   rk, _ := client.ZRank("zaddr", "yangmi").Result()
   fmt.Println(rk)
}

六.事务处理

edis乐观锁支持，可以通过watch监听一些Key, 如果这些key的值没有被其他人改变的话，才可以提交事务。

// 定义一个回调函数，用于处理事务逻辑
fn := func(tx *redis.Tx) error {
        // 先查询下当前watch监听的key的值
        v, err := tx.Get("key").Result()
        if err != nil && err != redis.Nil {
            return err
        }
​
        // 这里可以处理业务
        fmt.Println(v)
​
        // 如果key的值没有改变的话，Pipelined函数才会调用成功
        _, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
            // 在这里给key设置最新值
            pipe.Set("key", "new value", 0)
            return nil
        })
        return err
    }
​
// 使用Watch监听一些Key, 同时绑定一个回调函数fn, 监听Key后的逻辑写在fn这个回调函数里面
// 如果想监听多个key，可以这么写：client.Watch(fn, "key1", "key2", "key3")
client.Watch(fn, "key")
Go基础：用Go语言操作redis详解
数据知道的博客
10-05 2825
本文介绍了Go语言通过go-redis库操作Redis的方法。主要内容包括：1）安装go-redis客户端库；2）连接Redis服务器的三种方式（基本连接、哨兵模式、集群模式）；3）Redis基本数据类型的操作（字符串、列表、哈希、有序集合）；4）高级功能如发布订阅、事务、管道和错误处理。go-redis库提供了丰富的API，使得Go程序能够高效便捷地与Redis进行交互。通过示例代码展示了各类操作的实现方式，为开发者使用Go操作Redis提供了实用参考。
Golang操作Redis的5种高效方式，你掌握了吗？
Golang编程笔记的博客
05-07 1194
在分布式系统开发中，Redis作为高性能键值存储系统被广泛应用。Golang凭借其原生并发特性和高效的内存管理，成为Redis客户端开发的优选语言。本文聚焦Golang操作Redis的五种核心技术方案，深入解析底层实现原理、代码实现细节及性能优化策略，帮助开发者构建高效稳定的Redis交互层。核心概念与技术原理：解析Redis客户端核心组件及五种操作方式的底层逻辑代码实现与最佳实践：提供完整代码示例及生产环境配置建议性能对比与场景适配：通过基准测试数据指导技术选型。
使用go-redis/redis依赖操作redis
weixin_52690231的博客
03-03 4093
使用go-redis/redis依赖操作redis
golang redis第三方库github.com/go-redis/redis/v8实践
qq_32421489的博客
07-05 5234
golang redis第三方库github.com/go-redis/redis/v8实践
golang操作redis学习笔记
weixin_44024220的博客
07-05 351
安装redis redis简介： redis(REmote DIctionary Server)是一个由Salvatore Sanfilippo写key-value存储系统，它由C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value类型的数据库，并提供多种语言的API。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支
redis 的sorted set 用法与golang操作redis中zadd
qq_30505673的博客
10-13 3917
redis 的sorted set 用法
GO语言操作redis
m0_56137272的博客
04-30 7670
本文仅仅简单介绍了如何使用go语言操作redis，分别展示了两种客户端包如何实现对redis的访问和操作，并展示了redis的部分指令，而redis提供的指令远不止这些。写博客的过程中，个人还是感觉Redigo使用起来更加易懂，而go-redis支持连接哨兵和集群模式的redis，还是要根据情况选择使用。
【Redis】golang操作Redis基础入门
寸铁的博客
04-07 5043
【Redis】golang操作Redis基础入门 如何使用golang操作Redis基础入门呢？下面寸铁手把手带你实现！
Golang 操作 Redis：连接设置与参数详解 - go-redis 使用指南
全球首个被优快云气死的程序员：阿小信
10-17 1401
在上一篇文章中，我们介绍了如何初始化 go-并进行了基本的 Redis 操作。本文将深入探讨 go-redis 的连接设置与参数配置，帮助你在实际项目中更好地使用 go-redis。在《go-redis 使用指南》系列文章中，我们将详细介绍如何在 Golang 项目中使用库与 Redis 进行交互。
Golang操作Redis的10个实用技巧
最新发布
Golang编程笔记的博客
05-24 799
本文面向使用Golang开发后端服务的工程师，重点解决「如何高效、稳定地用Golang操作Redis」的实际问题。内容覆盖连接管理、性能优化、并发控制、故障处理等核心场景，所有技巧均基于生产环境验证。本文从连接池配置等基础优化开始，逐步深入到事务、分布式锁等高级操作，最后讲解监控和未来趋势。每个技巧包含「生活比喻」「核心原理」「代码示例」「注意事项」四部分，确保读者「能理解、会使用、避坑点」。连接池：管理Redis连接的「电动车池」，合理配置提升性能。Pipeline。
Redis ZADD命令
极品小肥羊的博客
07-25 2875
Redis ZADD命令添加所有指定的成员指定的分数存放在键的有序集合。它可以指定多个分/成员对。如果指定的成员已经是有序集合中的一员，分数被更新，并在合适的位置插入元素，以确保正确的顺序。如果键不存在，一个新的有序集合的指定成员作为唯一的成员创建，就像如果有序集合是空的。如果该键存在，但不持有有序集合，则返回一个错误。 返回值 返回整型添加到有序集合，不包括被更新元素元素的数量。
go-redis——入门
m0_61366135的博客
01-15 969
Pipeline可以将多个Redis命令打包成一个请求发送给Redis服务器，减少了网络延迟和I/O开销，提高了数据处理效率。函数创建了一个带有截止日期的上下文，并将其作为参数传递给 Redis 操作。如果 Redis 操作的执行时间超过了指定的截止日期，操作将会被中止。对象，可以将上下文相关的信息传递到应用程序的不同部分中，使得这些部分可以更加灵活地响应不同的情况。go-redis库提供了事务功能，可以将多个命令组合在一起作为一个原子操作，保证数据的一致性和完整性。在 Go-Redis 中，可以使用。
Go语言：go-redis客户端读写队列的相关命令LPush,RPush,LRange,LPop,RPop的用法示例
pengpengzhou的博客
09-02 3898
redis的值的数据结构可以是队列，并且可以操作头部或者尾部，用法如下： package main import ( "fmt" "github.com/go-redis/redis" ) func main() { client := redis.NewClient(&redis.Options{ Addr: "127.0.0.1:6380", Password: "".
golang入门笔记—redis
qq_43716830的博客
04-21 1207
golang连接和初始化redis package main import ( "context" "fmt" "time" "github.com/go-redis/redis/v8" ) var redisdb *redis.Client func initRedis() (err error) { redisdb = redis.NewClient(&redis.Options{ Addr: "127.0.0.1:6379", Password: "",
golang利用redis实现简单延时队列
liyunlonghere
05-08 2803
redis的zset是一种能自动排序的数据结构，我们可以用这个特性来实现简单的延时队列。 利用zadd将数据添加到zset中，每个数据的score值设置为数据的延时时间+当前时间戳，后台goroutine不断zrange轮询zset，取出score值小于当前时间戳的数据，然后再对数据进一步处理，这样就实现了简单延时队列的功能。 Zadd zadd支持批量添加的功能，有需要可以自己去探索下，这里...
golang工程组件之Redis整体结构和存储结构
SMILY12138的博客
05-19 251
本文介绍了 Redis 的整体结构和不同的存储结构类型，希望能够帮助您更好地理解 Redis 并将其应用于实际场景中。例如：HSET myhash field1 "value1" 可以创建一个包含字段名 field1 和它的值 value1 的键值对，并将其存储在一个名为 myhash 的散列中。在这篇文章中，我们将会介绍Redis的整体结构以及其使用的不同存储结构。例如：ZADD myzset 0 "hello" 可以向一个名为 myzset 的有序集中添加一个分数为 0 的元素 "hello"。
Go语言学习笔记—golang操作Redis
qq_39280718的博客
07-27 2572
Redis时NoSQL数据库，不是传统的关系型数据库。
Go操作Redis基础方法小全
BOBO博客
08-21 1493
在Go中操作Redis时，除了之前提到的字符串、列表、集合、哈希和有序集合等常用命令外，Redis还支持许多其他类型的命令。由于Redis的命令集非常庞大，这里无法一一列举所有命令，但我可以概述一些其他常见的Redis命令类别以及如何在Go中使用它们的基本思路。注：由于Redis的命令集不断发展和更新，建议查阅最新的Redis官方文档以获取最准确和最新的信息。同时，库也会随着Redis的发展而更新，因此请确保你使用的是与你的Redis服务器版本兼容的库版本。
Golang 操作Redis五大数据类型 String、List、Hash、Set、Zset
July_whj
05-30 3291
前言 使用redis首先要部署redis，载个安装包，部署下即可，本文不赘述了。redis官网：https://redis.io/ 接着要下载golang的redis资源包，golang官方推荐的有redisgo和go-reids，个人认为go-redis的封装更加人性化，redisgo的调用是基于命令的，go-redis是基于方法的，所以本文先来介绍go-redis的使用。 2行代码来比较下2种资源包的调用方式： redisgo： client.Do("SET", "mykey", "我是数据", "EX
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值