go语言web开发系列之十:gin框架中通过订阅redis消息更新进程内缓存bigcache

已于 2023-06-16 13:28:35 修改
阅读量872 收藏 2
点赞数
分类专栏： 用go做web开发 文章标签： go golang web 缓存 redis
于 2020-12-22 18:24:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43881017/article/details/111561594
版权

一，安装用到的库

1,安装go-redis

liuhongdi@ku:~$ go get -u github.com/go-redis/redis

2,安装bigcache

liuhongdi@ku:~$ go get -u github.com/allegro/bigcache

说明：刘宏缔的go森林是一个专注golang的博客，
网站：https://blog.imgtouch.com
原文: go语言web开发系列之十:gin框架中通过订阅redis消息更新进程内缓存bigcache – 架构森林

说明：作者:刘宏缔 邮箱: 371125307@qq.com

二，演示项目的相关信息

1,项目地址:

GitHub - liuhongdi/digv10: gin框架中通过订阅redis消息更新进程内缓存bigcache

2,项目功能：演示redis+bigcache两级缓存，

                    通过订阅redis消息更新进程内缓存bigcache

3,项目结构：如图:

三，go代码说明

1，config/config.yaml

Database:
  DBType: mysql
  UserName: root
  Password: password
  Host: 127.0.0.1:3306
  DBName: dig
  Charset: utf8
  ParseTime: True
  MaxIdleConns: 10
  MaxOpenConns: 30
Server:
  RunMode: debug
  HttpPort: 8000
  ReadTimeout: 60
  WriteTimeout: 60
Redis:
  Addr: 127.0.0.1:6379
  Password:

2,controller/setController.go

package controller

import (
	"github.com/gin-gonic/gin"
	"github.com/liuhongdi/digv10/global"
	"github.com/liuhongdi/digv10/pkg/result"
)

type SetController struct{}

//new
func NewSetController() SetController {
	return SetController{}
}

//发布一条消息到redis
func (u *SetController) Pub(c *gin.Context) {
	resultRes := result.NewResult(c)
	data:=c.Query("id")

	err := global.RedisDb.Publish("articleMsg", data).Err()
	if err != nil {
		resultRes.Error(400,err.Error())
		return
	} else {
		resultRes.Success("发送成功")
	}
}

3,bigcache/article.go

package bigcache

import (
	"encoding/json"
	"fmt"
	"github.com/liuhongdi/digv10/global"
	"github.com/liuhongdi/digv10/model"
	"strconv"
)

//bigcache中索引的名字
func getArticleCacheName(articleId uint64) (string) {
	return "article_"+strconv.FormatUint(articleId,10)
}

//从bigcache得到一篇文章
func GetOneArticleBigCache(articleId uint64) (*model.Article,error) {
	fmt.Println("bigcache:GetOneArticleBigCache")
	key := getArticleCacheName(articleId);
	val,err := global.BigCache.Get(key)
	if (err != nil) {
		return nil,err
	} else {
		article := model.Article{}
		if err := json.Unmarshal([]byte(val), &article); err != nil {
			return nil,err
		}
		return &article,nil
	}
}
//向bigcache保存一篇文章
func SetOneArticleBigCache(articleId uint64,article *model.Article) (error) {
	key := getArticleCacheName(articleId);
	content,err := json.Marshal(article)
	if (err != nil){
		fmt.Println(err)
		return err;
	}
	errSet := global.BigCache.Set(key,[]byte(content))
	if (errSet != nil) {
		return errSet
	}
	return nil
}

4,rediscache/article.go

package rediscache

import (
	"encoding/json"
	"fmt"
	"github.com/go-redis/redis"
	"github.com/liuhongdi/digv10/global"
	"github.com/liuhongdi/digv10/model"
	"strconv"
	"time"
)
//cache的过期时长
const ArticleDuration = time.Minute * 10

//cache的名字
func getArticleCacheName(articleId uint64) (string) {
	return "article_"+strconv.FormatUint(articleId,10)
}

