炸裂！Spring Boot 3 搭配 AI 实现智能弹幕审核 + Redis 热点缓存 + 上下文识别

最新推荐文章于 2025-11-24 20:19:24 发布

原创最新推荐文章于 2025-11-24 20:19:24 发布 · 473 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#缓存 #spring boot #人工智能

我们用 Spring Boot 3 + WebSocket 打造了一个实时弹幕系统。但如果直接上线，你很快会遇到两个大坑：弹幕内容违规：低俗、谩骂、广告等让平台形象瞬间翻车；高并发压力大：弹幕量一多，数据库吃不消，延迟飙升。

我们用 Spring Boot 3 + WebSocket 打造了一个实时弹幕系统。但如果直接上线，你很快会遇到两个大坑：

弹幕内容违规：低俗、谩骂、广告等让平台形象瞬间翻车
高并发压力大：弹幕量一多，数据库吃不消，延迟飙升

这次升级，我们带来三个杀手锏：

AI 上下文审核：不仅看当前弹幕，还结合前后语境识别违规内容
Redis 热点缓存：热门视频弹幕秒加载，架构简单高效
前端实时渲染：秒进直播间就能看到历史弹幕

为什么需要“上下文审核”

传统方式的短板

人工审核：效率低，延迟大
关键词过滤：只能处理已知词库，容易被谐音梗绕过
单句 AI 审核：可能漏判连续擦边球弹幕

上下文审核的优势

AI 能够结合前后几条弹幕判断是否存在隐晦违规
可识别“接龙式”或“暗示型”违规行为
有助于减少误判和漏判

整体架构

复制

[前端发弹幕]
      ↓
[WebSocket 收到弹幕]
      ↓
[AI 审核模块(带上下文)] —— 违规 → 丢弃/替换
      ↓
[Redis 缓存 + 推送给前端]
      ↓
[前端实时渲染弹幕]

依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

AI 审核服务（支持上下文）

@Service
public class AiModerationService {
    private static final String API_URL = "https://api.openai.com/v1/chat/completions";
    private static final String API_KEY = "你的AI_KEY";


    // 每个视频保留最近5条弹幕作为上下文
    private final Map<String, Deque<String>> contextMap = new ConcurrentHashMap<>();


