redis在go语言中的使用

已于 2024-03-09 08:45:19 修改
阅读量1.2k 收藏 20
点赞数 13
文章标签： redis golang 数据库
于 2024-02-18 08:12:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63728673/article/details/136144774
版权

redis在go语言中的使用

以下说明以读者有redis基础的前提下进行

未学习redis的可以到b站1小时浅学redis了解大概，学会如何使用

【GeekHour】一小时Redis教程_哔哩哔哩_bilibili

以下开发环境以windows为测试环境，旨在练习redis在go语言中的使用

redis使用的是5.0.14的windows版本（正常开发项目redis都是在linux上使用，windows的redis版本很低），但基础功能都有，满足学习要求；

下载链接：https://github.com/tporadowski/redis/releases
（官网是没有windows版本的）

下载完成后，打开黑窗口，输入redis-cli显示

image-20240217171150476

即为成功，可以选择性下载redis的gui工具redisInsight，官网链接：

RedisInsight | The Best Redis GUI

使用时截图：

image-20240217171350265

左侧会显示key，点击后右侧会显示value的值，使用和查找起来较为方便，能够增加学习效率，当然还有很多功能，这里就不赘述

1引入go-redis库

为什么使用这个库，而不是其他的库呢？

理由：

  1. 性能高效： Go-Redis实现了高性能的Redis客户端，具有低延迟和高吞吐量。它采用了异步的方式处理多个并发请求，从而提高了性能。
  2. 完整支持Redis功能： Go-Redis库提供了对Redis的全面支持，包括对基本数据结构（字符串、哈希、列表、集合等）的操作，事务，流水线（pipeline）等功能。
  3. 易用性： Go-Redis提供了简单而直观的API，易于使用。它封装了与Redis的底层通信细节，使得开发者可以专注于业务逻辑而不必过多关注底层实现。
  4. 连接池： Go-Redis包含了连接池的支持，这有助于有效地管理和复用与Redis的连接，减少了连接的创建和销毁开销，提高了性能。
  5. Active development和社区支持： Go-Redis是一个活跃的项目，有一个庞大的社区支持。这意味着它经常得到更新和改进，并且有丰富的文档和社区资源可供参考。
  6. 灵活性： Go-Redis允许开发者选择不同的执行模式，如同步、异步和流水线，以满足不同场景下的需求。

总之，这个库用的人多，并且功能齐全，很适合在go语言中与redis交互；（好用就完事了！！！）

2在go项目中的初始化

其实很简单，和mysql初始化优点相似；

为了方便学习，初始化都写在一个文件中

如下：

package main

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

func main() {
	// 创建一个新的Redis客户端实例
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis服务器地址
		Password: "",               // 可选：如果有密码的话
		DB:       0,                // 使用的数据库编号
	})

	// 使用Ping测试连接
	pong, err := client.Ping(context.Background()).Result()
	if err != nil {
		fmt.Println("连接Redis出错：", err)
		return
	}
	fmt.Println("连接成功，Ping结果：", pong)

	// 在程序结束时关闭连接
	defer client.Close()
	
	// 在这里可以继续执行其他与Redis相关的操作
}
测试运行成功会输出：
连接成功，Ping结果： PONG

我们知道redis共有五大基本数据类型：string，hash，list，set，Sorted Set

  1. 字符串（String）： 字符串是最基本的数据类型，可以包含任何数据，比如文本、数字等。在Redis中，字符串可以用于存储各种类型的数据，例如配置信息、计数器、缓存等。常用的字符串操作命令有 SET、GET、INCR、DECR 等。
  2. 哈希（Hash）： 哈希是一个键值对集合，每个键值对称为字段和值。哈希适用于存储对象，可以将一个对象存储在一个哈希中，然后通过字段来访问对象的各个属性。常用的哈希操作命令有 HSET、HGET、HMSET、HGETALL 等。
  3. 列表（List）： 列表是一个有序的字符串元素集合，可以在列表的两端执行添加和删除操作。列表适用于实现队列、栈等数据结构，也可以用于存储一系列有序的数据。常用的列表操作命令有 LPUSH、RPUSH、LPOP、RPOP 等。
  4. 集合（Set）： 集合是一组唯一的无序字符串元素的集合。集合适用于存储一组不重复的元素，可以执行交集、并集、差集等操作。常用的集合操作命令有 SADD、SREM、SISMEMBER、SMEMBERS 等。
  5. 有序集合（Sorted Set）： 有序集合是集合的一个扩展，其中每个成员都关联了一个分数，可以按照分数对成员进行排序。有序集合适用于实现排行榜、时间线等功能。常用的有序集合操作命令有 ZADD、ZRANGE、ZSCORE、ZREMRANGEBYRANK 等。

