redis连接池 golang redis连接池以及超时设置

转载

梦想启航吧 2023-08-15 17:18:05

文章标签 redis连接池 golang redis golang 数据库验证码 文章分类 Redis 数据库

使用go-redis作为连接工具
特别以下这一部分作为连接池等一些常用配置。放在最前面方便查阅。

rdb := redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",
		DB:       0,
		Username: "",
		Password: "",
		Network:  "tcp",

		//连接池容量及闲置连接数量
		PoolSize:     15, // 连接池最大socket连接数，默认为4倍CPU数， 4 * runtime.NumCPU
		MinIdleConns: 10, //在启动阶段创建指定数量的Idle连接，并长期维持idle状态的连接数不少于指定数量；。

		//超时
		DialTimeout:  5 * time.Second, //连接建立超时时间，默认5秒。
		ReadTimeout:  3 * time.Second, //读超时，默认3秒， -1表示取消读超时
		WriteTimeout: 3 * time.Second, //写超时，默认等于读超时
		PoolTimeout:  4 * time.Second, //当所有连接都处在繁忙状态时，客户端等待可用连接的最大等待时长，默认为读超时+1秒

		//闲置连接检查包括IdleTimeout，MaxConnAge
		IdleCheckFrequency: 60 * time.Second, //闲置连接检查的周期，默认为1分钟，-1表示不做周期性检查，只在客户端获取连接时对闲置连接进行处理。
		IdleTimeout:        5 * time.Minute,  //闲置超时，默认5分钟，-1表示取消闲置超时检查
		MaxConnAge:         0 * time.Second,  //连接存活时长，从创建开始计时，超过指定时长则关闭连接，默认为0，即不关闭存活时长较长的连接

		//命令执行失败时的重试策略
		MaxRetries:      0,                      // 命令执行失败时，最多重试多少次，默认为0即不重试
		MinRetryBackoff: 8 * time.Millisecond,   //每次计算重试间隔时间的下限，默认8毫秒，-1表示取消间隔
		MaxRetryBackoff: 512 * time.Millisecond, //每次计算重试间隔时间的上限，默认512毫秒，-1表示取消间隔

		可自定义连接函数
		Dialer: func(ctx context.Context, network, addr string) (net.Conn, error) {
			netDialer := &net.Dialer{
				Timeout:   5 * time.Second,
				KeepAlive: 5 * time.Minute,
			}
			return netDialer.Dial("tcp", "127.0.0.1:6379")
		},

		//钩子函数
		OnConnect: func(ctx context.Context, cn *redis.Conn) error { //仅当客户端执行命令时需要从连接池获取连接时，如果连接池需要新建连接时则会调用此钩子函数
			fmt.Printf("conn=%v\n", cn)
			return nil
		},
	})

1、测试连接redis

package main

import (
	"context"
	"fmt"
	"/go-redis/redis/v8"
)

// Background返回一个非空的Context。 它永远不会被取消，没有值，也没有期限。
// 它通常在main函数，初始化和测试时使用，并用作传入请求的顶级上下文。
var ctx = context.Background()

var DB *redis.Client

func main() {
	rdb := redis.NewClient(&redis.Options{
		// 需要修改成你的配置，本地无需修改
		Addr:     "127.0.0.1:6379",
		Password: "",
		DB:       0,
	})
	_, err := rdb.Ping(ctx).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("连接成功")
	// 成功连接将其赋值给全局变量
	DB = rdb
}

2、go-redis操作String

