2-测试bigcache做进程内缓存 --开源项目obtain_data测试

2-测试bigcache做进程内缓存

1.bigcache做进程内缓存测试效果

a.测试页面

mysql 复制代码

测试页面：--这里使用 Postman 来做测试
http://127.0.0.1:8000/novels/getone/4
http://127.0.0.1:8000/novels/getone/5
http://127.0.0.1:8000/novels/getone/6

b.测试效果

go 复制代码

查看终端：
直接使用mysql数据库查询数据时间比较长；
使用 bigcache 做进程内缓存用时比较短。
使用 bigcache 缓存可以缩短查找数据的时间10倍以上。

2.bigcache做进程内缓存代码实现

a.程序从main函数开始

go 复制代码

/main.go
操作：
1.先配置 bigcache

err = global.SetupGlobalCache()
if err != nil {
	log.Fatalf("init.SetupGlobalCache err: %v", err)
}

b.路由的路径映射

go 复制代码

/routers/routers.go
操作：
1.测试需要一个路由

	//小说路由部分
	novels_r := r.Group("/novels/")
	{
		//获取一篇小说详情
		novels_c := controllers.NewNovelsController()
		novels_r.GET("/getone/:id", novels_c.GetOne)
	}

c.在控制器中增加GetOne方法

go 复制代码

/controllers/novelsController.go
操作：
1.获取参数
2.将参数带入服务中查找数据
3.返回数据

// 得到一篇文章的详情
func (a *NovelsController) GetOne(c *gin.Context) {
	result := result.NewResult(c)
	param := request.Request{ID: validCheck.StrTo(c.Param("id")).MustUInt64()}
	valid, _ := validCheck.BindAndValid(c, &param)
	if !valid {
		result.Error(global.ErrParam)
		return
	}

	novelsOne, err := service.GetOneNovels(param.ID)
	if err != nil {
		result.Error(global.ErrArticleNot)
	} else {
		result.Success(&novelsOne)
	}
}

d.在服务里获取一篇文章

go 复制代码

/service/novels.go
操作：
1.想看缓存中有没有查找的数据
2.如果有，就把数据返回到控制器
3.如果缓存中没有，就到mysql中查找，然后把数据保存到 bigcache 缓存，最后返回数据

// 得到一篇文章的详情
func GetOneNovels(id uint64) (*model.Novels, error) {
	//get from bigcache
	novels, err := cache.GetOneNovelsCache(id)
	if err != nil {
		//get from mysql
		novels, errSel := dao.SelectOneNovels(id)
		if errSel != nil {
			return nil, errSel
		} else {
			//set bigcache
			errSet := cache.SetOneNovelsCache(id, novels)
			if errSet != nil {
				return nil, errSet
			} else {
				return novels, errSel
			}
		}
	} else {
		return novels, err
	}
}

e.cache的设置与获得

go 复制代码

/cache/novels.go
操作：
1.bigcache中索引的名字
2.从bigcache得到一篇文章
3.向bigcache保存一篇文章

package cache

import (
	"encoding/json"
	"fmt"
	"strconv"

	"gitee.com/wao520/obtain_data/global"
	"gitee.com/wao520/obtain_data/model"
)

// bigcache中索引的名字
func getNovelsCacheName(id uint64) string {
	return "novels_" + strconv.FormatUint(id, 10)
}

// 从bigcache得到一篇文章
func GetOneNovelsCache(id uint64) (*model.Novels, error) {
	key := getNovelsCacheName(id)
	val, err := global.BigCache.Get(key)

	if err != nil {
		return nil, err
	} else {
		novels := model.Novels{}
		if err := json.Unmarshal([]byte(val), &novels); err != nil {
			return nil, err
		}
		return &novels, nil
	}
}

// 向bigcache保存一篇文章
func SetOneNovelsCache(id uint64, novels *model.Novels) error {
	key := getNovelsCacheName(id)
	content, err := json.Marshal(novels)
	if err != nil {
		fmt.Println(err)
		return err
	}
	errSet := global.BigCache.Set(key, []byte(content))
	if errSet != nil {
		return errSet
	}
	return nil
}

f.全局的bigcache

go 复制代码

/global/bigCache.go
操作：
1.定义一个全局的bigcache

package global

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

//创建一个全局的bigcache
func SetupGlobalCache() (error) {
	config := bigcache.Config {
		Shards: 1024,   			// 存储的条目数量，值必须是2的幂
		LifeWindow: 5*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
	}
	return nil
}

g.数据库查询一条记录

go 复制代码

/dao/novels.go
操作：
1.从mysql数据库查询一条记录

package dao

import (
	"gitee.com/wao520/obtain_data/global"
	"gitee.com/wao520/obtain_data/model"
)

// 查询一条novels记录
func SelectOneNovels(id uint64) (*model.Novels, error) {
	fields := []string{"id", "title", "author", "genre", "description"}
	novelsOne := &model.Novels{}
	err := global.DBLink.Select(fields).Where("id=?", id).First(&novelsOne).Error
	if err != nil {
		return nil, err
	} else {
		return novelsOne, nil
	}
}

h.创建数据表模型

go 复制代码

/model/novels.go
操作：
1.可以使用模型获取数据库数据

package model

type Novels struct {
	Id          uint64 `gorm:"column:id" json:"id"`
	Title       string `gorm:"column:title" json:"title"`
	Author      string `gorm:"column:author" json:"author"`
	Genre       string `gorm:"column:genre" json:"genre"`
	Description string `gorm:"column:description" json:"description"`
}

func (Novels) TableName() string {
	return "novels"
}

3.获取开源项目

a.gin框架中用bigcache做进程内缓存

b.本测试代码下载