golang实现纯非侵入式分布式缓存插件库gdcache的使用

gdcache简介

gdcache是一个用Golang实现的纯非侵入式缓存库，你可以用它来实现自己的缓存功能。

特性

• 自动缓存SQL查询结果
• 复用ID缓存
• 适配Xorm和Gorm框架
• 支持联合键缓存
• 轻量级
• 非侵入式
• 高性能
• 灵活

核心原理

gdcache的核心原理是将SQL转换为ID并缓存，同时缓存ID对应的实体。这样，相同的SQL可以复用对应的实体内容。

如上图所示，每条SQL都可以转换为对应的SQL，底层会复用这些ID。如果这些ID没有被查询过，我们会从数据库中获取这些无法从缓存中检索到的实体，如果能获取到，就会缓存一次。

节省内存

传统的缓存框架会缓存结果的内容，但gdcache缓存库不同，它只会缓存结果的ID，并通过ID查找值。这样做的优点是可以重用值，ID对应的值只会被缓存一次。

安装

go get github.com/ulovecode/gdcache

快速开始

基本使用

要被缓存的类必须实现TableName()方法，并使用cache:"id"来指示缓存的键。默认是按id缓存，cache标签的值对应数据库中的字段，通常可以忽略。

type User struct {
    Id   uint64 `cache:"id"` // 或者省略标签
    Name string
    Age  int
}

func (u User) TableName() string {
    return "user"
}

联合键使用

如果想使用联合键，可以在多个字段上添加cache标签

type PublicRelations struct {
    RelatedId uint64 `cache:"related_id"`
    RelatedType string
    SourceId uint64 `cache:"source_id"`
    SourceType string
}

func (u PublicRelations) TableName() string {
    return "public_relations"
}

实现ICache接口

你可以使用redis或gocache作为底层实现。

type MemoryCacheHandler struct {
    data map[string][]byte
}

func (m MemoryCacheHandler) StoreAll(keyValues ...gdcache.KeyValue) (err error) {
    for _, keyValue := range keyValues {
        m.data[keyValue.Key] = keyValue.Value
    }
    return nil
}

func (m MemoryCacheHandler) Get(key string) (data []byte, has bool, err error) {
    bytes, has := m.data[key]
    return bytes, has, nil
}

func (m MemoryCacheHandler) GetAll(keys schemas.PK) (data []gdcache.ReturnKeyValue, err error) {
    returnKeyValues := make([]gdcache.ReturnKeyValue, 0)
    for _, key := range keys {
        bytes, has := m.data[key]
        returnKeyValues = append(returnKeyValues, gdcache.ReturnKeyValue{
            KeyValue: gdcache.KeyValue{
                Key:   key,
                Value: bytes,
            },
            Has: has,
        })
    }
    return returnKeyValues, nil
}

func (m MemoryCacheHandler) DeleteAll(keys schemas.PK) error {
    for _, k := range keys {
        delete(m.data, k)
    }
    return nil
}

func NewMemoryCacheHandler() *MemoryCacheHandler {
    return &MemoryCacheHandler{
        data: make(map[string][]byte, 0),
    }
}

Gorm使用示例

实现IDB接口

type GormDB struct {
    db *gorm.DB
}

func (g GormDB) GetEntries(entries interface{}, sql string) error {
    tx := g.db.Raw(sql).Find(entries)
    return tx.Error
}

func (g GormDB) GetEntry(entry interface{}, sql string) (bool, error) {
    tx := g.db.Raw(sql).Take(entry)
    if gorm.ErrRecordNotFound == tx.Error {
        return false, nil
    }
    return tx.Error != gorm.ErrRecordNotFound, tx.Error
}

func NewGormCacheHandler() *gdcache.CacheHandler {
    return gdcache.NewCacheHandler(NewMemoryCacheHandler(), NewGormDd())
}

func NewGormDd() gdcache.IDB {
    db, err := gorm.Open(mysql.Open("root:root@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local"), &gorm.Config{})
    if err != nil {
        panic(err)
    }
    return GormDB{
        db: db,
    }
}

Xorm使用示例

实现IDB接口

