Springboot3 如何打造一个能承载百万用户同时在线的超强直播评论系统？-优快云博客

篇文章不仅展示了如何设计一个百万级并发的直播评论系统，还强调了在系统设计过程中结构化思考的重要性。通过不断迭代、权衡不同方案，最终实现了高效且稳定的架构设计。

随着直播行业的迅猛发展，越来越多的平台开始承载着数百万甚至上千万用户的同时在线互动。尤其在直播评论系统中，如何保持高并发、大规模的用户参与，成为了一个不可回避的技术挑战。类似于抖音、B站的实时弹幕系统，它们能够处理每秒成千上万的评论请求，同时又要确保低延迟、稳定性以及系统的高可用性。

在本篇文章中，我们将通过系统设计的思路，逐步解析如何用 Spring Boot 3 打造一个支持百万用户同时在线的超强直播评论系统。我们将通过面试官与候选人的对话模式，结合实际应用场景，一步步搭建起这个系统架构。希望通过这篇文章，能帮助你在技术面试中应对类似的系统设计问题时，展示出更加清晰和理性的思维。

需求梳理与边界界定

面试官： “如果要你设计一个类似 B站的直播评论系统，你会怎么着手？”

候选人： “首先，我们需要明确直播评论系统的核心功能和非功能需求。”

功能需求

核心需求：

a.发布评论：用户能够在观看直播时发布实时评论。

b.实时查看评论：所有观众能够实时看到新发布的评论。

c.历史评论展示：新加入的观众能够看到他们加入直播前已发布的评论。

非核心需求：

a.评论回复功能：允许评论之间进行嵌套回复。

b.评论点赞与表情回应：增加互动性。

非功能需求

明确了核心功能需求后，我们需要确认系统在百万级并发情况下的非功能性要求：

高扩展性：支持水平扩展，处理数百万观众的并发评论。
高可用性：即使在分布式环境下也能保证系统高可用，最终一致性可接受。
低延迟：评论广播的端到端延迟应控制在200毫秒以内。

底层设计

面试官： “需求很清晰。接下来你打算如何进行底层设计？”

候选人： “我倾向于从宏观到微观，先定义系统的核心实体和接口，这样能够帮助我们理清系统的基本构成。”

核心实体定义

我们需要关注三个核心实体：

用户（User）：发布评论的用户，可以是观众或主播。
直播视频（LiveVideo）：评论依附的直播视频。
评论（Comment）：用户发布的评论。

系统接口设计

我们可以为每个功能设计接口，确保清晰的功能实现。

发布评论接口：

@PostMapping("/comments/{liveVideoId}")
public ResponseEntity<Void> createComment(@PathVariable String liveVideoId, 
                                         @RequestBody CommentRequest commentRequest,
                                         @RequestHeader("Authorization") String token) {
    commentService.createComment(liveVideoId, commentRequest, token);
    return ResponseEntity.ok().build();
}

获取历史评论接口：

@GetMapping("/comments/{liveVideoId}")
public ResponseEntity<List<CommentResponse>> getComments(@PathVariable String liveVideoId,
                                                         @RequestParam Long cursor,
                                                         @RequestParam int pageSize) {
    List<CommentResponse> comments = commentService.getComments(liveVideoId, cursor, pageSize);
    return ResponseEntity.ok(comments);
}

高层架构设计

面试官： “从架构层面看，如何实现高并发评论发布？”

候选人： “我们可以采用三层架构：客户端、服务端、数据库。”

客户端：负责向后端发送评论请求并进行用户认证。
服务端：处理评论的接收、校验及持久化操作。
数据库：使用如 AWS DynamoDB 或阿里云 Table Store 这样的 NoSQL 数据库来存储评论数据。

实现评论发布

在客户端提交评论后，通过 RESTful 接口 POST /comments/{liveVideoId} 将评论发送到服务端，服务端校验并将评论存储到数据库中。

@Service
public class CommentService {


    @Autowired
    private CommentRepository commentRepository;


