用go设计开发一个自己的轻量级登录库/框架吧(拓展篇) ...

给自己的库/框架拓展一下吧(拓展篇)

主库：weloe/token-go: a light login library.
扩展库：weloe/token-go-extensions (github.com)
本篇给主库扩展一个Adapter提供简单的外部数据存储。
思路

一个库/框架往往不能完成所有事情，需要其他库/框架的支持才能达到更加完善的效果。本篇会对token-go框架的Adapter进行简单的拓展。
首先我们应该想想Adapter是用来干什么的？
从第一篇我们就明确其职责，就是存储数据。我们在token-go里提供了一个内置的adapter:default_adapter，用于框架底层的数据存储，但是这种内存的数据存储有着很多的缺陷，并且没有经过实际的生产测试使用。也因此，我们应该提供更成熟的存储方案来提供给使用者去替代它。
这就是本篇要实现的redis_adapter了
实现

这里还有一个点要注意，将数据存储到外部需要确定数据的序列化和反序列化方法。因此，我们加了一个SerializerAdapter接口，要求新的Adapter选择实现。
token-go/serializer_adapter.go at master · weloe/token-go · GitHub

1. package persist
3. import "github.com/weloe/token-go/model"
5. type SerializerAdapter interface {
6.         Adapter
7.         Serialize(*model.Session) ([]byte, error)
8.         UnSerialize([]byte) (*model.Session, error)
9. }

复制代码

具体的调用则是在enforcer对session进行存储或者取出数据的时候进行调用。

1. func (e *Enforcer) GetSession(id string) *model.Session {
2.         if v := e.adapter.Get(e.spliceSessionKey(id)); v != nil {
3.                 if s := e.sessionUnSerialize(v); s != nil {
4.                         return s
5.                 } else {
6.                         session, ok := v.(*model.Session)
7.                         if !ok {
8.                                 return nil
9.                         }
10.                         return session
11.                 }
12.         }
13.         return nil
14. }

复制代码

这里的sessionUnSerialize()实际上就是尝试调用了adapter实现的反序列化方法。同理SetSession()也是一样的。
最后就是RedisAdapter了
token-go-extensions/adapter.go at master · weloe/token-go-extensions · GitHub
并不难，只要实现我们之前的Adapter和SerializerAdapter两个接口就行了。
序列化方法使用json，方便查看

