java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > SpringBoot整合Redis缓存

SpringBoot4整合Redis的缓存实战:序列化配置与多级缓存详解

作者:gis开发之家

缓存是高并发系统的第一道防线,本文将系统讲解 Spring Cache 抽象、Redis 整合、缓存三大问题(穿透/击穿/雪崩)的解决方案、多级缓存与分布式锁,帮你构建生产级缓存体系

缓存是高并发系统的"第一道防线"。本文将系统讲解 Spring Cache 抽象、Redis 整合、缓存三大问题(穿透/击穿/雪崩)的解决方案、多级缓存与分布式锁,帮你构建生产级缓存体系。

一、为什么要用缓存?

没有缓存的痛点

用户请求 → Controller → Service → 数据库(磁盘 I/O)
                                    ↑
                              每次都查 DB
                              响应慢、数据库压力大

加了缓存之后

用户请求 → Controller → Service → Cache(内存/Redis)
                              ↓(命中)返回
                              ↓(未命中)→ 数据库 → 回填缓存

效果:

二、Spring Cache 抽象:一套 API 适配所有缓存

核心注解

注解作用类比 SQL
@Cacheable先查缓存,没有再执行方法SELECT
@CachePut执行方法后更新缓存UPDATE
@CacheEvict删除缓存DELETE
@Caching组合多个缓存操作复合操作
@CacheConfig类级别公共配置—

开启缓存

@SpringBootApplication
@EnableCaching
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@Cacheable 实战

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Cacheable(value = "user", key = "#id", unless = "#result == null")
    public User getUserById(Long id) {
        System.out.println("查询数据库..."); // 只有缓存未命中时才打印
        return userMapper.selectById(id);
    }
}

调用两次:

userService.getUserById(1L); // 打印"查询数据库..."
userService.getUserById(1L); // 不打印,直接从缓存返回

key 生成策略

@Cacheable(value = "user", key = "#id")
// key = "user::1"

@Cacheable(value = "user", key = "#root.methodName + ':' + #id")
// key = "user::getUserById:1"

@Cacheable(value = "user", key = "T(String).format('%s:%s', #id, #type)")
// key = "user::1:vip"

@CachePut 更新缓存

@CachePut(value = "user", key = "#user.id")
public User updateUser(User user) {
    userMapper.updateById(user);
    return user; // 返回值自动写入缓存
}

@CacheEvict 删除缓存

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

// 删除整个分区
@CacheEvict(value = "user", allEntries = true)
public void clearUserCache() {}

三、Spring Boot 4 整合 Redis

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 连接池(推荐 Lettuce + commons-pool2) -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

配置(application.yml)

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: 
      database: 0
      timeout: 5000ms
      lettuce:
        pool:
          max-active: 16
          max-idle: 8
          min-idle: 2
          max-wait: 3000ms

序列化配置(非常重要!)

默认 JDK 序列化会导致 Redis 中数据不可读,必须自定义:

@Configuration
public class RedisConfig {

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

        // Key 用 String 序列化
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        template.setKeySerializer(keySerializer);
        template.setHashKeySerializer(keySerializer);

        // Value 用 JSON 序列化(Jackson)
        Jackson2JsonRedisSerializer<Object> valueSerializer =
                new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        valueSerializer.setObjectMapper(mapper);
        template.setValueSerializer(valueSerializer);
        template.setHashValueSerializer(valueSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

✅ 配置后 Redis 中数据:

key: user::1
value: {"id":1,"username":"zhangsan","email":"zs@test.com"}

直接使用 RedisTemplate

@Service
public class CacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void set(String key, Object value, long expireSeconds) {
        redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(expireSeconds));
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void delete(String key) {
        redisTemplate.delete(key);
    }

    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
}

四、缓存穿透、击穿、雪崩(三大杀手)

缓存穿透:查不存在的数据

场景:​ 恶意请求 id = -1、id = 999999999

请求 → 缓存(没有)→ 数据库(没有)→ 每次都打到 DB

解决方案1:缓存空值

@Cacheable(value = "user", key = "#id", unless = "#result == null")
public User getUserById(Long id) {
    User user = userMapper.selectById(id);
    if (user == null) {
        // 缓存空值,过期时间短一些
        redisTemplate.opsForValue().set("user::" + id, "", Duration.ofMinutes(5));
    }
    return user;
}

解决方案2:布隆过滤器

// 启动时将所有存在的 ID 加入布隆过滤器
@PostConstruct
public void init() {
    List<Long> allIds = userMapper.selectAllIds();
    allIds.forEach(id -> bloomFilter.put(id));
}

public User getUserById(Long id) {
    if (!bloomFilter.mightContain(id)) {
        return null; // 一定不存在
    }
    return userMapper.selectById(id);
}

缓存击穿:热点 Key 过期瞬间

场景:​ 某个热点数据(如首页推荐)过期瞬间,大量并发请求同时打到 DB

解决方案1:互斥锁(Mutex)

public User getUserById(Long id) {
    String key = "user::" + id;
    User user = (User) redisTemplate.opsForValue().get(key);
    if (user != null) {
        return user;
    }

    // 尝试获取锁
    String lockKey = "lock::" + key;
    Boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", Duration.ofSeconds(10));

    if (locked != null && locked) {
        try {
            // 双重检查
            user = (User) redisTemplate.opsForValue().get(key);
            if (user != null) {
                return user;
            }
            // 查数据库
            user = userMapper.selectById(id);
            redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
            return user;
        } finally {
            redisTemplate.delete(lockKey); // 释放锁
        }
    } else {
        // 没拿到锁,稍等重试
        Thread.sleep(100);
        return getUserById(id); // 递归重试
    }
}

解决方案2:逻辑过期(不设物理过期)

// 缓存永不过期,后台异步更新
@Scheduled(fixedRate = 1800000) // 每 30 分钟更新
public void refreshHotData() {
    List<Long> hotIds = getHotUserIds();
    hotIds.forEach(id -> {
        User user = userMapper.selectById(id);
        redisTemplate.opsForValue().set("user::" + id, user);
    });
}

缓存雪崩:大量 Key 同时过期

场景:​ 大批缓存同时过期 → 请求全部打到 DB → DB 崩溃

解决方案:过期时间加随机值

int baseExpire = 30; // 基础 30 分钟
int randomExpire = new Random().nextInt(10); // 随机 0-10 分钟
redisTemplate.opsForValue().set(key, value, Duration.ofMinutes(baseExpire + randomExpire));

解决方案:集群 + 哨兵 + 限流

五、多级缓存(Caffeine + Redis)

架构

请求 → Caffeine(本地缓存,L1)→ Redis(分布式缓存,L2)→ 数据库
        ↑ 命中率 90%+         ↑ 命中率 99%+
        纳秒级                 毫秒级

整合 Caffeine

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

配置

@Configuration
public class CacheConfig {