    @Autowired
    private RedisService redisService;


    public void createComment(String liveVideoId, CommentRequest commentRequest, String token) {
        User user = userService.getUserFromToken(token);
        Comment comment = new Comment(liveVideoId, user.getId(), commentRequest.getMessage(), new Date());
        commentRepository.save(comment);


        // 使用Redis进行实时评论推送
        redisService.pushToChannel(liveVideoId, comment);
    }
}

高性能设计

面试官： “如何解决实时评论的广播问题？”

候选人： “要解决实时广播的问题，我们可以采用 WebSocket 或服务器发送事件（SSE）。考虑到直播场景下读写不平衡，SSE 更为合适。”

实时广播评论

WebSocket：适用于双向通信，确保客户端实时接收到新评论，但对于高并发场景，维护大量的 WebSocket 连接开销较大。
SSE（推荐方案）：通过建立持久化的 HTTP 连接，服务端可以主动推送数据，适合大规模阅读场景。

@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {


    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new CommentWebSocketHandler(), "/comments/{liveVideoId}")
                .setAllowedOrigins("*");
    }
}

如何水平扩展 SSE 服务？

要支持百万级并发，SSE 服务必须能够水平扩展，处理大量的并发连接。单台服务器无法承载百万个长连接，必须采用分布式架构和负载均衡方案。

负载均衡与分布式 SSE

为确保高并发时服务端可以支撑数百万观众，我们需要引入 负载均衡 和 分布式 SSE 服务。具体步骤如下：

负载均衡：通过负载均衡器（如 Nginx 或 HAProxy）将客户端的 SSE 请求分配到不同的后端服务器。
发布/订阅机制（Pub/Sub）：使用 Redis 或 Kafka 等消息队列系统进行实时的评论推送，确保所有的服务器都能够获取到新的评论并推送到观众客户端。

分布式 SSE 服务实现

我们可以通过 Redis 来实现分布式 SSE 服务。在 Redis 中设置一个频道，当有新的评论时，服务器将其发布到该频道，所有订阅了该频道的 SSE 服务实例会收到新评论并推送给客户端。

Redis Pub/Sub 实现：

@Service
public class RedisService {


    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    public void pushToChannel(String liveVideoId, Comment comment) {
        redisTemplate.convertAndSend("live:" + liveVideoId, comment);
    }
}

SSE 服务端推送实现：

@Service
public class SSEService {


    private final Map<String, List<SseEmitter>> emittersMap = new ConcurrentHashMap<>();


    public SseEmitter connect(String liveVideoId) {
        SseEmitter sseEmitter = new SseEmitter();
        emittersMap.computeIfAbsent(liveVideoId, k -> new ArrayList<>()).add(sseEmitter);


        sseEmitter.onTimeout(() -> emittersMap.get(liveVideoId).remove(sseEmitter));
        sseEmitter.onCompletion(() -> emittersMap.get(liveVideoId).remove(sseEmitter));


        return sseEmitter;
    }


    public void pushComment(String liveVideoId, Comment comment) throws IOException {
        List<SseEmitter> emitters = emittersMap.get(liveVideoId);
        if (emitters != null) {
            for (SseEmitter emitter : emitters) {
                emitter.send(comment);
            }
        }
    }
}

SSE Controller 实现：

@RestController
public class CommentController {


    @Autowired
    private SSEService sseService;


    @GetMapping("/sse/comments/{liveVideoId}")
    public SseEmitter getComments(@PathVariable String liveVideoId) {
        return sseService.connect(liveVideoId);
    }


    @PostMapping("/comments/{liveVideoId}")
    public ResponseEntity<Void> createComment(@PathVariable String liveVideoId, 
                                               @RequestBody CommentRequest commentRequest,
                                               @RequestHeader("Authorization") String token) throws IOException {
        commentService.createComment(liveVideoId, commentRequest, token);
        sseService.pushComment(liveVideoId, new Comment(liveVideoId, commentRequest.getMessage()));
        return ResponseEntity.ok().build();
    }
}