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

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password:
      database: 0
      timeout: 2000ms

@Service
public class UserService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    private UserMapper userMapper;
    public User getUserById(Long id) {
        String key = "user:" + id;
        // Step 1: 嘗試從緩存中讀取
        User user = (User) redisTemplate.opsForValue().get(key);
        if (user != null) {
            System.out.println("【命中緩存】userId = " + id);
            return user;
        }
        // Step 2: 緩存未命中 → 查詢數(shù)據(jù)庫(kù)
        user = userMapper.selectById(id);
        if (user == null) {
            return null;
        }
        // Step 3: 寫(xiě)入緩存，設(shè)置過(guò)期時(shí)間 10 分鐘
        redisTemplate.opsForValue().set(key, user, 10, TimeUnit.MINUTES);
        System.out.println("【寫(xiě)入緩存】userId = " + id);
        return user;
    }
}

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

spring:
  session:
    store-type: redis
  redis:
    host: localhost
    port: 6379

@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginRequest request) {
    User user = userMapper.findByUsername(request.getUsername());
    if (user == null || !user.getPassword().equals(request.getPassword())) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("用戶名或密碼錯(cuò)誤");
    }
    // 生成 token
    String token = UUID.randomUUID().toString();
    redisTemplate.opsForValue().set("login:token:" + token, user, 30, TimeUnit.MINUTES);
    return ResponseEntity.ok(Map.of("token", token));
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
    String token = request.getHeader("Authorization");
    if (token == null) return false;
    User user = (User) redisTemplate.opsForValue().get("login:token:" + token);
    if (user == null) {
        response.setStatus(401);
        return false;
    }
    request.setAttribute("user", user);
    return true;
}

@Service
public class OrderService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    public void placeOrder(Long productId) {
        String lockKey = "lock:product:" + productId;
        String clientId = UUID.randomUUID().toString();
        try {
            Boolean locked = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, clientId, 10, TimeUnit.SECONDS);
            if (Boolean.FALSE.equals(locked)) {
                throw new RuntimeException("系統(tǒng)繁忙，請(qǐng)稍后再試");
            }
            // 模擬扣庫(kù)存邏輯
            Integer stock = getStock(productId);
            if (stock > 0) {
                updateStock(productId, stock - 1);
                System.out.println("下單成功，庫(kù)存剩余：" + (stock - 1));
            } else {
                System.out.println("庫(kù)存不足");
            }
        } finally {
            // 釋放鎖（防止誤刪）
            String value = (String) redisTemplate.opsForValue().get(lockKey);
            if (clientId.equals(value)) {
                redisTemplate.delete(lockKey);
            }
        }
    }
    private Integer getStock(Long id) { return 5; } // 模擬
    private void updateStock(Long id, Integer newStock) {}
}

// 生產(chǎn)者：發(fā)送任務(wù)
public void sendMailTask(String mailJson) {
    redisTemplate.opsForList().leftPush("queue:mail", mailJson);
}
// 消費(fèi)者：異步線程處理任務(wù)
@Scheduled(fixedDelay = 2000)
public void consumeMailTask() {
    String task = (String) redisTemplate.opsForList().rightPop("queue:mail");
    if (task != null) {
        System.out.println("發(fā)送郵件任務(wù)：" + task);
        // 執(zhí)行郵件發(fā)送邏輯
    }
}

XADD queue:order * orderId 1001 userId 2002
XGROUP CREATE queue:order group1 0 MKSTREAM

@Scheduled(fixedDelay = 3000)
public void consumeOrder() {
    List<MapRecord<String, Object, Object>> messages = redisTemplate.opsForStream()
        .read(Consumer.from("group1", "consumerA"),
              StreamReadOptions.empty().count(1),
              StreamOffset.create("queue:order", ReadOffset.lastConsumed()));
    if (messages != null) {
        for (MapRecord<String, Object, Object> msg : messages) {
            System.out.println("消費(fèi)訂單消息：" + msg.getValue());
            redisTemplate.opsForStream().acknowledge("queue:order", "group1", msg.getId());
        }
    }
}

@Service
public class RankService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    private static final String RANK_KEY = "rank:user:score";
    // 增加用戶積分
    public void addScore(String userId, double score) {
        redisTemplate.opsForZSet().incrementScore(RANK_KEY, userId, score);
    }
    // 獲取前 N 名用戶
    public Set<String> getTopUsers(int limit) {
        return redisTemplate.opsForZSet().reverseRange(RANK_KEY, 0, limit - 1);
    }
    // 查詢某個(gè)用戶的排名
    public Long getRank(String userId) {
        return redisTemplate.opsForZSet().reverseRank(RANK_KEY, userId);
    }
    // 查詢某個(gè)用戶的分?jǐn)?shù)
    public Double getUserScore(String userId) {
        return redisTemplate.opsForZSet().score(RANK_KEY, userId);
    }
}

