cache

package module
v1.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 16, 2022 License: MIT Imports: 13 Imported by: 0

README

cache

License Go Reference

提供一套缓存操作的语义，以及一些已实现的缓存提供器。

功能

  • 缓存key管理
  • 随机过期时间管理
  • 自定义缓存提供器
  • 缓存提供器
    • Redis缓存
    • memory缓存
    • 二级缓存, 不支持Increase
  • 支持泛型(version >= v1.1.0)

快速开始

go get -u github.com/thisXYH/cache@latest

注意事项

  • redis cahce provider 的测试用例需要自己提供redis连接信息才能测试成功。通过 conf_test.go 的 getNewEveryTime 调整 redis 配置，默认使用 127.0.0.1:6379 。
  • concurrent rand source 的测试用例是并发测试，可能需要跑多次才能成功。
  • 新建 redis client 时 Options.MaxRetries 用于指定客户端失败重试，当重试次数不等于 1 的时候，由于客户端会自动重试，可能会导致 Increase 和 IncreaseOrCreate 语义不准。

缓存语义

// CacheProvider 提供一套缓存语义。
type CacheProvider interface {
	// Get 获取指定缓存值。
	//  @key: cache key.
	//  @value: receive value.
	// return: 如果key存在，value被更新成对应值, 反之value值不做改变。
	Get(key string, value any) error

	// TryGet 尝试获取指定缓存。
	//  @key: cache key.
	//  @value: receive value.
	// return: 若 key 存在，value 被更新成对应值，返回 true；反之 value 值不做改变，返回 false。
	TryGet(key string, value any) (bool, error)

	// Create 仅当缓存键不存在时，创建缓存。
	//  @key: cache key.
	//  @value: receive value.
	//  @t: 过期时长， 0表不过期。
	// return: true表示创建了缓存；false说明缓存已经存在了。
	Create(key string, value any, t time.Duration) (bool, error)

	// Set 设置或者更新缓存。
	//  @key: cache key.
	//  @value: receive value.
	//  @t: 过期时长， 0表不过期。
	Set(key string, value any, t time.Duration) error

	// Remove 移除指定缓存,
	//  @key: cache key.
	// return: true 成功移除；false 缓存不存在。
	Remove(key string) (bool, error)

	// Increase 为已存在的指定缓存的值（必须是整数）增加1。
	//  @key: cache key.
	// return: 符合条件返回增加后的值，反之返回默认值，以及对应的 error。
	Increase(key string) (int64, error)

	// Increase 为指定缓存的值增加一个增量(负数==减法)，如果不存在则创建该缓存。
	//  @key: cache key.
	//  @increment: 增量，如果 key 不存在，则当成新缓存的 value。
	//  @t: 过期时长， 0表不过期。
	// return: 返回增加后的值。
	IncreaseOrCreate(key string, increment int64, t time.Duration) (int64, error)
}

使用示例

base use sample

package cache_example

import (
	"fmt"
	"time"

	"github.com/thisXYH/cache"
)

func ExampleKeyOperation() {
	// 初始化一个 内存缓存提供器。
	provider := cache.NewMemoryCacheProvider(time.Second)

	// 初始化一个 缓存操作对象, 通常这个对象会被用作全局, 不需要每次使用都创建。
	op := cache.NewOperation("ns", "prefix", 2, provider, cache.CacheExpirationZero)

	// 根据指定的数量给定 unique flag, 获取对应的缓存 key 操作对象。
	key := op.Key("a", 1)
	fmt.Println(key.Key)

	var res time.Time
	if key.MustTryGet(&res) {
		// 如果 key 存在，进入这个代码块(当前一定不存在，展示作用)。
		panic("key should not be")
	}

	v := time.Date(2022, 03, 27, 18, 55, 0, 0, time.UTC)
	key.MustSet(v)

	if !key.MustTryGet(&res) {
		panic("key should be")
	}

	if res != v {
		panic("value err")
	}

	v2 := time.Now()

	// 当 key 不存在的时候，设置缓存返回 true, 反之 false 。
	if key.MustCreate(v2) {
		panic("key exist, cannot set cache")
	}

	// 最后删除缓存, 删除成功返回 true, 反之 false 。
	if !key.MustRemove() {
		panic("remove fail")
	}

	// output:
	// ns:prefix_a_1
}