func OperateString() {
	// 测试添加
	res1, err := DB.Set(ctx, "name", "kevin", time.Minute).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("插入成功:%s\n", res1)

	// 同时多行插入
	res2, err := DB.MSet(ctx, "car", "BMW", "flower", "ross").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("插入多行成功：%s\n", res2)

	// 获取
	res3, err := DB.Get(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("key=name value=%s\n", res3)

	// 追加
	res4, err := DB.Append(ctx, "car", "benz").Result()
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("追加成功:%d", res4)

	// 获取长度
	res5, err := DB.StrLen(ctx, "car").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("长度为：%d\n", res5)

	// value值增加1
	DB.MSet(ctx, "age", 15).Result()
	res6, err := DB.Incr(ctx, "age").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res6)

	// 按照指定的值增加
	res7, err := DB.IncrBy(ctx, "age", 4).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("增长后的age值：", res7)

	// 一次获取多对值
	res8, err := DB.MGet(ctx, "age", "car", "flower").Result()
	if err != nil {
		fmt.Println(err)
	}
	for _, v := range res8 {
		fmt.Println(v)
	}

	// 从指定的位置获取值
	res9, err := DB.GetRange(ctx, "car", 0, 1).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("值为：", res9)

	// 设置键的过期时间
	res10, err := DB.SetEX(ctx, "animal", "bird", 30*time.Minute).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res10)
}

3、go-redis操作List

func OperateList() {
	// 添加
	DB.LPush(ctx, "name", "marry")
	DB.LPush(ctx, "name", "tom")
	DB.LPush(ctx, "name", "jack")

	// 查看
	res2, err := DB.LRange(ctx, "mame", 0, -1).Result()
	if err != nil {
		fmt.Println(err)
	}
	for _, v := range res2 {
		fmt.Println(v)
	}

	// 导出一个
	// 获取列表长度
	length, err := DB.LLen(ctx, "name").Uint64()
	fmt.Println("长度为：", length)
	res3, err := DB.LPop(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("pop的结果是：%s\n", res3)
	length, err = DB.LLen(ctx, "name").Uint64()
	fmt.Println("长度为：", length)

	//从左边删除一个
	n, err := DB.LRem(ctx, "name", 1, "jack").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("删除了%d\n", n)

	// 将下标为index的value改为指定的值
	res4, err := DB.LSet(ctx, "name", 1, "ross").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("改值后", res4)
}

4、go-redis操作Set

func OperateSet() {
	// 添加
	DB.SAdd(ctx, "name", "xh")
	DB.SAdd(ctx, "name", "ross")
	DB.SAdd(ctx, "name", "kevin")
	DB.SAdd(ctx, "name", "jack")
	DB.SAdd(ctx, "name", "scoot")
	DB.SAdd(ctx, "car", "scoot")
	DB.SAdd(ctx, "car", "ross")
	DB.SAdd(ctx, "car", "dz")

	// 获取
	res1, err := DB.SMembers(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	for _, v := range res1 {
		fmt.Println(v)
	}

	// 删除
	res2, err := DB.SRem(ctx, "name", "xh").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("删除%d\n个", res2)

	// 判断集合中是否有该值
	res3, err := DB.SIsMember(ctx, "name", "kevin").Result()
	if err != nil {
		fmt.Println(err)
	}
	if res3 {
		fmt.Println("该集合中有kevin")
	}

	//	获取集合元素的个数
	res4, err := DB.SCard(ctx, "name").Uint64()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("此时集合中有%d个\n", res4)

	// 随机吐出1个
	res5, err := DB.SPop(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("随机突出的一个元素是：", res5)

	// 随机吐出n个
	res6, err := DB.SRandMemberN(ctx, "name", 3).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res6)

	// 返回两个集合的交集
	res7, err := DB.SInter(ctx, "name", "car").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res7)

	// 返回两个集合的并集
	res8, err := DB.SUnion(ctx, "name", "car").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res8)

	// 返回两个集合的差集【name中有，而car中没有】
	res9, err := DB.SDiff(ctx, "name", "car").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res9)
}

5、go-redis操作Hash

func OperateHash() {
	// 添加
	DB.HSet(ctx, "user001", "name", "kevin")
	DB.HSet(ctx, "user001", "age", 15)
	DB.HSet(ctx, "user001", "year", 1999)
	DB.HSet(ctx, "user001", "country", "China")

	DB.HSet(ctx, "user002", "name", "ross")
	DB.HSet(ctx, "user002", "age", 17)
	DB.HSet(ctx, "user002", "year", 2000)
	DB.HSet(ctx, "user002", "country", "American")

	// 获取指定filed
	name002, err := DB.HGet(ctx, "user002", "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("user002_name=", name002)

	// 批量设置
	res1, err := DB.HMSet(ctx, "user003", "name", "zhangsan", "age", 12).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res1)

	// 判断key是否存在
	res2, err := DB.HExists(ctx, "user002", "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res2)

	// 查看该hash集合的所有value
	res3, err := DB.HVals(ctx, "user001").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res3)

	// 在指定的值加上增量1
	res4, err := DB.HIncrBy(ctx, "user001", "age", 1).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res4)
}

