[golang gin框架] 24.Gin 商城项目-redis讲解以及操作

zhoupenghui168

已于 2023-04-20 23:03:15 修改

阅读量1.7k

点赞数 2

分类专栏： golang # gin框架开发文章标签： go-redis redis Powered by 金山文档

于 2023-04-16 16:29:54 首次发布

本文链接：https://blog.csdn.net/zhoupenghui168/article/details/130173214

版权

golang 同时被 2 个专栏收录

156 篇文章 57 订阅

订阅专栏

gin框架开发

52 篇文章 26 订阅

订阅专栏

一.reids相关文章

Redis五种数据类型及其应用场景

REDIS中的缓存穿透，缓存击穿，缓存雪崩原因以及解决方案

redis实现用户签到，统计活跃用户，用户在线状态，用户留存率

[golang gin框架] 12.Gin 商城项目-base64Captcha生成图形验证码以及分布式架构中配置Captcha

[go学习笔记.第十七章.redis的使用] 1.redis的使用

linux下yum安装redis服务

二.golang中使用redis

redis介绍以及安装见: [go学习笔记.第十七章.redis的使用] 1.redis的使用

在这里使用go-redis插件来对接redis
模块： https://github.com/go-redis/redis
文档： https://redis.uptrace.dev/
安装go-redis:
下载go-redis,在main.go目录下,执行: go get github.com/redis/go-redis/v9,然后:
import (
"github.com/redis/go-redis/v9"
)
就可以使用go-redis了
下面看看redis相关代码:

1.redisCore.go

该文件中是连接redis数据库核心代码

package models

//redis官网: github.com/go-redis
//下载go-redis: go get github.com/redis/go-redis/v9
//连接redis数据库核心代码

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

//Go1.7 加入了一个新的标准库 context，它定义了 Context 类型，专门用来简化 对于处理
单个请求的多个 goroutine 之间与请求域的数据、取消信号、截止时间等相关操作
var ctx = context.Background()
//全局使用,就需要把定义成公有的
var ctxRedis = context.Background()

var (
    RedisDb *redis.Client
)