//从redis cache得到一篇文章
func GetOneArticleRedisCache(articleId uint64) (*model.Article,error) {
	fmt.Println("redis:GetOneArticleRedisCache")
	key := getArticleCacheName(articleId);
	val, err := global.RedisDb.Get(key).Result()

	if (err == redis.Nil || err != nil) {
		return nil,err
	} else {
		article := model.Article{}
		if err := json.Unmarshal([]byte(val), &article); err != nil {
			//t.Error(target)
			return nil,err
		}
		return &article,nil
	}
}
//向redis cache保存一篇文章
func SetOneArticleRedisCache(articleId uint64,article *model.Article) (error) {
	key := getArticleCacheName(articleId);
	content,err := json.Marshal(article)
	if (err != nil){
		fmt.Println(err)
		return err;
	}
	errSet := global.RedisDb.Set(key, content, ArticleDuration).Err()
	if (errSet != nil) {
		return errSet
	}
	return nil
}

5,service/article.go

package service

import (
	"fmt"
	"github.com/liuhongdi/digv10/bigcache"
	"github.com/liuhongdi/digv10/dao"
	"github.com/liuhongdi/digv10/global"
	"github.com/liuhongdi/digv10/model"
	"github.com/liuhongdi/digv10/rediscache"
	"strconv"
)

//得到一篇文章的详情
func GetOneArticle(articleId uint64) (*model.Article, error) {
	//get from bigcache
	article,err := bigcache.GetOneArticleBigCache(articleId);
	if ( err != nil) {
		//get from redis
		article,errSel := rediscache.GetOneArticleRedisCache(articleId)
		if (errSel != nil) {
			//get from mysql
			article,errSel := dao.SelectOneArticle(articleId);
			if (errSel != nil) {
				return nil,errSel
			} else {
				//set redis cache
				errSetR := rediscache.SetOneArticleRedisCache(articleId,article)
				if (errSetR != nil){
					fmt.Println(errSetR)
				}
				//set bigcache
				errSetB := bigcache.SetOneArticleBigCache(articleId,article)
				if (errSetB != nil){
					fmt.Println(errSetB)
				}
				return article,nil
			}
			//return nil,errSel
		} else {
			//set bigcache
			errSet := bigcache.SetOneArticleBigCache(articleId,article)
			if (errSet != nil){
				return nil,errSet
			} else {
				return article,errSel
			}
		}

	} else {
		return article,err
	}
}

func GetArticleSum() (int, error) {
	return dao.SelectcountAll()
}

//得到多篇文章，按分页返回
func GetArticleList(page int ,pageSize int) ([]*model.Article,error) {
	articles, err := dao.SelectAllArticle(page,pageSize)
	if err != nil {
		return nil,err
	} else {
		return articles,nil
	}
}

//从redis更新bigcache
func UpdateArticleBigcache(articleId uint64) (error) {
	//get from redis
	article,errSel := rediscache.GetOneArticleRedisCache(articleId)
	if (errSel != nil) {

		return errSel
	} else {
		errSetB := bigcache.SetOneArticleBigCache(articleId, article)
		if (errSetB != nil) {
			fmt.Println(errSetB)
			return errSetB
		}
		return nil
	}
}

//订阅redis消息
func SubMessage(channel string) {
	pubsub := global.RedisDb.Subscribe(channel)
	fmt.Println("subscribe begin Receive")
	_, err := pubsub.Receive()
	if err != nil {
		return
	}
	fmt.Println("subscribe begin channel")
	ch := pubsub.Channel()
	for msg := range ch {
		fmt.Println("message:")
		fmt.Println( msg.Channel, msg.Payload, "\r\n")
		//把字符串转articleid
		articleId,errUint := strconv.ParseUint(msg.Payload, 0, 64)
		if (errUint != nil) {
			fmt.Println(errUint)
		} else {
			//更新bigcache
			errB := UpdateArticleBigcache(articleId)
			if (errB != nil){
				fmt.Println(errB)
			}
		}
	}
}

