Skip to content

Commit

Permalink
⚡ Optimize project structure
Browse files Browse the repository at this point in the history
  • Loading branch information
feyman committed May 11, 2023
1 parent 8908c10 commit ef68b2b
Show file tree
Hide file tree
Showing 9 changed files with 313 additions and 131 deletions.
3 changes: 2 additions & 1 deletion .gitignore
View file
Expand Up @@ -14,4 +14,5 @@
*.out

# Dependency directories (remove the comment below to include it)
# vendor/
vendor/
_example/
172 changes: 112 additions & 60 deletions README.md
View file
@@ -1,22 +1,25 @@
# cacheit

![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/feymanlee/cacheit?style=flat-square)
[![Go Report Card](https://goreportcard.com/badge/github.com/feymanlee/cacheit)](https://goreportcard.com/report/github.com/feymanlee/cacheit)
[![Unit-Tests](https://github.com/feymanlee/logit/workflows/Unit-Tests/badge.svg)](https://github.com/feymanlee/cacheit/actions)
[![Coverage Status](https://coveralls.io/repos/github/feymanlee/cacheit/badge.svg?branch=main)](https://coveralls.io/github/feymanlee/cacheit?branch=main)
[![Go Reference](https://pkg.go.dev/badge/github.com/feymanlee/cacheit.svg)](https://pkg.go.dev/github.com/feymanlee/cacheit)
[![License](https://img.shields.io/github/license/feymanlee/cacheit)](./LICENSE)

GO 缓存库，支持 [go-redis](https://github.com/redis/go-redis/tree/v8) 和 [go-cache](https://github.com/patrickmn/go-cache) 作为缓存驱动。它提供了一个简单的接口，允许您轻松地在您的项目中实现缓存。

GO 缓存库，支持 [go-redis](https://github.com/redis/go-redis/tree/v8)
和 [go-cache](https://github.com/patrickmn/go-cache) 作为缓存驱动。它提供了一个简单的接口，允许您轻松地在您的项目中实现缓存。

## 安装

使用以下命令将 `cacheit` 添加到您的 Go 项目中：

```sh
go get github.com/feymanlee/cacheit
```

## 接口定义

```go
type Driver[V any] interface {
// Add Store an item in the cache if the key doesn't exist.
Expand Down Expand Up @@ -45,198 +48,247 @@ type Driver[V any] interface {
// Decrement the value of an item in the cache.
Decrement(key string, n V) (V, error)
// Remember Get an item from the cache, or execute the given Closure and store the result.
Remember(key string, ttl time.Duration, callback func() (V, error)) (V, error)
Remember(key string, ttl time.Duration, callback func () (V, error)) (V, error)
// RememberForever Get an item from the cache, or execute the given Closure and store the result forever.
RememberForever(key string, callback func() (V, error)) (V, error)
RememberForever(key string, callback func () (V, error)) (V, error)
// TTL Get cache ttl
TTL(key string) (time.Duration, error)
// WithCtx with context
WithCtx(ctx context.Context) Driver[V]
// WithWithSerializer with cache serializer
WithWithSerializer(ctx context.Context) Driver[V]
}
```

## Usage
### Redis Driver

### Base Usage

```go
// 初始化 Redis 客户端
redisClient := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
package main

import (
"fmt"
"log"
"time"

// 创建缓存驱动实例
driver, err := cacheit.New[string](cacheit.DriverRedis,
cacheit.WithRedisClient(redisClient),
cacheit.WithPrefix("myapp"),
cacheit.WithSerializer(cacheit.JsonSerializer)
"github.com/feymanlee/cacheit"
"github.com/go-redis/redis/v8"
gocache "github.com/patrickmn/go-cache"
)
if err != nil {
log.Fatal(err)

func main() {
redisClient := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
err := cacheit.RegisterRedisDriver("redis_test", redisClient, "cache_prefix")
if err != nil {
log.Fatal(err)
}
// go-cache 客户端
memCache := gocache.New(5*time.Minute, 10*time.Minute)
err = cacheit.RegisterGoCacheDriver("memory_test", memCache, "cache_prefix")
if err != nil {
log.Fatal(err)
}
// set default cache
cacheit.SetDefault("redis_test")

driver, err := cacheit.Use[string]("memory_test")
if err != nil {
log.Fatal(err)
}
err = driver.Set("cache_key", "cache_value", time.Minute)
if err != nil {
log.Fatal(err)
}
get, err := cacheit.UseDefault[string]().Get("cache_key")
if err != nil {
return
}
fmt.Println(get)
}
```
### Go-cache Driver
```go
// go-cache 客户端
memCache := gocache.New(5*time.Minute, 10*time.Minute)
// 初始化 GoCacheDriver
driver, _ := New[string](DriverMemory,
WithMemCache(memCache),
cacheit.WithPrefix("myapp")
)

```
### Add Cache

```go
err = driver.Add("key", "value", time.Minute*10)
if err != nil {
log.Println("Error adding cache:", err)
log.Println("Error adding cache:", err)
}
```

### Set Cache

```go
err = driver.Set("key2", "value2", time.Minute*5)
if err != nil {
log.Println("Error setting cache:", err)
log.Println("Error setting cache:", err)
}
```

### Get Cache

```go
value, err := driver.Get("key2")
if err != nil {
log.Println("Error getting cache:", err)
log.Println("Error getting cache:", err)
} else {
log.Println("Cache value:", value)
log.Println("Cache value:", value)
}
```

### Batch Set Cache

```go
err = driver.SetMany([]cacheit.Many[string]{
{Key: "key3", Value: "value3", TTL: time.Minute * 10},
{Key: "key4", Value: "value4", TTL: time.Minute * 15},
{Key: "key3", Value: "value3", TTL: time.Minute * 10},
{Key: "key4", Value: "value4", TTL: time.Minute * 15},
})
if err != nil {
log.Println("Error setting many caches:", err)
log.Println("Error setting many caches:", err)
}
```

### Batch Get Cache

```go
values, err := driver.Many([]string{"key2", "key3", "key4"})
if err != nil {
log.Println("Error getting many caches:", err)
log.Println("Error getting many caches:", err)
} else {
log.Println("Cache values:", values)
log.Println("Cache values:", values)
}
```

### Set Cache Not Expired

```go
err = driver.Forever("key5", "value5")
if err != nil {
log.Println("Error storing cache forever:", err)
log.Println("Error storing cache forever:", err)
}
```

### Remove Cache

```go
err = driver.Forget("key")
if err != nil {
log.Println("Error removing cache:", err)
log.Println("Error removing cache:", err)
}
```

### Remove All Cache

```go
err = driver.Flush()
if err != nil {
log.Println("Error flushing cache:", err)
log.Println("Error flushing cache:", err)
}
```

### Determined Cache Has Existed

```go
has, err := driver.Has("key2")
if err != nil {
log.Println("Error checking if cache exists:", err)
log.Println("Error checking if cache exists:", err)
} else if has {
log.Println("Cache key2 exists")
log.Println("Cache key2 exists")
} else {
log.Println("Cache key2 does not exist")
log.Println("Cache key2 does not exist")
}
```

### Set Numeric Cache

```go
err = driver.SetNumber("number_key", 1, time.Minute*10)
if err != nil {
log.Println("Error setting number cache:", err)
log.Println("Error setting number cache:", err)
}
```

### Increment Numeric Cache

```go
newValue, err := driver.Increment("number_key", 1)
if err != nil {
log.Println("Error incrementing cache value:", err)
log.Println("Error incrementing cache value:", err)
} else {
log.Println("Incremented cache value:", newValue)
log.Println("Incremented cache value:", newValue)
}
```

### Decrement Numeric Cache

```go
newValue, err := driver.Increment("number_key", 1)
if err != nil {
log.Println("Error incrementing cache value:", err)
log.Println("Error incrementing cache value:", err)
} else {
log.Println("Incremented cache value:", newValue)
log.Println("Incremented cache value:", newValue)
}
```

### Get Cache Or Set It If Cache Not Exist

```go
rememberValue, err := driver.Remember("remember_key", time.Minute*10, func() (string, error) {
time.Sleep(time.Millisecond * 50)
return "remember_value", nil
rememberValue, err := driver.Remember("remember_key", time.Minute*10, func () (string, error) {
time.Sleep(time.Millisecond * 50)
return "remember_value", nil
})
if err != nil {
log.Println("Error remembering cache:", err)
log.Println("Error remembering cache:", err)
} else {
log.Println("Remember cache value:", rememberValue)
log.Println("Remember cache value:", rememberValue)
}
```

### Retrieve The Cache Or Set It To Never Expire If The Cache Does Not Exist

```go
rememberForeverValue, err := driver.RememberForever("remember_forever_key", func() (string, error) {
time.Sleep(time.Millisecond * 50)
return "remember_forever_value", nil
time.Sleep(time.Millisecond * 50)
return "remember_forever_value", nil
})
if err != nil {
log.Println("Error remembering cache forever:", err)
log.Println("Error remembering cache forever:", err)
} else {
log.Println("Remember cache value forever:", rememberForeverValue)
log.Println("Remember cache value forever:", rememberForeverValue)
}
```

### Get Cache TTL

```go
ttl, err := driver.TTL("key2")
if err != nil {
log.Println("Error getting cache TTL:", err)
log.Println("Error getting cache TTL:", err)
} else {
log.Println("Cache TTL:", ttl)
log.Println("Cache TTL:", ttl)
}
```

### With Context

```go
err = driver.WithCtx(context.TODO()).Set("key2", "value2", time.Minute*5)
if err != nil {
log.Println("Error setting cache:", err)
log.Println("Error setting cache:", err)
}
```

## 更多功能

请查阅源代码以了解更多功能和用法。

## 贡献

欢迎向项目贡献代码、提交 bug 报告或提出新功能建议。请务必遵循贡献指南。

## 许可证

本项目基于 MIT 许可证 发布。

0 comments on commit ef68b2b

Please sign in to comment.