go-redis 常用操作工具类封装

已于 2023-02-07 16:40:23 修改
阅读量1.3k 收藏 5
点赞数 2
分类专栏： golang go-redis 文章标签： redis golang 数据库
于 2023-02-07 16:24:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44237719/article/details/128920821
版权

go-redis 引入、使用、以及常用操作工具类封装

文章目录

1. 项目中引入 go-redis

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

2. 编写连接 redis 配置类

package config

import (
	"github.com/go-redis/redis/v8"
	"time"
)

var client *redis.Client

func init() {
	InitRedisClient()
}

func InitRedisClient() {
	client = redis.NewClient(&redis.Options{
		Addr:        "localhost:6379", // 连接地址
		Password:    "",               // 密码
		DB:          0,                // 数据库编号
		DialTimeout: 1 * time.Second,  // 链接超时
	})
}

func GetRedisClient() *redis.Client {
	return client
}

3. 编写常用操作工具类

package util

import (
	"context"
	"fmt"
	"go-redis-demo/config"
	"time"
)

var client = config.GetRedisClient()
var ctx = context.Background()

/*------------------------------------ 字符 操作 ------------------------------------*/

// Set 设置 key的值
func Set(key, value string) bool {
	result, err := client.Set(ctx, key, value, 0).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return result == "OK"
}

// SetEX 设置 key的值并指定过期时间
func SetEX(key, value string, ex time.Duration) bool {
	result, err := client.Set(ctx, key, value, ex).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return result == "OK"
}

// Get 获取 key的值
func Get(key string) (bool, string) {
	result, err := client.Get(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
		return false, ""
	}
	return true, result
}

// GetSet 设置新值获取旧值
func GetSet(key, value string) (bool, string) {
	oldValue, err := client.GetSet(ctx, key, value).Result()
	if err != nil {
		fmt.Println(err)
		return false, ""
	}
	return true, oldValue
}

