redis在Go项目中的使用

redis安装

windows docker 安装 史上最详细Docker安装Redis （含每一步的图解）实战_docker redis_宁在春的博客-CSDN博客

ifconfig | grep "inet " | grep -v 127.0.0.1

redis mac docker 安装 mac系统Docker安装Redis教程

docker run -d --name redis -p 6379:6379 redis:6.2.4 redis-server --appendonly yes --requirepass "zxcv123"

• docker run -d ：后台运行

• --name redis：服务名

• -p 6379:6379    ： 将容器6379端口映射到主机6379端口

• redis-server --appendonly yes：在容器执行redis-server启动命令，并打开redis持久化配置

• --requirepass "你的密码" ：设置密码

docker exec -ti 95b40 redis-cli

127.0.0.1：6379

发现提示(error) NOAUTH Authentication required.这是因为需要输入密码进行验证。解决方案：auth 你的密码

quit 退出

Tips:远程连接时，如果不知道容器运行的地址，可以通过这个命令查看：

docker inspect redis | grep IPAddress

docker inspect --format '{{ .NetworkSettings.IPAddress}}' id

docker inspect

Redis的基本使用

说明：Redis安装好后，默认有16个数据库，初始默认使用0号库，标号是0…15

1.添加key-val[set]

2.查看当前redis的所有key [keys*]

3.获取key对应的值.[get key]

4.切换redis数据库[select index]

5.如何查看当前数据库的key-val数量[dbsize]

6.清空当前数据库的key-val和清空所有数据库的key-val[flushdb flushall]

Go链接到Redis

cache/common.go  初始化

var RedisClient *redis.Client   设定全局变量

package cache

import (
	"Todolist/config"
	"fmt"
	"github.com/go-redis/redis"
)

var RedisClient *redis.Client

func RedisInit() {
	rConfig := config.Config.Redis
	client := redis.NewClient(&redis.Options{
		Addr:     fmt.Sprintf("%s:%s", rConfig.RedisHost, rConfig.RedisPort),
		Password: rConfig.RedisPassword,
		DB:       rConfig.RedisDbName,
	})
	_, err := client.Ping().Result()
	if err != nil {
		panic(err)

	}
	RedisClient = client
}

config/local/ config.yaml

system:
  domain: Todolist
  version: 1.0
  appEnv: "test"
  HttpPort: ":4000"
  Host: "localhost"

mysql:
  default:
    dialect: "mysql"
    dbhost: "你的host"
    dbport: "你的端口"
    dbName: "你的数据库名字"
    userName: ""
    password: "你的密码"
    charset: "utf8mb4"

redis:
  redisDbName: 1    使用的哪一个数据库  0-15  一共16个
  redisHost: 你的host  这里不用引号
  redisPort: 端口
  redisPassword: 密码
  redisNetwork: tcp

config/config.go

package config

import (
	"github.com/spf13/viper"
	"os"
)

var Config *Conf

type Conf struct {
	System *System           `yaml:"system"`
	MySql  map[string]*MySql `yaml:"mysql"`
	Redis  *Redis            `yaml:"redis"`
}

type MySql struct {
	Dialect  string `yaml:"dialect"`
	DbHost   string `yaml:"dbHost"`
	DbPort   string `yaml:"dbPort"`
	DbName   string `yaml:"dbName"`
	UserName string `yaml:"userName"`
	Password string `yaml:"password"`
	Charset  string `yaml:"charset"`
}

type Redis struct {
	RedisHost     string `yaml:"redisHost"`
	RedisPort     string `yaml:"redisPort"`
	RedisPassword string `yaml:"redisPassword"`
	RedisDbName   int    `yaml:"redisDbName"`
	RedisNetwork  string `yaml:"redisNetwork"`
}

type System struct {
	AppEnv   string `yaml:"appEnv"`
	Domain   string `yaml:"domain"`
	Version  string `yaml:"version"`
	HttpPort string `yaml:"httpPort"`
	Host     string `yaml:"host"`
}

func InitConfig() {
	workDir, _ := os.Getwd()
	viper.SetConfigName("config")
	viper.SetConfigType("yaml")
	viper.AddConfigPath(workDir + "/config/local")
	viper.AddConfigPath(workDir)
	err := viper.ReadInConfig()
	if err != nil {
		panic(err)
	}
	err = viper.Unmarshal(&Config)
	if err != nil {
		panic(err)
	}
}

这里这个InitConfig 方法 一般都是在main 中初始化使用

cache/key.go  KEY

package cache

import (
	"fmt"
	"strconv"
)

const (
	RankKey = "rank"
)

// TaskViewKey 点击数的key
func TaskViewKey(id uint) string {
	//key ="view:task:%s"   s为id  get key 可查找 对应的value
	return fmt.Sprintf("view:task:%s", strconv.Itoa(int(id)))
}

model/task.go

1. View() 方法：

   • 这个方法用于获取任务的点击数。
   • 它首先尝试从 Redis 缓存中使用任务的 ID 作为缓存键获取点击数。
   • 如果成功从 Redis 获取到点击数的字符串表示 (countStr)，然后使用 strconv.ParseUint 将其转换为无符号 64 位整数 (count)。
   • 最后，它将点击数作为返回值返回。

2. AddView() 方法：

   • 这个方法用于增加任务的点击数。
   • 它使用 cache.RedisClient.Incr 方法递增任务的点击数，这意味着它会将点击数加一。
   • 接着，它使用 cache.RedisClient.ZIncrBy 方法，通过指定一个排行榜的键 (cache.RankKey) 和任务的 ID，来递增排行榜中的点击数。这可能用于跟踪任务的热门程度或排名。

总之，这两个方法共同用于管理任务的点击数，将点击数存储在 Redis 缓存中，以便快速检索和更新。

绑定了只有task model模型才能使用的方法

func (Task *Task) View() uint64 {
	// 增加点击数
    
	countStr, _ := cache.RedisClient.Get(cache.TaskViewKey(Task.ID)).Result()
	count, _ := strconv.ParseUint(countStr, 10, 64)
	return count
}

func (Task *Task) AddView() {
	cache.RedisClient.Incr(cache.TaskViewKey(Task.ID))                      // 增加视频点击数
	cache.RedisClient.ZIncrBy(cache.RankKey, 1, strconv.Itoa(int(Task.ID))) // 增加排行点击数
}

逻辑

func (s *TaskSrv) ShowTask(ctx context.Context, req *types.ShowTaskReq) (resp interface{}, err error) {
	u, err := ctl.GetUserInfo(ctx)
	if err != nil {
		utils.LogrusObj.Info(err)
		return
	}
	task, err := dao.NewTaskDao(ctx).FindTaskByIdAndUserId(req.Id, u.Id)
	if err != nil {
		utils.LogrusObj.Info(err)
		return
	}
	task.AddView()
	tResp := &types.ListTaskResp{
		Id:        task.ID,
		Title:     task.Title,
		Content:   task.Content,
		View:      task.View(), //放在内存中 定时写入数据库
		Status:    task.Status,
		CreatedAt: task.CreatedAt.Unix(),
		StartTime: task.StartTime,
		EndTime:   task.EndTime,
	}

	return ctl.RespSuccessWithData(tResp), nil

}