    @Bean
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                .maximumSize(10000)               // 最大条目
                .expireAfterWrite(Duration.ofMinutes(10)) // 写入后过期
                .recordStats()                    // 统计
                .build();
    }
}

多级缓存 Service

@Service
public class MultiLevelCacheService {

    @Autowired
    private Cache<String, Object> caffeineCache;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private UserMapper userMapper;

    public User getUser(Long id) {
        String key = "user::" + id;

        // L1: Caffeine
        Object cached = caffeineCache.getIfPresent(key);
        if (cached != null) {
            return (User) cached;
        }

        // L2: Redis
        cached = redisTemplate.opsForValue().get(key);
        if (cached != null) {
            caffeineCache.put(key, cached); // 回填 L1
            return (User) cached;
        }

        // 数据库
        User user = userMapper.selectById(id);
        if (user != null) {
            redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
            caffeineCache.put(key, user);
        }
        return user;
    }
}

六、分布式锁(Redisson)

引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.32.0</version>
</dependency>

配置

@Configuration
public class RedissonConfig {

    @Value("${spring.data.redis.host}")
    private String host;

    @Value("${spring.data.redis.port}")
    private int port;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://" + host + ":" + port)
              .setConnectionPoolSize(16);
        return Redisson.create(config);
    }
}

使用分布式锁

@Service
public class StockService {

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private StockMapper stockMapper;

    public boolean deductStock(Long productId, int count) {
        RLock lock = redissonClient.getLock("stock:" + productId);

        try {
            // 尝试加锁,最多等待 3 秒,锁 10 秒后自动释放
            boolean acquired = lock.tryLock(3, 10, TimeUnit.SECONDS);
            if (!acquired) {
                return false; // 获取锁失败
            }

            // 核心业务逻辑
            Stock stock = stockMapper.selectById(productId);
            if (stock.getCount() < count) {
                return false;
            }
            stock.setCount(stock.getCount() - count);
            stockMapper.updateById(stock);
            return true;

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock(); // 释放锁
            }
        }
    }
}

Redisson 锁特性:

七、缓存最佳实践清单

实践说明
✅ 设置过期时间防止内存泄漏
✅ 过期时间加随机值防止雪崩
✅ 缓存空值防止穿透
✅ 热点数据互斥锁防止击穿
✅ 先更新 DB,再删缓存Cache Aside 模式
✅ 批量操作使用 Pipeline减少网络往返
✅ 大 Value 拆分防止网络阻塞
✅ 监控命中率低于 80% 需优化

八、Spring Boot 4 新变化

九、常见坑位总结

坑1:缓存雪崩

过期时间加随机值

坑2:缓存与数据库不一致

更新策略:先更 DB → 再删缓存(延时双删更安全)

坑3:Redis 中存 JDK 序列化乱码

自定义 JSON 序列化

坑4:@Cacheable 在同类方法自调用失效

同 @Transactional,用代理对象调用

坑5:大 Key 导致 Redis 阻塞

Value 控制在 10KB 以内,超过拆分

十、本篇总结

  1. Spring Cache 抽象:@Cacheable / @CachePut / @CacheEvict
  2. Redis 必须配置 JSON 序列化
  3. 穿透 → 缓存空值 / 布隆过滤器
  4. 击穿 → 互斥锁 / 逻辑过期
  5. 雪崩 → 过期时间加随机值 + 集群
  6. 分布式锁用 Redisson,别自己实现 SETNX

以上就是SpringBoot4整合Redis的缓存实战:序列化配置与多级缓存详解的详细内容,更多关于SpringBoot整合Redis缓存的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文