在go-redis中也是如此，再加上发布订阅和事务处理基本就是要学习的go-redis知识了；

基础键值对相关操作 string

在go中简单设置键值对并查找键值对

简单设置一个键值对，来试试是否能够查找成功：

在go中设置key方法：Set
// 生成测试用的key
testKey := "test_key"
// 设置key的值，演示Set方法

err = client.Set(context.Background(), testKey, "Hello, Redis!", 0).Err()
if err != nil {
    fmt.Println("设置key出错：", err)
    return
}
fmt.Println("设置key成功")
//解释：
//通过创建testKey变量，你定义了一个测试用的键。

//使用client.Set方法设置了键test_key的值为字符串"Hello, Redis!"，并指定了过期时间为0，表示不设置过期时间。

//通过检查错误（err != nil）来确保设置操作是否成功。如果设置失败，你输出了错误信息；否则，你输出了"设置key成功"。
检测key对应的value的值的方法：Get
// 获取key的值，演示Get方法
	value, err := client.Get(context.Background(), testKey).Result()
//result作用是：等待并返回实际的 Redis 命令执行结果。  这种异步操作和等待结果的方式有助于确保代码在获取 Redis 操作结果时不会阻塞整个程序，以便更好地处理并发性能。
	if err != nil {
		fmt.Println("获取key出错：", err)
		return
	}
	fmt.Printf("获取key的值：%s\n", value)
}
//成功运行时会返回：
//获取key的值：Hello, Redis!

redisInsight截图：
image-20240217172811496

获取指定键的当前值并设置一个新的值：GetSet
// 使用 GETSET 获取testKey原有的值存入到oldValue中，并设置新值为NewValue
	oldValue, err := client.GetSet(context.Background(), testKey, "NewValue").Result()
	if err != nil {
		fmt.Println("GETSET 操作出错：", err)
		return
	}

	fmt.Printf("旧值：%s\n", oldValue)

	// 获取更新后testKey中的值并存到newValue中
	newValue, err := client.Get(context.Background(), testKey).Result()
	if err != nil {
		fmt.Println("获取key出错：", err)
		return
	}
	fmt.Printf("新值：%s\n", newValue)

其实还是很简单的，都是一些重复代码段；

批量设置key的值：MSet
// 准备要设置的键值对
keyValues := map[string]interface{}{
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
}

// 使用 MSet 方法批量设置键值对
err = client.MSet(context.Background(), keyValues).Err()
if err != nil {
    fmt.Println("批量设置键值对出错:", err)
    return
}
//这个M的意思其实是mutiple（多个），不止针对普通string，对于HGet等等都能变成HMGet，批量增加

成功image-20240217180202018

增加整数的值的两个方法：Incr,Incrby

前者可以将值每次增加1，当要增加的值不存在时，会先自动置为0进行操作。下例就是

	// 示例使用的键名
	key := "myKey"

	// 使用 INCR 递增键的值， myKey初值为空，自动置为0+1了
	newValue, err := client.Incr(context.Background(), key).Result()
	if err != nil {
		fmt.Println("INCR 操作出错:", err)
		return
	}
	fmt.Printf("INCR 后 %s 的值为 %d\n", key, newValue)

	// 使用 INCRBY 指定增量递增键的值    1+5=6；
	increment := 5
	newValue, err = client.IncrBy(context.Background(), key, int64(increment)).Result()
	if err != nil {
		fmt.Println("INCRBY 操作出错:", err)
		return
	}
	fmt.Printf("INCRBY %d 后 %s 的值为 %d\n", increment, key, newValue)

