美团一面：项目中使用过Redis吗？

@Service
public class ProductService {

    @Autowired
    private RedisTemplate redisTemplate;

    // 使用@Cacheable注解进行缓存
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(String id) {
        // 此处是从数据库或其他数据源获取商品的方法
        // 在实际场景中，如果缓存命中，则不会执行下面的数据库查询逻辑
        return getProductFromDatabase(id);
    }
}

    org.springframework.session
    spring-session-data-redis
    3.2.0

@Configuration
@EnableRedisHttpSession
public class RedisSessionConfig {

    @Bean
    public RedisConnectionFactory connectionFactory() {
        // 这里假设你已经在application.properties或application.yml中配置了Redis的信息
        // 根据实际情况填写Redis服务器地址、端口等信息
        return new LettuceConnectionFactory();
    }

}

@Service
public class RankingService {

    @Autowired
    private RedisTemplate redisTemplate;

    public void addToRanking(String playerName, int score) {
        redisTemplate.opsForZSet().add("ranking", playerName, score);
    }

    public List getRanking() {
        List rankingInfos = new ArrayList<>();
        Set> rankingSet = redisTemplate.opsForZSet().rangeWithScores("ranking", 0, -1);
        for (ZSetOperations.TypedTuple tuple : rankingSet) {
            RankingInfo rankingInfo = new RankingInfo();
            rankingInfo.setPlayerName(tuple.getValue());
            rankingInfo.setScore(tuple.getScore().intValue());
            rankingInfos.add(rankingInfo);
            System.out.println("playerName: " + tuple.getValue() + ", score: " + tuple.getScore().intValue());
        }
        return rankingInfos;
    }
}

@Service
public class CounterService {

    @Autowired
    private RedisTemplate redisTemplate;

    public void incrementLikeCount(String postId) {
        redisTemplate.opsForValue().increment(postId + ":likes");
    }

    public void decrementLikeCount(String postId) {
        redisTemplate.opsForValue().decrement(postId + ":likes");
    }

    public long getLikeCount(String postId) {
        String value = redisTemplate.opsForValue().get(postId + ":likes");
        return StringUtils.isBlank(value) ? 0 : Long.parseLong(value);
    }
}

@Component
public class DistributedLock {

    @Autowired
    private RedisTemplate redisTemplate;

    public boolean acquireLock(String lockKey, String requestId, long expireTime) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, expireTime);
        return result != null && result;
    }

    public void releaseLock(String lockKey, String requestId) {
        String value = redisTemplate.opsForValue().get(lockKey);
        if (value != null && value.equals(requestId)) {
            redisTemplate.delete(lockKey);
        }
    }
}

@Component
public class UniqueIdGenerator {

    @Autowired
    private RedisTemplate redisTemplate;

    public long generateUniqueId(String key) {
        return redisTemplate.opsForValue().increment(key, 1);
    }
}

@Component
public class StockService {

    @Autowired
    private RedisTemplate redisTemplate;

    
    private static final String STOCK_PREFIX = "stock:%s:%s";

    
    public boolean decreaseStock(String warehouseCode, String productId, long quantity) {
        String key = String.format(STOCK_PREFIX, warehouseCode, productId);
        Long stock = redisTemplate.opsForValue().decrement(key, quantity);
        return stock >= 0;
    }
}

-- 获取Lua脚本参数：商品ID和要购买的数量
local productId = KEYS[1]
local amount = tonumber(ARGV[1])

-- 获取当前库存
local currentStock = tonumber(redis.call('GET', 'seckill:product:'..productId))

-- 判断库存是否充足
if currentStock <= 0 or currentStock < amount then
    return 0
end

-- 扣减库存
redis.call('DECRBY', 'seckill:product:'..productId, amount)

-- 返回成功标志
return 1

@Component
public class SeckillService {

    @Autowired
    private RedisTemplate redisTemplate;

    
    private final DefaultRedisScript seckillScript = new DefaultRedisScript<>();
    {
        seckillScript.setLocation(new ClassPathResource("rate_limiter.lua"));
        seckillScript.setResultType(Long.class);
    }

    public boolean seckillyLua(String productId, int amount){
        // 设置Lua脚本参数
        List keys = Collections.singletonList(productId);
        List args = Collections.singletonList(Integer.toString(amount));

        // 执行Lua脚本
        Long result = redisTemplate.execute(seckillScript, keys, args);

        // 如果执行结果为1，表示秒杀成功
        return Objects.equals(result, 1L);
    }
}

    @Transactional(rollbackFor = Exception.class)
    public boolean seckilByWatch(String productId, int amount) {
        // 乐观锁事务操作
        while (true) {
            // WATCH指令监控库存键
            redisTemplate.watch("stock:" + productId);

            // 获取当前库存
            String currentStockStr = redisTemplate.opsForValue().get("stock:" + productId);
            if (currentStockStr == null) {
                // 库存不存在，可能是商品已售罄或异常情况
                return false;
            }
            int currentStock = Integer.parseInt(currentStockStr);

            // 判断库存是否充足
            if (currentStock < amount) {
                // 库存不足，取消WATCH并退出循环
                redisTemplate.unwatch();
                return false;
            }

            // 开启Redis事务
            redisTemplate.multi();

            // 执行扣减库存操作
            redisTemplate.opsForValue().decrement("stock:" + productId, amount);

            // 执行其他与秒杀相关的操作，如增加订单、更新用户余额等...

            // 提交事务，如果在此期间库存被其他客户端修改，则exec返回null
            List