func ExampleKeyOperationT() {
	// 初始化一个 内存缓存提供器。
	provider := cache.NewMemoryCacheProvider(time.Second)

	// 初始化一个 缓存操作对象, 通常这个对象会被用作全局, 不需要每次使用都创建。
	op := cache.NewOperation2[string, int, time.Time]("ns", "prefix", provider, cache.CacheExpirationZero)

	// 根据指定的数量给定 unique flag, 获取对应的缓存 key 操作对象。
	key := op.Key("a", 1)
	fmt.Println(key.Key)

	res, ok := key.MustTryGet()
	if ok {
		// 如果 key 存在，进入这个代码块(当前一定不存在，展示作用)。
		panic("key should not be")
	}

	v := time.Date(2022, 03, 27, 18, 55, 0, 0, time.UTC)
	key.MustSet(v)

	res, ok = key.MustTryGet()
	if !ok {
		panic("key should be")
	}

	if res != v {
		panic("value err")
	}

	v2 := time.Now()

	// 当 key 不存在的时候，设置缓存返回 true, 反之 false 。
	if key.MustCreate(v2) {
		panic("key exist, cannot set cache")
	}

	// 最后删除缓存, 删除成功返回 true, 反之 false 。
	if !key.MustRemove() {
		panic("remove fail")
	}

	// output:
	// ns:prefix_a_1
}

Documentation

Index

Examples

Constants

View Source 
const NoExpiration time.Duration = 0 // 缓存不过期。

Variables

This section is empty.

Functions

This section is empty.

Types

type CacheProvider 

type CacheProvider interface {
	// Get 获取指定缓存值。
	//  @key: cache key.
	//  @value: receive value.
	// return: 如果key存在，value被更新成对应值, 反之value值不做改变。
	Get(key string, value any) error

	// TryGet 尝试获取指定缓存。
	//  @key: cache key.
	//  @value: receive value.
	// return: 若 key 存在，value 被更新成对应值，返回 true；反之 value 值不做改变，返回 false。
	TryGet(key string, value any) (bool, error)

	// Create 仅当缓存键不存在时，创建缓存。
	//  @key: cache key.
	//  @value: receive value.
	//  @t: 过期时长， 0表不过期。
	// return: true表示创建了缓存；false说明缓存已经存在了。
	Create(key string, value any, t time.Duration) (bool, error)

	// Set 设置或者更新缓存。
	//  @key: cache key.
	//  @value: receive value.
	//  @t: 过期时长， 0表不过期。
	Set(key string, value any, t time.Duration) error

	// Remove 移除指定缓存,
	//  @key: cache key.
	// return: true 成功移除；false 缓存不存在。
	Remove(key string) (bool, error)

	// Increase 为已存在的指定缓存的值（必须是整数）增加1。
	//  @key: cache key.
	// return: 符合条件返回增加后的值，反之返回默认值，以及对应的 error。
	Increase(key string) (int64, error)

	// IncreaseOrCreate 为指定缓存的值增加一个增量(负数==减法)，如果不存在则创建该缓存。
	//  @key: cache key.
	//  @increment: 增量，如果 key 不存在，则当成新缓存的 value。
	//  @t: 过期时长， 0表不过期。
	// return: 返回增加后的值。
	IncreaseOrCreate(key string, increment int64, t time.Duration) (int64, error)
}

CacheProvider 提供一套缓存语义。

type Expiration 

type Expiration struct {
	// contains filtered or unexported fields
}

Expiration 缓存过期时间。 

