Redis 在 Spring 项目中的使用及操作方法

<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: 缓存未命中 → 查询数据库
        user = userMapper.selectById(id);
        if (user == null) {
            return null;
        }
        // Step 3: 写入缓存，设置过期时间 10 分钟
        redisTemplate.opsForValue().set(key, user, 10, TimeUnit.MINUTES);
        System.out.println("【写入缓存】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("用户名或密码错误");
    }
    // 生成 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("系统繁忙，请稍后再试");
            }
            // 模拟扣库存逻辑
            Integer stock = getStock(productId);
            if (stock > 0) {
                updateStock(productId, stock - 1);
                System.out.println("下单成功，库存剩余：" + (stock - 1));
            } else {
                System.out.println("库存不足");
            }
        } 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) {}
}

// 生产者：发送任务
public void sendMailTask(String mailJson) {
    redisTemplate.opsForList().leftPush("queue:mail", mailJson);
}
// 消费者：异步线程处理任务
@Scheduled(fixedDelay = 2000)
public void consumeMailTask() {
    String task = (String) redisTemplate.opsForList().rightPop("queue:mail");
    if (task != null) {
        System.out.println("发送邮件任务：" + task);
        // 执行邮件发送逻辑
    }
}

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("消费订单消息：" + 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);
    }
    // 查询某个用户的排名
    public Long getRank(String userId) {
        return redisTemplate.opsForZSet().reverseRank(RANK_KEY, userId);
    }
    // 查询某个用户的分数
    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;
    // 每分钟最多请求 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("请求过于频繁，请稍后再试！");
        }
    }
}

@GetMapping("/api/test")
public String test(HttpServletRequest request) {
    String ip = request.getRemoteAddr();
    rateLimitService.checkRateLimit(ip);
    return "正常访问成功";
}

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";
    // 添加延时任务
    public void addDelayTask(Long orderId, long delayMs) {
        long executeTime = System.currentTimeMillis() + delayMs;
        redisTemplate.opsForZSet().add(DELAY_KEY, orderId, executeTime);
        System.out.println("添加延迟任务: orderId=" + orderId + ", 执行时间=" + executeTime);
    }
    // 定时扫描执行任务
    @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("执行超时任务: orderId=" + task);
                // 执行业务逻辑：关闭订单
                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) {
                    // 防止穿透：缓存空对象
                    redisTemplate.opsForValue().set(key, new Product(), 2, TimeUnit.MINUTES);
                } else {
                    // 防止雪崩：过期时间随机
                    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";
    // 添加商铺坐标
    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) {
            // 假设从数据库加载配置
            value = loadFromDb(key);
            redisTemplate.opsForHash().put("config:system", key, value);
        }
        return value;
    }
    private String loadFromDb(String key) {
        // 模拟数据库
        if ("maxLoginRetry".equals(key)) return "5";
        return "default";
    }
}