go实践十五使用redis缓存操作普通队列

最新推荐文章于 2024-04-26 20:43:31 发布

daily886

最新推荐文章于 2024-04-26 20:43:31 发布

阅读量1k

点赞数

分类专栏： go

本文链接：https://blog.csdn.net/daily886/article/details/97521050

版权

go 专栏收录该内容

74 篇文章 6 订阅

订阅专栏

目录架构+http服务器+redis+热重启的参考：https://blog.csdn.net/daily886/article/details/97241319

下面说的是使用redis缓存队列和操作普通队列FIFO(先进先出)

建立文件夹和文件 httpredis/model/queue.go ，queue.go 内容如下：

package model

/*********普通队列 使用先进先出FIFO *********/
type NormalQueue struct {
	//数据
	List []string `json:"list"`
}
//队列长度
func (queue *NormalQueue) Length() int{
	return len(queue.List)
}

//插入队列
func (queue *NormalQueue) Innormalqueue(value string) []string {
	if value == "" {
		return []string{}
	}
	//插入
	queue.List = append(queue.List,value)
	return queue.List
}

//排在第一的, 先出队列
func (queue *NormalQueue) Outnormalqueue() []string {
	lenth := queue.Length()
	if(lenth > 1){
		queue.List = queue.List[1:]
	}else{
		queue.List = []string{}
	}
	return queue.List
}

建立文件夹和文件 httpredis/router/router.go ，router.go 内容如下：

package router

import (
	"net/http"

	"github.com/gin-gonic/gin"

	"httpredisqueue/service"
	"httpredisqueue/router/middleware"
)

//初始化路由
func InitRouter(g *gin.Engine){
	middlewares := []gin.HandlerFunc{}
	//中间件
	g.Use(gin.Recovery())
	g.Use(middleware.NoCache)
	g.Use(middleware.Options)
	g.Use(middleware.Secure)
	g.Use(middlewares...)

	//404处理
	g.NoRoute(func(c *gin.Context){
		c.String(http.StatusNotFound,"该路径不存在")
	})
	//健康检查中间件
	g.GET("/",service.Index)//主页
	g.GET("/setRedis",service.SetRedis) //设置redis
	g.GET("/getRedis",service.GetRedis) //获取redis
	g.GET("/inqueue",service.Inqueue) //获取队列
	g.GET("/outqueue",service.Outqueue) //出队列
}

建立文件夹和文件 httpredis/service/service.go ，service.go 内容如下：

package service

import (
	"fmt"
	"log"
	"encoding/json"

	"github.com/gin-gonic/gin"
	"github.com/go-redis/redis"

	"httpredisqueue/pkg/errno"
	"httpredisqueue/model"
	. "httpredisqueue/handler"
)
var cli *redis.Client

//列表数据的结构体
type ResultList struct {
	Total int `json:"total"`
	List []string `json:"list"`
}

//设置redis客户端构造体
func SetRedisCli(client *redis.Client){
	cli = client
}

//首页
func Index(c *gin.Context){
	html := `
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>hello world</title>
</head>
<body>
    hello world
</body>
</html>
`
	SendResponseHtml(c,nil,html)
}

func SetRedis(c *gin.Context){
	key := c.Query("key")
	value := c.Query("value")
	if key == "" || value == ""{
		SendResponse(c,errno.VALUEERROR,nil)
		return
	}
	_,err := cli.Set(key,value,0).Result();
	if(err != nil){
		SendResponse(c,errno.ApiServerError,err)
	}
	results := "成功"
	SendResponse(c,nil,results)
}

func GetRedis(c *gin.Context){
	key := c.Query("key")
	if key == ""{
		SendResponse(c,errno.VALUEERROR,nil)
		return
	}
	log.Printf("key  %+v\n",key)
	results,err := cli.Get(key).Result();
	if(err != nil){
		SendResponse(c,errno.ApiServerError,err)
	}
	log.Printf("results  %+v\n",results)
	SendResponse(c,nil,results)
}