6、go-redis操作Zset

func OperateZset() {
	// 添加
	DB.ZAdd(ctx, "name", &redis.Z{
		Score:  2,
		Member: "kevin",
	})
	DB.ZAdd(ctx, "name", &redis.Z{
		Score:  3,
		Member: "jack",
	})
	DB.ZAdd(ctx, "name", &redis.Z{
		Score:  1,
		Member: "ross",
	})
	DB.ZAdd(ctx, "name", &redis.Z{
		Score:  5,
		Member: "tom",
	})

	//获取
	res1, err := DB.ZRange(ctx, "name", 1, 3).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res1)

	//返回指定分数之间结果集
	res2, err := DB.ZRangeByScore(ctx, "name", &redis.ZRangeBy{
		Min: "0",
		Max: "3",
	}).Result()
	fmt.Println(res2)

	//删除某一个元素
	res3, err := DB.ZRem(ctx, "name", "jack").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res3)

	// 返回集合中的排名
	res4, err := DB.ZRank(ctx, "name", "tom").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res4)
}

7 、一些常规库操作

func OperateDB() {
	// 查看所有的键
	res, err := DB.Keys(ctx, "*").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res)
	// 查看某一个键是否存在
	n, err := DB.Exists(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(n)
	// 查看键的类型
	str, err := DB.Type(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(str)
	// 为键设置过期时间
	success, err := DB.Expire(ctx, "name", 5*time.Minute).Result()
	if err != nil {
		fmt.Println(err)
	}
	if success {
		fmt.Println("设置时间成功")
	}
	//查看键的过期时间
	t, err := DB.TTL(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(t)
	time.Sleep(5 * time.Second)
	t, err = DB.TTL(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(t)

	//更换数据库
	n, err = DB.DBSize(ctx).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("数据库的大小为", n)

	//删除键
	n, err = DB.Del(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("删除成功")

	//删除库中所有的数据
	DB.FlushDB(ctx).Result()

}

8、一个简单的案例

如何使用redis实现一个手机验证码功能，主要有以下两个功能：

验证码3min分钟就会过期
验证码每天只能发送三次

package main

import (
	"context"
	"fmt"
	"/go-redis/redis/v8"
	"math/rand"
	"strconv"
	"time"
)

var ctx = context.Background()

var DB *redis.Client

func init() {

	rdb := redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",
		Password: "",
		DB:       0,
	})
	res, err := rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("connect ok:", res)
	DB = rdb
}

// PhoneCode 实现手机验证码的功能
func PhoneCode(phone string, code string) {
	// 一个手机号码一天只能发三次验证码
	CountKey := "PhoneCode" + phone + "Count:"
	// 每个验证的时间为3min
	CodeKey := "PhoneCode" + phone + "Code:"

	// 取出Key对应的次数
	count, _ := DB.Get(ctx, CountKey).Uint64()

	if count < 3 {
		// 在范围内，对应数字加一即可
		_, err := DB.Incr(ctx, CountKey).Uint64()
		if err != nil {
			panic("验证码数字增长的时候发生错误")
		}
		_, err = DB.SetEX(ctx, CodeKey, code, 3*time.Minute).Result()
		if err != nil {
			panic("原始状态大于0小于3时，添加code时候发生错误")
		}
	} else if count >= 3 {
		// 该手机号码对应的count数已超过限制
		fmt.Println("今天该手机号发送验证的次数已经达到上限")
	}
	// 业务逻辑完成
}
// PhoneCodeCheck 验证对应验证码是否对应
func PhoneCodeCheck(phone string, code string) bool {
	key := "PhoneCode" + phone + "Code:"
	res, err := DB.Get(ctx, key).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res)
	return res == code

}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。