    public boolean isSafe(String videoId, String currentMsg) {
        Deque<String> context = contextMap.computeIfAbsent(videoId, k -> new LinkedList<>());


        // 构建上下文
        List<String> conversation = new ArrayList<>(context);
        conversation.add(currentMsg);


        try (OkHttpClient client = new OkHttpClient()) {
            StringBuilder prompt = new StringBuilder("你是一个弹幕审核系统，请判断以下多条弹幕整体是否存在违规内容（涉黄、暴力、辱骂、广告等）。只返回 true 或 false。\n\n弹幕内容：\n");
            for (String msg : conversation) {
                prompt.append("- ").append(msg).append("\n");
            }


            String json = """
            {
              "model": "gpt-3.5-turbo",
              "messages": [
                {"role": "system", "content": "你是一个安全审核系统"},
                {"role": "user", "content": "%s"}
              ],
              "temperature": 0
            }
            """.formatted(prompt.toString());


            RequestBody body = RequestBody.create(json, MediaType.parse("application/json"));
            Request request = new Request.Builder()
                    .url(API_URL)
                    .post(body)
                    .addHeader("Authorization", "Bearer " + API_KEY)
                    .build();


            Response response = client.newCall(request).execute();
            String result = response.body().string();
            boolean safe = result.toLowerCase().contains("true");


            // 维护上下文（只保留最新5条）
            context.addLast(currentMsg);
            if (context.size() > 5) {
                context.removeFirst();
            }


            return safe;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

每个视频维护一个最近 5 条弹幕的队列
每次审核时，AI 会看到上下文而不是单条弹幕
有助于识别“连续擦边”或“接龙违规”

Redis 热点缓存方案

思路

弹幕审核通过后，直接存入 Redis List，按 videoId 作为 key
前端首次进入视频时，从 Redis 获取最新 N 条弹幕
Redis 弹幕过期时间设置为视频播放窗口（例如 1 小时）

核心代码

@Service
public class DanmakuService {
    @Autowired
    private AiModerationService aiService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private SimpMessagingTemplate messagingTemplate;


    private static final String REDIS_KEY_PREFIX = "danmaku:";


    public void handleIncomingDanmaku(DanmakuDTO dto) {
        if (aiService.isSafe(dto.getVideoId(), dto.getContent())) {
            String key = REDIS_KEY_PREFIX + dto.getVideoId();
            redisTemplate.opsForList().rightPush(key, dto.getContent());
            redisTemplate.expire(key, Duration.ofHours(1));
            messagingTemplate.convertAndSend("/topic/video/" + dto.getVideoId(), dto);
        } else {
            System.out.println("违规弹幕已拦截: " + dto.getContent());
        }
    }


    public List<String> getLatestDanmakus(String videoId, int limit) {
        String key = REDIS_KEY_PREFIX + videoId;
        Long size = redisTemplate.opsForList().size(key);
        if (size == null || size == 0) return List.of();
        return redisTemplate.opsForList().range(key, Math.max(0, size - limit), size - 1);
    }
}

历史弹幕 API

@RestController
@RequestMapping("/api/danmaku")
public class DanmakuController {
    @Autowired
    private DanmakuService danmakuService;


    @GetMapping("/latest")
    public List<String> getLatestDanmakus(@RequestParam String videoId,
                                          @RequestParam(defaultValue = "20") int limit) {
        return danmakuService.getLatestDanmakus(videoId, limit);
    }
}

前端弹幕展示实现（Vue 3）

页面结构

<template>
  <div class="video-container">
    <video :src="videoSrc" controls autoplay></video>
    <div class="danmaku-container">
      <div v-for="(msg, index) in danmakus" 
           :key="index" 
           class="danmaku"
           :style="{ top: `${getRandomTop()}%` }">
        {{ msg }}
      </div>
    </div>
    <input v-model="inputMsg" placeholder="发送弹幕..." @keyup.enter="sendDanmaku" />
  </div>
</template>

样式（CSS 漂浮效果）

.video-container {
  position: relative;
  width: 800px;
  height: 450px;
}
.danmaku-container {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  pointer-events: none;
}
.danmaku {
  position: absolute;
  white-space: nowrap;
  animation: danmaku-move 5s linear forwards;
  font-size: 18px;
  color: white;
  text-shadow: 1px 1px 2px black;
}
@keyframes danmaku-move {
  from { transform: translateX(100%); }
  to { transform: translateX(-100%); }
}

Vue 脚本逻辑

<script setup>
import { ref, onMounted, onBeforeUnmount } from "vue";
import axios from "axios";


const videoSrc = "/videos/sample.mp4";
const videoId = "123"; 
const danmakus = ref([]);
const inputMsg = ref("");
let ws = null;


function getRandomTop() {
  return Math.floor(Math.random() * 80);
}


function connectWebSocket() {
  ws = new WebSocket(`ws://localhost:8080/ws/video/${videoId}`);
  ws.onmessage = (event) => {
    const msg = JSON.parse(event.data);
    danmakus.value.push(msg.content);
    if (danmakus.value.length > 50) {
      danmakus.value.shift();
    }
  };
}


async function loadHistoryDanmakus() {
  const res = await axios.get(`/api/danmaku/latest`, {
    params: { videoId, limit: 20 }
  });
  danmakus.value.push(...res.data);
}


function sendDanmaku() {
  if (inputMsg.value.trim()) {
    ws.send(JSON.stringify({
      videoId,
      content: inputMsg.value
    }));
    inputMsg.value = "";
  }
}


onMounted(() => {
  loadHistoryDanmakus();
  connectWebSocket();
});


onBeforeUnmount(() => {
  if (ws) ws.close();
});
</script>