image-20240218081020253

在实际开发中还是要看需要什么用什么

设置过期时间

之前的Set方法中，最后一个参数是0，表示的就是过期时间设置，默认以秒为单位，当为0时，表示永不过期，写10，就是10s后过期，写其他单位的数字就需要加单位，如1*time.Minute就是1分钟；

而正规一点的过期时间设置方法是：

使用Expire方法：直接设置key在生成后多少时间过期，比如10秒后过期

// 设置 key 的值
	err := client.Set(context.Background(), "myKey", "myValue", 0).Err()
	if err != nil {
		fmt.Println("设置 key 的值出错:", err)
		return
	}
	// 给 key 设置过期时间为 10 秒
	err = client.Expire(context.Background(), "myKey", 10*time.Second).Err()
	if err != nil {
		fmt.Println("给 key 设置过期时间出错:", err)
		return
	}

使用ExpireAt方法：表示过期的具体时间点，比如直接写成25年的1月1号0点0分过期；

// 设置 key 的值
	err := client.Set(context.Background(), "myKey", "myValue", 0).Err()
	if err != nil {
		fmt.Println("设置 key 的值出错:", err)
		return
	}

	// 给 key 设置过期时间为 10 秒后的某个特定时间
	expirationTime := time.Now().Add(10 * time.Second)
	err = client.ExpireAt(context.Background(), "myKey", expirationTime).Err()
	if err != nil {
		fmt.Println("给 key 设置过期时间出错:", err)
		return
	}

哈希键值对操作：

HGet

先举个例子方便理解，比如，原来的Get命令只能生成简单的键值对，但使用HGet，可以将多个键值对变成同一个哈希表对应的键值对，例如：

image-20240217210237677

这样就清楚了吧，代码示例：

创建和获取哈希类型
// 准备哈希名、字段和值
	hashName := "user:1"
	fieldName := "username"
	fieldValue := "JohnDoe"

	// 使用 HSet 方法设置哈希字段的值
	err := client.HSet(context.Background(), hashName, fieldName, fieldValue).Err()
	if err != nil {
		fmt.Println("设置哈希字段的值出错:", err)
		return
	}

	// 使用 HGet 方法获取哈希字段的值
	result, err := client.HGet(context.Background(), hashName, fieldName).Result()
	if err != nil {
		fmt.Println("获取哈希字段的值出错:", err)
		return
	}
批量创建哈希类型中的键值对

一看就会

	// 准备哈希名
	hashName := "user:1"

	// 使用 HMSet 一次性设置多个键值对
	keyValueMap := map[string]interface{}{
		"username": "JohnDoe",
		"email":    "john@example.com",
		"age":      "30",
	}

	err := client.HMSet(context.Background(), hashName, keyValueMap).Err()
	if err != nil {
		fmt.Println("一次性设置多个键值对出错:", err)
		return
	}

	fmt.Printf("成功一次性设置多个键值对到哈希表 %s\n", hashName)
}

到这里其实我们已经发现了，对于redis的操作基本都是相同的，只是调用函数和一两个参数的不同，最主要的还是学好redis基础，

哈希中使用Incr，Incrby增加值的大小

和string的很像，只是多了一个哈希的参数

// 哈希键名
	hashKey := "myHash"

	// 哈希字段名
	fieldName := "myField"

	// 使用Incr方法自增哈希中的字段值
	result, err := client.HIncrBy(hashKey, fieldName, 1).Result()
	if err != nil {
		fmt.Println("Error incrementing field:", err)
		return
	}

	fmt.Printf("Incr Result: %d\n", result)

	// 使用IncrBy方法自定义增量自增哈希中的字段值
	customIncrement := 5
	result, err = client.HIncrBy(hashKey, fieldName, int64(customIncrement)).Result()
	if err != nil {
		fmt.Println("Error incrementing field:", err)
		return
	}

	fmt.Printf("IncrBy Result: %d\n", result)

