Go go-redis应用

于 2024-06-07 11:24:59 发布
阅读量401 收藏 2
点赞数 5
分类专栏： Go Redis 文章标签： golang redis 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39335595/article/details/139517076
版权

go-redis 是 Go 语言的一个流行的 Redis 客户端库，它提供了丰富的功能来与 Redis 数据库进行交互。 

1、简单应用 

package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	ctx := context.Background()

	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	// 设置值
	err1 := rdb.Set(ctx, "your_key1", "your_value1", 0).Err()
	if err1 != nil {
		log.Fatalf("无法设置键值: %v", err1)
	}

	// 获取值
	val, _ := rdb.Get(ctx, "your_key1").Result()
	fmt.Println("your_key1: ", val)

	err2 := rdb.LPush(ctx, "your_key2", 111, 222, 333, "444").Err()
	if err2 != nil {
		log.Fatalf("无法推送到列表: %v", err2)
	}
	// 循环处理邮件队列
	for {
		// 从 Redis 队列中获取邮件
		email, err := rdb.RPop(ctx, "your_key2").Result()
		if err == redis.Nil {
			// 队列为空，退出循环
			fmt.Println("电子邮件队列为空。")
			break
		} else if err != nil {
			log.Fatalf("无法从队列中获取电子邮件: %v", err)
		} else {
			fmt.Println(email)
		}
	}
}

2、连接池管理

使用 go-redis 可以方便地管理 Redis 连接池，确保高效的连接复用。 

package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
)

func main() {
	var ctx = context.Background()

	// 创建一个新的 Redis 客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
		PoolSize: 10, // 设置连接池大小
	})

	// 使用客户端
	pong, err := client.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(pong) // 输出 PONG
}

3、管道和事务

go-redis 支持管道（pipelines）和事务（transactions），可以批量执行命令，减少网络往返次数。 

事务（Transactions）

事务在 Redis 中用来执行一系列命令，这些命令被打包在一起，然后一起执行。如果在执行过程中遇到错误，整个事务将被取消。事务可以保证操作的原子性。

package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
)

func main() {
	var ctx = context.Background()
	// 创建 Redis 客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})

	// 检查连接
	pong, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Printf("连接失败: %v", err)
		return
	}
	fmt.Printf("连接成功: %s\n", pong)

	key1 := "key1"
	key2 := "key2"

	// 使用 WATCH 命令监视键
	err = client.Watch(ctx, func(tx *redis.Tx) error {
		// 事务中的命令
		// SetNX函数：当该键不存在时才设置。如果键已经存在，命令将不执行任何操作。第三个参数为设置过期时间，0表示永不过期
		k1, err := tx.SetNX(ctx, key1, "value1", 0).Result() // 仅当 key1 不存在时设置值
		if err != nil {
			return err
		}
		if k1 {
			fmt.Println("key1 设置成功")
		} else {
			fmt.Println("key1 已存在，未进行设置操作")
		}
		k2, err := tx.SetNX(ctx, key2, "value2", 0).Result() // 仅当 key2 不存在时设置值
		if err != nil {
			return err
		}
		if k2 {
			fmt.Println("key2 设置成功")
		} else {
			fmt.Println("key2 已存在，未进行设置操作")
		}

		// 使用 MULTI 命令开始事务
		pipe := tx.Pipeline()

		// 将命令添加到事务队列
		_, err = pipe.Set(ctx, key1, "value1", 0).Result()
		if err != nil {
			return err
		}
		_, err = pipe.Set(ctx, key2, "value2", 0).Result()
		if err != nil {
			return err
		}

		// 使用 EXEC 命令执行事务
		_, err = pipe.Exec(ctx)
		if err != nil {
			return err
		}
		return nil
	}, key1, key2)

	if err != nil {
		if err == redis.TxFailedErr {
			fmt.Println("事务失败，可能因为键被其他客户端修改")
		} else {
			fmt.Printf("发生错误: %v", err)
		}
		return
	}

	// 如果事务成功，获取 key1 和 key2 的值
	val1, err := client.Get(ctx, key1).Result()
	if err != nil {
		fmt.Printf("获取 key1 失败: %v", err)
		return
	}
	val2, err := client.Get(ctx, key2).Result()
	if err != nil {
		fmt.Printf("获取 key2 失败: %v", err)
		return
	}

	fmt.Printf("key1: %s, key2: %s\n", val1, val2)
}

