<!-- Spring Boot Web 核心依賴 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Redis 緩存依賴（核心，自動(dòng)配置） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- Spring Boot 緩存抽象依賴（提供緩存注解支持） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- MyBatis-Plus 依賴（操作數(shù)據(jù)庫(kù)） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>
<!-- MySQL 驅(qū)動(dòng) -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- lombok 簡(jiǎn)化代碼 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!-- 可選：Redis 連接池依賴（提升Redis連接性能） -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

spring:
  # 數(shù)據(jù)庫(kù)配置（替換為自己的數(shù)據(jù)庫(kù)信息）
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_redis?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    username: root
    password: 123456
  # Redis 核心配置
  redis:
    host: localhost # Redis服務(wù)器地址（本地為localhost，遠(yuǎn)程為服務(wù)器IP）
    port: 6379 # Redis默認(rèn)端口
    password: # Redis密碼（無密碼則留空）
    database: 0 # 操作的Redis數(shù)據(jù)庫(kù)（默認(rèn)0號(hào)庫(kù)）
    # Redis連接池配置（提升連接性能，推薦配置）
    lettuce:
      pool:
        max-active: 16 # 最大連接數(shù)
        max-idle: 8 # 最大空閑連接
        min-idle: 4 # 最小空閑連接
        max-wait: 1000 # 最大等待時(shí)間（毫秒）
  # 緩存配置（開啟緩存，指定緩存類型為Redis）
  cache:
    type: redis # 緩存類型：Redis（默認(rèn)是Simple，本地內(nèi)存，不適用于生產(chǎn)）
    redis:
      time-to-live: 3600000 # 緩存默認(rèn)過期時(shí)間（1小時(shí)，單位：毫秒）
      cache-null-values: false # 是否緩存null值（避免緩存穿透，根據(jù)需求調(diào)整）
      key-prefix: springboot:cache: # 緩存key前綴（避免與其他Redis數(shù)據(jù)沖突）
      use-key-prefix: true # 啟用key前綴
# MyBatis-Plus 配置（打印SQL，便于調(diào)試緩存效果）
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mybatis/mapper/**/*.xml
  type-aliases-package: com.example.demo.entity

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
/**
 * 啟動(dòng)類：開啟緩存功能（@EnableCaching）
 */
@SpringBootApplication
@EnableCaching // 開啟緩存功能，必須添加，否則緩存注解無效
public class SpringBootRedisCacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootRedisCacheApplication.class, args);
    }
}

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
/**
 * Redis緩存序列化配置（將對(duì)象序列化為JSON格式）
 */