redis中的方法很多，之后就不一一展示了，只会挑选一些比较重要或者难以掌握的强调，毕竟有些简单操作真正使用时直接套代码就可以了；

Hkeys：获取指定哈希键名的哈希表中所有字段
// 哈希键名
	hashKey := "myHash"

	// 使用HKeys方法获取哈希表中所有字段
	fields, err := client.HKeys(hashKey).Result()
	if err != nil {
		fmt.Println("Error getting hash keys:", err)
		return
	}
HGetAll：返回哈希键中的所有字段及其对应的值
// 哈希键名
	hashKey := "myHash"

	// 使用HGetAll方法获取哈希表中所有字段及其对应的值
	fieldValues, err := client.HGetAll(hashKey).Result()
	if err != nil {
		fmt.Println("Error getting hash field values:", err)
		return
	}

	fmt.Printf("Hash field values for %s: %v\n", hashKey, fieldValues)
HMGet同时设置多个哈希字段
// 哈希键名
	hashKey := "myHash"

	// 使用HMSet方法设置多个哈希字段及其对应的值
	fieldsAndValues := map[string]interface{}{
		"field1": "value1",
		"field2": "value2",
		"field3": 123,
	}

	result, err := client.HMSet(hashKey, fieldsAndValues).Result()
	if err != nil {
		fmt.Println("Error setting hash fields:", err)
		return
	}

	fmt.Printf("HMSet Result: %v\n", result)
HSetNX：用于在哈希表中设置字段的命令，但是只有在字段不存在时才会设置成功
	// 哈希键名
	hashKey := "myHash"
	field := "myField"
	value := "myValue"

	// 使用HSetNX方法设置哈希字段，只有在字段不存在时才会设置成功
	result, err := client.HSetNX(hashKey, field, value).Result()
	if err != nil {
		fmt.Println("Error setting hash field:", err)
		return
	}

	if result {
		fmt.Printf("HSetNX: Field %s set to %s successfully.\n", field, value)
	} else {
		fmt.Printf("HSetNX: Field %s already exists in hash %s.\n", field, hashKey)
	}
}
HDel：删除hash中的键值对，支持批量删除

例：

image-20240218091433710

HExists：检测哈希中指定键是否存在

image-20240218091718568

该方法返回布尔值，存在就返回true，不存在返回false

3. List

1. LPush

从列表左边插入数据

// 插入一个数据
rdb.LPush(ctx,"key", "data1")

// LPush支持一次插入任意个数据
err := rdb.LPush(ctx,"key", 1,2,3,4,5).Err()
if err != nil {
	panic(err)
}

2. LPushX

跟LPush的区别是，仅当列表存在的时候才插入数据,用法完全一样。

err := rdb.LPushX(ctx, "key", "sss").Err()
	if err != nil {
		panic(err)
	}

3. RPop

从列表的右边删除第一个数据，并返回删除的数据

val, err := rdb.RPop(ctx,"key").Result()
if err != nil {
	panic(err)
}

fmt.Println(val)

4. RPush

从列表右边插入数据

// 插入一个数据
rdb.RPush(ctx,"key", "data1")

// 支持一次插入任意个数据
err := rdb.RPush(ctx,"key", 1,2,3,4,5).Err()
if err != nil {
	panic(err)
}

5. RPushX

跟RPush的区别是，仅当列表存在的时候才插入数据, 他们用法一样

err := rdb.RPushX(ctx,"key", "right_x").Err()
if err != nil {
	panic(err)
}

6. LPop

从列表左边删除第一个数据，并返回删除的数据

val, err := rdb.LPop(ctx,"key").Result()
if err != nil {
	panic(err)
}

fmt.Println(val)

7. LLen

返回列表的大小

val, err := rdb.LLen(ctx,"key").Result()
if err != nil {
	panic(err)
}

fmt.Println(val)

8. LRange

返回列表的一个范围内的数据，也可以返回全部数据

