# 1. 拉取 Redis 鏡像（最新穩(wěn)定版）
docker pull redis:latest
# 2. 啟動(dòng) Redis 容器（配置密碼、持久化、端口映射）
docker run -d --name redis -p 6379:6379 \
  -v redis-data:/data \ # 掛載數(shù)據(jù)卷，持久化數(shù)據(jù)
  -e REDIS_PASSWORD=redis123 \ # 設(shè)置訪問(wèn)密碼
  redis:latest \
  redis-server --requirepass redis123 \ # 開啟密碼驗(yàn)證
  --appendonly yes # 開啟 AOF 持久化（數(shù)據(jù)更可靠）

<!-- Spring Data Redis 依賴（簡(jiǎn)化 Redis 操作） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 連接池依賴（提升 Redis 連接效率） -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<!-- Web 依賴 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

# Redis 配置
spring:
  redis:
    host: localhost # Redis 服務(wù)地址
    port: 6379 # 端口
    password: redis123 # 訪問(wèn)密碼
    database: 0 # 數(shù)據(jù)庫(kù)索引（默認(rèn) 0，Redis 支持 16 個(gè)數(shù)據(jù)庫(kù)）
    timeout: 10000 # 連接超時(shí)時(shí)間（毫秒）
    lettuce: # 連接池配置（Lettuce 是 SpringBoot 2.x 默認(rèn) Redis 客戶端）
      pool:
        max-active: 16 # 最大連接數(shù)
        max-idle: 8 # 最大空閑連接數(shù)
        min-idle: 4 # 最小空閑連接數(shù)
        max-wait: -1 # 最大等待時(shí)間（-1 表示無(wú)限制）
# 服務(wù)端口
server:
  port: 8085

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.core.RedisTemplate;
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;
@Configuration
public class RedisConfig {
    // 自定義 RedisTemplate（JSON 序列化，支持復(fù)雜對(duì)象存儲(chǔ)）
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 字符串序列化器（Key 用字符串序列化）
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        // JSON 序列化器（Value 用 JSON 序列化，保留對(duì)象結(jié)構(gòu)）
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
        // 配置 Key、Value 序列化方式
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(jsonSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setHashValueSerializer(jsonSerializer);
        // 初始化 RedisTemplate
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    // 配置緩存管理器（支持緩存注解）
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 緩存配置（設(shè)置默認(rèn)過(guò)期時(shí)間 30 分鐘，JSON 序列化）
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30)) // 默認(rèn)緩存過(guò)期時(shí)間
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .disableCachingNullValues(); // 禁止緩存 null 值（避免緩存穿透）
        // 創(chuàng)建緩存管理器
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(cacheConfig)
                .build();
    }
}

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import com.example.redis.entity.User;
import com.example.redis.mapper.UserMapper;
import javax.annotation.Resource;
@Service
public class UserService {
    @Resource
    private UserMapper userMapper;
    // ? 緩存查詢結(jié)果：key 為 "user:info:" + id，緩存過(guò)期時(shí)間 30 分鐘
    @Cacheable(value = "user", key = "'info:' + #id", unless = "#result == null")
    public User getUserById(Long id) {
        // 緩存不存在時(shí)，查詢數(shù)據(jù)庫(kù)（僅執(zhí)行一次）
        System.out.println("查詢數(shù)據(jù)庫(kù)，用戶ID：" + id);
        return userMapper.selectById(id);
    }
    // ? 更新緩存：更新數(shù)據(jù)庫(kù)后，同步更新緩存（避免緩存與數(shù)據(jù)庫(kù)不一致）
    @CachePut(value = "user", key = "'info:' + #user.id", unless = "#user == null")
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }
    // ? 清除緩存：刪除數(shù)據(jù)庫(kù)數(shù)據(jù)后，刪除對(duì)應(yīng)緩存
    @CacheEvict(value = "user", key = "'info:' + #id")
    public void deleteUser(Long id) {
        userMapper.deleteById(id);
    }
    // ? 清除所有緩存（如批量更新時(shí)）
    @CacheEvict(value = "user", allEntries = true)
    public void clearUserCache() {
        // 僅清除緩存，無(wú)業(yè)務(wù)邏輯
    }
}

