@Service
public class ProductService {

    @Autowired
    private RedisTemplate<String, Product> redisTemplate;

    // 使用@Cacheable注解進(jìn)行緩存
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(String id) {
        // 此處是從數(shù)據(jù)庫或其他數(shù)據(jù)源獲取商品的方法
        // 在實(shí)際場景中，如果緩存命中，則不會執(zhí)行下面的數(shù)據(jù)庫查詢邏輯
        return getProductFromDatabase(id);
    }
}

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

@Configuration
@EnableRedisHttpSession
public class RedisSessionConfig {

    @Bean
    public RedisConnectionFactory connectionFactory() {
        // 這里假設(shè)你已經(jīng)在application.properties或application.yml中配置了Redis的信息
        // 根據(jù)實(shí)際情況填寫Redis服務(wù)器地址、端口等信息
        return new LettuceConnectionFactory();
    }

}

@Service
public class RankingService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

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

    public List<RankingInfo> getRanking() {
        List<RankingInfo> rankingInfos = new ArrayList<>();
        Set<ZSetOperations.TypedTuple<String>> rankingSet = redisTemplate.opsForZSet().rangeWithScores("ranking", 0, -1);
        for (ZSetOperations.TypedTuple<String> 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<String, String> 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<String, String> 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<String, String> redisTemplate;

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

@Component
public class StockService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**商品庫存的key*/
    private static final String STOCK_PREFIX = "stock:%s:%s";

    /**
     * 扣減庫存
     * @param warehouseCode
     * @param productId
     * @param quantity
     * @return
     */
    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腳本參數(shù)：商品ID和要購買的數(shù)量
local productId = KEYS[1]
local amount = tonumber(ARGV[1])

-- 獲取當(dāng)前庫存
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)

-- 返回成功標(biāo)志
return 1

@Component
public class SeckillService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 初始化RedisScript對象
     */
    private final DefaultRedisScript<Long> seckillScript = new DefaultRedisScript<>();
    {
        seckillScript.setLocation(new ClassPathResource("rate_limiter.lua"));
        seckillScript.setResultType(Long.class);
    }

    public boolean seckillyLua(String productId, int amount){
        // 設(shè)置Lua腳本參數(shù)
        List<String> keys = Collections.singletonList(productId);
        List<String> args = Collections.singletonList(Integer.toString(amount));

        // 執(zhí)行Lua腳本
        Long result = redisTemplate.execute(seckillScript, keys, args);

        // 如果執(zhí)行結(jié)果為1，表示秒殺成功
        return Objects.equals(result, 1L);
    }
}

/**
     * 秒殺方法
     * @param productId 商品ID
     * @param amount 要購買的數(shù)量
     * @return 秒殺成功與否
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean seckilByWatch(String productId, int amount) {
        // 樂觀鎖事務(wù)操作
        while (true) {
            // WATCH指令監(jiān)控庫存鍵
            redisTemplate.watch("stock:" + productId);

            // 獲取當(dāng)前庫存
            String currentStockStr = redisTemplate.opsForValue().get("stock:" + productId);
            if (currentStockStr == null) {
                // 庫存不存在，可能是商品已售罄或異常情況
                return false;
            }
            int currentStock = Integer.parseInt(currentStockStr);

            // 判斷庫存是否充足
            if (currentStock < amount) {
                // 庫存不足，取消WATCH并退出循環(huán)
                redisTemplate.unwatch();
                return false;
            }

            // 開啟Redis事務(wù)
            redisTemplate.multi();

            // 執(zhí)行扣減庫存操作
            redisTemplate.opsForValue().decrement("stock:" + productId, amount);

            // 執(zhí)行其他與秒殺相關(guān)的操作，如增加訂單、更新用戶余額等...

            // 提交事務(wù)，如果在此期間庫存被其他客戶端修改，則exec返回null
            List<Object> results = redisTemplate.exec();

            // 如果事務(wù)執(zhí)行成功，跳出循環(huán)
            if (!results.isEmpty()) {
                return true;
            }
        }
    }

public interface MessageListener {
    void onMessage(String channel, String message);
}

@Component
public class MessageQueue {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public void publish(String channel, String message) {
        redisTemplate.convertAndSend(channel, message);
    }

    public void subscribe(String channel, MessageListener listener) {
        redisTemplate.getConnectionFactory().getConnection().subscribe((message, pattern) -> {
            listener.onMessage(channel, message);
        }, channel.getBytes());
    }
}

@Component
public class RelationshipGraphService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**用戶資料*/
    private static final String USER_PROFILE_PREFIX = "user_profile:";

    /**
     * 存儲用戶個(gè)人資料
     * @param userId
     * @param profile
     */
    public void setUserProfile(String userId, Map<String, String> profile) {
        String key = USER_PROFILE_PREFIX + userId;
        redisTemplate.opsForHash().putAll(key, profile);
    }

    /**
     * 獲取用戶個(gè)人資料
     * @param userId
     * @return
     */
    public Map<Object, Object> getUserProfile(String userId) {
        String key = USER_PROFILE_PREFIX + userId;
        return redisTemplate.opsForHash().entries(key);
    }
}