// 返回从0开始到-1位置之间的数据，意思就是返回全部数据
vals, err := rdb.LRange(ctx,"key",0,-1).Result()
if err != nil {
	panic(err)
}
fmt.Println(vals)

9. LRem

删除列表中的数据

// 从列表左边开始，删除100， 如果出现重复元素，仅删除1次，也就是删除第一个
dels, err := rdb.LRem(ctx,"key",1,100).Result()
if err != nil {
	panic(err)
}

// 如果存在多个100，则从列表左边开始删除2个100
rdb.LRem(ctx,"key",2,100)


// 如果存在多个100，则从列表右边开始删除2个100
// 第二个参数负数表示从右边开始删除几个等于100的元素
rdb.LRem(ctx,"key",-2,100)

// 如果存在多个100，第二个参数为0，表示删除所有元素等于100的数据
rdb.LRem(ctx,"key",0,100)

10. LIndex

根据索引坐标，查询列表中的数据

// 列表索引从0开始计算，这里返回第6个元素
val, err := rdb.LIndex(ctx,"key",5).Result()
if err != nil {
	panic(err)
}

fmt.Println(val)

11. LInsert

在指定位置插入数据

// 在列表中5的前面插入4
// before是之前的意思
err := rdb.LInsert(ctx,"key","before", 5, 4).Err()
if err != nil {
	panic(err)
}

// 在列表中 zhangsan 元素的前面插入 欢迎你
rdb.LInsert(ctx,"key","before", "zhangsan", "欢迎你")

// 在列表中 zhangsan 元素的后面插入 2022
rdb.LInsert(ctx,"key","after", "zhangsan", "2022")

4. Set

1. SAdd

添加集合元素

// 添加100到集合中
err := rdb.SAdd(ctx,"key",100).Err()
if err != nil {
	panic(err)
}

// 将100,200,300添加到集合中
rdb.SAdd(ctx,"key",100, 200, 300)

2. SCard

获取集合元素个数

size, err := rdb.SCard(ctx,"key").Result()
if err != nil {
	panic(err)
}
fmt.Println(size)

3. SIsMember

判断元素是否在集合中

// 检测100是否包含在集合中
ok, _ := rdb.SIsMember(ctx,"key", 100).Result()
if ok {
	fmt.Println("集合包含指定元素")
}

4. SMembers

获取集合中所有的元素

es, _ := rdb.SMembers(ctx,"key").Result()
// 返回的es是string数组
fmt.Println(es)

5. SRem

删除集合元素

// 删除集合中的元素100
	rdb.SRem(ctx, "key", 100)

	// 删除集合中的元素200和300
	rdb.SRem(ctx, "key", 200, 300)

6. SPop,SPopN

随机返回集合中的元素，并且删除返回的元素

// 随机返回集合中的一个元素，并且删除这个元素
val, _ := rdb.SPop(ctx,"key").Result()
fmt.Println(val)

// 随机返回集合中的5个元素，并且删除这些元素
vals, _ := rdb.SPopN(ctx,"key", 5).Result()
fmt.Println(vals)

5. sorted set

1. ZAdd

添加一个或者多个元素到集合，如果元素已经存在则更新分数

// 添加一个集合元素到集合中， 这个元素的分数是2.5，元素名是zhangsan
err := rdb.ZAdd(ctx, "key", &redis.Z{Score: 2.5, Member: "zhangsan"}).Err()
if err != nil {
		panic(err)
}

2. ZCard

返回集合元素个数

size, err := rdb.ZCard(ctx,"key").Result()
if err != nil {
	panic(err)
}
fmt.Println(size)

3. ZCount

统计某个分数范围内的元素个数

// 返回： 1<=分数<=5 的元素个数, 注意："1", "5"两个参数是字符串
size, err := rdb.ZCount(ctx,"key", "1","5").Result()
if err != nil {
	panic(err)
}
fmt.Println(size)

// 返回： 1<分数<=5 的元素个数
// 说明：默认第二，第三个参数是大于等于和小于等于的关系。
// 如果加上（ 则表示大于或者小于，相当于去掉了等于关系。
size, err := rdb.ZCount(ctx,"key", "(1","5").Result()

