1. Toy模板网首页
  2. > Toy博客

【go语言开发】redis简单使用

6月前 作者：猫哥说 分类：Toy博客 阅读(46) 违法举报

这篇具有很好参考价值的文章主要介绍了【go语言开发】redis简单使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

本文主要介绍redis安装和使用。首先安装redis依赖库，这里是v8版本；然后连接redis，完成基本配置；最后测试封装的工具类

欢迎大家访问个人博客网址：https://www.maogeshuo.com，博主努力更新中…

参考文件：

  • Yaml文件配置，Config使用
  • Log日志封装
  • 常用工具类封装

安装redis依赖库

命令行安装redis

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

连接redis和配置

首先创建了一个 Redis 客户端，并连接到本地 Redis 服务器（默认端口为 6379）。连接完成后，使用Ping函数测试连接是否成功。

package core

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

// https://zhuanlan.zhihu.com/p/637537337
// https://blog.csdn.net/qq_44237719/article/details/128920821

var Redis *RedisClient

type RedisClient struct {
	client *redis.Client
	ctx    context.Context
}

// InitRedis 初始化redis
func InitRedis() {
	redisConfig := Config.Redis
	client := redis.NewClient(&redis.Options{
		Addr:     fmt.Sprintf("%s:%d", redisConfig.Host, redisConfig.Port),
		Password: redisConfig.Password,
		DB:       redisConfig.Db,
	})
	redisClient := &RedisClient{
		client: client,
		ctx:    context.Background(),
	}
	Redis = redisClient
	_, err := client.Ping(client.Context()).Result()
	if err != nil {
		LOG.Println("redis连接失败！")
		return
	}
	LOG.Println("redis连接成功！")
}

工具类封装

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

代码测试

func TestRedis() {
	core.Redis.Set("test", "value1")
	if ok, s := core.Redis.Get("test"); ok {
		core.LOG.Println("test: ", s)
	}
	core.Redis.SetEX("test2", "value2", 10*time.Minute)
	if okEx, sEx := core.Redis.Get("test2"); okEx {
		core.LOG.Println("test2: ", sEx)
	}
}

【go语言开发】redis简单使用,go,golang,redis,bootstrap文章来源地址https://www.toymoban.com/news/detail-838801.html

到了这里，关于【go语言开发】redis简单使用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Go语言开发】简单了解一下搜索引擎并用go写一个demo

    【Go语言开发】简单了解一下搜索引擎并用go写一个demo

    这篇文章我们一起来了解一下搜索引擎的原理，以及用go写一个小demo来体验一下搜索引擎。 搜索引擎一般简化为三个步骤 爬虫：爬取数据源，用做搜索数据支持。 索引：根据爬虫爬取到的数据进行索引的建立。 排序：对搜索的结果进行排序。 然后我们再对几个专业名词做

    2024年02月16日
    浏览(33)

  • Go语言之 go-redis 基本使用

    Redis：https://redis.io/ Redis 中文网：https://www.redis.net.cn/ REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。 Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 它通常被称为

    2024年02月09日
    浏览(25)
  • 一个golang小白使用vscode搭建Ununtu20.04下的go开发环境

    一个golang小白使用vscode搭建Ununtu20.04下的go开发环境

    先交代一下背景，距离正式接触golang这门语言已经有5年时间，平时偶尔也会用go写写工具和功能，但其实充其量就是语言小白，基本上就是按照教程配置好环境，按照需求写写逻辑，能跑起来就行了。golang随着这几年的变化，这门语言的变化还是非常大的，之前写过一篇《

    2024年01月22日
    浏览(52)
  • Go语言之反射（反射的简单使用，原理）

    Go语言之反射（反射的简单使用，原理）

    1.什么是反射 Go语言中，反射的机制就是在运行的时候，可以获取到其变量的类型和值，且可以对其类型和值进行检查，对其值进行修改。 即在不知道具体的类型的情况下，可以用反射机制来查看变量类型、更新变量的值。 Go中反射主要涉及到两个概念：Type和Value。对所有的

    2023年04月25日
    浏览(25)

  • Go 语言之 zap 日志库简单使用

    log：https://pkg.go.dev/log log 包是一个简单的日志包。 Package log implements a simple logging package. It defines a type, Logger, with methods for formatting output. It also has a predefined \\\'standard\\\' Logger accessible through helper functions Print[f|ln], Fatal[f|ln], and Panic[f|ln], which are easier to use than creating a Logger manually. Th

    2024年02月09日
    浏览(22)

  • 【设计模式】使用 go 语言实现简单工厂模式

    最近在看《大话设计模式》，这本书通过对话形式讲解设计模式的使用场景，有兴趣的可以去看一下。 第一篇讲的是 简单工厂模式 ，要求输入两个数和运算符号，得到运行结果。 这个需求不难，难就难在类要怎么设计，才能达到可复用、维护性强、可拓展和灵活性高。 运

    2024年02月05日
    浏览(29)
  • GO语言使用最简单的UI方案govcl

    GO语言使用最简单的UI方案govcl

    接触go语言有一两年时间了。 之前用Qt和C#写过桌面程序，C#会被别人扒皮，极度不爽；Qt默认要带一堆dll，或者静态编译要自己弄或者找库，有的库还缺这缺那，很难编译成功。 如果C# winform可以编译成二进制原生exe的话，给人感觉是开发效率最好的。 C#有nuget可以用别人的库

    2024年02月15日
    浏览(22)
  • 使用Go语言编写简单的HTTP服务器

    使用Go语言编写简单的HTTP服务器

    在Go语言中，我们可以使用标准库中的\\\"net/http\\\"包来编写HTTP服务器。下面是一个简单的示例，展示了如何使用Go编写一个基本的HTTP服务器。 go 复制代码 package  main import  ( \\\"fmt\\\"   \\\"net/http\\\"   ) func   main ()  { // 创建一个处理器函数，处理所有对根路径的请求 handler := func (w http.

    2024年01月24日
    浏览(35)

  • golang redis第三方库github.com/go-redis/redis/v8实践

    这里示例使用 go-redis v8 ，不过 go-redis latest 是 v9 安装v8：go get github.com/go-redis/redis/v8 Redis 5 种基本数据类型：  string 字符串类型；list列表类型；hash哈希表类型；set集合类型；zset有序集合类型   最基本的Set/Get操作 # setget.go package  main import  ( \\\"context\\\" \\\"fmt\\\" \\\"time\\\" \\\"github.com/go-re

    2024年02月12日
    浏览(54)

  • Golang：Go语言结构

    在我们开始学习 Go 编程语言的基础构建模块前，让我们先来了解 Go 语言最简单程序的结构。 Go 语言的基础组成有以下几个部分： 包声明 引入包 函数 变量 语句 表达式 注释 接下来让我们来看下简单的代码，该代码输出了\\\"Hello World!\\\": 让我们来看下以上程序的各个部分： 第一

    2024年02月10日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包