var CacheExpirationZero *Expiration = NewExpiration(0, 0) // 缓存不过期。

func NewExpiration 

func NewExpiration(baseExpireTime, randomRangeTime time.Duration) *Expiration

NewExpiration 新建缓存过期时间。 

@baseExpireTime: 基准过期时长，0表不过期。
@randomRangeTime: 随机过期市场，0表不随机，否则baseExpireTime将增加[-randomRangeTime, +randomRangeTime]。

func NewExpirationFromHour 

func NewExpirationFromHour(baseExpireTime, randomRangeTime int64) *Expiration

NewExpirationFromHour 以小时为单位创建缓存过期时间。

func NewExpirationFromMillisecond 

func NewExpirationFromMillisecond(baseExpireTime, randomRangeTime int64) *Expiration

NewExpirationFromMillisecond 以毫秒为单位创建缓存过期时间。

func NewExpirationFromMinute 

func NewExpirationFromMinute(baseExpireTime, randomRangeTime int64) *Expiration

NewExpirationFromMinute 以分钟为单位创建缓存过期时间。

func NewExpirationFromSecond 

func NewExpirationFromSecond(baseExpireTime, randomRangeTime int64) *Expiration

NewExpirationFromSecond 以秒为单位创建缓存过期时间。

func (*Expiration) NextExpireTime 

func (c *Expiration) NextExpireTime() time.Duration

NextExpireTime 获取一个新的过期时间，如果存在随机量的话，返回值已经过随机量计算。

type KeyOperation 

type KeyOperation struct {

	// 缓存key。
	Key string
	// contains filtered or unexported fields
}
Example 
// 初始化一个 内存缓存提供器。
provider := NewMemoryCacheProvider(time.Second)

// 初始化一个 缓存操作对象, 通常这个对象会被用作全局, 不需要每次使用都创建。
op := NewOperation("ns", "prefix", 2, provider, CacheExpirationZero)

// 根据指定的数量给定 unique flag, 获取对应的缓存 key 操作对象。
key := op.Key("a", 1)
fmt.Println(key.Key)

var res time.Time
if key.MustTryGet(&res) {
	// 如果 key 存在，进入这个代码块(当前一定不存在，展示作用)。
	panic("key should not be")
}

v := time.Date(2022, 03, 27, 18, 55, 0, 0, time.UTC)
key.MustSet(v)

if !key.MustTryGet(&res) {
	panic("key should be")
}

if res != v {
	panic("value err")
}

v2 := time.Now()

// 当 key 不存在的时候，设置缓存返回 true, 反之 false 。
if key.MustCreate(v2) {
	panic("key exist, cannot set cache")
}

// 最后删除缓存, 删除成功返回 true, 反之 false 。
if !key.MustRemove() {
	panic("remove fail")
}

Output:

ns:prefix_a_1

func (*KeyOperation) Create 

func (keyOp *KeyOperation) Create(value any) (bool, error)

Create 仅当缓存键不存在时，创建缓存。 

return: true表示创建了缓存；false说明缓存已经存在了。

func (*KeyOperation) Get 

func (keyOp *KeyOperation) Get(value any) error

Get 获取指定缓存值。 如果key存在，value被更新成对应值， 反之value值不做改变。

func (*KeyOperation) Increase added in v1.1.1 

func (keyOp *KeyOperation) Increase() (int64, error)

Increase 为已存在的指定缓存的值（必须是整数）增加1。 

return: 符合条件返回增加后的值，反之返回默认值，以及对应的 error。

func (*KeyOperation) IncreaseOrCreate added in v1.1.1 

func (keyOp *KeyOperation) IncreaseOrCreate(increment int64) (int64, error)

IncreaseOrCreate 为指定缓存的值增加一个增量(负数==减法)，如果不存在则创建该缓存。 

@increment: 增量，如果 key 不存在，则当成新缓存的 value。

return: 返回增加后的值。

