> wsl.exe -v
WSL version: 1.2.5.0
Kernel version: 5.15.90.1
WSLg version: 1.0.51
MSRDC version: 1.2.3770
Direct3D version: 1.608.2-61064218
DXCore version: 10.0.25131.1002-220531-1700.rs-onecore-base2-hyp
Windows version: 10.0.19045.3031

package cache

// 缓存，一般先将数据从磁盘读出来写到内存里，供用户高速访问，减少读磁盘 -- 快取
// 另有缓冲，将数据先写到内存里，待装满后一次性写入磁盘，可以少写很多次 -- 缓冲
//
// 不难看出，无论快取还是缓冲，都涉及到内存和磁盘的读写。
//
// 首先，对于缓存，目前使用较多的中间件是redis、memcached等，当然也有自己在程序中内置map充当缓存的。
// 那么，下面来看下如何在内存和磁盘之间同步数据：

type Cache interface {
	// exp表示当前时间后的exp秒后过期，传0则无过期
	Set(key, value string, exp int) error
	Del(key string) error
	Get(key string) (value string, err error)
}

type Store interface {
	Create(key, value string, exp int) error
	Delete(key string) error
	Update(key, value string, exp int) error
	Get(key string) (vlaue string, err error)
}

// 用户 有增删改查四个操作，在操作时，对应的缓存和磁盘如何变化呢？
type Client struct {
	cache Cache
	store Store
}

func NewClient(
	cache Cache,
	store Store,
) *Client {
	return &Client{
		cache: cache,
		store: store,
	}
}

const (
	defExp = 300
)

// Add 先写磁盘还是缓存呢？
func (client *Client) Add(key, value string) {
	// 会不会已经在Store里存在了呢？
	// 先从Store Get一次？
	// 一般来说，key都是唯一的：
	// 此时，必须请求一次Store，确认数据不存在；如果此时数据存在，直接返回错误
	if v, err := client.store.Get(key); err == nil && v != "" {
		return
	}

	// 缓存里会不会也有呢？
	// 先从Cache里读一次？
	// 如果能通过业务检查，正常来说，缓存里是没有的；

	// 写磁盘
	client.store.Create(key, value, defExp)

	// 1. 写缓存
	// client.cache.Set(key, value, defExp)
	// 2. 不写，等获取时从磁盘取
}

func (client *Client) Mod(key, value string) {
	// 更新磁盘
	client.store.Update(key, value, defExp)

	// 1. 更新缓存
	// client.cache.Set(key, value, defExp)
	// 2. 不更新，删掉缓存，等获取时从磁盘取 -- Cache Aside Pattern(旁路缓存方案): 一个 lazy 计算的思想，不要每次都重新做复杂的计算，而是让它到需要被使用的时候再重新计算
	client.cache.Del(key)
}

func (client *Client) Del(key string) {
	// 从磁盘删除
	client.store.Delete(key)

	// 1. 从缓存删除
	client.cache.Del(key)
}

func (client *Client) Get(key string) (string, error) {
	// 从Cache获取
	v, err := client.cache.Get(key)
	if err != nil {
		return "", err
	}
	if v == "" {
		// 以SingleFlight方式从Store读:
		// https://pkg.go.dev/golang.org/x/sync/singleflight
		// 这个库的主要作用就是将一组相同的请求合并成一个请求，实际上只会去请求一次，然后对所有的请求返回相同的结果。
		// 在一个请求的时间周期内实际上只会向底层的数据库发起一次请求大大减少对数据库的压力。
		{
			valueFromStore, err := client.store.Get(key)
			if err != nil {
				return "", err
			}
			v = valueFromStore
		}

		// 设置Cache
		client.cache.Set(key, v, defExp)
	}

	return v, nil
}