imicola MemoryStore分层
MemoryStore分层

MemoryStore分层

432 字 · 约 1 分钟

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 提及笔记
局部关系图谱 悬停高亮 · 点击跳转