func (*KeyOperation) MustCreate 

func (keyOp *KeyOperation) MustCreate(value any) bool

MustCreate 是 Create 的 panic 版。

func (*KeyOperation) MustGet 

func (keyOp *KeyOperation) MustGet(value any)

MustGet 是 Get 的 panic 版。

func (*KeyOperation) MustIncrease added in v1.1.1 

func (keyOp *KeyOperation) MustIncrease() int64

MustRemove 是 Increase 的 panic 版。

func (*KeyOperation) MustIncreaseOrCreate added in v1.1.1 

func (keyOp *KeyOperation) MustIncreaseOrCreate(increment int64) int64

MustIncreaseOrCreate 是 IncreaseOrCreate 的 panic 版。

func (*KeyOperation) MustRemove 

func (keyOp *KeyOperation) MustRemove() bool

MustRemove 是 Remove 的 panic 版。

func (*KeyOperation) MustSet 

func (keyOp *KeyOperation) MustSet(value any)

MustSet 是 Set 的 panic 版。

func (*KeyOperation) MustTryGet added in v1.1.0 

func (keyOp *KeyOperation) MustTryGet(value any) bool

MustTryGet 是 TryGet 的 panic 版。

func (*KeyOperation) Remove 

func (keyOp *KeyOperation) Remove() (bool, error)

Remove 移除指定缓存, 

return: true成功移除，false缓存不存在。

func (*KeyOperation) Set 

func (keyOp *KeyOperation) Set(value any) error

Set 设置或者更新缓存。

func (*KeyOperation) TryGet 

func (keyOp *KeyOperation) TryGet(value any) (bool, error)

TryGet 尝试获取指定缓存。 若key存在，value被更新成对应值，返回true，反之value值不做改变，返回false。

type KeyOperationT added in v1.1.0 

type KeyOperationT[T any] struct {

	// 缓存key。
	Key string
	// contains filtered or unexported fields
}

KeyOperationT 是泛型版本的 KeyOperation 。

Example 
// 初始化一个 内存缓存提供器。
provider := NewMemoryCacheProvider(time.Second)

// 初始化一个 缓存操作对象, 通常这个对象会被用作全局, 不需要每次使用都创建。
// 指定了 unique flag 有两个，一个是 string 、一个是 int 。
op := NewOperation2[string, int, time.Time]("ns", "prefix", provider, CacheExpirationZero)

// 根据 unique flag, 获取对应的缓存 key 操作对象。
key := op.Key("a", 1)
fmt.Println(key.Key)

res, ok := key.MustTryGet()
if ok {
	// 如果 key 存在，进入这个代码块(当前一定不存在，展示作用)。
	panic("key should not be")
}

v := time.Date(2022, 03, 27, 18, 55, 0, 0, time.UTC)
key.MustSet(v)

res, ok = key.MustTryGet()
if !ok {
	panic("key should be")
}

if res != v {
	panic("value err")
}

v2 := time.Now()

// 当 key 不存在的时候，设置缓存返回 true, 反之 false 。
if key.MustCreate(v2) {
	panic("key exist, cannot set cache")
}

// 最后删除缓存, 删除成功返回 true, 反之 false 。
if !key.MustRemove() {
	panic("remove fail")
}

Output:

ns:prefix_a_1

func (*KeyOperationT[T]) Create added in v1.1.0 

func (keyOp *KeyOperationT[T]) Create(value T) (bool, error)

Create 仅当缓存键不存在时，创建缓存。 

return: true表示创建了缓存；false说明缓存已经存在了。

func (*KeyOperationT[T]) Get added in v1.1.0 

func (keyOp *KeyOperationT[T]) Get() (T, error)

Get 获取指定缓存值。

func (*KeyOperationT[T]) Increase added in v1.1.1 

func (keyOp *KeyOperationT[T]) Increase() (int64, error)

Increase 为已存在的指定缓存的值（必须是整数）增加1。 

