Comment créer une API RESTful à l'aide de Golang et utiliser la mise en cache ?

Intégrez la mise en cache lors de la création d'API RESTful avec Golang : utilisez Gin pour créer des API ; intégrez le cache Redis ; définissez une couche de cache pour gérer les valeurs mises en cache ; utilisez la couche de cache dans les gestionnaires Gin pour obtenir et définir les données de Redis.

Comment intégrer la mise en cache lors de la création d'une API RESTful avec Golang

Lors de la création d'une API RESTful, la mise en cache peut considérablement améliorer les performances, réduire la charge du serveur et améliorer l'expérience utilisateur. Cet article vous guidera pour créer une API RESTful et intégrer la mise en cache à l'aide de Golang.

Créez une API RESTful à l'aide de Gin

Tout d'abord, créez une nouvelle API Golang RESTful à l'aide du framework Gin :

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/api/v1/users", GetUsers)
    r.Run()
}

Intégration du cache Redis

Pour utiliser la mise en cache, nous utiliserons Redis, une valeur-clé hautement disponible magasin . Assurez-vous que Redis est installé et en cours d'exécution.

Dans Golang, nous pouvons utiliser la bibliothèque redigo pour nous connecter à Redis :

import (
    "time"

    "github.com/gomodule/redigo/redis"
)

// redisPool is a global variable to manage the Redis connection pool.
var redisPool *redis.Pool

func init() {
    redisPool = &redis.Pool{
        MaxIdle:   10,
        MaxActive: 10,
        IdleTimeout: 30 * time.Second,
        Dial: func() (redis.Conn, error) {
            return redis.Dial("tcp", "localhost:6379")
        },
    }
}

Cache Layer

Maintenant, définissons une nouvelle couche pour gérer le cache. Cette couche fournira des fonctions pour obtenir, définir et supprimer les valeurs mises en cache.

import (
    "time"

    "github.com/gomodule/redigo/redis"
)

type Cache struct {
    pool *redis.Pool
}

func NewCache(pool *redis.Pool) *Cache {
    return &Cache{
        pool: pool,
    }
}

func (c *Cache) Get(key string) ([]byte, error) {
    conn := c.pool.Get()
    defer conn.Close()

    return redis.Bytes(conn.Do("GET", key))
}

func (c *Cache) Set(key string, value string) error {
    conn := c.pool.Get()
    defer conn.Close()

    _, err := conn.Do("SET", key, value)
    return err
}

func (c *Cache) Delete(key string) error {
    conn := c.pool.Get()
    defer conn.Close()

    _, err := conn.Do("DEL", key)
    return err
}

Utilisation de la mise en cache

Dans la fonction de gestionnaire Gin, nous pouvons utiliser la couche de mise en cache pour mettre en cache la réponse de l'API. Voici la fonction de gestionnaire GetUsers modifiée :

func GetUsers(c *gin.Context) {
    // 获取 Redis 缓存
    key := "users"
    cachedBytes, err := cache.Get(key)
    if err != nil {
        // 缓存中没有值，从数据库中获取
        users, err := getUserFromDB()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        // 将 users 序列化为 JSON 并存储在缓存中
        userJSON, err := json.Marshal(users)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        err = cache.Set(key, string(userJSON))
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        c.JSON(http.StatusOK, users)
    } else {
        // 从缓存中获取值，反序列化回 []User 类型
        var users []User
        err := json.Unmarshal(cachedBytes, &users)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        c.JSON(http.StatusOK, users)
    }
}

// getUserFromDB 从数据库中获取用户
func getUserFromDB() ([]User, error) {
    // 假设这是从数据库获取用户数据的模拟函数
    return []User{{ID: 1, Name: "John"}}, nil
}

Désormais, l'API obtiendra d'abord la réponse du cache, et si la valeur n'existe pas dans le cache, elle obtiendra les données de la base de données et les stockera dans le cache. Cela réduira considérablement les requêtes de base de données demandées en double, améliorant ainsi les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!