-
Notifications
You must be signed in to change notification settings - Fork 0
/
redis.go
128 lines (105 loc) · 3.2 KB
/
redis.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package cache
import (
"encoding/json"
"sync"
"time"
"github.com/go-redis/redis"
)
// RedisDriver implements the Cache interface using Redis as the storage driver.
type RedisDriver struct {
client *redis.Client
}
// NewRedisDriver creates a new RedisDriver instance.
func NewRedisDriver(addr, password string, db int) *RedisDriver {
return NewRedisDriverWithOptions(&redis.Options{
Addr: addr,
Password: password,
DB: db,
})
}
// NewRedisDriverWithOptions creates a new RedisDriver instance with the specified options.
func NewRedisDriverWithOptions(opt *redis.Options) *RedisDriver {
client := redis.NewClient(opt)
return &RedisDriver{
client: client,
}
}
// Set stores the given value in the cache with the specified expiration time.
func (c *RedisDriver) Set(key string, value interface{}, expiration time.Duration) error {
data, err := json.Marshal(value)
if err != nil {
return err
}
return c.client.Set(key, data, expiration).Err()
}
// Get retrieves the value from the cache for the given key.
// If the key is found, the value is unmarshaled into the provided variable.
// Returns true if the key is found in the cache, false otherwise.
func (c *RedisDriver) Get(key string, value interface{}) (bool, error) {
data, err := c.client.Get(key).Bytes()
if err == redis.Nil {
return false, nil
} else if err != nil {
return false, err
}
err = json.Unmarshal(data, value)
if err != nil {
return false, err
}
return true, nil
}
// OptimizedRedisDriver implements the Cache interface using Redis as the storage driver with performance optimizations.
type OptimizedRedisDriver struct {
client *redis.Client
cache sync.Map
}
// NewOptimizedRedisDriver creates a new OptimizedRedisDriver instance.
func NewOptimizedRedisDriver(addr, password string, db int) *OptimizedRedisDriver {
return NewOptimizedRedisDriverWithOptions(&redis.Options{
Addr: addr,
Password: password,
DB: db,
})
}
// NewOptimizedRedisDriverWithOptions creates a new OptimizedRedisDriver instance with the specified options.
func NewOptimizedRedisDriverWithOptions(opt *redis.Options) *OptimizedRedisDriver {
client := redis.NewClient(opt)
return &OptimizedRedisDriver{
client: client,
cache: sync.Map{},
}
}
// Set stores the given value in the cache with the specified expiration time.
func (c *OptimizedRedisDriver) Set(key string, value interface{}, expiration time.Duration) error {
data, err := json.Marshal(value)
if err != nil {
return err
}
err = c.client.Set(key, data, expiration).Err()
if err != nil {
return err
}
c.cache.Store(key, value)
return nil
}
// Get retrieves the value from the cache for the given key.
// If the key is found, the value is returned from the cache.
// Returns true if the key is found in the cache, false otherwise.
func (c *OptimizedRedisDriver) Get(key string, value interface{}) (bool, error) {
cachedValue, ok := c.cache.Load(key)
if ok {
return true, json.Unmarshal(cachedValue.([]byte), value)
}
data, err := c.client.Get(key).Bytes()
if err == redis.Nil {
return false, nil
} else if err != nil {
return false, err
}
err = json.Unmarshal(data, value)
if err != nil {
return false, err
}
c.cache.Store(key, data)
return true, nil
}