使用 Watch 方法监视了两个键 "key1" 和 "key2"。在 Watch 的回调函数中，我们尝试设置这两个键的值，如果设置成功，我们使用 Pipeline 方法将设置操作添加到事务队列中。最后，我们使用 Exec 方法提交事务。

请注意，如果 "key1" 或 "key2" 在我们设置它们之前已经被其他客户端设置，那么事务将不会执行，并且 Watch 方法将返回 redis.TxFailedErr 错误。在实际应用中，你可能需要根据这个错误来决定是否重试事务。

 事务&管道

package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
)

func main() {
	var ctx = context.Background()

	// 创建一个新的 Redis 客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
		PoolSize: 10, // 设置连接池大小
	})

	// 假设我们想检查并更新的key以及期望的旧值和新值
	key := "mykey"
	oldValue := "expectedOldValue"
	newValue := "newValue"

	// 事务：使用 MULTI 和 EXEC 命令保证操作的原子性
	err := client.Watch(ctx, func(tx *redis.Tx) error {
		// 在事务中获取key的值
		val, err := tx.Get(ctx, key).Result()
		if err != nil && err != redis.Nil {
			return err
		}

		// 检查值是否与预期相符
		if val == oldValue {
			// 如果相符，尝试更新值
			_, err := tx.Set(ctx, key, newValue, 0).Result()
			if err != nil {
				return err
			}
			fmt.Println("更新成功")
			return nil
		} else {
			fmt.Println("键存在，值与预期值不匹配。")
			return nil // 这里返回nil表示不执行任何操作，事务会因为没有EXEC调用而自动取消
		}
	}, key)

	if err != nil {
		panic(err)
	}

	// 管道：批量发送命令
	cmds, err := client.Pipelined(ctx, func(pipe redis.Pipeliner) error {
		pipe.Set(ctx, "key1", "value1", 0)
		pipe.Get(ctx, "key1")
		return nil
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(cmds) // 输出 [SetResult(string) <nil>, StringResult(value1, nil)]
}

4、发布/订阅模式

发布：

package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
	"time"
)

func main() {
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})

	ctx := context.Background()

	// 发送消息的循环
	for {
		err := client.Publish(ctx, "my_channel", "Hello, Redis!").Err()
		if err != nil {
			fmt.Printf("发布消息失败: %v\n", err)
			return
		}
		fmt.Println("消息发布成功")

		// 每5秒发布一条消息
		time.Sleep(5 * time.Second)
	}
}

 订阅：

package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
	"log"
	"os"
	"os/signal"
)

func main() {
	// 创建 Redis 客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})

	ctx := context.Background()

	// 订阅频道
	pubsub := client.Subscribe(ctx, "my_channel")

	// 处理接收到的消息
	go func() {
		defer func() {
			if err := pubsub.Close(); err != nil {
				log.Printf("关闭订阅失败: %v", err)
			}
		}()

		for {
			msg, err := pubsub.ReceiveMessage(ctx)
			if err != nil {
				log.Printf("接收消息失败: %v", err)
				return
			}

			fmt.Printf("接收到消息: %s\n", msg.Payload)
		}
	}()

	// 等待中断信号以退出
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt)
	<-sigChan

	fmt.Println("正在关闭订阅...")
}
package main

import (
	"context"
	"github.com/redis/go-redis/v9"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"
)

var ctx = context.Background()

func main() {
	// 创建 Redis 客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})

	if err := client.Ping(ctx).Err(); err != nil {
		log.Fatalf("无法连接到 Redis: %v", err)
	}

	// 启动订阅者
	go runSubscriber(client)

	// 发布者循环发送消息
	runPublisher(client)

	// 等待中断信号以优雅退出
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit

	log.Println("接收到退出信号，正在关闭...")
	if err := client.Close(); err != nil {
		log.Fatalf("关闭 Redis 客户端失败: %v", err)
	}
}