6,main.go

package main

import (
	"github.com/gin-gonic/gin"
	_ "github.com/jinzhu/gorm/dialects/mysql"
	"github.com/liuhongdi/digv10/global"
	"github.com/liuhongdi/digv10/router"
	"github.com/liuhongdi/digv10/service"
	"log"
)

//init
func init() {
	//setting
	err := global.SetupSetting()
	if err != nil {
		log.Fatalf("init.setupSetting err: %v", err)
	}
    //mysql
	err = global.SetupDBLink()
	if err != nil {
		log.Fatalf("init.setupDBEngine err: %v", err)
	}
    //redis
	err = global.SetupRedisDb()
	if err != nil {
		log.Fatalf("init.SetupRedisDb err: %v", err)
	}
    //bigcache
	err = global.SetupBigCache()
	if err != nil {
		log.Fatalf("init.SetupGlobalCache err: %v", err)
	}

	//redis sub
	go service.SubMessage("articleMsg")
}


func main() {
	//设置运行模式
	gin.SetMode(global.ServerSetting.RunMode)
	//引入路由
	r := router.Router()
	//run
	r.Run(":"+global.ServerSetting.HttpPort)
}

7,global/bigcache.go

package global

import (
	"github.com/allegro/bigcache"
	"log"
	"time"
)
//定义一个全局的bigcache
var (
	BigCache *bigcache.BigCache
)

//创建一个全局的bigcache
func SetupBigCache() (error) {
	config := bigcache.Config {
		Shards: 1024,   			// 存储的条目数量，值必须是2的幂
		LifeWindow: 3*time.Minute,	// 超时后条目被处理
		CleanWindow: 2*time.Minute, //处理超时条目的时间范围
		MaxEntriesInWindow: 0,		// 在 Life Window 中的最大数量，
		MaxEntrySize: 0,			// 条目最大尺寸，以字节为单位
		HardMaxCacheSize: 0,		// 设置缓存最大值，以MB为单位，超过了不在分配内存。0表示无限制分配
	}
    var initErr error
	BigCache, initErr = bigcache.NewBigCache(config)
	if initErr != nil {
		log.Fatal(initErr)
		return initErr
	}
	//BigCache.Stats().
	return nil
}

8,global/redisDb.go

package global

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

var (
	RedisDb *redis.Client
)