@Component
public class RelationshipGraphService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

     /**用戶好友*/
    private static final String FRIENDS_PREFIX = "friends:";

    /**
     * 添加好友關(guān)系
     * @param userId
     * @param friendId
     */
    public void addFriend(String userId, String friendId) {
        String key = FRIENDS_PREFIX + userId;
        redisTemplate.opsForSet().add(key, friendId);
    }

    /**
     * 獲取用戶的所有好友
     * @param userId
     * @return
     */
    public Set<String> getFriends(String userId) {
        String key = FRIENDS_PREFIX + userId;
        return redisTemplate.opsForSet().members(key);
    }
}

@Service
public class LikeService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 點(diǎn)贊
     * @param objectId
     * @param userId
     */
    public void like(String objectId, String userId) {
        // 將點(diǎn)贊人放入zset中
        redisTemplate.opsForSet().add(getLikeKey(objectId), userId);
    }

    /**
     * 取消點(diǎn)贊
     * @param objectId
     * @param userId
     */
    public void unlike(String objectId, String userId) {
        // 減少點(diǎn)贊人數(shù)
        redisTemplate.opsForSet().remove(getLikeKey(objectId), userId);
    }

    /**
     * 是否點(diǎn)贊
     * @param objectId
     * @param userId
     * @return
     */
    public Boolean isLiked(String objectId, String userId) {
        return redisTemplate.opsForSet().isMember(getLikeKey(objectId), userId);
    }

    /**
     * 獲取點(diǎn)贊數(shù)
     * @param objectId
     * @return
     */
    public Long getLikeCount(String objectId) {
       return redisTemplate.opsForSet().size(getLikeKey(objectId));
    }

    /**
     * 獲取所有點(diǎn)贊的用戶
     * @param objectId
     * @return
     */
    public Set<String> getLikedUsers(String objectId) {
        return redisTemplate.opsForSet().members(getLikeKey(objectId));
    }

    private String getLikeKey(String objectId) {
        return "likes:" + objectId;
    }

}

@Component
public class RelationshipGraphService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**用戶關(guān)注者*/
    private static final String FOLLOWERS_PREFIX = "followers:";

    /**
     * 添加關(guān)注者
     * @param userId
     * @param followerId
     * @param score
     */
    public void addFollower(String userId, String followerId, double score) {
        String key = FOLLOWERS_PREFIX + userId;
        redisTemplate.opsForZSet().add(key, followerId, score);
    }

    /**
     * 獲取用戶的關(guān)注者列表（按照關(guān)注時(shí)間排序）
     * @param userId
     * @return
     */
    public Set<String> getFollowers(String userId) {
        String key = FOLLOWERS_PREFIX + userId;
        return redisTemplate.opsForZSet().range(key, 0, -1);
    }

}

-- rate_limiter.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local timeWindow = tonumber(ARGV[2]) -- 時(shí)間窗口，例如單位為秒

-- 獲取當(dāng)前時(shí)間戳
local currentTime = redis.call('TIME')[1]

-- 獲取最近timeWindow秒內(nèi)的請求次數(shù)
local count = redis.call('ZCOUNT', key .. ':requests', currentTime - timeWindow, currentTime)

-- 如果未超過限制，則累加請求次數(shù)，并返回true
if count < limit then
  redis.call('ZADD', key .. ':requests', currentTime, currentTime)
  return 1
else
  return 0