type XormDB struct {
    db *xorm.Engine
}

func (g XormDB) GetEntries(entries interface{}, sql string) ( error) {
    err := g.db.SQL(sql).Find(entries)
    return err
}

func (g XormDB) GetEntry(entry interface{}, sql string) ( bool, error) {
    has, err := g.db.SQL(sql).Get(entry)
    return has, err
}

func NewXormCacheHandler() *gdcache.CacheHandler {
    return gdcache.NewCacheHandler(NewMemoryCacheHandler(), NewXormDd())
}

func NewXormDd() gdcache.IDB {
    db, err := xorm.NewEngine("mysql", "root:root@/test?charset=utf8")
    if err != nil {
        panic(err)
    }
    return XormDB{
        db: db,
    }
}

原生SQL使用示例

实现IDB接口

type MemoryDb struct {
}

func NewMemoryDb() *MemoryDb {
    return &MemoryDb{}
}

func (m MemoryDb) GetEntries(entries interface{}, sql string) error {
    mockEntries := make([]MockEntry, 0)
    mockEntries = append(mockEntries, MockEntry{
        RelateId:   1,
        SourceId:   2,
        PropertyId: 3,
    })
    marshal, _ := json.Marshal(mockEntries)
    json.Unmarshal(marshal, entries)
    return nil
}

func (m MemoryDb) GetEntry(entry interface{}, sql string) (bool, error) {
    mockEntry := &MockEntry{
        RelateId:   1,
        SourceId:   2,
        PropertyId: 3,
    }
    marshal, _ := json.Marshal(mockEntry)
    json.Unmarshal(marshal, entry)
    return true, nil
}

func NewMemoryCache() *gdcache.CacheHandler {
    return gdcache.NewCacheHandler(NewMemoryCacheHandler(), NewMemoryDb())
}

如何使用

查询单个实体时，通过实体的id查询并填充到实体中。获取多个实体时，可以使用任何sql查询，最后填充到实体中。两种方法都必须引入主体的指针。

func TestNewGormCache(t *testing.T) {
    handler := NewGormCacheHandler()

    user := User{
        Id: 1,
    }
    has, err := handler.GetEntry(&user)
    if err != nil {
        t.FailNow()
    }
    if has {
        t.Logf("%v", user)
    }
    
    users := make([]User, 0)
    err = handler.GetEntries(&users, "SELECT * FROM user WHERE name = '33'")
    if err != nil {
        t.FailNow()
    }
    for _, user := range users {
        t.Logf("%v", user)
    }
    
    err = handler.GetEntries(&users, "SELECT * FROM user WHERE id in (3)")
    if err != nil {
        t.FailNow()
    }
    for _, user := range users {
        t.Logf("%v", user)
    }
    
    count, err := handler.GetEntriesAndCount(&users1, "SELECT * FROM user WHERE id in (1,2)")
    if err != nil {
        t.FailNow()
    }
    for _, user := range users1 {
        t.Logf("%v", user)
    }
    t.Log(count)
    
    users3 := make([]User, 0)
    ids := make([]uint64, 0)
    count, err = handler.GetEntriesAndCount(&users3, "SELECT * FROM user WHERE id in ?", ids)
    if err != nil {
        t.FailNow()
    }
    for _, user := range users1 {
        t.Logf("%v", user)
    }
    t.Log(count)
    
    count, err = handler.GetEntriesAndCount(&users1, "SELECT * FROM user WHERE id =  ?", 1)
    if err != nil {
        t.FailNow()
    }
    for _, user := range users1 {
        t.Logf("%v", user)
    }
    t.Log(count)
    
    condition := []User{{Id: 1},{Id: 2},{Id: 3}}
    
    err = handler.GetEntriesByIds(&users1, condition)
    if err != nil {
        t.FailNow()
    }
    for _, user := range users1 {
        t.Logf("%v", user)
    }
    t.Log(count)
}

支持占位符?，替换数组和基本类型。

贡献

你可以通过提交PR来帮助提供更好的gdcache。

许可证

© Jovanzhu, 2021~time.Now

根据MIT许可证发布