//创建redis链接
func SetupRedisDb() (error) {

	RedisDb = redis.NewClient(&redis.Options{
		Addr:     RedisSetting.Addr,
		Password: RedisSetting.Password, // no password set
		DB:       0,  // use default DB
	})

	_, err := RedisDb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

9,global/setting.go

package global

import (
	"github.com/liuhongdi/digv10/pkg/setting"
	"time"
)
//服务器配置
type ServerSettingS struct {
	RunMode      string
	HttpPort     string
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
}
//数据库配置
type DatabaseSettingS struct {
	DBType       string
	UserName     string
	Password     string
	Host         string
	DBName       string
	Charset      string
	ParseTime    bool
	MaxIdleConns int
	MaxOpenConns int
}
//redis配置
type RedisSettingS struct {
	Addr      string
	Password     string
}
//定义全局变量
var (
	ServerSetting   *ServerSettingS
	DatabaseSetting *DatabaseSettingS
	RedisSetting   *RedisSettingS
)

//读取配置到全局变量
func SetupSetting() error {
	s, err := setting.NewSetting()
	if err != nil {
		return err
	}
	err = s.ReadSection("Database", &DatabaseSetting)
	if err != nil {
		return err
	}

	err = s.ReadSection("Server", &ServerSetting)
	if err != nil {
		return err
	}

	err = s.ReadSection("Redis", &RedisSetting)
	if err != nil {
		return err
	}
	return nil
}

10,其他相关代码可访问github

四，测试效果

1,查看两级缓存的效果

访问url:

http://127.0.0.1:8000/article/getone/2

返回:

查看控制台:

bigcache:GetOneArticleBigCache
redis:GetOneArticleRedisCache
mysql:SelectOneArticle

(/data/liuhongdi/digv10/dao/article.go:13) 
[2020-12-22 17:06:12]  [99.30ms]  SELECT articleId, subject, url FROM `article`  WHERE (articleId=2) LIMIT 1  
[1 rows affected or returned ] 
len: 1
Capacity: 350
[GIN] 2020/12/22 - 17:06:12 | 200 |   156.31128ms |       127.0.0.1 | GET      "/article/getone/2"
bigcache:GetOneArticleBigCache
[GIN] 2020/12/22 - 17:06:16 | 200 |     116.705µs |       127.0.0.1 | GET      "/article/getone/2"
bigcache:GetOneArticleBigCache
[GIN] 2020/12/22 - 17:06:18 | 200 |      82.248µs |       127.0.0.1 | GET      "/article/getone/2"
bigcache:GetOneArticleBigCache
[GIN] 2020/12/22 - 17:06:20 | 200 |      90.045µs |       127.0.0.1 | GET      "/article/getone/2"

可以看到，第一次从数据库查询时用了100ms以上,

而从bigcache查询时，时间在100µs左右

重启一次应用，因为重启后bigcache已丢失，应用会从redis中读取数据

查看控制台:

bigcache:GetOneArticleBigCache
redis:GetOneArticleRedisCache
len: 1
Capacity: 350
[GIN] 2020/12/22 - 17:08:28 | 200 |     535.077µs |       127.0.0.1 | GET      "/article/getone/2"
bigcache:GetOneArticleBigCache
[GIN] 2020/12/22 - 17:08:30 | 200 |     121.435µs |       127.0.0.1 | GET      "/article/getone/2"
bigcache:GetOneArticleBigCache
[GIN] 2020/12/22 - 17:08:37 | 200 |      96.567µs |       127.0.0.1 | GET      "/article/getone/2"
bigcache:GetOneArticleBigCache
[GIN] 2020/12/22 - 17:08:39 | 200 |      84.293µs |       127.0.0.1 | GET      "/article/getone/2"

可以看到从redis中查询时，用时在500µs以上

2,通过订阅redis消息更新进程内缓存：

访问url:

http://127.0.0.1:8000/article/getone/2

返回:

我们手动更新redis,

然后通过push消息让本地的应用内缓存得到及时更新:

访问:

http://127.0.0.1:8000/set/pub?id=2

再次访问文章地址:

五，查看库的版本

module github.com/liuhongdi/digv10

go 1.15

require (
	github.com/gin-gonic/gin v1.6.3
	github.com/go-playground/universal-translator v0.17.0
	github.com/go-playground/validator/v10 v10.2.0
	github.com/jinzhu/gorm v1.9.16
	github.com/magiconair/properties v1.8.4 // indirect
	github.com/mitchellh/mapstructure v1.3.3 // indirect
	github.com/pelletier/go-toml v1.8.1 // indirect
	github.com/spf13/afero v1.4.1 // indirect
	github.com/spf13/cast v1.3.1 // indirect
	github.com/spf13/jwalterweatherman v1.1.0 // indirect
	github.com/spf13/pflag v1.0.5 // indirect
	github.com/spf13/viper v1.7.1
	github.com/allegro/bigcache v1.2.1
	github.com/go-redis/redis v6.15.9+incompatible
	golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 // indirect
	golang.org/x/text v0.3.4 // indirect
	gopkg.in/ini.v1 v1.62.0 // indirect
	gopkg.in/yaml.v2 v2.3.0 // indirect
)

老刘你真牛
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
gin go 更新缓存_golang gin 框架 异步同步 goroutine 并发操作
weixin_30324103的博客
01-13 612
goroutine机制可以方便地实现异步处理package mainimport ("log""time""github.com/gin-gonic/gin")func main() {// 1.创建路由// 默认使用了2个中间件Logger(), Recovery()r := gin.Default()// 1.异步r.GET("/long_async", func(c *gin.Context...
go语言web开发系列之九:gin框架中用bigcache做进程内缓存
刘老师的技术森林
12-21 1293
一，安装用到的库 liuhongdi@ku:~$ go get -u github.com/allegro/bigcache 说明：刘宏缔的go森林是一个专注golang的博客， 地址：https://blog.csdn.net/weixin_43881017 说明：作者:刘宏缔 邮箱: 371125307@qq.com 二，演示项目的相关信息 1,项目地址: https://github.com/liuhongdi/digv09 2,项目功能说明: ...
Spring Boot整合Redis实现发布/订阅功能
最新发布
傲泣龙腾的博客
06-10 1万+
Redis作为一个高性能的内存数据存储，除了支持缓存和持久化数据，它还有很多功能，如：在博主分享的上一篇文章中，我们介绍了使用Redis实现的延迟队列功能【Spring Boot整合Redis通过Zset数据类型+定时任务实现延迟队列】发布/订阅（Pub/Sub）发布/订阅是一种消息通信模式，其中发送者（发布者）发布消息，多个接收者（订阅者）订阅并接收这些消息。发布者和订阅者之间没有直接联系，消息由消息中间件（如Redis）传递。通过本文，我们详细介绍了如何在中整合Redis。
go语言web开发系列之八:gin框架中用go-redis缓存数据
刘老师的技术森林
12-18 4570
一，安装需要用到的库 1,安装go-redis liuhongdi@ku:~$ go get -u github.com/go-redis/redis 说明：刘宏缔的go森林是一个专注golang的博客， 地址：https://blog.csdn.net/weixin_43881017 说明：作者:刘宏缔 邮箱: 371125307@qq.com 二，演示项目的相关信息 1,项目地址: https://github.com/liuhongdi/digv08 ...
[随笔]通过redis的发布订阅功能实现多服务请求同步场景
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
04-13 201
[随笔]通过redis的发布订阅功能实现多服务请求同步场景
gin go 更新缓存_【One by one系列】一步步学习Golang web框架Gin
weixin_42635849的博客
12-27 301
一步步学习Golang web框架Gin建立项目go mod 管理依赖cd $gopathsrcgithub.comcarfieldWebapigo mod init 如果不是在gopath下，其实也是提倡不在gopath下做开发，go mod init后需要跟具体路径go mod init github.comcarfieldWebapi go get -u github.com/gin-gon...
Go语言中的gin框架之GET/POST请求参数接收传值（五）
06-15
在Go语言中，Gin框架是一个非常流行的HTTP微服务框架，它提供了简洁的API来处理HTTP请求，使得开发Web应用变得更加高效。本教程将详细讲解如何在Gin中接收GET和POST请求的参数。 首先，我们需要引入Gin库。在`go....
Go Web开发进阶实战（gin框架）
01-05
Go Web开发进阶实战（gin框架）课程，适用于Go语言初学者、掌握Go语言基础语法想学习进阶内容。 由在职程序员打造的Go语言实战课程体系，与你分享企业项目开发经验与技巧。真正做到课程有内容、有深度，并且老师讲...
Golang：通过Gin框架+Redis+责任链，实现一个简单的钉钉机器人，进行消息处理 ps:多应用版
04-26
在本文中，我们将深入探讨如何使用Golang编程语言，结合Gin框架、Redis数据库和责任链模式，构建一个能够处理钉钉机器人消息的多应用版本系统。首先，我们需要理解每个组件的作用及其在整体架构中的重要性。 **Gin...
基于Go语言Gin框架的Web项目骨架设计源码
05-23
GinSkeleton是一个基于Go语言Gin框架封装的Web项目骨架，包含145个文件，其中包括94个Go源文件、36个Markdown文件、3个文本文件、3个SQL文件、2个YAML文件、1个Git忽略文件、1个LICENSE文件、1个Go Mod文件、1个Sum...
GIN+SCUI企业级后台管理系统;后端基于go语言开发，前端基于vue3开发的scui框架
06-01
Gin 是一个用 Go 语言编写的轻量级、高性能的 Web 开发框架，它提供了快速开发 RESTful API 的工具集。Gin 使用中间件链来处理请求，使得路由、认证、日志记录等功能的实现变得简单。它的性能优秀，代码结构清晰，...
gin-cache:gin 框架的小而简单的缓存中间件
06-23
gin-cache gin 框架的小而简单的缓存中间件 用法 package main import ( "time" "github.com/gin-gonic/gin" "github.com/olebedev/gin-cache" ) func main () { r := gin . New () r . Use ( cache . New (cache. Options { // set expire duration // by default zero, it means that cached content won't drop Expire : 5 * time . Minute , // store interface, see cache.go // by default it uses cache.I
golang Redis的发布和订阅demo
qq_28053177的博客
11-20 4102
//redis 发布订阅 func main() { err := initRedis() if err != nil { logs.Debug(fmt.Sprintf("connect redis err: %s", err.Error())) os.Exit(1) } //监听test频道 pubSub,err:=rds.Sub("test") if err!=nil ...
Golang与Redis
Gcaptain
11-02 404
文章目录1. 知识储备2. 安装redis客户端3. 常见的全局命令4. Redis的string类型操作5. Redis的hash类型操作6. Redis的list类型操作7. Redis的set类型操作8. Redis的zset类型操作9. Redis简单的订阅/发布 1. 知识储备 知道Redis是个啥? 知道Redis的基础命令怎么操作 测试的环境中安装了Redis的服务端(无论是w...
在golang中测试订阅发布功能
weixin_44432032的博客
09-17 580
我们这边有三个项目分别是redis1、redis2、redis3；redis1用来发送消息，redis2和redis3用来接收消息。命令分别启动redis2和redis3用来监听，然后运行redis1使用命令。
gin中间件实现对查询缓存
白马啸西施
03-07 394
在实际工作中，有时候需要对提供的api实现数据缓存，缓解数据压力.一般的做饭就是先查询是否有缓存，如果有则用缓存，没有就查询数据库。在中间件根据请求参数和api地址作为缓存key, 如果有缓存key,直接返回，没有则放行，从response中拿结果。在gin中的response其实是gin.context.writer,为实现这个功能，需要重新writer方法，但是每个方法都去实现一遍有点累，现考了到在中间件实现。
redis发布订阅示例
Donny的专栏
09-14 724
在redis中可以同时订阅多个频道，有消息发布时redis会发出通知。jedis中提供了JedisPubSub抽象类来提供发布/订阅的机制，在实际应用中需要实现JedisPubSub类。 示例代码： import org.apache.log4j.Logger; import org.springframework.context.ApplicationContext; import ...
gin go 更新缓存_go语言web开发系列之九:gin框架中用bigcache做进程内缓存
weixin_39719732的博客
02-01 244
一，安装用到的库1,安装go-redisliuhongdi@ku:~$ go get -u github.com/go-redis/redis2,安装bigcacheliuhongdi@ku:~$ go get -u github.com/allegro/bigcache说明：刘宏缔的go森林是一个专注golang的博客，地址：https://blog.csdn.net/weixin_438810...
Golang操作Redis
weixin_57023347的博客
04-26 999
Redis是完全开源免费的，遵循BSD协议，是一个高性能的key-value数据库。
Gin框架：高性能的Go语言HTTP web框架
"Gin是一个用Go语言编写的高性能HTTP Web框架，它的API设计类似Martini，但性能表现更优秀，最高可达到40倍的提升。如果你需要卓越的性能，Gin是理想...Gin的灵活性和高性能使其成为Go语言开发Web应用的首选框架之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老刘你真牛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值