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 進行緩存。

通過這種分層設計，可以實現緩存的高效訪問和數據的持久化存儲。