SET user:1001 '{"name":"张三","age":28,"city":"杭州"}'

HSET user:1001 name 张三 age 28 city 杭州
HINCRBY user:1001 age 1        # 单独自增，无需读全量
HGET user:1001 name

# 下单后 30 分钟未支付自动关闭，用时间戳做 score
ZADD order:delay 1756646400 "ORDER_20260831_001"

# 定时任务轮询已到期的订单
ZRANGEBYSCORE order:delay 0 1756646460 LIMIT 0 100
ZREM order:delay "ORDER_20260831_001"

PFADD uv:20260831 user1 user2 user3
PFCOUNT uv:20260831          # 返回去重后的近似值
PFMERGE uv:202608 uv:20260830 uv:20260831

public User getUser(Long id) {
    String key = "user:" + id;
    String cached = redisTemplate.opsForValue().get(key);

    if (cached != null) {
        // 空值标记，避免重复查库
        if ("__NULL__".equals(cached)) return null;
        return JSON.parseObject(cached, User.class);
    }

    User user = userMapper.selectById(id);
    if (user == null) {
        // 数据库也没有，缓存空值，TTL 设短一点
        redisTemplate.opsForValue().set(key, "__NULL__", 2, TimeUnit.MINUTES);
        return null;
    }
    redisTemplate.opsForValue().set(key, JSON.toJSONString(user), 30, TimeUnit.MINUTES);
    return user;
}

// 初始化时把所有有效 id 载入布隆过滤器
if (!bloomFilter.mightContain(id)) {
    return null;   // 一定不存在，不用查缓存和数据库
}

public Product getHotProduct(Long id) {
    String key = "product:" + id;
    Product p = getFromCache(key);
    if (p != null) return p;

    String lockKey = "lock:product:" + id;
    boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);

    if (locked) {
        try {
            // 双重检查，防止等待期间已被其他线程写入
            p = getFromCache(key);
            if (p != null) return p;

            p = productMapper.selectById(id);
            setCache(key, p, 30, TimeUnit.MINUTES);
            return p;
        } finally {
            redisTemplate.delete(lockKey);
        }
    } else {
        // 没抢到锁，短暂休眠后重试读缓存
        Thread.sleep(50);
        return getHotProduct(id);
    }
}

@Data
class RedisData {
    private LocalDateTime expireTime;  // 逻辑过期时间
    private Object data;
}

// 基础 30 分钟，随机浮动 5 分钟，打散过期时间
int baseTtl = 30 * 60;
int random = new Random().nextInt(5 * 60);
redisTemplate.opsForValue().set(key, value, baseTtl + random, TimeUnit.SECONDS);

@Transactional
public void updateProduct(Product product) {
    // 1. 先删缓存
    redisTemplate.delete("product:" + product.getId());
    // 2. 更新数据库
    productMapper.updateById(product);
    // 3. 延迟一小段时间再删一次，清掉期间可能被写入的脏数据
    scheduledExecutor.schedule(() ->
        redisTemplate.delete("product:" + product.getId()), 500, TimeUnit.MILLISECONDS);
}

# 900 秒内至少 1 次修改
save 900 1
save 300 10
save 60 10000

dbfilename dump.rdb
dir /var/lib/redis

appendonly yes
appendfilename "appendonly.aof"

# 刷盘策略
appendfsync everysec

auto-aof-rewrite-percentage 100   # 比上次重写后增长 100%
auto-aof-rewrite-min-size 64mb    # 且文件至少 64MB

aof-use-rdb-preamble yes

# 内存上限，务必设置，建议物理内存的 60%~70%
maxmemory 4gb
maxmemory-policy allkeys-lru

# 网络
tcp-backlog 511
timeout 0              # 0 表示不断开空闲连接
tcp-keepalive 300

# 安全
requirepass your-strong-password
# 危险命令重命名，防误操作
rename-command FLUSHALL ""
rename-command KEYS ""
rename-command CONFIG "b840fc02d5240454299"

# 慢查询
slowlog-log-slower-than 10000    # 超过 10ms 记录
slowlog-max-len 128

# 安全的遍历方式，不会阻塞
SCAN 0 MATCH user:* COUNT 100
# 异步删除，不阻塞主线程
UNLINK big:key

# 查看慢查询日志
SLOWLOG GET 10
# 慢日志条数
SLOWLOG LEN
# 清空
SLOWLOG RESET

1) (integer) 12                  # 日志 id
2) (integer) 1756646400          # 时间戳
3) (integer) 15230               # 执行耗时（微秒）
4) 1) "KEYS"                     # 命令与参数
   2) "user:*"
5) "127.0.0.1:54321"
6) ""

# 找出大 key（离线分析用，比 MEMORY USAGE 遍历更安全）
redis-cli --bigkeys

# 查看单个 key 的内存占用
MEMORY USAGE user:1001

# 一个 10 万字段的 Hash，拆成 100 个
big:hash  →  big:hash:0  big:hash:1  ...  big:hash:99
# 通过 hash 取模路由
slot = crc32(field) % 100

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring:
  data:
    redis:
      host: 127.0.0.1
      port: 6379
      password: your-password
      database: 0
      timeout: 3s
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 2
          max-wait: 3s

@Configuration
public class RedisConfig {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer<Object> jsonSerializer =
                new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL);
        jsonSerializer.setObjectMapper(om);

        StringRedisSerializer stringSerializer = new StringRedisSerializer();

        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

@Cacheable(value = "user", key = "#id", unless = "#result == null")
public User getUser(Long id) { ... }

@CacheEvict(value = "user", key = "#user.id")
public void updateUser(User user) { ... }

@CacheEvict(value = "user", key = "#id")
public void deleteUser(Long id) { ... }