end

@Component
public class RateLimiter {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**限流Key*/
    private static final String TATE_LIMITER_KEY = "rate-limit:%s";

    /**規(guī)定的時(shí)間窗口內(nèi)允許的最大請求數(shù)量*/
    private static final Integer LIMIT = 100;

    /**限流策略的時(shí)間窗口長度，單位是秒*/
    private static final Integer TIME_WINDOW = 60;

    /**
     * 初始化RedisScript對象
     */
    private final DefaultRedisScript<Long> rateLimiterScript = new DefaultRedisScript<>();
    {
        rateLimiterScript.setLocation(new ClassPathResource("rate_limiter.lua"));
        rateLimiterScript.setResultType(Long.class);
    }


    /**
     * 限流方法 1分鐘內(nèi)最多100次請求
     * @param userId
     * @return
     */
    public boolean allowRequest(String userId) {
        String key = String.format(TATE_LIMITER_KEY, userId);
        List<String> keys = Collections.singletonList(key);
        List<String> args = Arrays.asList(String.valueOf(LIMIT), String.valueOf(TIME_WINDOW));

        // 執(zhí)行Lua腳本
        Long result = redisTemplate.execute(rateLimiterScript, keys, args);

        // 結(jié)果為1表示允許請求，0表示請求被限流
        return Objects.equals(result, 1L);
    }
}

@Service
public class UserOnlineStatusService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String ONLINE_STATUS_KEY = "online_status";
    private static final String RETENTION_RATE_KEY_PREFIX = "retention_rate:";
    private static final String DAILY_ACTIVITY_KEY_PREFIX = "daily_activity:";

    /**
     * 設(shè)置用戶在線狀態(tài)為在線
     * @param userId
     */
    public void setUserOnline(long userId) {
        redisTemplate.opsForValue().setBit(ONLINE_STATUS_KEY, userId, true);
    }

    /**
     * 設(shè)置用戶在線狀態(tài)為離線
     * @param userId
     */
    public void setUserOffline(long userId) {
        redisTemplate.opsForValue().setBit(ONLINE_STATUS_KEY, userId, false);
    }

    /**
     * 獲取用戶在線狀態(tài)
     * @param userId
     * @return
     */
    public boolean isUserOnline(long userId) {
        return redisTemplate.opsForValue().getBit(ONLINE_STATUS_KEY, userId);
    }

    /**
     * 統(tǒng)計(jì)在線用戶數(shù)量
     * @return
     */
    public long countOnlineUsers() {
        return  getCount(ONLINE_STATUS_KEY);
    }

    /**
     * 記錄用戶的留存情況
     * @param userId
     * @param daysAgo
     */
    public void recordUserRetention(long userId, int daysAgo) {
        String key = RETENTION_RATE_KEY_PREFIX + LocalDate.now().minusDays(daysAgo).toString();
        redisTemplate.opsForValue().setBit(key, userId, true);
    }

    /**
     * 獲取指定日期的留存率
     * @param daysAgo
     * @return
     */
    public double getRetentionRate(int daysAgo) {
        String key = RETENTION_RATE_KEY_PREFIX + LocalDate.now().minusDays(daysAgo).toString();
        long totalUsers = countOnlineUsers();
        long retainedUsers = getCount(key);
        return (double) retainedUsers / totalUsers * 100;
    }

    /**
     * 記錄用戶的每日活躍情況
     * @param userId
     */
    public void recordUserDailyActivity(long userId) {
        String key = DAILY_ACTIVITY_KEY_PREFIX + LocalDate.now().toString();
        redisTemplate.opsForValue().setBit(key, userId, true);
    }

    /**
     * 獲取指定日期的活躍用戶數(shù)量
     * @param date
     * @return
     */
    public long countDailyActiveUsers(LocalDate date) {
        String key = DAILY_ACTIVITY_KEY_PREFIX + date.toString();
        return getCount(key);
    }

    /**
     * 獲取最近幾天每天的活躍用戶數(shù)量列表
     * @param days
     * @return
     */
    public List<Long> getDailyActiveUsers(int days) {
        LocalDate currentDate = LocalDate.now();
        List<Long> results = Lists.newArrayList();
        for (int i = 0; i < days; i++) {
            LocalDate date = currentDate.minusDays(i);
            String key = DAILY_ACTIVITY_KEY_PREFIX + date.toString();
            results.add(getCount(key));
        }
        return results;
    }

    /**
     * 獲取key下的數(shù)量
     * @param key
     * @return
     */
    private long getCount(String key) {
        return (long) redisTemplate.execute((RedisCallback<Long>) connection -> connection.bitCount(key.getBytes()));
    }
}

