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

news2024/12/26 23:52:00

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

文章目录

  • 安装redis依赖库
  • 连接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)
	}
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1508075.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

labview的常用小技巧

labview的常用小技巧

1.切换：labview中控件函数与函数选板的使用非常频繁，而使用菜单来调用他们非常不方便。最简单的调用方法是：右击前面板，弹出控件选板；右击程序框图，弹出函数选板。然后按住CtrlE组合键，即可快速…
阅读更多...
工业数据采集网关的功能与应用-天拓四方

工业数据采集网关的功能与应用-天拓四方

工业数据采集网关是一种专门用于采集、处理、传输工业现场数据的设备。它能够实时收集来自各种传感器、仪表和设备的数据，并通过网络将这些数据传输到云端或数据中心。同时，数据采集网关还具备数据清洗、转换和压缩等功能，确保数据的质量和传…
阅读更多...
MySQL将两条记录根据相同条件合并

MySQL将两条记录根据相同条件合并

知识点：在MySQL中，可以使用GROUP BY子句和聚合函数如CONCAT或CONCAT_WS来将多条记录基于相同条件合并为一条记录 【主要是GROUP_CONCAT这个函数的运用】 例如将员工信息表中相同门店的员工信息合并为一条记录 MySQL语句如下： SELECT dept_…
阅读更多...
一文读懂：公网IP地址证书

一文读懂：公网IP地址证书

公网IP证书是一种SSL证书，用于验证和确认特定的公网IP地址是否实际属于申请者。如果验证通过，证书颁发机构将向该IP地址持有人颁发一个以IP地址为主题的SSL证书。使用公网IP证书可以有效提升IP身份的辨识度，减少网站链接被假冒的风险&#xf…
阅读更多...
建模杂谈系列237 使用FSM进行状态管理

建模杂谈系列237 使用FSM进行状态管理

说明 使用FSM来对状态的变化进行管理，一方面有助于我们将问题定义的更清晰，同时也让程序设计更可靠、可读性(事后)更强。 内容 1 问题描述 假设有一笔投资用于证券交易，随着交易、市场价格变化，投资的状态也随之改变。我们需要…
阅读更多...
巫蛊之祸——汉武帝后期的一次重大事件

巫蛊之祸——汉武帝后期的一次重大事件

引 言 “巫蛊之祸”是汉武帝在位后期发生的一次重大政治事件，也是西汉历史上最大的冤案，此案导致皇后卫子夫和太子刘据自杀，数万人头落地，几十万人被牵连。 一、巫蛊之术的由来 《汉书》记载，巫蛊之术起源自胡巫&am…
阅读更多...
解决Iterm2升级后遇到“Stashed changes“的问题

解决Iterm2升级后遇到“Stashed changes“的问题

＜＜＜＜＜＜＜ Updated upstream ...... ＞＞＞＞＞＞＞ Stashed changes冲突标记符的代码如题，最近有升级Item2…
阅读更多...
ROS的消息发布者与订阅者示例

ROS的消息发布者与订阅者示例

前言 Topic话题，是节点之间信息交换的方法，在向话题发生送消息的节点叫做发布者，接收消息的节点叫做订阅者。 一个ROS程序中话题可以有很多个，一个话题中也可以有多个发布者和订阅者。一个订阅者可以订阅多个话题。同样 &#xff…
阅读更多...
Linux 地址空间

Linux 地址空间

目录 一、程序地址空间 1、虚拟地址 Makefile新写法 2、进程地址空间分布 3、栈&堆 4、static修饰局部变量 5、字符串常量不可修改 6、虚拟地址与物理地址的联系 二、CPU读取程序全过程 1、形成可执行程序 2、生成虚拟地址 3、程序的启动 4、创建进程 5、地…
阅读更多...
MyBatis-Plus生成sql语句时怎么知道表名和表的字段名，表的主键名的

MyBatis-Plus生成sql语句时怎么知道表名和表的字段名，表的主键名的

MyBatis-Plus通过反射获取实体类的信息。 实体类的类名驼峰转下划线为表名 实体类的属性名驼峰转下划线为字段名 表的主键名默认为id selectById就是基于这个id，select 查询字段 from user where id ？ 自定义告诉mybatisplus数据库的表名&#xff0c…
阅读更多...
SpringMVC10、拦截器

SpringMVC10、拦截器