//自动初始化数据库
func init() {
    RedisDb = redis.NewClient(&redis.Options{
        Addr:     "127.0.0.1:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    //连接redis
    _, err := RedisDb.Ping(ctxRedis).Result()
    //判断连接是否成功
    if err != nil {
        println(err)
    }
}

2.redisOper.go

操作redis案例说明

package models

import (
    "context"
    "fmt"
    "time"
)

var ctx = context.Background()

type RedisOper struct {
}

//RedisDb调用上面代码中的RedisDb

//操作字符串:Set
func (r RedisOper) Set(key string, value string) error {

    err := RedisDb.Set(ctx, key, value, 0).Err()
    return err
}

//操作字符串:Get
func (r RedisOper) Get(key string) string {

    val, err := RedisDb.Get(ctx, key).Result()
    if err != nil {
        fmt.Println(err)
        return ""
    }
    return val
}

//操作列表（list）
func (r RedisOper) ListOper() {
    RedisDb.LPush(ctx, "hobby", "吃饭")
    RedisDb.LPush(ctx, "hobby", "睡觉")
    RedisDb.RPush(ctx, "hobby", "写代码")

    hobby, _ := RedisDb.LRange(ctx, "hobby", 0, -1).Result()
    fmt.Println(hobby)
}

//操作集合（set）
func (r RedisOper) SetOper() {
    RedisDb.SAdd(ctx, "hobby", "吃饭", "睡觉", "吃饭")
    RedisDb.SAdd(ctx, "hobby", "写代码")
    hobby, _ := RedisDb.SMembers(ctx, "hobby").Result()
    fmt.Println(hobby)
}


//操作哈希（hash）
func (r RedisOper) SetOper() {
    err := RedisDb.HMSet(ctx, "userinfo", map[string]interface{}{
        "username": "张三",
        "age":      "20",
    }).Err()

    if err != nil {
        fmt.Println(err)
    }
    userinfo, _ := RedisDb.HGetAll(ctx, "userinfo").Result()

    fmt.Println(userinfo)

    fmt.Println(userinfo["username"])
}

//设置过期时间
func (r RedisOper) SetExpire() {
    RedisDb.Set(ctx, "age", 20, time.Second*10)

    RedisDb.LPush(ctx, "hobby", "吃饭")
    RedisDb.Expire(ctx, "hobby", time.Second*10)
}

//删除数据
func (r RedisOper) Del() {
    RedisDb.Set(ctx, "age", 20, 0)
    RedisDb.Del(ctx, "age")
    RedisDb.LPush(ctx, "hobby", "吃饭")
    RedisDb.FlushAll(ctx)
}

3.Redis 分布式架构订阅发布

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。
Redis 客户端可以订阅任意数量的频道。
下图展示了频道 channel1 ，以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1
之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时，这个消息就会被发送给订阅它的三个客户端:

案例演示:

redis_pub.go是一个发布的频道端,发布消息,redis_sub1.go,redis_sub2.go,redis_sub3.go是三个客户端,订阅redis_pub.go这个频道端对应频道发布的消息,当频道端发布消息时,三个订阅的客户端会各自订阅频道收到的消息.代码如下:

redis_pub.go

package main

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

var ctx = context.Background()

func main() {
    //连接redis数据库
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    _, err := rdb.Ping(ctx).Result()
    if err != nil {
        fmt.Println("redis数据库连接失败")
    } else {
        fmt.Println("redis数据库连接成功...")
    }

    //发布消息:
    rdb.Publish(ctx, "ch", "我是ch的数据...")

    rdb.Publish(ctx, "ch2", "我是ch2的数据...")
}

假如redis_sub1.go订阅了ch这个频道,redis_sub2.go,redis_sub3.go订阅了ch,ch2这两个频道,对应的代码如下:

redis_sub1.go

package main

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

var ctx = context.Background()

func main() {
    //连接redis数据库
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    _, err := rdb.Ping(ctx).Result()
    if err != nil {
        fmt.Println("redis数据库连接失败")
    } else {
        fmt.Println("redis数据库连接成功...")
    }
    //订阅消息
    pubsub := rdb.Subscribe(ctx, "ch")
    ch := pubsub.Channel()
    for msg := range ch {
        fmt.Println(msg.Channel, msg.Payload)
    }
}

redis_sub2.go,redis_sub3.go

package main

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

var ctx = context.Background()

func main() {
    //连接redis数据库
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    _, err := rdb.Ping(ctx).Result()
    if err != nil {
        fmt.Println("redis数据库连接失败")
    } else {
        fmt.Println("redis数据库连接成功...")
    }
    //订阅消息
    pubsub := rdb.Subscribe(ctx, "ch")
    ch := pubsub.Channel()
    for msg := range ch {
        fmt.Println(msg.Channel, msg.Payload)
    }
   //订阅消息
    pubsub2 := rdb.Subscribe(ctx, "ch2")
    ch2 := pubsub2.Channel()
    for msg2 := range ch2 {
        fmt.Println(ms2g.Channel, msg2.Payload)
    }
}

三.项目中使用redis

修改redisCore.go核心代码

(1).redis配置修改

把redis配置放入conf/app.ini下,app.ini增加如下代码:

[redis]
ip          = localhost
port        = 6379
database    = 1
redisEnable = true

(2).完善redisCore.go

package models

//redis官网: github.com/go-redis
//下载go-redis: go get github.com/redis/go-redis/v9
//连接redis数据库核心代码

import (
    "context"
    "fmt"
    "github.com/redis/go-redis/v9"
    "gopkg.in/ini.v1"
    "os"
)

//全局使用,就需要把定义成公有的
var ctxRedis = context.Background()

var (
    RedisDb *redis.Client
)

//是否开启redis
var redisEnable bool

//自动初始化数据库
func init() {
    //加载配置文件
    config, iniErr := ini.Load("./conf/app.ini")
    if iniErr != nil {
        fmt.Printf("Fail to read file: %v", iniErr)
        os.Exit(1)
    }
    //获取redis配置
    ip := config.Section("redis").Key("ip").String()
    port := config.Section("redis").Key("port").String()
    redisEnable, _ = config.Section("redis").Key("redisEnable").Bool()
    
    //判断是否开启redis
    if redisEnable {
        RedisDb = redis.NewClient(&redis.Options{
            Addr:     ip + ":" + port,
            Password: "", // no password set
            DB:       0,  // use default DB
        })

        //连接redis
        _, err := RedisDb.Ping(ctxRedis).Result()
        //判断连接是否成功
        if err != nil {
            println(err)
        }
    }
}

2.创建redisCache.go

里面重构Set,Get方法

package models

import (
    "encoding/json"
    "time"
)

type RedisCache struct {
}

//设置
func (r RedisCache) Set(key string, value interface{}, expiration int) {
    if redisEnable {  //判断是否开启redis
        v, err := json.Marshal(value)  //value是一个空接口类型,里面可以是字符串,切片,结构体,所以转成json保存
        if err == nil {
            //RedisDb:调用redisCore.go中的RedisDb
            RedisDb.Set(ctxRedis, key, string(v), time.Second*time.Duration(expiration))
        }
    }
}

//获取
func (r RedisCache) Get(key string, obj interface{}) bool {
    if redisEnable { //判断是否开启redis
        valueStr, err1 := RedisDb.Get(ctxRedis, key).Result()
        if err1 == nil && valueStr != "" {
            err2 := json.Unmarshal([]byte(valueStr), obj)
            return err2 == nil
        }
    }
    return false
}

3.商品首页控制器IndexController.go使用redis

package frontend

//首页

import (
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
    "goshop/models"
    "net/http"
    "strings"
)

type IndexController struct {
}

func (con IndexController) Index(c *gin.Context) {
    //实例化redisCache结构体
    redisCache := models.RedisCache{}

    //获取顶部导航列表
    topNavList := []models.Nav{}
    //判断redis中是否存在数据
    if hasTopNavList := redisCache.Get("topNavList", &topNavList); !hasTopNavList {  //不存在数据,则从数据中获取数据,并把数据保存到redis
        models.DB.Where("status = 1 AND position = 1").Find(&topNavList)
        redisCache.Set("topNavList", topNavList, 3600)
    }

    //获取网站轮播图数据
    focusList := []models.Focus{}
    if hasFocusList := redisCache.Get("focusList", &focusList); !hasFocusList {
        models.DB.Where("status = 1 AND focus_type = 1").Find(&focusList)
        redisCache.Set("focusList", focusList, 3600)
    }

    //获取分类数据
    goodsCateList := []models.GoodsCate{}
    if hasGoodsCateList := redisCache.Get("goodsCateList", &goodsCateList); !hasGoodsCateList {
        //获取分类列表以及下级分类,并进行排序
        models.DB.Where("pid = ? AND status = ?", 0, 1).Order("sort DESC").Preload("GoodsCateItems", func(db *gorm.DB) *gorm.DB {
            return db.Where("goods_cate.status = 1").Order("goods_cate.sort DESC")
        } ).Find(&goodsCateList)
        redisCache.Set("goodsCateList", goodsCateList, 3600)
    }

    //获取中间导航
    middleNavList := []models.Nav{}
    if hasMiddleNavList := redisCache.Get("middleNavList", &middleNavList); !hasMiddleNavList {
        models.DB.Where("status = ? AND position = ? ", 1, 2).Find(&middleNavList)
        redisCache.Set("middleNavList", middleNavList, 3600)
        //循环,获取中间导航对应的商品数据
        for i:= 0; i < len(middleNavList);i++{
            //获取管理商品
            //替换字符串中的中文逗号strings.ReplaceAll()
            relation := strings.ReplaceAll(middleNavList[i].Relation, "，", ",")
            //把字符串转换成切片
            relationIds := strings.Split(relation, ",")
            //获取对应的商品信息
            goodsList := []models.Goods{}
            models.DB.Where("status = ?", 1).Where("id in ?", relationIds).Select("id, title, goods_img, price").Find(&goodsList)
            middleNavList[i].GoodsItems = goodsList
        }
    }

    //获取手机分类下面的商品
    phoneList := []models.Goods{}
    if hasPhoneList := redisCache.Get("phoneList", &phoneList); !hasPhoneList {
        phoneList := models.GetGoodsByCategory(23, "best", 10)
        redisCache.Set("phoneList", phoneList, 3600)
    }

    c.HTML(http.StatusOK, "frontend/index/index.html", gin.H{
        "topNavList": topNavList,
        "focusList": focusList,
        "goodsCateList": goodsCateList,
        "middleNavList": middleNavList,
        "phoneList": phoneList,
    })
}

[上一节][golang gin框架] 23.Gin 商城项目-前台templates模板分离,首页,顶部导航,轮播图左侧分类数据渲染

[下一节][golang gin框架] 25.Gin 商城项目-配置清除缓存以及前台列表页面数据渲染公共数据