return: 符合条件返回增加后的值，反之返回默认值，以及对应的 error。

func (*KeyOperationT[T]) IncreaseOrCreate added in v1.1.1 

func (keyOp *KeyOperationT[T]) IncreaseOrCreate(increment int64) (int64, error)

IncreaseOrCreate 为指定缓存的值增加一个增量(负数==减法)，如果不存在则创建该缓存。 

@increment: 增量，如果 key 不存在，则当成新缓存的 value。

return: 返回增加后的值。

func (*KeyOperationT[T]) MustCreate added in v1.1.0 

func (keyOp *KeyOperationT[T]) MustCreate(value T) bool

MustCreate 是 Create 的 panic 版。

func (*KeyOperationT[T]) MustGet added in v1.1.0 

func (keyOp *KeyOperationT[T]) MustGet() T

MustGet 是 Get 的 panic 版。

func (*KeyOperationT[T]) MustIncrease added in v1.1.1 

func (keyOp *KeyOperationT[T]) MustIncrease() int64

MustRemove 是 Increase 的 panic 版。

func (*KeyOperationT[T]) MustIncreaseOrCreate added in v1.1.1 

func (keyOp *KeyOperationT[T]) MustIncreaseOrCreate(increment int64) int64

MustIncreaseOrCreate 是 IncreaseOrCreate 的 panic 版。

func (*KeyOperationT[T]) MustRemove added in v1.1.0 

func (keyOp *KeyOperationT[T]) MustRemove() bool

MustRemove 是 Remove 的 panic 版。

func (*KeyOperationT[T]) MustSet added in v1.1.0 

func (keyOp *KeyOperationT[T]) MustSet(value T)

MustSet 是 Set 的 panic 版。

func (*KeyOperationT[T]) MustTryGet added in v1.1.0 

func (keyOp *KeyOperationT[T]) MustTryGet() (T, bool)

MustTryGet 是 TryGet 的 panic 版。

func (*KeyOperationT[T]) Remove added in v1.1.0 

func (keyOp *KeyOperationT[T]) Remove() (bool, error)

Remove 移除指定缓存, 

return: true成功移除，false缓存不存在。

func (*KeyOperationT[T]) Set added in v1.1.0 

func (keyOp *KeyOperationT[T]) Set(value T) error

Set 设置或者更新缓存。

func (*KeyOperationT[T]) TryGet added in v1.1.0 

func (keyOp *KeyOperationT[T]) TryGet() (T, bool, error)

TryGet 尝试获取指定缓存。 若key存在，value被更新成对应值，返回true，反之value值不做改变，返回false。

type Level2CacheProvider 

type Level2CacheProvider struct {
	// contains filtered or unexported fields
}

Level2CacheProvider 实现简单的两级缓存，不支持Increase， 两个层次的缓存使用相同的缓存key, 所以两个层级的缓存需要使用不同的缓存提供器，防止相互覆盖。

当一级获取不到，将从二级获取（一般来说，一级回收间隔更短）， 并且根据二级缓存更新一级缓存。

实际上可以看成以 Level 2 为主，Level 1 为辅助，提高访问性能。

func NewLevel2CacheProvider added in v0.1.2 

func NewLevel2CacheProvider(l1, l2 CacheProvider, expireTime *Expiration) *Level2CacheProvider

NewLevel2CacheProvider 新建一个二级缓存提供器。 

@l1: 一级缓存。
@l2: 二级级缓存。
@expireTime: 一级缓存的过期时间。

func (*Level2CacheProvider) Create 

func (p *Level2CacheProvider) Create(key string, value any, t time.Duration) (result bool, err error)

implement CacheProvider.Create .

func (*Level2CacheProvider) Get 

func (p *Level2CacheProvider) Get(key string, value any) error

implement CacheProvider.Get .

func (*Level2CacheProvider) Increase 

func (p *Level2CacheProvider) Increase(key string) (int64, error)

