Architecture du projet FastCache

La structure de FastCache est organisée pour séparer la logique de partitionnement (shrading) de l'implémentation de stockage brut. Voici une vue d'ensemble de l'arborescence du dépôt :

fastcache/
├── go.mod            # Définition du module Go
├── go.sum            # Sommes de contrôle des dépendances
├── cache/            # Noyau du moteur de mise en cache
│   ├── fastcache.go  # Logique principale de l'API
│   ├── shard.go      # Gestion de la segmentation des données
│   ├── utils.go      # Fonctions utilitaires internes
│   └── *_test.go     # Tests unitaires et d'intégration
├── examples/         # Scénarios d'utilisation
│   ├── basic/        # Usage élémentaire
│   └── ttl/          # Usage avec expiration temporelle
└── benchmarks/       # Outils d'évaluation des performances

Description des composants clés

• cache/ : Contient les mécanismes de gestion de la mémoire. Le fichier shard.go est crucial car il divise le cache en segments indépendants pour réduire la contention lors des accès concurrents.
• examples/ : Fournit des modèles d'implémentation concrets pour les développeurs souhaitant intégrer la bibliothèque rapidement.
• benchmarks/ : Permet de comparer l'efficacité de FastCache par rapport à d'autres solutions comme BigCache.

Mise en œuvre initiale

L'amorçage de FastCache ne nécessite pas de fichier de configuration externe. Tout le paramétrage s'effectue via l'instanciation programmatique. Voici un exemple d'intégration basique pour stocker et récupérer une donnée :

package main

import (
    "fmt"
    "github.com/pbrady/fastcache"
)

func main() {
    // Allocation d'un cache de 2 Mo
    monCache := fastcache.New(2 * 1024 * 1024)

    clef := []byte("utilisateur_101")
    donnee := []byte("donnees_serializees")

    // Insertion d'une entrée
    monCache.Set(clef, donnee)

    // Récupération sécurisée
    resultat, trouve := monCache.Get(clef)
    if trouve {
        fmt.Printf("Valeur récupérée : %s\n", string(resultat))
    } else {
        fmt.Println("Clé inexistante.")
    }
}

Gestion avancée de la durée de vie (TTL)

FastCache permet de définir une durée de validité pour chaque entrée. Une fois le délai dépassé, la donnée est considérée comme expirée et n'est plus retournée par le système.

package main

import (
    "fmt"
    "time"
    "github.com/pbrady/fastcache"
)

func main() {
    // Initialisation d'un espace de stockage de 5 Mo
    stockage := fastcache.New(5 * 1024 * 1024)
    
    token := []byte("session_id_456")
    meta := []byte("actif")

    // Configuration d'une expiration à 3 secondes
    stockage.SetWithTTL(token, meta, 3*time.Second)

    // Vérification immédiate
    if val, ok := stockage.Get(token); ok {
        fmt.Printf("Session valide : %s\n", string(val))
    }

    // Attente de l'expiration
    fmt.Println("Attente de l'expiration du cache...")
    time.Sleep(4 * time.Second)

    if _, ok := stockage.Get(token); !ok {
        fmt.Println("La session a expiré avec succès.")
    }
}

Configuration et Paramétrage

L'approche de FastCache privilégie la "configuration par le code". Il n'y a pas de fichiers YAML ou JSON à charger. Les deux leviers de contrôle principaux sont :

1. La taille mémoire : Définie lors de l'appel à fastcache.New(tailleEnOctets). Ce paramètre détermine la limite supérieure de la mémoire vive allouée.
2. La durée d'expiration : Spécifiée individuellement pour chaque clé via SetWithTTL, offrant une granularité fine sur la fraîcheur des données.