import org.springframework.web.bind.annotation.*;
import com.example.redis.entity.User;
import com.example.redis.result.Result;
import com.example.redis.service.UserService;
import javax.annotation.Resource;
@RestController
@RequestMapping("/user")
public class UserController {
    @Resource
    private UserService userService;
    @GetMapping("/{id}")
    public Result<User> getUserById(@PathVariable Long id) {
        User user = userService.getUserById(id);
        return Result.success(user);
    }
    @PutMapping
    public Result<User> updateUser(@RequestBody User user) {
        User updatedUser = userService.updateUser(user);
        return Result.success(updatedUser);
    }
    @DeleteMapping("/{id}")
    public Result<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return Result.success();
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtils {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    // ? 存儲(chǔ) String 類型數(shù)據(jù)（設(shè)置過(guò)期時(shí)間）
    public void setString(String key, Object value, Long expireTime, TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
    }
    // ? 獲取 String 類型數(shù)據(jù)
    public Object getString(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    // ? 刪除數(shù)據(jù)
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }
    // ? 判斷鍵是否存在
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
    // ? 設(shè)置鍵過(guò)期時(shí)間
    public Boolean expire(String key, Long expireTime, TimeUnit timeUnit) {
        return redisTemplate.expire(key, expireTime, timeUnit);
    }
    // ? 存儲(chǔ) Hash 類型數(shù)據(jù)（示例：存儲(chǔ)用戶詳情，字段拆分）
    public void setHash(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }
    // ? 獲取 Hash 類型數(shù)據(jù)
    public Object getHash(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }
}

import org.springframework.stereotype.Service;
import com.example.redis.entity.Goods;
import com.example.redis.mapper.GoodsMapper;
import com.example.redis.utils.RedisUtils;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
@Service
public class GoodsService {
    @Resource
    private GoodsMapper goodsMapper;
    @Resource
    private RedisUtils redisUtils;
    // 熱點(diǎn)商品緩存（手動(dòng)控制緩存邏輯）
    public Goods getHotGoodsById(Long id) {
        String key = "goods:hot:" + id;
        // 1. 先查緩存
        Goods goods = (Goods) redisUtils.getString(key);
        if (goods != null) {
            return goods;
        }
        // 2. 緩存不存在，查數(shù)據(jù)庫(kù)
        goods = goodsMapper.selectById(id);
        if (goods != null) {
            // 3. 存入緩存，設(shè)置過(guò)期時(shí)間 10 分鐘（熱點(diǎn)數(shù)據(jù)可縮短過(guò)期時(shí)間）
            redisUtils.setString(key, goods, 10L, TimeUnit.MINUTES);
        }
        return goods;
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
@Component
public class RedisDistributedLock {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    // 鎖前綴（避免鍵沖突）
    private static final String LOCK_PREFIX = "lock:";
    // 鎖過(guò)期時(shí)間（避免死鎖，默認(rèn) 30 秒）
    private static final Long LOCK_EXPIRE = 30L;
    /**
     * 獲取分布式鎖
     * @param lockKey 鎖標(biāo)識(shí)（如 "stock:1001"）
     * @param requestId 唯一標(biāo)識(shí)（如 UUID，確保釋放鎖時(shí)是自己的鎖）
     * @return 是否獲取成功
     */
    public Boolean tryLock(String lockKey, String requestId) {
        String key = LOCK_PREFIX + lockKey;
        // SETNX 命令：當(dāng)鍵不存在時(shí)設(shè)置值，原子操作（確保并發(fā)安全）
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(key, requestId, LOCK_EXPIRE, TimeUnit.SECONDS);
        return locked != null && locked;
    }
    /**
     * 釋放分布式鎖
     * @param lockKey 鎖標(biāo)識(shí)
     * @param requestId 唯一標(biāo)識(shí)
     */
    public void unlock(String lockKey, String requestId) {
        String key = LOCK_PREFIX + lockKey;
        try {
            String value = (String) redisTemplate.opsForValue().get(key);
            // 僅釋放自己的鎖（避免釋放其他線程的鎖）
            if (requestId.equals(value)) {
                redisTemplate.delete(key);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import org.springframework.stereotype.Service;
import com.example.redis.mapper.StockMapper;
import com.example.redis.utils.RedisDistributedLock;
import javax.annotation.Resource;
import java.util.UUID;
@Service
public class StockService {
    @Resource
    private StockMapper stockMapper;
    @Resource
    private RedisDistributedLock distributedLock;
    // 庫(kù)存扣減（分布式環(huán)境下安全操作）
    public Boolean deductStock(Long goodsId, Integer num) {
        String lockKey = "stock:" + goodsId;
        String requestId = UUID.randomUUID().toString();
        try {
            // 1. 獲取分布式鎖（最多等待 5 秒，每隔 1 秒重試）
            Boolean locked = false;
            int count = 0;
            while (!locked && count < 5) {
                locked = distributedLock.tryLock(lockKey, requestId);
                if (!locked) {
                    Thread.sleep(1000);
                    count++;
                }
            }
            if (!locked) {
                // 獲取鎖失敗（限流）
                return false;
            }
            // 2. 扣減庫(kù)存（業(yè)務(wù)邏輯）
            int row = stockMapper.deductStock(goodsId, num);
            return row > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            // 3. 釋放鎖（確保無(wú)論是否異常，都釋放鎖）
            distributedLock.unlock(lockKey, requestId);
        }
    }
}

// 緩存 null 值解決方案（修改查詢方法）
public Goods getGoodsById(Long id) {
    String key = "goods:info:" + id;
    Goods goods = (Goods) redisUtils.getString(key);
    if (goods != null) {
        return goods;
    }
    // 數(shù)據(jù)庫(kù)查詢也不存在，緩存 null 值（過(guò)期時(shí)間 5 分鐘）
    goods = goodsMapper.selectById(id);
    if (goods == null) {
        redisUtils.setString(key, null, 5L, TimeUnit.MINUTES);
        return null;
    }
    redisUtils.setString(key, goods, 30L, TimeUnit.MINUTES);
    return goods;
}