MemoryStore分层
MemoryStore的分层主要是将数据库中的需要的操作都抽象分离开,在原理的设计中,Handler操作全局状态的 Targets 和 mux。但是显然这样会出现或多或少的问题
比如当我们进行并发测试等,虽然我们有锁了,但是对于连续的两个测试来说,如果只靠锁,无法解决串行污染和数据污染的问题,我们需要在每次测试前初始化数据让测试得以进行,这同时就直觉性的引出我们需要将对数据的操作 “抽象” 出来的思想,于是我们遍设计了 MemoryStore分层这样的工程架构
什么架构?
package main
import (
"errors"
"sync"
)
var (
ErrTargetNotFound = errors.New("target not found")
ErrInvalidTarget = errors.New("name and address are required")
)
type MemoryStore struct {
targets map[int]Target
nextID int
mu sync.Mutex
}
func InitMemoryStore() *MemoryStore {
return &MemoryStore{
targets: make(map[int]Target),
nextID: 0,
}
}
func (store *MemoryStore) Create(req TargetRequest) Target {
store.mu.Lock()
defer store.mu.Unlock()
store.nextID += 1
store.targets[store.nextID] = Target{
Id: store.nextID,
Name: req.Name,
Addr: req.Addr,
}
return store.targets[store.nextID]
}
func (store *MemoryStore) List() []Target {
store.mu.Lock()
list := make([]Target, 0, len(store.targets))
for _, target := range store.targets {
list = append(list, target)
}
store.mu.Unlock()
return list
}
func (store *MemoryStore) Get(id int) (Target, error) {
store.mu.Lock()
res, ok := store.targets[id]
store.mu.Unlock()
if !ok {
err := errors.New("invalid user id")
return res, err
}
return res, nil
}
func (store *MemoryStore) Update(id int, req TargetRequest) (Target, error) {
store.mu.Lock()
defer store.mu.Unlock()
target, ok := store.targets[id]
if !ok {
return target, ErrTargetNotFound
}
if req.Name == "" || req.Addr == "" {
return target, ErrInvalidTarget
}
store.targets[id] = Target{
Name: req.Name,
Addr: req.Addr,
Id: target.Id,
}
return store.targets[id], nil
}
func (store *MemoryStore) Delete(id int) error {
store.mu.Lock()
defer store.mu.Unlock()
_, ok := store.targets[id]
if !ok {
err := errors.New("invaild target")
return err
}
delete(store.targets, id)
return nil
}go这是store.go的源码,我们可以注意到所有之前的全局变量被抽象成了 MemoryStore 的 struct,同时对这些数据的读写操作都被统一抽象为了这个 struct 的成员业务函数
Store的注入
现在我们将基础的CRUD抽象成为了业务函数并且抽象出 MemoryStore 后,对于主函数中的Handler也要进行修改,随后将 Store 注入这些 Handler 中
这里做的就是,也将 Handler 抽象成一个 Struct,并且里面的成员含有 *MemoryStore ,随后这个 Handler 就“拥有了” 这个 store 并且能够访问其方法
type Handler struct {
store *MemoryStore
}go同时我们重构了 main 函数,将注入过程抽离成 run 函数
func run() error {
store := InitMemoryStore()
mux := NewRouter(store)
server := &http.Server{
Addr: ":9090",
Handler: mux,
ReadHeaderTimeout: 5 * time.Second, // 客户端传入Header限制
ReadTimeout: 8 * time.Second, // 服务器读取整个请求时间限制
WriteTimeout: 10 * time.Second, // 服务器写入响应时间限制
IdleTimeout: 30 * time.Second, // HTTP keep-alive
}
serverErr := make(chan error, 1)
ctx, stop := signal.NotifyContext(
context.Background(),
os.Interrupt,
syscall.SIGTERM,
)
defer stop()
go func() {
serverErr <- server.ListenAndServe()
}()
select {
case err := <-serverErr:
if err != nil && !errors.Is(err, http.ErrServerClosed) {
return fmt.Errorf("listen and serve: %w", err)
}
log.Println("Server Normal exit")
return nil
case <-ctx.Done():
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err := server.Shutdown(shutdownCtx)
if err != nil {
return fmt.Errorf("shutdown server: %w", err)
}
log.Println("get system stop signal,exit Http server")
return nil
}
}go知识关联
0 反向链接 · 1 提及笔记反向链接0
暂无其他笔记引用本篇
提及笔记1
局部关系图谱
悬停高亮 · 点击跳转