implement CacheProvider.Increase, not supported, will panic!

func (*Level2CacheProvider) IncreaseOrCreate 

func (p *Level2CacheProvider) IncreaseOrCreate(key string, increment int64, t time.Duration) (int64, error)

implement CacheProvider.IncreaseOrCreate, not supported, will panic!

func (*Level2CacheProvider) Remove 

func (p *Level2CacheProvider) Remove(key string) (bool, error)

implement CacheProvider.Remove .

func (*Level2CacheProvider) Set 

func (p *Level2CacheProvider) Set(key string, value any, t time.Duration) error

implement CacheProvider.Set .

func (*Level2CacheProvider) TryGet 

func (p *Level2CacheProvider) TryGet(key string, value any) (result bool, err error)

implement CacheProvider.TryGet .

type MemoryCacheProvider 

type MemoryCacheProvider struct {
	// contains filtered or unexported fields
}

MemoryCacheProvider 内存类型的缓存提供器。

func NewMemoryCacheProvider 

func NewMemoryCacheProvider(cleanupInterval time.Duration) *MemoryCacheProvider

NewMemoryCacheProvider 用来获取内存缓存提供器。 

@cleanupInterval: 缓存 key 的过期清理周期，必须大于 1 秒。

func (*MemoryCacheProvider) Create 

func (cp *MemoryCacheProvider) Create(key string, value any, t time.Duration) (bool, error)

implement CacheProvider.Create .

func (*MemoryCacheProvider) Get 

func (cp *MemoryCacheProvider) Get(key string, value any) error

implement CacheProvider.Get .

func (*MemoryCacheProvider) Increase 

func (cp *MemoryCacheProvider) Increase(key string) (int64, error)

implement CacheProvider.Increase .

func (*MemoryCacheProvider) IncreaseOrCreate 

func (cp *MemoryCacheProvider) IncreaseOrCreate(key string, increment int64, t time.Duration) (int64, error)

implement CacheProvider.IncreaseOrCreate .

func (*MemoryCacheProvider) Remove 

func (cp *MemoryCacheProvider) Remove(key string) (bool, error)

implement CacheProvider.Remove .

func (*MemoryCacheProvider) Set 

func (cp *MemoryCacheProvider) Set(key string, value any, t time.Duration) error

implement CacheProvider.Set .

func (*MemoryCacheProvider) TryGet 

func (cp *MemoryCacheProvider) TryGet(key string, value any) (bool, error)

implement CacheProvider.TryGet .

type Operation 

type Operation struct {
	// contains filtered or unexported fields
}

Operation 缓存操作对象。

func NewOperation 

func NewOperation(cacheNamespace, keyPrefix string, uniqueFlagLen int, cacheProvider CacheProvider, expireTime *Expiration) *Operation

NewOperation 创建一个缓存操作对象。 缓存key分三段 <CacheNamespace>:<Prefix>[:unique flag]。 expireTime: 过期时长， nil 或者 CacheExpirationZero 表不过期。 uniqueFlagLen: 指定用来拼接 [:unique flag] 部分的元素个数(>=0)。 受支持的 [:unique flag] 类型: bool, int*, uint*, float*, string, time.time, UnixTime 。

func (*Operation) Key 

func (c *Operation) Key(keys ...interface{}) *KeyOperation

Key 获取指定key的缓存 key 操作对象。 

受支持的 key 类型: bool, int*, uint*, float*, string, time.time, UnixTime 。

type Operation0 added in v1.1.0 

type Operation0[TRes any] struct {
	// contains filtered or unexported fields
}

Operation0 表示 key 只由0个元素组成的缓存操作对象。

func NewOperation0 added in v1.1.0 

