Nutzen Sie Hochleistungs-Cache mit TTL und Festplattenpersistenz

1.Einleitung

Beschleunigen Sie Ihre Golang-Projekte, ohne jedes Mal eine Datenbank einrichten zu müssen, wenn Sie ein neues Projekt beginnen. Sind Sie es leid, Datenbanken von Grund auf neu zu konfigurieren? Nur um sich neuen Problemen zu stellen? Suchen Sie nicht weiter. In diesem Blog werden wir uns mit der Golang-Caching-Bibliothek mit Unterstützung für TTL, Festplattenpersistenz und Hash-Datentyp befassen.

GoSwift.

2.Voraussetzung

• Grundkenntnisse von Golang
• Wissen darüber, wie ein typischer Cache funktioniert

3.Eigenschaften

1. Befehl festlegen und abrufen
2. Befehl aktualisieren
3. Entf-Befehl
4. Existiert-Befehl
5. Unterstützung für TTL
6. Unterstützung für Festplattenspeicherung (Snapshots)
7. Unterstützt Hash-Datentypen (Hset, Hget, HgetAll, HMset)
8. Sicheres Verriegeln

Set & Get-Befehl

import (
    "fmt"
    "github.com/leoantony72/goswift"
)

func main(){
    cache := goswift.NewCache()

    // Value 0 indicates no expiry
    cache.Set("key", "value", 0)

    val, err := cache.Get("key")
    if err !=nil{
        fmt.Println(err)
        return
    }
    fmt.Println("key", val)
}

Befehl aktualisieren

// Update value
// @Update(key string, val interface{}) error
err = cache.Update("key","value2")
if err != nil{
    fmt.Println(err)
    return
}

Del-Befehl && Existiert-Befehl

// Delete command
// @Del(key string)
cache.Del("key")

// Exist command
// @Exists(key string) bool
value = cache.Exists("key")
fmt.Println(value) // returns false

Unterstützung für TTL

// Set Value with Expiry
// @Set(key string, val interface{}, exp int)
// Here expiry is set to 1sec
cache.Set("key","value",1000)

// Hset command
// @Hset(key, field string, value interface{}, exp int)
// in this case the "key" expires in 1sec
cache.Hset("key","name","value",1000)
cache.Hset("key","age",18,1000)

Unterstützt Hash-Datentypen (Hset, Hget, HgetAll, HMset)

// Hset command
// @Hset(key, field string, value interface{}, exp int)
// in this case the "key" expires in 1sec
cache.Hset("key","name","value",1000)
cache.Hset("key","age",18,1000)


// HMset command
// @HMset(key string, d interface{}, exp int) error
// Set a Hash by passing a Struct/Map
// ---by passing a struct---
type Person struct{
    Name  string
    Age   int
    Place string
}

person1 := &Person{Name:"bob",Age:18,Place:"NYC"}
err = cache.HMset("key",person1)
if err != nil{
    fmt.Println(err)
    return
}

// ---by passing a map---
person2 := map[string]interface{Name:"john",Age:18,Place:"NYC"}
err = cache.HMset("key",person2)
if err != nil{
    fmt.Println(err)
    return
}


// Hget command
// @HGet(key, field string) (interface{}, error)
// get individual fields in Hash
data,err := cache.HGet("key","field")
if err != nil{
    fmt.Println(err)
    return
}
fmt.Println(data)

// HgetAll command
// @HGetAll(key string) (map[string]interface{}, error)
// gets all the fields with value in a hash key
// retuns a map[string]interface{}
data,err = cache.HGetAll("key")
if err != nil{
    fmt.Println(err)
    return
}

Schnappschüsse

opt := goswift.CacheOptions{
        EnableSnapshots:  true,
        SnapshotInterval: time.Second*5,
    }
c := goswift.NewCache(opt)

Dadurch wird alle 5 Sekunden ein Schnappschuss der Daten erstellt und in einer Snapshot.data-Datei gespeichert. Standardmäßig sind Snapshots deaktiviert und wenn das SnapshotInterval nicht angegeben ist, beträgt der Standardwert 5 Sekunden.

HINWEIS: Wenn EnableSnapshot falsch ist, werden die in der Datei gespeicherten Daten nicht importiert

Fehlerbehandlung

const (
    ErrKeyNotFound   = "key does not Exists"
    ErrFieldNotFound = "field does not Exists"
    ErrNotHashvalue  = "not a Hash value/table"
    ErrHmsetDataType = "invalid data type, Expected Struct/Map"
)

Dies sind die häufigsten Fehler, die beim Schreiben des Codes auftreten können. Diese Variablen bieten Ihnen eine klare und einfache Fehlervergleichsmethode zur Fehlerermittlung.

data,err := cache.Get("key")
if err != nil {
    if err.Error() == goswift.ErrKeyNotFound {
        //do something
}
}    

Innenleben des Cache-Ablaufs

Alle 3 Sekunden wird die Funktion **sweaper ** aufgerufen, um die abgelaufenen Werte aus der Hash-Tabelle zu löschen. Wir pflegen einen Min-Heap, der auf die Hash-Map verweist. Das oberste Element ist der Schlüssel mit der kleinsten TTL. Wir durchlaufen den Baum, bis TTL größer als die aktuelle Zeit ist.

Zusammenfassung

Ich würde Ihnen nicht raten, dies in der Produktion zu verwenden!!, aber Sie können es gerne in Ihrem kleinen Nebenprojekt verwenden. Probieren Sie es aus und wenn Sie auf einen Fehler stoßen, erstellen Sie ein Problem im GitHub-Repo.

E-Mail: leoantony102@gmail.com
Github: https://github.com/leoantony72
Repo: https://github.com/leoantony72/goswift

Das obige ist der detaillierte Inhalt vonNutzen Sie Hochleistungs-Cache mit TTL und Festplattenpersistenz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!