当涉及到在工作中使用 Redis 时，下面是一些具体的场景和相应的例子：

1. 缓存加速

• 场景：用户登录信息缓存
• 示例：将用户的登录信息缓存在 Redis 中，包括用户ID、用户名和权限等。当用户进行登录验证时，首先从 Redis 中获取缓存数据，如果存在则直接返回缓存数据，减少对数据库的查询次数。

import redis.clients.jedis.Jedis;

public class UserCache {
    private Jedis jedis = new Jedis("localhost");

    public String getUserInfo(int userId) {
        String userInfo = jedis.get("user:" + userId);
        if (userInfo == null) {
            // 从数据库获取用户信息
            userInfo = db.queryUserInfo(userId);
            // 将用户信息存入 Redis，并设置过期时间
            jedis.setex("user:" + userId, 3600, userInfo);
        }
        return userInfo;
    }
}

• 场景：热门商品缓存
• 示例：将热门商品的详细信息存储在 Redis 中，并设置适当的过期时间。当用户浏览商品页面时，首先尝试从 Redis 获取商品信息，如果缓存不存在，则从数据库中获取，并将结果缓存在 Redis 中，以便下次查询。

public class ProductCache {
    private Jedis jedis = new Jedis("localhost");

    public String getProductInfo(int productId) {
        String productInfo = jedis.get("product:" + productId);
        if (productInfo == null) {
            productInfo = db.queryProductInfo(productId);
            jedis.setex("product:" + productId, 600, productInfo);
        }
        return productInfo;
    }
}

2. 计数器和统计

• 场景：页面访问次数统计
• 示例：使用 Redis 的计数器功能，每次有用户访问页面时，对应页面的访问次数加1。通过 Redis 的 INCR 命令实现原子性操作和高性能的计数功能。

public class PageVisitCounter {
    private Jedis jedis = new Jedis("localhost");

    public void recordPageVisit(int pageId) {
        jedis.incr("page:" + pageId + ":visits");
    }
}

• 场景：用户点赞数统计
• 示例：将每个用户的点赞数存储在 Redis 的 Hash 数据结构中，用用户 ID 作为字段，点赞数作为值。每次用户进行点赞操作时，更新对应用户的点赞数。

public class LikeCounter {
    private Jedis jedis = new Jedis("localhost");

    public void likePost(int userId, int postId) {
        jedis.hincrBy("post:" + postId + ":likes", String.valueOf(userId), 1);
    }
}

3. 分布式锁

• 场景：订单库存扣减
• 示例：使用 Redis 实现分布式锁，保证在多个服务同时操作订单库存时的一致性。当多个服务需要扣减某个商品的库存时，先尝试获取 Redis 锁，成功获取锁后执行库存扣减操作，完成后释放锁。

public class StockManager {
    private Jedis jedis = new Jedis("localhost");

    public void reduceStockWithLock(int productId, int quantity) {
        String lockKey = "lock:reduce_stock:" + productId;
        String lockValue = "locked";
        
        // 尝试获取分布式锁
        String result = jedis.set(lockKey, lockValue, "NX", "EX", 10);
        if ("OK".equals(result)) {
            // 执行库存扣减操作
            // ...
            // 释放锁
            jedis.del(lockKey);
        }
    }
}

• 场景：避免重复提交
• 示例：在需要防止表单重复提交的场景中，使用 Redis 的分布式锁功能。当用户提交表单时，先尝试获取 Redis 锁，如果成功获取则进行表单处理，处理完成后释放锁，防止重复提交。

public class FormHandler {
    private Jedis jedis = new Jedis("localhost");

    public void handleFormSubmission(FormData formData) {
        String lockKey = "lock:form_submission:" + formData.getUserId();
        String lockValue = "locked";

        String result = jedis.set(lockKey, lockValue, "NX", "EX", 60);
        if ("OK".equals(result)) {
            // 处理表单提交
            // ...
            // 释放锁
            jedis.del(lockKey);
        }
    }
}

4. 排行榜

• 场景：文章阅读量排行
• 示例：将每篇文章的阅读量存储在 Redis 的有序集合中，以文章ID作为成员，阅读量作为分数。通过 Redis 的 ZINCRBY 命令更新阅读量，并通过 ZREVRANGE 命令获取阅读量排名靠前的文章。

import redis.clients.jedis.Jedis;
import java.util.Set;

public class ArticleRanking {
    private Jedis jedis = new Jedis("localhost");

    public void incrementArticleReadCount(int articleId) {
        jedis.zincrby("article_ranking", 1, "article:" + articleId);
    }

    public Set<String> getTopArticles(int count) {
        return jedis.zrevrange("article_ranking", 0, count - 1);
    }
}

• 场景：游戏玩家积分排行
• 示例：使用 Redis 的有序集合保存玩家的积分信息，以玩家ID作为成员，积分作为分数。通过 ZINCRBY 命令更新玩家积分，使用 ZREVRANGE 命令获取积分排名前几名的玩家。

import redis.clients.jedis.Jedis;
import java.util.Set;

public class PlayerScoreRanking {
    private Jedis jedis = new Jedis("localhost");

    public void incrementPlayerScore(int playerId, int score) {
        jedis.zincrby("player_score_ranking", score, "player:" + playerId);
    }

    public Set<String> getTopPlayers(int count) {
        return jedis.zrevrange("player_score_ranking", 0, count - 1);
    }
}

5. 消息队列

• 场景：异步任务处理
• 示例：使用 Redis 的列表结构作为消息队列，生产者将需要处理的任务推入队列，消费者从队列中获取任务进行处理。例如，通过 LPUSH 和 BRPOP 实现异步发送邮件、生成报表等任务。

import redis.clients.jedis.Jedis;

public class AsyncTaskQueue {
    private Jedis jedis = new Jedis("localhost");

    public void enqueueTask(String task) {
        jedis.lpush("async_task_queue", task);
    }

    public String dequeueTask() {
        return jedis.brpop(0, "async_task_queue").get(1);
    }
}

• 场景：事件驱动架构
• 示例：将系统中的事件以消息的形式发布到 Redis 的消息通道，不同的服务订阅感兴趣的事件并进行相应的处理。例如，用户注册成功后，发布注册成功的事件，用户服务和积分服务订阅该事件进行后续处理。

import redis.clients.jedis.Jedis;

public class EventPublisher {
    private Jedis jedis = new Jedis("localhost");

    public void publishEvent(String channel, String event) {
        jedis.publish(channel, event);
    }
}

public class EventSubscriber extends JedisPubSub {
    private Jedis jedis = new Jedis("localhost");

    public void subscribeToChannel(String channel) {
        jedis.subscribe(this, channel);
    }

    @Override
    public void onMessage(String channel, String message) {
        // 处理接收到的事件消息
        System.out.println("Received event: " + message);
    }
}

6.限流

场景描述： 防止恶意请求或者突发流量对系统造成影响，可以使用 Redis 实现限流控制。

import redis.clients.jedis.Jedis;

public class RequestRateLimiter {
    private Jedis jedis = new Jedis("localhost");

    public boolean isAllowed(String ipAddress, int maxRequestsPerMinute) {
        String key = "rate_limit:" + ipAddress + ":" + System.currentTimeMillis() / 60000;
        long count = jedis.incr(key);
        if (count == 1) {
            jedis.expire(key, 60); // 设置过期时间为一分钟
        }
        return count <= maxRequestsPerMinute;
    }
}

示例： 使用 Redis 的计数器或漏桶算法实现接口访问频率限制、短信验证码发送限制、防火墙规则等，通过监控请求频率并拒绝超出限制的请求。