func NewOperation0[TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation0[TRes]

NewOperation0 类似 NewOperation ，但创建一个 key 只由0个元素组成的缓存操作对象。

func (*Operation0[TRes]) Key added in v1.1.0 

func (c *Operation0[TRes]) Key() *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation1 added in v1.1.0 

type Operation1[TKey UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation1 表示 key 只由0个元素组成的缓存操作对象。

func NewOperation1 added in v1.1.0 

func NewOperation1[TKey UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation1[TKey, TRes]

NewOperation1 类似 NewOperation ，但创建一个 key 只由1个元素组成的缓存操作对象。

func (*Operation1[TKey, TRes]) Key added in v1.1.0 

func (c *Operation1[TKey, TRes]) Key(v TKey) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation2 added in v1.1.0 

type Operation2[TKey1 UniqueFlag, TKey2 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation2 表示 key 只由2个元素组成的缓存操作对象。

func NewOperation2 added in v1.1.0 

func NewOperation2[TKey1 UniqueFlag, TKey2 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation2[TKey1, TKey2, TRes]

NewOperation2 类似 NewOperation ，但创建一个 key 只由2个元素组成的缓存操作对象。

func (*Operation2[TKey1, TKey2, TRes]) Key added in v1.1.0 

func (c *Operation2[TKey1, TKey2, TRes]) Key(v1 TKey1, v2 TKey2) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation3 added in v1.1.0 

type Operation3[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation3 表示 key 只由3个元素组成的缓存操作对象。

func NewOperation3 added in v1.1.0 

func NewOperation3[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation3[TKey1, TKey2, TKey3, TRes]

NewOperation3 类似 NewOperation ，但创建一个 key 只由3个元素组成的缓存操作对象。

func (*Operation3[TKey1, TKey2, TKey3, TRes]) Key added in v1.1.0 

func (c *Operation3[TKey1, TKey2, TKey3, TRes]) Key(v1 TKey1, v2 TKey2, v3 TKey3) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation4 added in v1.1.0 

type Operation4[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation4 表示 key 只由4个元素组成的缓存操作对象。

func NewOperation4 added in v1.1.0 

func NewOperation4[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation4[TKey1, TKey2, TKey3, TKey4, TRes]

NewOperation4 类似 NewOperation ，但创建一个 key 只由4个元素组成的缓存操作对象。

func (*Operation4[TKey1, TKey2, TKey3, TKey4, TRes]) Key added in v1.1.0 

func (c *Operation4[TKey1, TKey2, TKey3, TKey4, TRes]) Key(v1 TKey1, v2 TKey2, v3 TKey3, v4 TKey4) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation5 added in v1.1.0 

type Operation5[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation5 表示 key 只由5个元素组成的缓存操作对象。

func NewOperation5 added in v1.1.0 

func NewOperation5[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation5[TKey1, TKey2, TKey3, TKey4, TKey5, TRes]

NewOperation5 类似 NewOperation ，但创建一个 key 只由5个元素组成的缓存操作对象。

func (*Operation5[TKey1, TKey2, TKey3, TKey4, TKey5, TRes]) Key added in v1.1.0 

func (c *Operation5[TKey1, TKey2, TKey3, TKey4, TKey5, TRes]) Key(v1 TKey1, v2 TKey2, v3 TKey3, v4 TKey4, v5 TKey5) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation6 added in v1.1.0 

type Operation6[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TKey6 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation6 表示 key 只由6个元素组成的缓存操作对象。

func NewOperation6 added in v1.1.0 

func NewOperation6[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TKey6 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation6[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TRes]

NewOperation6 类似 NewOperation ，但创建一个 key 只由6个元素组成的缓存操作对象。

func (*Operation6[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TRes]) Key added in v1.1.0 

func (c *Operation6[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TRes]) Key(v1 TKey1, v2 TKey2, v3 TKey3, v4 TKey4, v5 TKey5, v6 TKey6) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation7 added in v1.1.0 

type Operation7[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TKey6 UniqueFlag, TKey7 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation7 表示 key 只由7个元素组成的缓存操作对象。

func NewOperation7 added in v1.1.0 

func NewOperation7[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TKey6 UniqueFlag, TKey7 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation7[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TKey7, TRes]

NewOperation7 类似 NewOperation ，但创建一个 key 只由7个元素组成的缓存操作对象。

func (*Operation7[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TKey7, TRes]) Key added in v1.1.0 

func (c *Operation7[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TKey7, TRes]) Key(v1 TKey1, v2 TKey2, v3 TKey3, v4 TKey4, v5 TKey5, v6 TKey6, v7 TKey7) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type Operation8 added in v1.1.0 

type Operation8[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TKey6 UniqueFlag, TKey7 UniqueFlag, TKey8 UniqueFlag, TRes any] struct {
	// contains filtered or unexported fields
}

Operation8 表示 key 只由8个元素组成的缓存操作对象。

func NewOperation8 added in v1.1.0 

func NewOperation8[TKey1 UniqueFlag, TKey2 UniqueFlag, TKey3 UniqueFlag, TKey4 UniqueFlag, TKey5 UniqueFlag, TKey6 UniqueFlag, TKey7 UniqueFlag, TKey8 UniqueFlag, TRes any](
	cacheNamespace, keyPrefix string,
	cacheProvider CacheProvider,
	expireTime *Expiration,
) *Operation8[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TKey7, TKey8, TRes]

NewOperation8 类似 NewOperation ，但创建一个 key 只由8个元素组成的缓存操作对象。

func (*Operation8[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TKey7, TKey8, TRes]) Key added in v1.1.0 

func (c *Operation8[TKey1, TKey2, TKey3, TKey4, TKey5, TKey6, TKey7, TKey8, TRes]) Key(v1 TKey1, v2 TKey2, v3 TKey3, v4 TKey4, v5 TKey5, v6 TKey6, v7 TKey7, v8 TKey8) *KeyOperationT[TRes]

Key 获取指定key的缓存操作对象。

type RedisCacheProvider 

type RedisCacheProvider struct {
	// contains filtered or unexported fields
}

Redis 类型的缓存提供器。

func NewRedisCacheProvider 

func NewRedisCacheProvider(cli redis.Cmdable) *RedisCacheProvider

func (*RedisCacheProvider) Create 

func (cli *RedisCacheProvider) Create(key string, value any, t time.Duration) (bool, error)

implement CacheProvider.Create .

func (*RedisCacheProvider) Get 

func (cli *RedisCacheProvider) Get(key string, value any) error

implement CacheProvider.Get .

func (*RedisCacheProvider) Increase 

func (cli *RedisCacheProvider) Increase(key string) (int64, error)

implement CacheProvider.Increase .

func (*RedisCacheProvider) IncreaseOrCreate 

func (cli *RedisCacheProvider) IncreaseOrCreate(key string, increment int64, t time.Duration) (int64, error)

implement CacheProvider.IncreaseOrCreate .

func (*RedisCacheProvider) Remove 

func (cli *RedisCacheProvider) Remove(key string) (bool, error)

implement CacheProvider.Remove .

func (*RedisCacheProvider) Set 

func (cli *RedisCacheProvider) Set(key string, value any, t time.Duration) error

implement CacheProvider.Set .

func (*RedisCacheProvider) TryGet 

func (cli *RedisCacheProvider) TryGet(key string, value any) (bool, error)

implement CacheProvider.TryGet .

type UniqueFlag added in v1.1.0 

type UniqueFlag interface {
	~bool | ~string |
		~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64 |

		time.Time | UnixTime
}

type UnixTime 

type UnixTime time.Time

UnixTime 毫秒级时间戳。

func (UnixTime) MarshalJSON 

func (t UnixTime) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler.

func (UnixTime) String 

func (t UnixTime) String() string

String implements fmt.Stringer.

func (*UnixTime) UnmarshalJSON 

func (t *UnixTime) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements json.UnmarshalJSON.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.