Bagaimana untuk Merekabentuk Cache Konfigurasi yang Mengendalikan Kemas Kini dan Ralat dengan Anggun?

Muat Konfigurasi Dari Fail dan Muat Semula dengan Kemas Kini Baharu

Pernyataan Masalah:

Kod reka bentuk melibatkan memuatkan konfigurasi daripada fail pada permulaan dan menyegarkannya secara berkala dengan versi yang lebih baharu. Matlamatnya adalah untuk mempunyai mekanisme yang mengendalikan keperluan berikut:

• Akses serentak kepada konfigurasi
• Memuat semula perubahan konfigurasi yang dikesan
• Kebolehaksesan kepada konfigurasi terkini
• Kebolehcapaian segera kepada konfigurasi terbaharu semasa kemas kini
• Pemeliharaan konfigurasi sebelumnya jika kemas kini gagal

Reka bentuk awal menggunakan peta serentak untuk menyimpan konfigurasi , tetapi menghadapi isu di mana ralat semasa mengemas kini boleh membawa kepada peta kosong.

Penyelesaian:

Reka bentuk ringkas dicadangkan yang memenuhi semua keperluan:

Struktur CustomerConfig:

Mentakrifkan konfigurasi untuk dicache:

type CustomerConfig struct {
    Data map[string]bool
    LoadedAt time.Time
}

Fungsi loadConfig:

Muat konfigurasi daripada fail:

func loadConfig() (*CustomerConfig, error) {
    cfg := &CustomerConfig{
        Data:     map[string]bool{},
        LoadedAt: time.Now(),
    }

    // Logic to load files and populate cfg.Data
    // If an error occurs, return it

    // If loading succeeds, return the config
    return cfg, nil
}

Struktur ConfigCache:

Mengurus caching konfigurasi:

type ConfigCache struct {
    configMu sync.RWMutex
    config   *CustomerConfig
    closeCh  chan struct{}
}

Fungsi NewConfigCache:

Mencipta cache konfigurasi baharu:

func NewConfigCache() (*ConfigCache, error) {
    cfg, err := loadConfig()
    if err != nil {
        return nil, fmt.Errorf("loading initial config failed: %w", err)
    }

    cc := &ConfigCache{
        config:  cfg,
        closeCh: make(chan struct{}),
    }

    // Launch a goroutine to periodically check for changes and load new configs
    go cc.refresher()

    return cc, nil
}

Fungsi penyegar:

Semak perubahan konfigurasi dan kemas kini cache secara berkala:

func (cc *ConfigCache) refresher() {
    ticker := time.NewTicker(1 * time.Minute) // Every minute
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            // Check for changes
            changes := false // Logic to detect changes
            if !changes {
                continue // No changes, continue
            }

            // Changes! Load new config:
            cfg, err := loadConfig()
            if err != nil {
                log.Printf("Failed to load config: %v", err)
                continue // Keep the previous config
            }

            // Apply / store new config
            cc.configMu.Lock()
            cc.config = cfg
            cc.configMu.Unlock()

        case <-cc.closeCh:
            return
        }
    }
}

Fungsi Berhenti:

Menghentikan goroutine penyegar:

func (cc *ConfigCache) Stop() {
    close(cc.closeCh)
}

Fungsi GetConfig:

Akses konfigurasi semasa:

func (cc *ConfigCache) GetConfig() *CustomerConfig {
    cc.configMu.RLock()
    defer cc.configMu.RUnlock()
    return cc.config
}

Penggunaan:

cc, err := NewConfigCache()
if err != nil {
    // Handle the error appropriately
}

// Access the configuration whenever needed:
cfg := cc.GetConfig()
// Use the configuration here

// Stop the cache refreshing when necessary:
cc.Stop()

Penyelesaian ini memastikan:

• Akses serentak kepada konfigurasi
• Muat semula pada perubahan yang dikesan
• Kebolehaksesan kepada konfigurasi terbaharu
• Kebolehcapaian segera semasa kemas kini
• Pemeliharaan konfigurasi sebelumnya pada kegagalan kemas kini

Atas ialah kandungan terperinci Bagaimana untuk Merekabentuk Cache Konfigurasi yang Mengendalikan Kemas Kini dan Ralat dengan Anggun?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!