@Service
public class LatestListService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String LATEST_LIST_KEY = "latest_list";

    /**
     * 添加最新內(nèi)容ID到列表頭部
     * @param contentId 內(nèi)容ID
     */
    public void addLatestContent(String contentId) {
        ListOperations<String, String> listOps = redisTemplate.opsForList();
        listOps.leftPush(LATEST_LIST_KEY, contentId);
        // 限制列表最多存儲N個(gè)ID，假設(shè)N為100
        listOps.trim(LATEST_LIST_KEY, 0, 99);
    }

    /**
     * 獲取最新的N個(gè)內(nèi)容ID
     * @param count 要獲取的數(shù)量，默認(rèn)為10
     * @return 最新的內(nèi)容ID列表
     */
    public List<String> getLatestContentIds(int count) {
        ListOperations<String, String> listOps = redisTemplate.opsForList();
        return listOps.range(LATEST_LIST_KEY, 0, count - 1);
    }
}

@Service
public class LotteryService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String PARTICIPANTS_SET_KEY = "lottery:participants";

    /**
     * 添加參與者到抽獎(jiǎng)名單
     * @param participant 參與者ID
     */
    public void joinLottery(String participant) {
        redisTemplate.opsForSet().add(PARTICIPANTS_SET_KEY, participant);
    }

    /**
     * 抽取一名幸運(yùn)兒
     * @return 幸運(yùn)兒ID
     */
    public String drawWinner() {
        // 使用Spop命令隨機(jī)抽取一個(gè)參與者
        return redisTemplate.opsForSet().pop(PARTICIPANTS_SET_KEY);
    }

    /**
     * 抽取N個(gè)幸運(yùn)兒
     * @param count 抽取數(shù)量
     * @return 幸運(yùn)兒ID列表
     */
    public List<String> drawWinners(int count) {
        return redisTemplate.opsForSet().pop(PARTICIPANTS_SET_KEY, count);
    }
}

@Component
public class LogCollector {

    private static final String LOGS_STREAM_KEY = "logs";
    private static final String GROUP_NAME = "log_consumers";
    private static final String CONSUMER_NAME = "log_consumer";

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 發(fā)送日志事件至 Redis Stream
    public void sendLogEvent(String message, Map<String, String> attributes) {
        StreamOperations<String, Object, Object> streamOperations = redisTemplate.opsForStream();
        RecordId messageId = streamOperations.add(StreamRecords.newRecord()
                .ofStrings(attributes)
                .withStreamKey(LOGS_STREAM_KEY));
    }

    // 實(shí)時(shí)消費(fèi)日志事件
    public StreamRecords<String, String> consumeLogs(int batchSize) {
        Consumer consumer = Consumer.from(CONSUMER_NAME, GROUP_NAME);
        StreamOffset<String> offset = StreamOffset.create(LOGS_STREAM_KEY, ReadOffset.lastConsumed());
        StreamReadOptions<String, String> readOptions = StreamReadOptions.empty().count(batchSize);
        return redisTemplate.opsForStream().read(readOptions, StreamOffset.create(LOGS_STREAM_KEY, ReadOffset.lastConsumed()), consumer);
    }
}

@Service
public class FriendService {

    private static final String FRIEND_LOCATIONS_KEY = "friend_locations";

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private GeoOperations<String, FriendLocation> geoOperations; // 自動裝配GeoOperations

    public void saveFriendLocation(FriendLocation location) {
        geoOperations.add(FRIEND_LOCATIONS_KEY, location.getLongitude(), location.getLatitude(), location);
    }

    public List<FriendLocation> findFriendsNearby(double myLongitude, double myLatitude, Distance radius) {
        Circle circle = new Circle(new Point(myLongitude, myLatitude), radius);
        return geoOperations.radius(FRIEND_LOCATIONS_KEY, circle, Metric.KILOMETERS).getContent();
    }
}