rankService.addScore("Tom", 10);
rankService.addScore("Jerry", 20);
rankService.addScore("Alice", 15);
System.out.println(rankService.getTopUsers(3)); // [Jerry, Alice, Tom]

@Service
public class RateLimitService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    // 每分鐘最多請(qǐng)求 60 次
    private static final int LIMIT_COUNT = 60;
    private static final int EXPIRE_TIME = 60;
    public void checkRateLimit(String ip) {
        String key = "limit:ip:" + ip;
        Long count = redisTemplate.opsForValue().increment(key);
        if (count == 1) {
            redisTemplate.expire(key, EXPIRE_TIME, TimeUnit.SECONDS);
        }
        if (count > LIMIT_COUNT) {
            throw new RuntimeException("請(qǐng)求過(guò)于頻繁，請(qǐng)稍后再試！");
        }
    }
}

@GetMapping("/api/test")
public String test(HttpServletRequest request) {
    String ip = request.getRemoteAddr();
    rateLimitService.checkRateLimit(ip);
    return "正常訪問(wèn)成功";
}

public boolean allowRequest(String key, int limit, int seconds) {
    long now = System.currentTimeMillis();
    long windowStart = now - seconds * 1000L;
    redisTemplate.opsForZSet().removeRangeByScore(key, 0, windowStart);
    redisTemplate.opsForZSet().add(key, String.valueOf(now), now);
    long count = redisTemplate.opsForZSet().zCard(key);
    redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
    return count <= limit;
}

@Service
public class DelayTaskService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    private static final String DELAY_KEY = "delay:order";
    // 添加延時(shí)任務(wù)
    public void addDelayTask(Long orderId, long delayMs) {
        long executeTime = System.currentTimeMillis() + delayMs;
        redisTemplate.opsForZSet().add(DELAY_KEY, orderId, executeTime);
        System.out.println("添加延遲任務(wù): orderId=" + orderId + ", 執(zhí)行時(shí)間=" + executeTime);
    }
    // 定時(shí)掃描執(zhí)行任務(wù)
    @Scheduled(fixedDelay = 5000)
    public void executeTasks() {
        long now = System.currentTimeMillis();
        Set<Object> tasks = redisTemplate.opsForZSet().rangeByScore(DELAY_KEY, 0, now);
        if (tasks != null) {
            for (Object task : tasks) {
                System.out.println("執(zhí)行超時(shí)任務(wù): orderId=" + task);
                // 執(zhí)行業(yè)務(wù)邏輯：關(guān)閉訂單
                redisTemplate.opsForZSet().remove(DELAY_KEY, task);
            }
        }
    }
}

delayTaskService.addDelayTask(1001L, 60000); // 1分鐘后取消訂單

@Service
public class ProductService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    private ProductMapper productMapper;
    public Product getProduct(Long id) {
        String key = "product:" + id;
        // 1. 先查緩存
        Product product = (Product) redisTemplate.opsForValue().get(key);
        if (product != null) {
            return product;
        }
        // 2. 緩存為空，加鎖防止擊穿
        synchronized (this) {
            product = (Product) redisTemplate.opsForValue().get(key);
            if (product == null) {
                product = productMapper.selectById(id);
                if (product == null) {
                    // 防止穿透：緩存空對(duì)象
                    redisTemplate.opsForValue().set(key, new Product(), 2, TimeUnit.MINUTES);
                } else {
                    // 防止雪崩：過(guò)期時(shí)間隨機(jī)
                    int expireTime = 10 + new Random().nextInt(5);
                    redisTemplate.opsForValue().set(key, product, expireTime, TimeUnit.MINUTES);
                }
            }
        }
        return product;
    }
}

@Service
public class GeoService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    private static final String GEO_KEY = "shop:geo";
    // 添加商鋪?zhàn)鴺?biāo)
    public void addShop(String shopName, double lon, double lat) {
        redisTemplate.opsForGeo().add(GEO_KEY, new Point(lon, lat), shopName);
    }
    // 查找附近商鋪
    public void findNearby(double lon, double lat, double distanceKm) {
        Circle area = new Circle(new Point(lon, lat), new Distance(distanceKm, Metrics.KILOMETERS));
        GeoResults<RedisGeoCommands.GeoLocation<Object>> results =
            redisTemplate.opsForGeo().radius(GEO_KEY, area);
        results.forEach(r -> System.out.println("附近店鋪：" + r.getContent().getName()));
    }
}

@Service
public class ConfigService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    public String getConfig(String key) {
        String value = (String) redisTemplate.opsForHash().get("config:system", key);
        if (value == null) {
            // 假設(shè)從數(shù)據(jù)庫(kù)加載配置
            value = loadFromDb(key);
            redisTemplate.opsForHash().put("config:system", key, value);
        }
        return value;
    }
    private String loadFromDb(String key) {
        // 模擬數(shù)據(jù)庫(kù)
        if ("maxLoginRetry".equals(key)) return "5";
        return "default";
    }
}