1. package redis_adapter
3. import (
4.         "context"
5.         "encoding/json"
6.         "github.com/go-redis/redis/v8"
7.         "github.com/weloe/token-go/model"
8.         "github.com/weloe/token-go/persist"
9.         "time"
10. )
12. var _ persist.Adapter = (*RedisAdapter)(nil)
14. var _ persist.SerializerAdapter = (*RedisAdapter)(nil)
16. type RedisAdapter struct {
17.         client *redis.Client
18. }
20. func (r *RedisAdapter) Serialize(session *model.Session) ([]byte, error) {
21.         return json.Marshal(session)
22. }
24. func (r *RedisAdapter) UnSerialize(bytes []byte) (*model.Session, error) {
25.         s := &model.Session{}
26.         err := json.Unmarshal(bytes, s)
27.         if err != nil {
28.                 return nil, err
29.         }
30.         return s, nil
31. }
33. func (r *RedisAdapter) GetStr(key string) string {
34.         res, err := r.client.Get(context.Background(), key).Result()
35.         if err != nil {
36.                 return ""
37.         }
38.         return res
39. }
41. func (r *RedisAdapter) SetStr(key string, value string, timeout int64) error {
42.         err := r.client.Set(context.Background(), key, value, time.Duration(timeout)*time.Second).Err()
43.         if err != nil {
44.                 return err
45.         }
46.         return nil
47. }
49. func (r *RedisAdapter) UpdateStr(key string, value string) error {
50.         err := r.client.Set(context.Background(), key, value, 0).Err()
51.         if err != nil {
52.                 return err
53.         }
54.         return nil
55. }
57. func (r *RedisAdapter) DeleteStr(key string) error {
58.         err := r.client.Del(context.Background(), key).Err()
59.         if err != nil {
60.                 return err
61.         }
62.         return nil
63. }
65. func (r *RedisAdapter) GetStrTimeout(key string) int64 {
66.         duration, err := r.client.TTL(context.Background(), key).Result()
67.         if err != nil {
68.                 return -1
69.         }
70.         return int64(duration.Seconds())
71. }
73. func (r *RedisAdapter) UpdateStrTimeout(key string, timeout int64) error {
74.         var duration time.Duration
75.         if timeout < 0 {
76.                 duration = -1
77.         } else {
78.                 duration = time.Duration(timeout) * time.Second
79.         }
80.         err := r.client.Expire(context.Background(), key, duration).Err()
81.         if err != nil {
82.                 return err
83.         }
84.         return nil
85. }
87. func (r *RedisAdapter) Get(key string) interface{} {
88.         res, err := r.client.Get(context.Background(), key).Result()
89.         if err != nil {
90.                 return nil
91.         }
92.         s := &model.Session{}
93.         err = json.Unmarshal([]byte(res), s)
94.         if err != nil {
95.                 return nil
96.         }
97.         return s
98. }
100. func (r *RedisAdapter) Set(key string, value interface{}, timeout int64) error {
101.         err := r.client.Set(context.Background(), key, value, time.Duration(timeout)*time.Second).Err()
102.         if err != nil {
103.                 return err
104.         }
105.         return nil
106. }
108. func (r *RedisAdapter) Update(key string, value interface{}) error {
109.         err := r.client.Set(context.Background(), key, value, 0).Err()
110.         if err != nil {
111.                 return err
112.         }
113.         return nil
114. }
116. func (r *RedisAdapter) Delete(key string) error {
117.         err := r.client.Del(context.Background(), key).Err()
118.         if err != nil {
119.                 return err
120.         }
121.         return nil
122. }
124. func (r *RedisAdapter) GetTimeout(key string) int64 {
125.         duration, err := r.client.TTL(context.Background(), key).Result()
126.         if err != nil {
127.                 return -1
128.         }
129.         return int64(duration.Seconds())
130. }
132. func (r *RedisAdapter) UpdateTimeout(key string, timeout int64) error {
133.         var duration time.Duration
134.         if timeout < 0 {
135.                 duration = -1
136.         } else {
137.                 duration = time.Duration(timeout) * time.Second
138.         }
139.         err := r.client.Expire(context.Background(), key, duration).Err()
140.         if err != nil {
141.                 return err
142.         }
143.         return nil
144. }
146. func (r *RedisAdapter) DeleteBatchFilteredKey(filterKeyPrefix string) error {
147.         var cursor uint64 = 0
148.         for {
149.                 keys, cursor, err := r.client.Scan(context.Background(), cursor, filterKeyPrefix+"*", 100).Result()
150.                 if err != nil {
151.                         return err
152.                 }
154.                 if len(keys) == 0 && cursor == 0 {
155.                         break
156.                 }
158.                 // use pip delete batch
159.                 pipe := r.client.Pipeline()
161.                 for _, key := range keys {
162.                         pipe.Del(context.Background(), key)
163.                 }
165.                 _, err = pipe.Exec(context.Background())
166.                 if err != nil {
167.                         return err
168.                 }
169.         }
171.         return nil
172. }

复制代码

实现完接口，再写几个初始化方法

1. func NewAdapter(addr string, username string, password string, db int) (*RedisAdapter, error) {
2.         return NewAdapterByOptions(&redis.Options{
3.                 Addr:     addr,
4.                 Username: username,
5.                 Password: password,
6.                 DB:       db,
7.         })
8. }
10. func NewAdapterByOptions(options *redis.Options) (*RedisAdapter, error) {
11.         client := redis.NewClient(options)
12.         _, err := client.Ping(context.Background()).Result()
13.         if err != nil {
14.                 return nil, err
15.         }
16.         return &RedisAdapter{client: client}, nil
17. }

复制代码

测试

就不贴测试代码了，就放个链接~
token-go-extensions/adapter_test.go at master · weloe/token-go-extensions · GitHub
最后

这样RedisAdapter就开发完了吗？不不不，并没有。
用户量的增大，对容错，一致性等等的要求提高，可能需要用到多个redis，这就需要我们继续适配开发一个ClusterAdapter了，为什么我这里不往下写了？阳了好累当然是因为还在开发中~~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！