框架开发(三):框架开发-集成Redis

1

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

1
2
3
4
5
6
7
8
9

...
[redis]
host=127.0.0.1
port=6379
# 密码
password=
# 默认DB
default_db=0
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

/**
 * @description: Redis配置信息
 * @user: Shershon
 */
type RedisConfig struct {
	Host      string `ini:"host"`
	Port      string `ini:"port"`
	DefaultDB string `ini:"default_db"`
	Password  string `ini:"password"`
}

1

var RedisClient  *redis.Client

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/**
 * @description: 连接Redis
 * @user: Shershon
 * @date 2021-02-23 17:06:27
 */
func connectRedis() {
	RedisClient = redis.NewClient(&redis.Options{
		Addr:     RedisConfigInstance.Host + ":" + RedisConfigInstance.Port,
		Password: RedisConfigInstance.Password, // 密码
		DB:       RedisConfigInstance.DefaultDB, // 默认数据库
		PoolSize: RedisConfigInstance.PoolSize, // 连接池大小
	})
	// 设置连接超时时间
	duration, err := time.ParseDuration(RedisConfigInstance.TimeOut)
	ctx, cancelFunc := context.WithTimeout(context.Background(), duration)
	defer cancelFunc()
	result, err := RedisClient.Ping(ctx).Result()
	fmt.Println("redis: " + result)
	BusErrorInstance.ThrowError(err)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var ctx = context.Background()
func (r RedisController) Normal() error  {
	opType := r.GetParam("opType")
	key := r.GetParam("key")
	if opType == "1" {
		// Set
		val := r.GetParam("val")
		err := RedisClient.Set(ctx, key, val, time.Second * 60).Err()
		if err != nil {
			return r.Error("Set: " + err.Error())
		}
		return r.Success(nil)
	} else  {
		// Get
		result, err := RedisClient.Get(ctx, key).Result()
		if err == redis.Nil {
			return r.Error(key + " not exist")
		} else if err != nil {
			return r.Error("Get: " + err.Error())
		}
		return r.Success(result)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/**
* @description: 有序集合添加
* @user: Shershon
* @receiver r RedisController
*/
func (r RedisController) SortSet() error  {
	opType := r.GetParam("opType")
	key := r.GetParam("key")
	if opType == "1" {
		// 有序集合添加
		zs := []*redis.Z{
			{Member: "小张",Score: 88},
			{Member: "小李",Score: 90},
			{Member: "小明",Score: 80},
			{Member: "小英",Score: 70},
			{Member: "小赵",Score: 95},
			{Member: "小王",Score: 75},
			{Member: "笨蛋",Score: 40},
		}
		result, err := RedisClient.ZAdd(ctx, key, zs...).Result()
		if err != nil {
			return r.Error(err.Error())
		}
		return r.Success(result)
	} else  {
		resultMap := make(map[string]interface{})
		// 获取成员数
		val := RedisClient.ZCard(ctx, key).Val()
		resultMap["获取成员数"] = val
		// 获取指定分数区间的成员数
		resultMap["70分-90分成员数"] = RedisClient.ZCount(ctx, key, "70", "90").Val()
		// 返回有序集中指定分数区间内的成员，分数从高到低排序
		result, _ := RedisClient.ZRevRangeByScoreWithScores(ctx, key, &redis.ZRangeBy{
			Min: "0", Max: "100", Offset: 0, Count: 3,
		}).Result()
		resultMap["分数前三排名"] = result
		// 返回分数值
		f, _ := RedisClient.ZScore(ctx, key, "小张").Result()
		resultMap["小张的分数"] = f
		// 给笨蛋加60分
		f2, err := RedisClient.ZIncrBy(ctx, key, 60.0, "笨蛋").Result()
		fmt.Println(err)
		fmt.Printf("新分数:%v \n",f2)
		result2, _ := RedisClient.ZRevRangeByScoreWithScores(ctx, key, &redis.ZRangeBy{
			Min: "0", Max: "100", Offset: 0, Count: 3,
		}).Result()
		resultMap["调整分后排名"] = result2
		return r.Success(resultMap)
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
 * @description: 哈希类型操作
 * @user: Shershon
 * @receiver r RedisController
 * @return error
 */
func (r RedisController) Hash() error {
	//  将哈希表 key 中的字段 field 的值设为 value 。
	opType := r.GetParam("opType")
	result := make(map[string]interface{})
	if opType == "1" {
		// Hset:将哈希表 key 中的字段 field 的值设为 value 。
		err := RedisClient.HSet(ctx, "HSet-key", "field_name", "张三").Err()
		// HmSET:同时将多个 field-value (域-值)对设置到哈希表 key 中。
		err = RedisClient.HMSet(ctx, "HMSet-key", "field1","val1","field2","val2","field3","val3").Err()
		if err != nil {
			return  r.Error(err.Error())
		}
		return  r.Success(nil)
	} else {
		// HEXISTS:查看哈希表key中，指定的字段是否存在。
		res, err := RedisClient.HExists(ctx, "HSet-key", "field_name").Result()
		result["HExists"] = res
		// HGET:获取存储在哈希表中指定字段的值。
		s, err := RedisClient.HGet(ctx, "HMSet-key", "field2").Result()
		result["HGet"] = s
		//HGETALL:获取在哈希表中指定 key 的所有字段和值
		m, err := RedisClient.HGetAll(ctx, "HMSet-key").Result()
		result["HGet"] = m
		// Hkeys:获取所有哈希表中的字段
		strings, err := RedisClient.HKeys(ctx, "HMSet-key").Result()
		result["HKeys"] = strings
		// HVALS:获取哈希表中所有值。
		i, err := RedisClient.HVals(ctx, "HMSet-key").Result()
		result["HVals"] = i
		// HMGET:获取所有给定字段的值
		i2, err := RedisClient.HMGet(ctx, "HMSet-key", "field1", "field2", "field3").Result()
		result["HMGet"] = i2
		if err != nil {
			return  r.Error(err.Error())
		}
		return  r.Success(result)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
 * @description: 列表类型操作
 * @user: Shershon
 * @receiver r RedisController
 * @return error
 */
func (r RedisController) List() error {
	opType := r.GetParam("opType")
	key := "List:Rows"
	result := make(map[string]interface{})
	if opType == "1" {
		// LPUSH: 将一个或多个值插入到列表头部
		err := RedisClient.LPush(ctx, key, "PHP", "C", "GO", "JAVA", "PYTHON").Err()
		// RPUSH:将一个或多个值插入到列表的尾部
		err = RedisClient.LPush(ctx, key, "C++", "HTML").Err()
		if err != nil {
			return  r.Error(err.Error())
		}
	} else if opType == "2"  {
		// BLPOP:移出并获取列表的第一个元素(阻塞)
		duration, err := time.ParseDuration("10s")
		res, err := RedisClient.BLPop(ctx, duration, key).Result()
		result["BLPOP"] = res
		//BRPOP:移出并获取列表的最后一个元素(阻塞)
		strings, err := RedisClient.BRPop(ctx, duration, key).Result()
		result["BRPop"] = strings
		// LPOP:移出并获取列表的第一个元素
		s, err := RedisClient.LPop(ctx, key).Result()
		result["LPop"] = s
		// RPOP:移除列表的最后一个元素，返回值为移除的元素。
		s2, err := RedisClient.RPop(ctx, key).Result()
		result["RPOP"] = s2
		if err != nil {
			return  r.Error(err.Error())
		}
	} else {
		//LINDEX: 通过索引获取列表中的元素
		s, err := RedisClient.LIndex(ctx, key, 0).Result()
		result["LIndex-0"] = s
		//LRANGE:获取列表指定范围内的元素
		strings, err := RedisClient.LRange(ctx, key, 0, 3).Result()
		result["LRange"] = strings
		if err != nil {
			return  r.Error(err.Error())
		}
	}
	return  r.Success(result)
}