2 道直播系统设计题，建议收藏

CREATE TABLE `gifts` (
  `gift_id` INT AUTO_INCREMENT PRIMARY KEY,
  `gift_name` VARCHAR(255) NOT NULL,
  `cost` INT NOT NULL,
  `image_url` VARCHAR(255)
);

CREATE TABLE `user_gifts` (
  `user_gift_id` INT AUTO_INCREMENT PRIMARY KEY,
  `user_id` INT NOT NULL,
  `gift_id` INT NOT NULL,
  `quantity` INT DEFAULT 1,
  `acquired_date` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '获得礼物日期'
);

CREATE TABLE `gift_consumption_records` (
  `record_id` INT AUTO_INCREMENT PRIMARY KEY,
  `user_id` INT NOT NULL,
  `gift_id` INT NOT NULL,
  `anchor_id` INT NOT NULL COMMENT '主播id',
  `quantity` INT NOT NULL,
  `consumed_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

// 校验接口
public boolean validateGiftAndBalance(int userId, int giftId, int quantity) {
    // 查询用户余额
    int userBalance = getUserBalance(userId);
    // 查询礼物价格
    int giftCost = getGiftCost(giftId);
    
    // 校验用户余额是否充足
    if (userBalance < giftCost * quantity) {
        return false;
    }
    return true;
}

// 异步处理
public void processGiftAsync(int userId, int giftId, int quantity, int anchorId) {
    CompletableFuture.runAsync(() -> {
        // 直播间礼物通知
        notifyLiveRoom(userId, giftId, quantity, anchorId);
        // 更新礼物排行榜
        updateGiftRanking(userId, giftId, quantity);
        // 记录消费日志
        recordGiftConsumption(userId, giftId, quantity, anchorId);
    });
}

# 用户、直播间是一对多关系的数据结构
live_room_users:room_id : [user_id, user_id]

# 例如
live_room_users:000 : [001, 002, 003]
live_room_users:111 : [004, 005, 005]

// WebSocket通知房间里所有用户
public void notifyLiveRoom(int userId, int giftId, int quantity, int roomId) {
    // 获取房间中所有用户
    Set<Integer> users = getUsersInLiveRoom(roomId);
    String message = String.format("User %d sent %d of gift %d", userId, quantity, giftId);

    // 推送消息给所有用户
    for (Integer user : users) {
        webSocketService.sendMessageToUser(user, message);
    }
}

// 批量送礼接口
public void batchSendGift(int userId, int giftId, int totalQuantity, int roomId, int anchorId) {
    // 客户端统计点击次数，作为一次送礼请求
    processGiftAsync(userId, giftId, totalQuantity, anchorId);
}

// 事务控制
@Transactional
public boolean processGiftTransaction(int userId, int giftId, int quantity, int anchorId) {
    try {
        // 礼物校验、资产校验
        if (!validateGiftAndBalance(userId, giftId, quantity)) {
            return false;
        }
        // 扣费
        deductUserBalance(userId, giftId, quantity);
        
        // 其他异步业务逻辑
        processGiftAsync(userId, giftId, quantity, anchorId)
        return true;
    } catch (Exception e) {
        throw new RuntimeException("Gift processing failed, transaction rolled back", e);
    }
}

// 创建Zset数据结构并设置10条的限制
public class DanmakuService {

    private Jedis jedis = new Jedis("localhost");

    public void addDanmaku(String roomId, String danmaku, long timestamp) {
        String key = "room:" + roomId + ":danmaku";
        jedis.zadd(key, timestamp, danmaku);
        // 只保留最新的10条弹幕
        jedis.zremrangeByRank(key, 0, -(11));
    }
}

// 轮询API接口
public class DanmakuService {

    private Jedis jedis = new Jedis("localhost");

    public Set<String> getRecentDanmaku(String roomId, long lastTimestamp) {
        String key = "room:" + roomId + ":danmaku";
        return jedis.zrangeByScore(key, lastTimestamp + 1, Long.MAX_VALUE);
    }
}

// 监听写入Redis
public class DanmakuListener {

    private Jedis jedis = new Jedis("localhost");

    @KafkaListener(topics = "danmaku", groupId = "group_id")
    public void listen(ConsumerRecord<String, String> record) {
        String roomId = record.key();
        String message = record.value();
        long timestamp = System.currentTimeMillis();
        
        String key = "room:" + roomId + ":danmaku";
        // 将弹幕消息写入Redis Zset
        jedis.zadd(key, timestamp, message);
        // 保留最近10条
        jedis.zremrangeByRank(key, 0, -11);
    }
}

// 在写入弹幕时获取分布式锁
public class DanmakuService {

    private RedisLockUtil redisLock = new RedisLockUtil();
    
    private Jedis jedis = new Jedis("localhost");

    public void addDanmakuWithLock(String roomId, String danmaku, long timestamp) {
        String lockKey = "lock:" + roomId;
        try {
            if (redisLock.acquireLock(lockKey)) {
                String key = "room:" + roomId + ":danmaku";
                jedis.zadd(key, timestamp, danmaku);
                jedis.zremrangeByRank(key, 0, -11);
            }
        } finally {
            redisLock.releaseLock(lockKey);
        }
    }
}

public class RedisLockUtil {

    private Jedis jedis = new Jedis("localhost");
    
    private static final int EXPIRE_TIME = 5000; // 5秒

    // 获取锁
    public boolean acquireLock(String lockKey) {
        long currentTime = System.currentTimeMillis();
        String result = jedis.set(lockKey, String.valueOf(currentTime), "NX", "PX", EXPIRE_TIME);
        return "OK".equals(result);
    }

    // 释放锁
    public void releaseLock(String lockKey) {
        jedis.del(lockKey);
    }
}