Bagaimana untuk Mengurus Data Konfigurasi Pelanggan Serentak dengan Kemas Kini Bertambah dan Mengelakkan Kehilangan Data?

Muat Data Permulaan dan Kemas Kini Proses daripada Fail Bertambah

Pernyataan Masalah

Kod ini mengurus peta serentak yang menyimpan data untuk konfigurasi pelanggan. Semasa permulaan pelayan, ia memuatkan data daripada fail tertentu ke dalam peta. Ia juga memantau fail baharu dan mengemas kini peta dengan data daripada fail tersebut, mengosongkan keadaan lama.

Isu timbul apabila kaedah baca menghadapi ralat. Dalam kes ini, keseluruhan peta dikosongkan, meninggalkannya kosong walaupun data konfigurasi sebelumnya harus disimpan.

Penyelesaian

Penyelesaian yang dicadangkan memudahkan proses pengurusan data:

• Buat struct CustomerConfig: Struk ini menyimpan data untuk dicache sebagai "snapshot".
• Tentukan fungsi loadConfig: Fungsi ini memuatkan konfigurasi daripada fail yang dikehendaki.
• Tubuhkan struct ConfigCache: Pengurus cache ini menyimpan konfigurasi semasa dan menyediakan akses kepadanya. Ia memastikan akses serentak yang selamat dan mempunyai keupayaan untuk memuat semula konfigurasi cache.
• Laksanakan fungsi penyegar(): Goroutine ini menyemak secara berkala untuk perubahan dan memuatkan konfigurasi baharu jika dikesan. Ia menghormati closeCh untuk berhenti jika diminta.
• Laksanakan kaedah GetConfig(): Kaedah ini menyediakan akses baca sahaja kepada konfigurasi semasa.

Butiran Pelaksanaan

<code class="go">type CustomerConfig struct {
    Data map[string]bool

    // Add other properties if needed
    LoadedAt time.Time
}

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

    // Implement the file loading logic here
    // If an error occurs, return it

    // If successful, return the config
    return cfg, nil
}

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

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 goroutine to refresh config
    go cc.refresher()

    return cc, nil
}

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

    for {
        select {
        case <-ticker.C:
            // Implement the logic to detect changes
            changes := false
            if !changes {
                continue
            }

            cfg, err := loadConfig()
            if err != nil {
                log.Printf("Failed to load config: %v", err)
                continue
            }

            cc.configMu.Lock()
            cc.config = cfg
            cc.configMu.Unlock()

        case <-cc.closeCh:
            return
        }
    }
}

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

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

Penggunaan

<code class="go">// Initialize the cache
cc, err := NewConfigCache()
if err != nil {
    // Handle the error
}

// Get the current configuration when needed
cfg := cc.GetConfig()

// Remember to stop the cache manager when appropriate
cc.Stop()</code>

Penyelesaian ini menghalang isu kehilangan konfigurasi sebelumnya dan memudahkan pengendalian kemas kini konfigurasi.

Atas ialah kandungan terperinci Bagaimana untuk Mengurus Data Konfigurasi Pelanggan Serentak dengan Kemas Kini Bertambah dan Mengelakkan Kehilangan Data?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!