4. ZIncrBy

增加元素的分数

// 给元素zhangsan，加上2分
rdb.ZIncrBy(ctx,"key", 2,"zhangsan")

5.ZRange,ZRevRange

返回集合中某个索引范围的元素，根据分数从小到大排序

// 返回从0到-1位置的集合元素， 元素按分数从小到大排序
// 0到-1代表则返回全部数据
vals, err := rdb.ZRange(ctx,"key", 0,-1).Result()
if err != nil {
	panic(err)
}

for _, val := range vals {
	fmt.Println(val)
}

ZRevRange用法跟ZRange一样，区别是ZRevRange的结果是按分数从大到小排序。

6. ZRangeByScore

根据分数范围返回集合元素，元素根据分数从小到大排序，支持分页。

// 初始化查询条件， Offset和Count用于分页
op := redis.ZRangeBy{
	Min:"2", // 最小分数
	Max:"10", // 最大分数
	Offset:0, // 类似sql的limit, 表示开始偏移量 
	Count:5, // 一次返回多少数据
}
	
vals, err := rdb.ZRangeByScore(ctx,"key", &op).Result()
if err != nil {
	panic(err)
}

for _, val := range vals {
	fmt.Println(val)
}

7. ZRevRangeByScore

用法类似ZRangeByScore，区别是元素根据分数从大到小排序。

8. ZRangeByScoreWithScores

用法跟ZRangeByScore一样，区别是除了返回集合元素，同时也返回元素对应的分数

// 初始化查询条件， Offset和Count用于分页
op := redis.ZRangeBy{
	Min:"2", // 最小分数
	Max:"10", // 最大分数
	Offset:0, // 类似sql的limit, 表示开始偏移量
	Count:5, // 一次返回多少数据
}

vals, err := rdb.ZRangeByScoreWithScores(ctx,"key", &op).Result()
if err != nil {
	panic(err)
}

for _, val := range vals {
	fmt.Println(val.Member) // 集合元素
	fmt.Println(val.Score) // 分数
}

9. ZRem

删除集合元素

// 删除集合中的元素zhangsan
rdb.ZRem(ctx,"key", "zhangsan")

// 删除集合中的元素zhangsan和zhangsan1
// 支持一次删除多个元素
rdb.ZRem(ctx,"key", "zhangsan", "zhangsan1")

10. ZRemRangeByRank

根据索引范围删除元素

// 集合元素按分数排序，从最低分到高分，删除第0个元素到第5个元素。
// 这里相当于删除最低分的几个元素
rdb.ZRemRangeByRank(ctx,"key", 0, 5)

// 位置参数写成负数，代表从高分开始删除。
// 这个例子，删除最高分数的两个元素，-1代表最高分数的位置，-2第二高分，以此类推。
rdb.ZRemRangeByRank(ctx,"key", -1, -2)

11.ZRemRangeByScore

根据分数范围删除元素

// 删除范围： 2<=分数<=5 的元素
rdb.ZRemRangeByScore(ctx,"key", "2", "5")

// 删除范围： 2<=分数<5 的元素
rdb.ZRemRangeByScore(ctx,"key", "2", "(5")

12. ZScore

查询元素对应的分数

// 查询集合元素zhangsan的分数
score, _ := rdb.ZScore(ctx,"key", "zhangsan").Result()
fmt.Println(score)

13. ZRank

根据元素名，查询集合元素在集合中的排名，从0开始算，集合元素按分数从小到大排序

rk, _ := rdb.ZRank(ctx,"key", "zhangsan").Result()
fmt.Println(rk)

ZRevRank的作用跟ZRank一样，区别是ZRevRank是按分数从大到小排序。