// Incr key值每次加一 并返回新值
func Incr(key string) int64 {
	val, err := client.Incr(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// IncrBy key值每次加指定数值 并返回新值
func IncrBy(key string, incr int64) int64 {
	val, err := client.IncrBy(ctx, key, incr).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// IncrByFloat key值每次加指定浮点型数值 并返回新值
func IncrByFloat(key string, incrFloat float64) float64 {
	val, err := client.IncrByFloat(ctx, key, incrFloat).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// Decr key值每次递减 1 并返回新值
func Decr(key string) int64 {
	val, err := client.Decr(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// DecrBy key值每次递减指定数值 并返回新值
func DecrBy(key string, incr int64) int64 {
	val, err := client.DecrBy(ctx, key, incr).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// Del 删除 key
func Del(key string) bool {
	result, err := client.Del(ctx, key).Result()
	if err != nil {
		return false
	}
	return result == 1
}

// Expire 设置 key的过期时间
func Expire(key string, ex time.Duration) bool {
	result, err := client.Expire(ctx, key, ex).Result()
	if err != nil {
		return false
	}
	return result
}

/*------------------------------------ list 操作 ------------------------------------*/

// LPush 从列表左边插入数据，并返回列表长度
func LPush(key string, date ...interface{}) int64 {
	result, err := client.LPush(ctx, key, date).Result()
	if err != nil {
		fmt.Println(err)
	}
	return result
}

// RPush 从列表右边插入数据，并返回列表长度
func RPush(key string, date ...interface{}) int64 {
	result, err := client.RPush(ctx, key, date).Result()
	if err != nil {
		fmt.Println(err)
	}
	return result
}

// LPop 从列表左边删除第一个数据，并返回删除的数据
func LPop(key string) (bool, string) {
	val, err := client.LPop(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
		return false, ""
	}
	return true, val
}

// RPop 从列表右边删除第一个数据，并返回删除的数据
func RPop(key string) (bool, string) {
	val, err := client.RPop(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
		return false, ""
	}
	return true, val
}

// LIndex 根据索引坐标，查询列表中的数据
func LIndex(key string, index int64) (bool, string) {
	val, err := client.LIndex(ctx, key, index).Result()
	if err != nil {
		fmt.Println(err)
		return false, ""
	}
	return true, val
}

// LLen 返回列表长度
func LLen(key string) int64 {
	val, err := client.LLen(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// LRange 返回列表的一个范围内的数据，也可以返回全部数据
func LRange(key string, start, stop int64) []string {
	vales, err := client.LRange(ctx, key, start, stop).Result()
	if err != nil {
		fmt.Println(err)
	}
	return vales
}

// LRem 从列表左边开始，删除元素data， 如果出现重复元素，仅删除 count次
func LRem(key string, count int64, data interface{}) bool {
	_, err := client.LRem(ctx, key, count, data).Result()
	if err != nil {
		fmt.Println(err)
	}
	return true
}

// LInsert 在列表中 pivot 元素的后面插入 data
func LInsert(key string, pivot int64, data interface{}) bool {
	err := client.LInsert(ctx, key, "after", pivot, data).Err()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return true
}

/*------------------------------------ set 操作 ------------------------------------*/

// SAdd 添加元素到集合中
func SAdd(key string, data ...interface{}) bool {
	err := client.SAdd(ctx, key, data).Err()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return true
}

// SCard 获取集合元素个数
func SCard(key string) int64 {
	size, err := client.SCard(ctx, "key").Result()
	if err != nil {
		fmt.Println(err)
	}
	return size
}

// SIsMember 判断元素是否在集合中
func SIsMember(key string, data interface{}) bool {
	ok, err := client.SIsMember(ctx, key, data).Result()
	if err != nil {
		fmt.Println(err)
	}
	return ok
}

// SMembers 获取集合所有元素
func SMembers(key string) []string {
	es, err := client.SMembers(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return es
}

// SRem 删除 key集合中的 data元素
func SRem(key string, data ...interface{}) bool {
	_, err := client.SRem(ctx, key, data).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return true
}

// SPopN 随机返回集合中的 count个元素，并且删除这些元素
func SPopN(key string, count int64) []string {
	vales, err := client.SPopN(ctx, key, count).Result()
	if err != nil {
		fmt.Println(err)
	}
	return vales
}

/*------------------------------------ hash 操作 ------------------------------------*/

// HSet 根据 key和 field字段设置，field字段的值
func HSet(key, field, value string) bool {
	err := client.HSet(ctx, key, field, value).Err()
	if err != nil {
		return false
	}
	return true
}

// HGet 根据 key和 field字段，查询field字段的值
func HGet(key, field string) string {
	val, err := client.HGet(ctx, key, field).Result()
	if err != nil {
		fmt.Println(err)
	}
	return val
}

// HMGet 根据key和多个字段名，批量查询多个 hash字段值
func HMGet(key string, fields ...string) []interface{} {
	vales, err := client.HMGet(ctx, key, fields...).Result()
	if err != nil {
		panic(err)
	}
	return vales
}

// HGetAll 根据 key查询所有字段和值
func HGetAll(key string) map[string]string {
	data, err := client.HGetAll(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return data
}

// HKeys 根据 key返回所有字段名
func HKeys(key string) []string {
	fields, err := client.HKeys(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return fields
}

// HLen 根据 key，查询hash的字段数量
func HLen(key string) int64 {
	size, err := client.HLen(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
	}
	return size
}

// HMSet 根据 key和多个字段名和字段值，批量设置 hash字段值
func HMSet(key string, data map[string]interface{}) bool {
	result, err := client.HMSet(ctx, key, data).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return result
}

// HSetNX 如果 field字段不存在，则设置 hash字段值
func HSetNX(key, field string, value interface{}) bool {
	result, err := client.HSetNX(ctx, key, field, value).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return result
}

// HDel 根据 key和字段名，删除 hash字段，支持批量删除
func HDel(key string, fields ...string) bool {
	_, err := client.HDel(ctx, key, fields...).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return true
}

// HExists 检测 hash字段名是否存在
func HExists(key, field string) bool {
	result, err := client.HExists(ctx, key, field).Result()
	if err != nil {
		fmt.Println(err)
		return false
	}
	return result
}

4. 测试

package main

import (
	"fmt"
	redisUtil "go-redis-demo/util"
)

func main() {
	//redisUtil.Set("test", "哈哈哈")
	//redisUtil.GetSet("test", "嘿嘿嘿")
	//redisUtil.Get("test")

	//redisUtil.Expire("test", 5*time.Second)

	//fmt.Println(redisUtil.LRem("list-1", 1, 3))

	redisUtil.HSet("stu-1", "username", "qqq")
	//redisUtil.HSet("stu-1", "pwd", "111")
	//redisUtil.HDel("stu-1", "username")

	name := redisUtil.HGetAll("stu-1")
	fmt.Println(name)

}

5. 项目结构截图

在这里插入图片描述

6. 源码下载

go-redis-demo

zhangwanyu_0923
关注
专栏目录
Go-基于redisgo进行了封装代码量减少
08-13
基于redigo的封装，写入好配置文件后，在任何地方随时调用，使用起来更简单，代码更优雅 支持和redigo同时使用
go手写Redis(4)之工具类
何忆清风
05-23 155
go实现redis中的一些常用的工具类
Go访问Redis代码封装
penngo的专栏
08-18 788
Go访问Redis代码封装
go-封装使用redis功能
一名运维开发工程师的日常记录
07-05 372
昨天上文中提过了通过连接池连接redis，日常redis常用的功能包括set,get , del,expire key等基础功能，以及sadd,hset,hget 功能，下面函数都封装好了，直接用即可。
Redis连接池的封装（go语言）
newbie_______的博客
05-07 1078
GO语言封装Redis连接池、Redis依赖的安装
go redis客户端如何进一步封装
最新发布
leijmdas的专栏
04-23 231
20. **版本兼容**：封装不同Redis版本的特定命令或行为，以确保客户端与不同版本的Redis兼容。1. **封装API**：创建一个更高层次的接口，将复杂的Redis命令封装成简单的函数调用。12. **集群支持**：如果使用Redis集群，封装集群的逻辑，简化节点发现和故障转移。5. **Lua脚本执行**：封装Lua脚本的执行过程，简化脚本的管理和调用。4. **事务处理**：简化事务的使用，通过封装提供更简洁的事务执行流程。11. **分布式锁**：封装分布式锁的实现，简化加锁和解锁的过程。
redis工具类_Redis分布式缓存工具类
weixin_39664585的博客
12-19 131
在实际go语言开发中经常会用到Redis分布式缓存，而苦于没有一个好的第三方工具包，现在分享下实际项目使用基于分布式缓存Codis时编写的Redis工具类。完整代码：https://github.com/dunzung/godis定义RoundRobinPool 的Codis连接池类package godisimport ("encoding/json""fmt""github.com/go-re...
go使用go-redis操作redis(一)安装及示例
comprel的博客
07-21 1万+
redis官网推荐redigo， 但同时go-redis也使用非常广泛， 并且go-redis封装得更好 因此这里研究下go-redis的使用方法 安装： go get -u github.com/go-redis/redis 源码地址： https://github.com/go-redis/redis 文档地址：https://godoc.org/github.com/go-redis/re...
Golang之redis中间件框架——go-redis的使用
QianLiStudent的博客
01-16 4869
写在前面       本文主要介绍操作redis数据库的框架go-redis，因此下面涉及到redis中的命令本文不做详解，下文通过使用go-redis实现go语言代码操作redis，对应命令的作用及说明请看这篇文章，里面介绍了redis各数据类型常用的一些命令。 go-redis简介     &n...
redis简单封装
05-16
redis简单封装及技术文档
go语言工具类
01-23
总结的go语言的工具类，包括json，xml，redis，memcache等的用法，配置的解析等
Go-该项目封装了多个数据库服务器redisledismemcache文件内存nosqlpostgresql
08-14
该项目封装了多个数据库服务器，redis，ledis，memcache，文件，内存，nosql，postgresql
golang redis封装工具
u013804416的博客
07-08 2387
1、redistools代码 package redistools import ( "github.com/garyburd/redigo/redis" "time" ) type RedisDataStore struct { RedisHost string RedisDB string RedisPwd string Timeout int64 RedisP...
【愚公系列】2024年01月 WPF+上位机+工业互联 093-Redis的基本使用
热门推荐
时光隧道
09-09 2万+
编程缓存工具主要有以下几种：内存缓存：内存缓存是将数据暂时存储在内存中，以提高应用程序的性能和响应时间。内存缓存通常涉及使用不同大小和类型的缓存区域，以缓存和重用数据。内存缓存的优点是快速、可靠、易于实现和管理。常用的内存缓存工具有Memcached、Redis等。硬盘缓存：硬盘缓存是将数据存储在磁盘上，以便在需要时更快地访问它们。硬盘缓存通常会在磁盘上创建一个缓存文件或目录，以保存已缓存的数据。硬盘缓存的优点是可以存储大量数据，而且可以长期保留数据。常用的硬盘缓存工具有文件系统缓存、数据库缓存等。数据库缓
Redis(七) - 封装Redis工具类
及时当勉励，岁月不待人
07-20 3454
Redis(七) - 封装Redis工具类
go redis 封装，简单使用
秋天的博客
10-19 4104
go redis 集合操作--sadd redis的go语言包，我们使用官方推荐的redigo，https://github.com/garyburd/redigo 安装redigo $ go get github.com/garyburd/redigo 带密码的redis操作 package main import ( "log" "github.com/gar...
go封装的日志工具
weixin_45251189的博客
07-14 169
package logger import ( "fmt" "io" "log" "os" "runtime" "time" ) var logger *log.Logger type LogMessage struct { file string line int message interface{} msgType string } const ( DEFAULT_DIR string = "log/" DEFAULT_PREFIX
go 进阶 三方库之 go-redis
qq_29799655的博客
05-12 1772
注意有个v8版本,是有方式上不太一样。1.提供获取锁脚本, 释放锁脚本,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值