@Configuration
@EnableCaching
public class RedisCacheConfig {
    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
        // 1. 配置緩存序列化方式
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                // 設(shè)置緩存過期時(shí)間（全局默認(rèn)，可在注解中單獨(dú)設(shè)置）
                .entryTtl(Duration.ofHours(1))
                // key序列化：String格式
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                // value序列化：JSON格式（支持對(duì)象序列化）
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 不緩存null值
                .disableCachingNullValues()
                // 啟用key前綴
                .prefixCacheNameWith("springboot:cache:");
        // 2. 創(chuàng)建緩存管理器并返回
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .build();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
 * Redis 集成測(cè)試控制器
 */
@RestController
@RequestMapping("/redis/test")
public class RedisTestController {
    // 注入Redis模板（StringRedisTemplate用于操作字符串，RedisTemplate用于操作對(duì)象）
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 測(cè)試Redis存儲(chǔ)字符串
     */
    @GetMapping("/set")
    public String setRedis(@RequestParam String key, @RequestParam String value) {
        // 存儲(chǔ)數(shù)據(jù)到Redis
        stringRedisTemplate.opsForValue().set(key, value);
        return "Redis存儲(chǔ)成功，key：" + key + "，value：" + value;
    }
    /**
     * 測(cè)試Redis獲取字符串
     */
    @GetMapping("/get")
    public String getRedis(@RequestParam String key) {
        // 從Redis獲取數(shù)據(jù)
        String value = stringRedisTemplate.opsForValue().get(key);
        return "Redis獲取結(jié)果，key：" + key + "，value：" + (value == null ? "無此key" : value);
    }
}

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.demo.entity.SysUser;
import com.example.demo.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 緩存注解測(cè)試控制器（用戶模塊）
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private SysUserService sysUserService;
    /**
     * 示例1：根據(jù)用戶ID查詢用戶（緩存key為用戶ID）
     * @Cacheable：查詢緩存，緩存名稱為user，key為用戶ID
     */
    @Cacheable(value = "user", key = "#userId", unless = "#result == null")
    @GetMapping("/{userId}")
    public SysUser getUserById(@PathVariable Long userId) {
        // 第一次查詢：無緩存，執(zhí)行方法，查詢數(shù)據(jù)庫(kù)，存入緩存
        // 第二次查詢：有緩存，直接返回緩存數(shù)據(jù)，不執(zhí)行該方法（不打印SQL）
        System.out.println("執(zhí)行數(shù)據(jù)庫(kù)查詢：根據(jù)ID查詢用戶，ID=" + userId);
        return sysUserService.getById(userId);
    }
    /**
     * 示例2：根據(jù)用戶名查詢用戶（自定義緩存key，添加過期時(shí)間）
     * key：拼接緩存名稱和用戶名，避免key沖突；expire：緩存10分鐘
     */
    @Cacheable(value = "user", key = "'username:'+#username", expire = 600)
    @GetMapping("/username/{username}")
    public SysUser getUserByUsername(@PathVariable String username) {
        System.out.println("執(zhí)行數(shù)據(jù)庫(kù)查詢：根據(jù)用戶名查詢用戶，用戶名=" + username);
        QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", username);
        return sysUserService.getOne(queryWrapper);
    }
}

// 在UserController中新增更新、刪除接口，添加@CacheEvict注解
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
 * 示例3：更新用戶信息（刪除對(duì)應(yīng)緩存，避免臟數(shù)據(jù)）
 * @CacheEvict：刪除key為#user.id的緩存
 */
@CacheEvict(value = "user", key = "#user.id")
@PutMapping("/update")
public String updateUser(@RequestBody SysUser user) {
    boolean success = sysUserService.updateById(user);
    return success ? "用戶更新成功，緩存已刪除" : "用戶更新失敗";
}
/**
 * 示例4：刪除用戶（刪除對(duì)應(yīng)緩存）
 */
@CacheEvict(value = "user", key = "#userId")
@DeleteMapping("/{userId}")
public String deleteUser(@PathVariable Long userId) {
    boolean success = sysUserService.removeById(userId);
    return success ? "用戶刪除成功，緩存已刪除" : "用戶刪除失敗";
}
/**
 * 示例5：批量刪除用戶（刪除user緩存下的所有緩存）
 * allEntries = true：刪除value="user"下的所有緩存
 */
@CacheEvict(value = "user", allEntries = true)
@DeleteMapping("/batchDelete")
public String batchDeleteUser(@RequestBody List<Long> userIds) {
    boolean success = sysUserService.removeByIds(userIds);
    return success ? "批量刪除成功，用戶緩存全部清空" : "批量刪除失敗";
}

// 1. 商品實(shí)體類（Product）
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Data
@TableName("product")
public class Product {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String productName; // 商品名稱
    private BigDecimal price; // 商品價(jià)格
    private String description; // 商品描述
    private Integer stock; // 庫(kù)存
    private LocalDateTime createTime; // 創(chuàng)建時(shí)間
}
// 2. 商品Mapper接口
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Product;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface ProductMapper extends BaseMapper<Product> {
}
// 3. 商品Service層
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.Product;
import com.example.demo.mapper.ProductMapper;
import org.springframework.stereotype.Service;
@Service
public class ProductService extends ServiceImpl<ProductMapper, Product> {
}

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
 * 商品緩存案例控制器（熱點(diǎn)數(shù)據(jù)緩存）
 */