func Inqueue(c *gin.Context){
	value := c.Query("value")
	if value == ""{
		SendResponse(c,errno.VALUEERROR,nil)
		return
	}
	//取出redis缓存队列
	redisstr,err := cli.Get("queuelist").Result()
	valueGet := []byte(redisstr) //队列数据转换为 byte
	if err != nil {
		fmt.Println(err)
	}
	var redislist []string
	//json解析队列数据
	errShal := json.Unmarshal(valueGet, &redislist)
	if errShal != nil {
		fmt.Println(err)
	}
	fmt.Printf("redislist %+v\n",redislist)

	//使用队列模型 插入队列
	queue := model.NormalQueue{}
	queue.List = redislist  //队列数据赋值
	list := queue.Innormalqueue(value) //插入队列
	total := queue.Length()			//获取队列长度

	//数据转换成json  保存到redis里面
	queuelist, _ := json.Marshal(list)
	_,err = cli.Set("queuelist",queuelist,0).Result()  //保存到redis里面
	if(err != nil){
		SendResponse(c,errno.ApiServerError,err)
	}
	//fmt.Printf("str %v",str)

	//返回数据
	var res interface{}
	res = ResultList{
		Total:total,
		List:list,
	}
	fmt.Printf("res %+v\n",res)
	SendResponse(c,nil,res)
}

func Outqueue(c *gin.Context){
	//取出redis缓存队列
	redisstr,err := cli.Get("queuelist").Result()
	valueGet := []byte(redisstr) //队列数据转换为 byte
	if err != nil {
		fmt.Println(err)
	}
	var redislist []string
	//json解析队列数据
	errShal := json.Unmarshal(valueGet, &redislist)
	if errShal != nil {
		fmt.Println(err)
	}
	fmt.Printf("redislist %+v\n",redislist)

	//使用队列模型 出队列
	queue := model.NormalQueue{}
	queue.List = redislist  //队列数据赋值
	list := queue.Outnormalqueue() //出队列
	total := queue.Length()			//获取队列长度//返回数据

	//数据转换成json  保存到redis里面
	queuelist, _ := json.Marshal(list)
	_,err = cli.Set("queuelist",queuelist,0).Result()  //保存到redis里面
	if(err != nil){
		SendResponse(c,errno.ApiServerError,err)
	}

	var res interface{}
	res = ResultList{
		Total:total,
		List:list,
	}
	fmt.Printf("res %+v\n",res)
	SendResponse(c,nil,res)
}

切换到httpredis目录中, 初始化包

[root@localhost httpredis]# go mod init httpredis
go: creating new go.mod: module httpredis

打包项目

[root@localhost httpredis]# go build

启动项目服务器

[root@localhost httpredis]# ./httpredis
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:	export GIN_MODE=release
 - using code:	gin.SetMode(gin.ReleaseMode)
 
[GIN-debug] GET    /                         --> httpredis/service.Index (5 handlers)
[GIN-debug] GET    /setRedis                 --> httpredis/service.SetRedis (5 handlers)
[GIN-debug] GET    /getRedis                 --> httpredis/service.GetRedis (5 handlers)
[GIN-debug] GET    /inqueue                  --> httpredis/service.Inqueue (5 handlers)
[GIN-debug] GET    /outqueue                 --> httpredis/service.Outqueue (5 handlers)

浏览器运行入队列:

浏览器运行出队列:

参考：https://www.cnblogs.com/DilonWu/p/8972288.html

daily886

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
go实践十五使用redis缓存操作普通队列

目录架构+http服务器+redis+热重启的参考：https://blog.csdn.net/daily886/article/details/97241319下面说的是使用redis缓存队列和操作普通队列FIFO(先进先出)建立文件夹和文件httpredis/model/queue.go，queue.go 内容如下：package model/*********普通队...
复制链接

扫一扫