Cache

import { createClient } from "redis";

const redis = await createClient({ url: process.env.REDIS_URL }).connect();

const TTL_SEGUNDOS = 300;

export async function buscarProduto(id: number) {
  const chave = `produto:${id}`;

  const emCache = await redis.get(chave);
  if (emCache) {
    return JSON.parse(emCache) as Produto;
  }

  const produto = await buscarProdutoNoBanco(id);
  if (produto) {
    const ttl = TTL_SEGUNDOS + Math.floor(Math.random() * 30);
    await redis.set(chave, JSON.stringify(produto), { EX: ttl });
  }
  return produto;
}

import json
import os
import random

import redis

cliente = redis.Redis.from_url(os.environ["REDIS_URL"])

TTL_SEGUNDOS = 300


def buscar_produto(produto_id: int) -> dict | None:
    chave = f"produto:{produto_id}"

    em_cache = cliente.get(chave)
    if em_cache is not None:
        return json.loads(em_cache)

    produto = buscar_produto_no_banco(produto_id)
    if produto is not None:
        ttl = TTL_SEGUNDOS + random.randint(0, 30)
        cliente.set(chave, json.dumps(produto), ex=ttl)
    return produto

package catalogo

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"math/rand/v2"
	"time"

	"github.com/redis/go-redis/v9"
)

const ttlBase = 5 * time.Minute

type Catalogo struct {
	rdb *redis.Client
}

func (c *Catalogo) BuscarProduto(ctx context.Context, id int64) (*Produto, error) {
	chave := fmt.Sprintf("produto:%d", id)

	emCache, err := c.rdb.Get(ctx, chave).Bytes()
	if err == nil {
		var p Produto
		if err := json.Unmarshal(emCache, &p); err == nil {
			return &p, nil
		}
	} else if !errors.Is(err, redis.Nil) {
		// Redis fora do ar: segue para o banco em vez de falhar
	}

	p, err := buscarProdutoNoBanco(ctx, id)
	if err != nil || p == nil {
		return p, err
	}

	if dados, err := json.Marshal(p); err == nil {
		ttl := ttlBase + time.Duration(rand.IntN(30))*time.Second
		c.rdb.Set(ctx, chave, dados, ttl)
	}
	return p, nil
}

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.concurrent.ThreadLocalRandom;
import redis.clients.jedis.JedisPooled;

public class Catalogo {
    private static final long TTL_SEGUNDOS = 300;

    private final JedisPooled redis = new JedisPooled("localhost", 6379);
    private final ObjectMapper json = new ObjectMapper();

    public Produto buscarProduto(long id) throws Exception {
        String chave = "produto:" + id;

        String emCache = redis.get(chave);
        if (emCache != null) {
            return json.readValue(emCache, Produto.class);
        }

        Produto produto = buscarProdutoNoBanco(id);
        if (produto != null) {
            long ttl = TTL_SEGUNDOS + ThreadLocalRandom.current().nextLong(30);
            redis.setex(chave, ttl, json.writeValueAsString(produto));
        }
        return produto;
    }
}

using System.Text.Json;
using StackExchange.Redis;

public class Catalogo(IConnectionMultiplexer conexao)
{
    private static readonly TimeSpan TtlBase = TimeSpan.FromMinutes(5);
    private readonly IDatabase redis = conexao.GetDatabase();

    public async Task<Produto?> BuscarProduto(long id)
    {
        var chave = $"produto:{id}";

        var emCache = await redis.StringGetAsync(chave);
        if (emCache.HasValue)
        {
            return JsonSerializer.Deserialize<Produto>(emCache.ToString());
        }

        var produto = await BuscarProdutoNoBanco(id);
        if (produto is not null)
        {
            var ttl = TtlBase + TimeSpan.FromSeconds(Random.Shared.Next(30));
            await redis.StringSetAsync(chave, JsonSerializer.Serialize(produto), ttl);
        }
        return produto;
    }
}