1.Introduction

Accélérez vos projets Golang sans avoir à configurer une base de données à chaque fois que vous démarrez un nouveau projet. Fatigué de configurer des bases de données à partir de zéro ? Seulement pour affronter de nouveaux problèmes ? Ne cherchez pas plus loin Dans ce blog, nous examinerons la bibliothèque de mise en cache Golang avec prise en charge de TTL, Persistance du disque et Type de données de hachage.

GoSwift.

2.Prérequis

• Connaissance de base du Golang
• Connaissance du fonctionnement d'un cache typique

3.Caractéristiques

1. Commande Définir et obtenir
2. Commande de mise à jour
3. Supprimer la commande
4. Commande existe
5. Prise en charge du TTL
6. Prise en charge de la sauvegarde sur disque (instantanés)
7. Prise en charge du type de données de hachage (Hset, Hget, HgetAll, HMset)
8. Verrouillage sécurisé

Commande Définir et obtenir

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)
}

Commande de mise à jour

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

Commande Suppr && Commande Existe

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

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

Prise en charge du 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)

Prise en charge du type de données de hachage (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
}

Instantanés

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

Cela prendra un instantané des données toutes les 5 secondes et l'enregistrera dans un fichier Snapshot.data. Par défaut, les instantanés sont désactivés et si SnapshotInterval n'est pas fourni, la valeur par défaut est de 5 secondes.

REMARQUE : Si EnableSnapshot est faux, les données enregistrées dans le fichier ne seront pas importées

Gestion des erreurs

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

Ce sont les erreurs courantes qui peuvent survenir lors de l'écriture du code. Ces variables vous fournissent une méthode de comparaison d'erreurs claire et simple pour déterminer les erreurs.

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

Fonctionnement interne de l'expiration du cache

Toutes les 3 secondes, la fonction **sweaper ** est appelée pour effacer les valeurs expirées de la table de hachage. Nous maintenons un tas min qui pointe vers la carte de hachage. L'élément supérieur sera la clé avec le plus petit TTL. nous parcourons l'arborescence jusqu'à ce que le TTL soit supérieur à l'heure actuelle.

Résumé

Je ne vous conseillerais pas de l'utiliser en production !!, mais n'hésitez pas à l'utiliser dans votre petit projet parallèle. Essayez-le et si vous rencontrez un bug, créez un problème sur le dépôt GitHub.

E-mail : [email protected]
Github : https://github.com/leoantony72
Dépôt : https://github.com/leoantony72/goswift