10、拦截器 10.1、概述 SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。 过滤器与拦截器的区别：拦截器是AOP思想的具体应用。 过滤器 servlet规范中的一部分&…
阅读更多...
AWS Database Migration Service 助力数据库搬迁

AWS Database Migration Service 助力数据库搬迁

在业务出海的过程中，少不了的就是云迁移，但在云迁移的过程中其中最重要的一环就是数据库。通常迁移的成功就取决于数据，如果应用成功搬迁，数据库没过来也是无用功。因此如何快速、安全的进行数据库搬迁也成为一大难题。九河云公司…
阅读更多...
8.5 Springboot项目实战 Redis缓存热点数据

8.5 Springboot项目实战 Redis缓存热点数据

文章目录 前言一、缓存与数据库一致性二、Repository层 -- Cache Aside模式实操BookRepositoryBookRepositoryImpl2.1 查询2.2 修改2.3 删除2.4 扩展Mapper修改三、Service层调用修改四、测试前言 前两文我们讲解了如何在SpringBoot中整合Redis，接下来我们将进行
阅读更多...
智慧水务大数据，信息化云平台建设，综合运营管理平台

智慧水务大数据，信息化云平台建设，综合运营管理平台

一、水务信息化的建设方向 1、完善基础设施构建软件定义的数据中心 基础设施，建设新一代软件定义的数据中心;逐步整合水务和海洋资源、统一、规范化各业务系统,按照一体化、一站式的服务进行建设。 2、整合信息资源建立智慧决策体系 统一信息采集方式，…
阅读更多...
STM32CubeIDE基础学习-STM32CubeIDE软件工程文件拷贝粘贴

STM32CubeIDE基础学习-STM32CubeIDE软件工程文件拷贝粘贴

STM32CubeIDE基础学习-STM32CubeIDE软件工程文件拷贝粘贴 前言 在后面开发程序时，往往不需要再重新新建工程的了，可以直接在原有的工程基础上直接复制粘贴新增功能就可以了。 具体的操作方法步骤如下介绍： 第一步：找到一个原有的…
阅读更多...
中医中的虚是什么？虚的分类？如何治疗气虚？

中医中的虚是什么？虚的分类？如何治疗气虚？

目录 中医中虚的分类气虚（此处指脾气虚）症状舌象：舌头中间区域有裂痕 或者 舌胖有齿痕身体上 解决方法其它脏腑气虚的情况及解决方法 血虚津液不足阴虚阳虚 中医中虚的分类 图片来源于微信视频的名为 路广林主任 的视频。 气虚（此…
阅读更多...
九州金榜｜孩子厌学怎么引导？

九州金榜｜孩子厌学怎么引导？

孩子在成长的过程中，尤其在上学的时候，孩子出现厌学情绪这是非常常见的事情，当孩子出现厌学情绪时，家长要采取什么样的方法才能帮助孩子找回学习兴趣和动力呢？九州金榜家庭教育给出建议，首先父母不应该过于…
阅读更多...
代码随想录day17（3）二叉树：二叉树的中序遍历（leetcode94）

代码随想录day17（3）二叉树：二叉树的中序遍历（leetcode94）

题目要求：实现二叉树的中序遍历。 思路：对于二叉树的中序遍历，通常可以使用递归算法与非递归（迭代）算法两种。 对于递归算法的处理与前序、后序基本相同，只是本次应先访问其左节点，然后进行pu…
阅读更多...
计算机网络—以太网接口和链路配置

计算机网络—以太网接口和链路配置

目录 1.拓扑图 2.以太网交换机基础配置 3.配置手动模式的链路聚合 4.配置静态 LACP 模式的链路聚合 5.配置文件 1.拓扑图 2.以太网交换机基础配置 华为交换机接口默认开启了自协商功能，需要手动配置S1与 S2上G0/0/9和G0/0/10接口的速率。 首先修改交换机的设…
阅读更多...
【力扣100】【好题】322.零钱兑换 || 01背包完全背包

【力扣100】【好题】322.零钱兑换 || 01背包完全背包

添加链接描述 思路： dp[j]数组表示的是在金额达到 j 的时候所需要的最小硬币数金额：背包容量，每个硬币的个数都为1：背包中物品的价值，硬币面额：物品重量dp[j]min(dp[j],dp[j-coin]1) class Solution:def …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023