Go HashMap缓存的缓存数据访问缓存分层设计

在Go语言中，实现一个HashMap缓存的缓存数据访问分层设计，可以分为以下几个层次：

1. 数据访问层（Data Access Layer）：负责与数据库或其他数据源进行交互，获取和存储数据。
2. 缓存管理层（Cache Management Layer）：负责管理缓存数据，包括缓存数据的存储、更新和失效。
3. 业务逻辑层（Business Logic Layer）：负责处理业务逻辑，调用数据访问层获取数据，并使用缓存管理层进行缓存。

下面是一个简单的示例代码，展示了如何实现这种分层设计：

package main

import (
	"fmt"
	"sync"
	"time"
)

// DataAccessLayer 负责与数据库交互
type DataAccessLayer struct {
	db map[string]string
}

func NewDataAccessLayer() *DataAccessLayer {
	return &DataAccessLayer{
		db: make(map[string]string),
	}
}

func (dal *DataAccessLayer) Get(key string) (string, bool) {
	value, ok := dal.db[key]
	return value, ok
}

func (dal *DataAccessLayer) Set(key, value string) {
	dal.db[key] = value
}

// CacheManager 负责管理缓存数据
type CacheManager struct {
	cache map[string]*CacheItem
	mu    sync.RWMutex
	ttl   time.Duration
}

type CacheItem struct {
	value      string
	expiration time.Time
}

func NewCacheManager(ttl time.Duration) *CacheManager {
	return &CacheManager{
		cache: make(map[string]*CacheItem),
		ttl:   ttl,
	}
}

func (cm *CacheManager) Get(key string) (string, bool) {
	cm.mu.RLock()
	defer cm.mu.RUnlock()
	item, ok := cm.cache[key]
	if !ok || time.Now().After(item.expiration) {
		return "", false
	}
	return item.value, true
}

func (cm *CacheManager) Set(key, value string) {
	expiration := time.Now().Add(cm.ttl)
	cm.mu.Lock()
	defer cm.mu.Unlock()
	cm.cache[key] = &CacheItem{
		value:      value,
		expiration: expiration,
	}
}

// BusinessLogicLayer 负责处理业务逻辑
type BusinessLogicLayer struct {
	dal *DataAccessLayer
	cm  *CacheManager
}

func NewBusinessLogicLayer(dal *DataAccessLayer, cm *CacheManager) *BusinessLogicLayer {
	return &BusinessLogicLayer{
		dal: dal,
		cm:  cm,
	}
}

func (bl *BusinessLogicLayer) GetData(key string) (string, error) {
	// 先从缓存中获取数据
	if value, ok := bl.cm.Get(key); ok {
		fmt.Println("Cache hit")
		return value, nil
	}

	// 如果缓存中没有数据，从数据库中获取
	value, err := bl.dal.Get(key)
	if err != nil {
		return "", err
	}

	// 将数据存入缓存
	bl.cm.Set(key, value)
	fmt.Println("Cache miss, data fetched from database")
	return value, nil
}

func main() {
	dal := NewDataAccessLayer()
	cm := NewCacheManager(5 * time.Second)
	bl := NewBusinessLogicLayer(dal, cm)

	// 模拟数据存储和访问
	dal.Set("key1", "value1")
	dal.Set("key2", "value2")

	data, err := bl.GetData("key1")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Data:", data)
	}

	data, err = bl.GetData("key2")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Data:", data)
	}

	time.Sleep(6 * time.Second)

	data, err = bl.GetData("key1")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Data:", data)
	}
}

在这个示例中：

1. DataAccessLayer 负责与数据库交互，提供 Get 和 Set 方法。
2. CacheManager 负责管理缓存数据，提供 Get 和 Set 方法。
3. BusinessLogicLayer 负责处理业务逻辑，调用 DataAccessLayer 获取数据，并使用 CacheManager 进行缓存。

通过这种分层设计，可以实现缓存的高效访问和数据的持久化存储。