func runSubscriber(client *redis.Client) {
	pubsub := client.Subscribe(ctx, "my_channel")
	defer func() {
		if err := pubsub.Close(); err != nil {
			log.Printf("关闭订阅失败: %v", err)
		}
	}()

	log.Println("订阅者启动，正在监听消息...")
	for {
		msg, err := pubsub.ReceiveMessage(ctx)
		if err != nil {
			log.Printf("接收消息失败: %v", err)
			return
		}

		log.Printf("接收到消息: %s\n", msg.Payload)
	}
}

func runPublisher(client *redis.Client) {
	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()

	log.Println("发布者启动，将定时发送消息...")
	for {
		select {
		case <-ticker.C:
			err := client.Publish(ctx, "my_channel", "Hello, Redis!").Err()
			if err != nil {
				log.Printf("发布消息失败: %v", err)
				return
			}
			log.Println("消息发布成功")
		}
	}
}

 

比猪聪明
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go-redis-Golang的类型安全Redis客户端
08-13
总的来说，Go-redis是Golang中用于与Redis交互的强大工具，它提供了类型安全的API、丰富的功能、高效的连接管理和错误处理机制，是开发Go语言Redis应用的理想选择。通过熟练掌握Go-redis，开发者可以构建稳定、可靠...
开源项目-go-redis-redis.zip
10-09
`go-redis`是用Go语言编写的Redis客户端，它旨在提供简单、高性能的API，使得开发者能够方便地在Go应用程序中集成Redis功能。这个库的特点包括： 1. **完整的Redis命令集**：`go-redis`实现了Redis的所有命令，允许...
go语言整合redis
ydl1128的博客
08-11 1109
从使用WATCH命令监视某个 key 开始，直到执行EXEC命令的这段时间里，如果有其他用户抢先对被监视的 key 进行了替换、更新、删除等操作，那么当用户尝试执行EXEC的时候，事务将失败并返回一个错误，用户可以根据这个错误选择重试事务或者放弃事务。Redis 是单线程执行命令的，因此单个命令始终是原子的，但是来自不同客户端的两个给定命令可以依次执行，例如在它们之间交替执行。下方的示例代码中使用pipiline一次执行了100个 Get 命令，在pipeline 执行后遍历取出100个命令的执行结果。..
redis常规操作
jkwanga的博客
12-28 847
高并发的瓶颈就是数据库 笔记记录 下面是redis 的client 端操作，一般还可以和上篇map+lock 联合使用。都是帮助数据库减压的好手段. //redis.go var redisClient *redis.Client func redisInit() { if redisClient == nil { redisClient = redis.NewClient(&redis.Options{ Addr: "127.0.0.1:6379", Passw.
Go连接Redis：快速入门
weixin_43495948的博客
11-16 1803
使用go-redis作为连接工具。
【Redis25】Redis进阶：分布式锁实现
硬核项目经理
05-29 698
Redis进阶：分布式锁实现锁这个概念，不知道大家掌握的怎么样。我是先通过 Java ，知道在编程语言中是如何使用锁的。一般 Java 的例子会是操作一个相同的文件，但其实我们知道，不管是文件，还是数据库中的一条数据，只要是多个进程或者线程共享的，需要共同操作的数据，都会因为异步读写而带来一些问题，这些问题最终的解决方案往往就是通过锁。MySQL 中，有表锁、行锁、读写锁、意向锁、间隙锁等等，而在...
Golang redis 学习指南
a...Z
07-19 589
Golang redis 学习指南 安装 我使用的是 https://github.com/go-redis/r… 这个 golang 客户端, 因此安装方式如下: go get gopkg.in/redis.v4 接着在代码中导入此包即可: import “gopkg.in/redis.v4” 基本操作 创建客户端 通过 redis.NewClient 函数即可创建一个 redis 客户端, 这个方法接收一个 redis.Options 对象参数, 通过这个参数, 我们可以配置 red
Go-Go-Redis是Redis数据库的GoogleGo语言的客户端开发包
08-14
总的来说，Go-Go-Redis是Go语言中与Redis数据库交互的重要工具，通过其丰富的功能和高效的性能，可以极大地简化开发过程，提升应用的性能。了解并熟练使用这个库，将有助于在实际项目中更好地利用Redis的特性。
go-redis-cache
03-18
"Go-Redis-Cache" 是一个基于 Go 语言实现的 Redis 缓存库，它为开发者提供了一种简单、高效的方式来使用 Redis 作为应用程序的缓存解决方案。在 Go 语言中，利用 Redis 的强大功能来处理高并发场景下的数据存储和...
go-Redis的go客户端-go-client.zip
最新发布
02-28
在Go语言中，Redis是一个非常流行的键值存储系统，它提供了高效的内存数据处理能力，并支持多种数据结构，如字符串、哈希、列表、集合和有序集合。为了与Redis服务器进行交互，开发人员通常会使用客户端库。"go-...
RedisClient 下载 最新版
09-11
Windows Explorer style UI Multiple Redis version adaptive Manage redis server, support server password authentication Manage redis data favorite Manage redis data New redis data: string, list, hash, set, sorted set Rename redis data Delete redis data Update redis data Cut, copy paste redis data Import, export redis data Search redis data Order redis data by key, data type, size Navigation history Support time to live Support paging query redis data Support multiple selection to delete, cut, copy, export redis data Support flat view and hierarchy view to list redis data Support multiple language, now support English and Chinese Support run redis command in console Support run publish/subscribe Watch redis data for different format(plain text, json, xml, base64 image)
Go-redis-migrate用于不同的redis集群数据的迁移
08-14
Go-redis-migrate是一个用Go语言编写的开源工具，专门用于在多个Redis集群间进行数据迁移。Go语言以其高效、简洁和跨平台的特性，成为了构建这类工具的理想选择。通过使用Go，开发者可以快速地编写出高性能且可靠的...
go-redis-demo:go-redis原始码分析
03-23
在现代Web开发中，Redis作为一种高性能的键值数据库，被广泛应用于缓存、队列等多种场景。Go语言作为近年来崛起的后端开发语言，以其简洁的语法和高效的性能受到了广大开发者喜爱。将Go与Redis结合，便诞生了go-...
Go-redis-一个简单的强大的Redis的Go客户端
08-13
Go-redis是一个专门为Go语言设计的高性能、功能丰富的Redis客户端库。它提供了全面的Redis命令支持，方便开发者在Go程序中与Redis服务器进行交互。这个客户端库被广泛使用，因为其简洁的API设计和高效的性能，使其...
redismock:Go在Go的单元测试中模拟Redis
05-17
软件包github.com/elliotchance/redismock对于与Redis交互的单元测试应用程序很有用。 它使用了。 与使用真实或伪造的Redis（在下文中有更多介绍）不同， redismock提供了正常且美观的redismock ，以提高控制行为...
在golang中去写redis客户端，建立连接
茂茂的博客
11-17 971
Redis在golang中的应用 我们在平时使用golang开发服务器的过程中，会遇见使用Redis的业务场景，Redis简单的来说就是一个缓存数据库。可以对其进行操作。首先，我们需要去在golang后端的项目中写一个Redis的客户端，以此和redis服务器来建立连接。 package redis import ( "context" "github.com/go-redis/redis/v8" "github.com/spf13/viper" ) var RedisClient *redis
redis实现基于令牌桶算法(控制速率)以及固定时间的固定请求次数的请求限流器(golang版)
Enjun97的博客
03-22 1459
具体地，我们可以使用Redis中的有序集合(sorted set)来实现令牌桶算法。首先，我们需要在Redis中设置一个有序集合，将时间戳作为成员(member)，将令牌数作为分值(score)。然后，每次收到一个请求时，就从有序集合中获取当前的令牌数，并将其减1。同时，我们也需要根据一定的规则，定期向有序集合中添加令牌，确保令牌桶中的令牌数不会永久耗尽。Redis可以通过实现一个基于令牌桶算法的限流器来限制HTTP请求的访问速率。令牌桶算法是一种常见的限流算法，它基于一个令牌桶来控制请求的速率。
【Go开发】go-redis快速入门
我们都有光明的未来
10-05 468
goredis简单案例
Gaache和go-redis的区别，分别有什么优缺点
07-17
Gache是一个基于Go语言的缓存库，而"go-redis"是一个用于Go语言的Redis客户端库。下面是它们的区别和各自的优缺点： Gache的特点和优缺点： - 特点：Gache是一个内存缓存库，它提供了简单而高效的缓存功能，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值