@RestController
@RequestMapping("/product")
public class ProductController {
    @Autowired
    private ProductService productService;
    /**
     * 熱點(diǎn)數(shù)據(jù)1：商品詳情（根據(jù)商品ID查詢）
     * 緩存key：product:id:xxx，緩存過期時(shí)間30分鐘（1800秒）
     * 說明：商品詳情訪問頻繁，且修改頻率低，適合長(zhǎng)期緩存
     */
    @Cacheable(value = "product", key = "'id:'+#productId", expire = 1800)
    @GetMapping("/{productId}")
    public Product getProductById(@PathVariable Long productId) {
        System.out.println("執(zhí)行數(shù)據(jù)庫(kù)查詢：查詢商品詳情，ID=" + productId);
        return productService.getById(productId);
    }
    /**
     * 熱點(diǎn)數(shù)據(jù)2：商品列表（分頁，無篩選條件）
     * 緩存key：product:list:pageNum:xxx:pageSize:xxx
     * 說明：首頁商品列表訪問量極高，緩存分頁數(shù)據(jù)，減輕數(shù)據(jù)庫(kù)壓力
     */
    @Cacheable(value = "product", key = "'list:pageNum:'+#pageNum+':pageSize:'+#pageSize")
    @GetMapping("/list")
    public IPage<Product> getProductList(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        System.out.println("執(zhí)行數(shù)據(jù)庫(kù)查詢：商品列表分頁，頁碼=" + pageNum + "，每頁條數(shù)=" + pageSize);
        Page<Product> page = new Page<>(pageNum, pageSize);
        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("create_time"); // 按創(chuàng)建時(shí)間降序
        return productService.page(page, queryWrapper);
    }
    /**
     * 商品新增（無需緩存，新增后無查詢緩存）
     */
    @PostMapping("/add")
    public String addProduct(@RequestBody Product product) {
        boolean success = productService.save(product);
        return success ? "商品新增成功" : "商品新增失敗";
    }
    /**
     * 商品更新（刪除對(duì)應(yīng)商品詳情緩存和列表緩存）
     * 說明：更新商品后，刪除該商品的詳情緩存和所有列表緩存，避免臟數(shù)據(jù)
     */
    @CacheEvict(value = "product", allEntries = true)
    @PutMapping("/update")
    public String updateProduct(@RequestBody Product product) {
        boolean success = productService.updateById(product);
        return success ? "商品更新成功，所有商品緩存已清空" : "商品更新失敗";
    }
    /**
     * 商品刪除（刪除對(duì)應(yīng)緩存）
     */
    @CacheEvict(value = "product", key = "'id:'+#productId")
    @DeleteMapping("/{productId}")
    public String deleteProduct(@PathVariable Long productId) {
        boolean success = productService.removeById(productId);
        return success ? "商品刪除成功，對(duì)應(yīng)緩存已刪除" : "商品刪除失敗";
    }
}

解決方案：配置自定義緩存序列化方式（如本文1.5節(jié)的配置），使用GenericJackson2JsonRedisSerializer將對(duì)象序列化為JSON格式，避免默認(rèn)的二進(jìn)制序列化。

解決方案：① 數(shù)據(jù)更新、刪除時(shí)，必須使用@CacheEvict刪除對(duì)應(yīng)緩存；② 復(fù)雜場(chǎng)景（如多表關(guān)聯(lián)更新），可使用@CacheEvict(allEntries = true)清空對(duì)應(yīng)緩存；③ 避免緩存過期時(shí)間過長(zhǎng)，合理設(shè)置過期時(shí)間。

解決方案：① 配置cache-null-values: true，緩存null值（但需注意過期時(shí)間，避免緩存大量null值占用內(nèi)存）；② 在接口層添加參數(shù)校驗(yàn)，過濾無效參數(shù)；③ 使用布隆過濾器，提前攔截不存在的key。

解決方案：① 檢查Redis服務(wù)是否正常啟動(dòng)；② 確認(rèn)Redis連接配置（host、port、password）正確；③ 檢查服務(wù)器防火墻是否開放Redis端口（6379）；④ 若使用遠(yuǎn)程Redis，確認(rèn)遠(yuǎn)程連接權(quán)限開啟。