佚名涙
关注
  • 13
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言开发中redis的使用详解
01-03
前段时间因为忙一些其它的事情，分享的有些少，最近学习一下redis在Go语言开发中的应用。 一、理论知识 Redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。 Redis 优势...
Go语言中操作Redis
ZN175623的博客
11-24 1071
Redis是一个开源的内存数据库，Redis提供了多种不同类型的数据结构，很多业务场景下的问题都可以很自然地映射到这些数据结构上。除此之外，通过复制、持久化和客户端分片等特性，我们可以很方便地将Redis扩展成一个能够包含数百GB数据、每秒处理上百万次请求的系统Redis支持的数据结构。
如何使用Go语言对Redis进行读写操作
lee1028的博客
07-02 347
本文示例使用的是redigo开源库对Redis进行操作，其实使用的更多的还有一个库，那就是go-redis，此库对Redis的操作封装的更为丰富，感兴趣的读者可以自行学习。
Go语言Redis理解和使用（十）—— Redis
qq_54353206的博客
02-15 1563
1、redis是什么 2、redis应用案例 3、redis使用注意事项
GO语言操作redis
m0_56137272的博客
04-30 7115
本文仅仅简单介绍了如何使用go语言操作redis，分别展示了两种客户端包如何实现对redis的访问和操作，并展示了redis的部分指令，而redis提供的指令远不止这些。写博客的过程中，个人还是感觉Redigo使用起来更加易懂，而go-redis支持连接哨兵和集群模式的redis，还是要根据情况选择使用。
Go语言中通过Lua脚本操作Redis的方法
01-03
Redis会根据脚本的SHA值缓存脚本，已经缓存过的脚本不需要再次传输Lua代码，减少了通信成本，此外在自己代码中改变Lua脚本，执行时Redis必定也会使用最新的代码。 导入常见的Go库如 “github.com/g
Go语言操作redis用法实例
09-10
主要介绍了Go语言操作redis用法,实例分析了Go语言操作redis的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
go语言编写的redis dmp文件分析工具.rar
07-07
go语言编写的redis dmp文件分析工具，windows下生成页面，执行 rdr_x64.exe加rdb备份文件，指定web页面端口，分析完成后即可展示redis的数量较多的key，分布情况，方便离线redis统计分析。
为什么Redis6.0引入了多线程
IT深耕十余载，大道之简
05-11 531
总的来说，Redis 6.0引入多线程是为了提高性能、降低延迟、更好地利用CPU资源，并保持Redis的简单性和高性能特点。这些改进有助于Redis更好地应对不断增长的数据量和并发量需求，同时保持其稳定性和可靠性。Redis 6.0引入多线程的决策是基于其性能优化和适应现代硬件架构的考虑。
Redis为什么快？
qq_51967234的博客
05-12 605
一个CPU同时只能执行一个线程的任务，如果是多线程的场景的话，不同线程去争夺CPU资源，上下文切换开销很大，所以redis采用了单线程。（注：Redis 6.0之前，服务端和客户端的连接以及如何去处理客户端的命令都是共用一个线程的，也就是单线程 ， 在Redis 6.0之后，处理服务端和客户端的连接专门用多线程去跑了，但是处理命令还是单线程。但不是每个连接时时刻刻都有数据的，维护太多的线程会浪费资源，通过IO多路复用可以让一个线程监控多个socket连接。（1）Redis是基于。
redis试题按知识点归类(三)
最新发布
u012728971的博客
05-13 135
十一、发布/订阅 1.Redis 的发布/订阅模型是如何工作的？ 2.如何使用 Redis 作为消息队列？ 3.发布/订阅在实际应用中有哪些用例？ 十二、缓存策略 1.如何确定 Redis 的缓存策略？ 2.Redis 的缓存替换策略有哪些？ 3.如何使用 Redis 作为缓存层？ 十三、客户端与生态系统 1.Redis 支持哪些编程语言的客户端？ 2.Redisson 和 Jedis 有什么不同？ 3.如何使用 Redis 模块？ 十四、运维与管理 1.如何监控和管理 Redis
【Redis7】10大数据类型之HyperLogLog类型
云泽野の编程日记
05-10 220
HyperLogLog是基于概率的数据结构，能够以极高的效率和极小的内存占用（固定12KB）来近似计算。个不同元素的基数，特别适合处理大规模数据集的统计计数，如网站独立访客（UV）计数等场景。类型,因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身.Redis的HyperLogLog是一种高级数据结构，专门用于基数估算。
redis中的大key问题
qq_35693377的博客
05-11 974
设置过期时间：为数据设置TTL（Time To Live），使得旧数据可以自动被清理，防止无限制地增长。数据分页处理：如果应用场景允许，通过分页方式只加载需要的部分数据，而不是一次性加载整个key。客户端缓存：对于读多写少的数据，可以考虑在客户端进行缓存，减少对Redis的访问压力。负载均衡：对于热点数据，考虑采用负载均衡策略，如一致性哈希等，以均衡各节点负载。评估数据模型：重新评估和设计数据模型，使用更适合的数据结构和存储策略。内存优化：优化数据存储格式，例如使用更紧凑的数据结构或者压缩数据。
redis的跳表
qq_35693377的博客
05-13 268
在当前层级上，从最右侧开始，逐个比较节点的值，直到找到一个节点的值大于或等于目标值。插入新节点时，需要在每一层都更新对应的指针，使得新节点能够正确地插入到每一层中。如果当前节点的值等于目标值，则返回该节点，查找结束。重复步骤2和3，直到找到目标节点或者到达跳表的底层。如果当前节点的值大于目标值，则向下移动到下一层级。从跳表的头节点开始。
Redis为什么最开始被设计成单线程而不是多线程
IT深耕十余载，大道之简
05-11 479
综上所述，Redis最初选择单线程模型是基于对内存效率、I/O效率、编程复杂性、CPU缓存利用、编程模型简化以及可维护性和稳定性的综合考虑。然而，随着技术的发展和硬件性能的提升，Redis也在不断探索如何在保持其简单性和稳定性的同时，进一步提高性能。由于不需要考虑多线程之间的数据共享和同步问题，开发者可以更加专注于实现核心的数据结构和算法，从而提高开发效率和代码质量。单线程模型还带来了更好的可维护性和稳定性。由于减少了多线程引入的复杂性和潜在的并发问题，Redis的故障率相对较低，且更易于调试和维护。
Redis 6.x的ACL功能
叱咤少帅的博客
05-11 214
Redis 6.x的ACL功能
Redis——Redis数据分片的三种算法
IT深耕十余载，大道之简
05-13 623
需要注意的是，Redis 3.0及以后的版本推出了原生的Redis Cluster集群方案，它采用了一种基于哈希槽（Hash Slot）的分片算法。当客户端需要存取某个key时，Redis首先会计算该key对应的哈希槽，然后找到负责该槽的节点进行存取操作。这种分片算法结合了哈希取模和一致性哈希的优点，既保证了数据的均匀分布，又能在增加或删除节点时只迁移部分数据。Redis的数据分片通常是为了实现水平扩展，将数据分散到多个Redis节点上，以提高系统的容量和性能。
Go语言中使用Redis的SetNX命令
07-15
在Go语言中，使用Redis的SetNX命令可以通过使用第三方库来实现，比如使用`go-redis/redis`库。下面是一个示例代码： ```go import ( "context" "fmt" "time" "github.com/go-redis/redis/v8" ) func main() { // 创建Redis客户端 client := redis.NewClient(&redis.Options{ Addr: "localhost:6379", // Redis服务器地址 Password: "", // Redis服务器密码，如果没有密码则为空字符串 DB: 0, // 使用的数据库编号 }) // 设置键值对，同时设置过期时间 key := "mykey" value := "myvalue" expiration := time.Hour result, err := client.SetNX(context.TODO(), key, value, expiration).Result() if err != nil { fmt.Println("SetNX error:", err) return } fmt.Println("SetNX result:", result) } ``` 以上代码创建了一个Redis客户端，并使用`SetNX`方法设置了一个键值对，并给这个键值设置了过期时间。`SetNX`方法返回一个布尔值表示操作是否成功。在示例中，我们将键名设置为"mykey"，值设置为"myvalue"，过期时间设置为1小时。你可以根据你的实际需求修改这些值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值