Vue3 + Spring Boot + VOD:视频点播平台从上传到播放的全栈实战

简介: 在线教育平台 1000+ 课程视频,自建 FFmpeg 转码集群 2 台服务器 24 小时跑不过来,首帧加载 3 秒起跳,Safari 下频繁黑屏——接入阿里云 VOD 后,转码速度提升 10 倍,首帧时间从 3 秒降到 200ms,HLS 自适应码率让弱网环境播放流畅度提升 85%。本文从视频平台五大痛点出发,详解 VOD 服务配置、Spring Boot 后端集成(STS 上传授权/分片上传/回调鉴权/视频管理)、Vue3 前端实战(上传组件/Aliplayer 播放器/弹幕/管理后台)、进阶功能(HLS 加密/智能审核/视频 AI),包含 5 个生产踩坑案例和选型决策树

摘要:在线教育平台 1000+ 课程视频,自建 FFmpeg 转码集群 2 台服务器 24 小时跑不过来,首帧加载 3 秒起跳,Safari 下频繁黑屏——接入阿里云 VOD 后,转码速度提升 10 倍,首帧时间从 3 秒降到 200ms,HLS 自适应码率让弱网环境播放流畅度提升 85%。本文从视频平台五大痛点出发,详解 VOD 服务配置、Spring Boot 后端集成(STS 上传授权/分片上传/回调鉴权/视频管理)、Vue3 前端实战(上传组件/Aliplayer 播放器/弹幕/管理后台)、进阶功能(HLS 加密/智能审核/视频 AI),包含 5 个生产踩坑案例和选型决策树,帮助企业构建生产级视频点播平台。

1. 场景:2 台转码服务器 24 小时跑不过来

2025 年初,我负责的一个在线教育平台课程视频突破 1000+,每节课平均 45 分钟,原始视频平均 1.5GB。平台初期用 2 台 ECS(8 核 16G)自建 FFmpeg 转码集群,问题随着业务增长彻底爆发:

故障数据:

指标 故障前 故障中 改造后
单视频转码耗时 30min 120min(队列积压) 3min(VOD 并行转码)
首帧加载时间 1.5s 3s+ 200ms
弱网播放卡顿率 15% 40% 3%
存储成本/月 ¥5.6 万 ¥5.6 万 ¥2.1 万
运维人力 1.5 人 2.5 人救火 0.3 人

转码队列积压最长时,老师周一上传的视频周四才能上线,学员投诉量翻了 3 倍。Safari 下 HLS 播放频繁黑屏,移动端弱网环境卡顿率高达 40%。

改造方案:阿里云 VOD 负责转码/存储/分发,Spring Boot 后端负责业务逻辑和鉴权,Vue3 前端负责上传交互和播放体验。转码速度提升 10 倍,首帧时间降到 200ms,CDN 加速后弱网卡顿率降到 3%。

VOD 视频点播平台性能对比

下面从视频平台的痛点开始,逐层展开完整实战。

2. 视频点播平台的五大痛点

很多团队做视频平台时,第一反应是"自建 FFmpeg + Nginx + HLS",毕竟几个开源组件拼一拼就能跑起来。但视频量级一旦突破百级、用户覆盖全国,每个环节都变成瓶颈。

痛点一:转码慢——队列积压如雪崩

FFmpeg 单进程转码一个 45 分钟 1080P 视频需要 30 分钟,2 台 ECS 并行一天最多处理 96 个视频。课程集中上传时(比如新学期开学),队列积压到数百个,老师上传后等 3 天才能上线。

痛点二:存储贵——视频是真正的存储吞金兽

1000 个视频 × 1.5GB = 1.5TB 原始数据,加上多码率转码输出(1080P/720P/480P 三种),总存储量超过 6TB。自建 NAS 存储成本高,且缺乏低频/归档自动降级能力,冷视频和热视频一个价。

痛点三:播放卡——弱网环境体验灾难

自建 Nginx 只能提供固定码率 HLS 流,用户在地铁、电梯等弱网环境下频繁缓冲。没有自适应码率(ABR)能力,1080P 视频在 2G 网络下基本无法播放,卡顿率高达 40%。

痛点四:防盗难——视频被批量下载如割韭菜

自建方案防盗链靠 Referer 白名单,轻易被绕过。视频 URL 一旦暴露,爬虫可以批量下载全部课程视频,付费课程被盗版传播,直接经济损失数十万。

痛点五:审核耗时——人工审视频如大海捞针

每个 45 分钟的视频人工审核需要 1 小时,1000 个视频需要 1000 小时。没有 AI 辅助审核,违规内容(涉黄/涉暴/侵权)只能靠审核员肉眼排查,漏审风险高、效率极低。

一句话总结:视频平台面临"转码慢、存储贵、播放卡、防盗难、审核耗时"五重困境,阿里云 VOD 是云原生场景下的标准解法。

3. 整体架构设计

3.1 架构全景

cloud-native_mermaid_1

3.2 核心流程

cloud-native_mermaid_2

架构核心思路:客户端直传 VOD 避免视频流经应用服务器,STS 临时凭证控制上传权限,VOD 自动转码和截图,CDN 加速分发,Spring Boot 只负责业务逻辑和鉴权。

4. VOD 服务配置

4.1 VOD 服务开通

登录阿里云控制台,搜索"视频点播",开通 VOD 服务。选择按量付费模式,无需预付资源费用。

为什么选按量付费:视频平台的流量存在明显波峰波谷(工作日白天高峰、夜间低谷),按量付费比包年包月节省 30% 以上成本。

4.2 转码模板组配置

进入 VOD 控制台 → 配置管理 → 转码模板组,创建自定义模板组"教育课程多码率":

模板名称 封装格式 视频编码 分辨率 码率 帧率 用途
course-1080p HLS(m3u8) H.264 1920×1080 4Mbps 30fps WiFi 高清
course-720p HLS(m3u8) H.264 1280×720 2Mbps 30fps 4G 流畅
course-480p HLS(m3u8) H.264 854×480 800Kbps 25fps 弱网省流
course-audio MP3 AAC - 128Kbps - 纯音频模式

关键配置:勾选"自适应码率",VOD 会自动生成 Master Playlist(主播放列表),播放器根据网络状况自动切换码率,这就是 HLS ABR 的核心能力。

4.3 水印配置 + 视频 AI 审核

水印配置:进入配置管理 → 水印管理,上传水印图片(建议 PNG 透明底,分辨率不超过 200×200),设置水印位置为右上角,偏移量 5%。

视频 AI 审核:进入配置管理 → 审核设置,开启智能审核:

审核类型 配置项 阈值
鉴黄 porn 置信度 ≥ 80 自动拦截
鉴暴 terrorism 置信度 ≥ 80 自动拦截
鉴政 ad 置信度 ≥ 70 人工复审
广告检测 ad 置信度 ≥ 60 标记

为什么 AI 审核 + 人工复审:AI 审核可以 5 秒内完成一个 45 分钟视频的初步筛查,将审核范围缩小到可疑片段,人工只需要复核这些片段,效率提升 20 倍。

4.4 CDN 加速域名配置

进入 VOD 控制台 → 配置管理 → 分发加速配置,添加加速域名。建议使用独立子域名如 vod.example.com,配置 CNAME 解析到阿里云 CDN 分配的 CNAME 地址。

CDN 关键配置:

  • 回源协议:HTTPS
  • 缓存策略:m3u8 文件缓存 10 秒,ts 分片缓存 7 天
  • 防盗链:Referer 白名单 + 鉴权 URL
  • HTTPS 配置:开启,强制 HTTPS 回源

5. 后端 Spring Boot 实战

5.1 项目依赖与配置

为什么用 VOD 服务端 SDK:客户端直传虽然减轻服务器压力,但部分场景需要服务端上传(如后台导入视频、定时任务同步),同时回调通知也需要 SDK 处理。

Maven 依赖:

<!-- pom.xml 关键依赖 -->
<dependencies>
    <!-- Spring Boot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 阿里云 VOD SDK -->
    <dependency>
        <groupId>com.aliyun</groupId>
        <artifactId>aliyun-java-sdk-vod</artifactId>
        <version>2.16.11</version>
    </dependency>
    <dependency>
        <groupId>com.aliyun</groupId>
        <artifactId>aliyun-java-sdk-core</artifactId>
        <version>4.6.3</version>
    </dependency>

    <!-- VOD 上传 SDK -->
    <dependency>
        <groupId>com.aliyun</groupId>
        <artifactId>aliyun-sdk-vod-upload</artifactId>
        <version>1.4.15</version>
    </dependency>

    <!-- STS SDK -->
    <dependency>
        <groupId>com.aliyun</groupId>
        <artifactId>aliyun-java-sdk-sts</artifactId>
        <version>3.1.3</version>
    </dependency>

    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <!-- WebSocket(弹幕) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
</dependencies>

YAML 配置:

# application.yml
aliyun:
  vod:
    access-key-id: ${
   ALIYUN_AK}
    access-key-secret: ${
   ALIYUN_SK}
    region-id: cn-shanghai
    template-group-id: "your-template-group-id"
    callback-url: "https://api.example.com/vod/callback"
  sts:
    role-arn: "acs:ram::your-account-id:role/vod-upload-role"
    session-name: "vod-upload-session"
    expire-seconds: 3600
  cdn:
    domain: "vod.example.com"
    auth-key: "your-cdn-auth-key"
    auth-timeout: 1800

5.2 STS 临时凭证上传授权

为什么不直接使用 AK/SK:前端直传如果暴露 AK/SK,等于把阿里云账号权限完全交出。STS 临时凭证限制权限范围和有效期,即使泄露也只影响限定时间内限定操作。

/**
 * STS 临时凭证服务
 * 限制:仅允许 VOD 上传操作,有效期 1 小时
 */
@Service
@Slf4j
public class StsCredentialService {
   

    @Value("${aliyun.vod.access-key-id}")
    private String accessKeyId;

    @Value("${aliyun.vod.access-key-secret}")
    private String accessKeySecret;

    @Value("${aliyun.sts.role-arn}")
    private String roleArn;

    @Value("${aliyun.sts.session-name}")
    private String sessionName;

    @Value("${aliyun.sts.expire-seconds}")
    private Long expireSeconds;

    /**
     * 获取 STS 临时凭证
     * Policy 限制:仅允许 vod:Upload* 操作
     */
    public StsCredentialVo getCredential(Long userId) {
   
        try {
   
            // 构造 STS Policy,限制只能上传视频
            String policy = buildUploadPolicy();

            AssumeRoleRequest request = new AssumeRoleRequest();
            request.setRoleArn(roleArn);
            request.setRoleSessionName(sessionName + "-" + userId);
            request.setPolicy(policy);
            request.setDurationSeconds(expireSeconds);

            DefaultProfile profile = DefaultProfile.getProfile(
                    "cn-shanghai", accessKeyId, accessKeySecret);
            IAcsClient client = new DefaultAcsClient(profile);

            AssumeRoleResponse response = client.getAcsResponse(request);
            AssumeRoleResponse.Credentials credentials = response.getCredentials();

            return StsCredentialVo.builder()
                    .accessKeyId(credentials.getAccessKeyId())
                    .accessKeySecret(credentials.getAccessKeySecret())
                    .securityToken(credentials.getSecurityToken())
                    .expiration(credentials.getExpiration())
                    .build();
        } catch (Exception e) {
   
            log.error("获取STS凭证失败, userId={}", userId, e);
            throw new RuntimeException("获取上传凭证失败");
        }
    }

    /**
     * 构建 STS Policy —— 仅允许 VOD 上传
     */
    private String buildUploadPolicy() {
   
        return """
            {
   
                "Version": "1",
                "Statement": [{
   
                    "Effect": "Allow",
                    "Action": [
                        "vod:UploadMediaByURL",
                        "vod:CreateUploadVideo",
                        "vod:RefreshUploadVideo",
                        "vod:GetVideoInfo"
                    ],
                    "Resource": "*"
                }]
            }
            """;
    }
}

Controller 层:

@RestController
@RequestMapping("/api/vod")
public class VodCredentialController {
   

    @Resource
    private StsCredentialService stsCredentialService;

    /**
     * 获取上传凭证
     * 前端拿到 STS 凭证后直传 VOD,视频不经过应用服务器
     */
    @GetMapping("/upload-credential")
    public Result<StsCredentialVo> getUploadCredential(
            @RequestAttribute("userId") Long userId) {
   
        return Result.success(stsCredentialService.getCredential(userId));
    }
}

5.3 VOD 上传 SDK 集成

服务端上传场景:后台管理员批量导入视频、定时任务从 OSS 同步视频到 VOD。

/**
 * VOD 服务端上传服务
 * 支持分片上传和断点续传
 */
@Service
@Slf4j
public class VodUploadService {
   

    @Value("${aliyun.vod.access-key-id}")
    private String accessKeyId;

    @Value("${aliyun.vod.access-key-secret}")
    private String accessKeySecret;

    @Value("${aliyun.vod.template-group-id}")
    private String templateGroupId;

    /**
     * 上传本地视频文件到 VOD
     * SDK 内置分片上传(每片 10MB)和断点续传能力
     */
    public String uploadVideo(String filePath, String title, String tags) {
   
        UploadVideoImpl uploader = new UploadVideoImpl();
        UploadVideoRequest request = new UploadVideoRequest();
        request.setTitle(title);
        request.setFileName(filePath);
        request.setTags(tags);
        request.setTemplateGroupId(templateGroupId);

        // 设置分片大小 10MB,超时时间 30 分钟
        request.setPartSize(10 * 1024 * 1024L);
        request.setEcsRegionId("cn-shanghai");

        UploadVideoImpl.setAccessKeyId(accessKeyId);
        UploadVideoImpl.setAccessKeySecret(accessKeySecret);

        UploadVideoResponse response = uploader.uploadVideo(request);
        if (response.isSuccess()) {
   
            log.info("视频上传成功, VideoId={}, filePath={}",
                    response.getVideoId(), filePath);
            return response.getVideoId();
        } else {
   
            log.error("视频上传失败, code={}, message={}",
                    response.getCode(), response.getMessage());
            throw new RuntimeException("视频上传失败: " + response.getMessage());
        }
    }

    /**
     * 刷新上传凭证(断点续传时凭证过期)
     * 前端上传过程中 STS 凭证过期,需要调用此接口刷新
     */
    public RefreshUploadVideoResponse refreshUploadCredential(
            String videoId) throws Exception {
   
        DefaultAcsClient client = initVodClient();
        RefreshUploadVideoRequest request =
                new RefreshUploadVideoRequest();
        request.setVideoId(videoId);
        return client.getAcsResponse(request);
    }

    private DefaultAcsClient initVodClient() throws Exception {
   
        DefaultProfile profile = DefaultProfile.getProfile(
                "cn-shanghai", accessKeyId, accessKeySecret);
        return new DefaultAcsClient(profile);
    }
}

5.4 上传回调处理

为什么需要回调:视频上传后 VOD 自动转码,转码是异步过程,应用需要知道转码何时完成才能更新视频状态为"可播放"。

/**
 * VOD 回调控制器
 * 处理 VOD 服务端的回调通知
 */
@RestController
@RequestMapping("/vod/callback")
@Slf4j
public class VodCallbackController {
   

    @Resource
    private VideoInfoService videoInfoService;

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    /**
     * VOD 回调入口
     * 回调类型:FileUploadComplete / TranscodeComplete / SnapshotComplete / AiReviewComplete
     */
    @PostMapping
    public Map<String, String> handleCallback(
            @RequestBody String body,
            @RequestHeader("X-VOD-Signature") String signature) {
   

        // 验证回调签名,防止伪造回调
        if (!verifySignature(body, signature)) {
   
            log.warn("VOD回调签名验证失败");
            return Map.of("Status", "Fail", "Message", "签名验证失败");
        }

        JSONObject json = JSON.parseObject(body);
        String eventType = json.getString("EventType");
        String videoId = json.getString("VideoId");

        log.info("收到VOD回调, type={}, videoId={}", eventType, videoId);

        switch (eventType) {
   
            case "FileUploadComplete" -> handleUploadComplete(json);
            case "TranscodeComplete" -> handleTranscodeComplete(json);
            case "SnapshotComplete" -> handleSnapshotComplete(json);
            case "AiReviewComplete" -> handleAiReviewComplete(json);
            default -> log.warn("未知回调类型: {}", eventType);
        }

        return Map.of("Status", "Success");
    }

    /**
     * 转码完成回调处理
     * 更新视频状态、记录多码率信息、缓存播放地址
     */
    private void handleTranscodeComplete(JSONObject json) {
   
        String videoId = json.getString("VideoId");
        String status = json.getString("Status");

        if ("success".equals(status)) {
   
            // 转码成功,更新视频状态为可用
            videoInfoService.updateStatus(videoId, VideoStatus.READY);

            // 解析转码输出,缓存各码率播放地址
            JSONArray outputs = json.getJSONArray("TranscodeOutputs");
            for (int i = 0; i < outputs.size(); i++) {
   
                JSONObject output = outputs.getJSONObject(i);
                String definition = output.getString("Definition");
                String playUrl = output.getString("PlayURL");
                // 缓存播放地址,有效期 1 小时
                String cacheKey = "vod:play:" + videoId + ":" + definition;
                redisTemplate.opsForValue().set(cacheKey, playUrl,
                        Duration.ofHours(1));
            }

            log.info("视频转码完成, videoId={}, 码率数={}", videoId, outputs.size());
        } else {
   
            // 转码失败,记录错误原因
            String errorCode = json.getString("ErrorCode");
            String errorMsg = json.getString("ErrorMessage");
            videoInfoService.updateStatusWithError(videoId,
                    VideoStatus.TRANSCODE_FAILED, errorCode, errorMsg);
            log.error("视频转码失败, videoId={}, error={}", videoId, errorMsg);
        }
    }

    /**
     * AI 审核完成回调
     * 根据审核结果决定自动通过还是人工复审
     */
    private void handleAiReviewComplete(JSONObject json) {
   
        String videoId = json.getString("VideoId");
        String suggestion = json.getString("Suggestion");

        // pass-通过, block-拦截, review-人工复审
        if ("block".equals(suggestion)) {
   
            videoInfoService.updateStatus(videoId, VideoStatus.BLOCKED);
            log.warn("视频被AI审核拦截, videoId={}", videoId);
        } else if ("review".equals(suggestion)) {
   
            videoInfoService.updateStatus(videoId, VideoStatus.NEED_REVIEW);
            log.info("视频需要人工复审, videoId={}", videoId);
        } else {
   
            log.info("视频审核通过, videoId={}", videoId);
        }
    }

    /**
     * 验证回调签名
     * VOD 使用 HMAC-SHA1 对回调 Body 签名
     */
    private boolean verifySignature(String body, String signature) {
   
        try {
   
            String computed = HmacUtils.hmacSha1Hex(
                    accessKeySecret, body);
            return computed.equals(signature);
        } catch (Exception e) {
   
            log.error("签名验证异常", e);
            return false;
        }
    }

    @Value("${aliyun.vod.access-key-secret}")
    private String accessKeySecret;
}

5.5 视频鉴权服务

为什么需要鉴权:付费视频的播放地址一旦暴露,任何人都能观看。URL 签名鉴权确保只有合法用户在有效期内才能访问视频。

/**
 * 视频鉴权服务
 * 支持三种鉴权方式:URL签名、防盗链、播放时长限制
 */
@Service
@Slf4j
public class VideoAuthService {
   

    @Value("${aliyun.cdn.domain}")
    private String cdnDomain;

    @Value("${aliyun.cdn.auth-key}")
    private String authKey;

    @Value("${aliyun.cdn.auth-timeout}")
    private Integer authTimeout;

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 生成带签名的播放地址
     * A 类鉴权:URI+Timestamp+MD5
     */
    public PlayInfoVo generatePlayUrl(String videoId, Long userId,
                                       String definition) {
   
        // 检查用户是否有播放权限
        if (!checkPlayPermission(videoId, userId)) {
   
            throw new RuntimeException("无播放权限");
        }

        // 从缓存或 VOD 获取播放地址
        String originUrl = getOriginPlayUrl(videoId, definition);

        // 生成带签名的 URL
        String signedUrl = signUrl(originUrl);

        // 记录播放日志
        logPlayAccess(videoId, userId);

        return PlayInfoVo.builder()
                .playUrl(signedUrl)
                .videoId(videoId)
                .definition(definition)
                .expiresIn(authTimeout)
                .build();
    }

    /**
     * A 类鉴权 URL 签名
     * 格式:http://domain/path?auth_key=timestamp-rand-uid-md5hash
     */
    private String signUrl(String originUrl) {
   
        try {
   
            URI uri = new URI(originUrl);
            String path = uri.getPath();
            long timestamp = System.currentTimeMillis() / 1000;
            String rand = UUID.randomUUID().toString().replace("-", "");
            String uid = "0";

            // MD5(path-timestamp-rand-uid-authKey)
            String signSource = path + "-" + timestamp + "-"
                    + rand + "-" + uid + "-" + authKey;
            String md5Hash = DigestUtils.md5Hex(signSource);

            String authKeyParam = "auth_key=" + timestamp
                    + "-" + rand + "-" + uid + "-" + md5Hash;

            String separator = originUrl.contains("?") ? "&" : "?";
            return originUrl + separator + authKeyParam;
        } catch (Exception e) {
   
            throw new RuntimeException("URL签名失败", e);
        }
    }

    /**
     * 检查播放权限
     * 1. 课程是否已购买
     * 2. 是否在播放时长限制内
     * 3. 并发播放数是否超限
     */
    private boolean checkPlayPermission(String videoId, Long userId) {
   
        // 检查购买状态
        String purchaseKey = "purchase:" + userId + ":" + videoId;
        if (!redisTemplate.hasKey(purchaseKey)) {
   
            return false;
        }

        // 检查并发播放数(同一用户最多 2 个设备同时播放)
        String concurrentKey = "play:concurrent:" + userId;
        String concurrentCount = redisTemplate.opsForValue()
                .get(concurrentKey);
        if (concurrentCount != null
                && Integer.parseInt(concurrentCount) >= 2) {
   
            log.warn("用户并发播放超限, userId={}", userId);
            return false;
        }

        return true;
    }

    /**
     * 记录播放日志,设置并发计数
     */
    private void logPlayAccess(String videoId, Long userId) {
   
        String concurrentKey = "play:concurrent:" + userId;
        redisTemplate.opsForValue().increment(concurrentKey);
        redisTemplate.expire(concurrentKey, Duration.ofMinutes(30));
    }
}

5.6 视频管理 CRUD

/**
 * 视频信息实体
 */
@Data
@TableName("video_info")
public class VideoInfo {
   

    @TableId(type = IdType.AUTO)
    private Long id;

    /** VOD 视频 ID */
    private String videoId;

    /** 视频标题 */
    private String title;

    /** 封面图 URL */
    private String coverUrl;

    /** 分类 ID */
    private Long categoryId;

    /** 标签,逗号分隔 */
    private String tags;

    /** 视频状态 */
    private VideoStatus status;

    /** 时长(秒) */
    private Integer duration;

    /** 文件大小(字节) */
    private Long fileSize;

    /** 上传用户 ID */
    private Long uploadUserId;

    /** 播放次数 */
    private Long playCount;

    private LocalDateTime createTime;

    private LocalDateTime updateTime;
}

/**
 * 视频状态枚举
 */
public enum VideoStatus {
   
    UPLOADING,           // 上传中
    TRANSCODING,         // 转码中
    READY,               // 可播放
    TRANSCODE_FAILED,    // 转码失败
    NEED_REVIEW,         // 待人工审核
    BLOCKED,             // 被拦截
    DISABLED             // 已下架
}
/**
 * 视频管理 Service
 */
@Service
@Slf4j
public class VideoInfoService {
   

    @Resource
    private VideoInfoMapper videoInfoMapper;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 分页查询视频列表
     * 支持按分类、标签、状态筛选
     */
    public PageResult<VideoInfoVo> listVideos(VideoQueryDto query) {
   
        LambdaQueryWrapper<VideoInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(query.getCategoryId() != null,
                VideoInfo::getCategoryId, query.getCategoryId())
               .eq(query.getStatus() != null,
                       VideoInfo::getStatus, query.getStatus())
               .like(StringUtils.isNotBlank(query.getTitle()),
                       VideoInfo::getTitle, query.getTitle())
               .orderByDesc(VideoInfo::getCreateTime);

        Page<VideoInfo> page = videoInfoMapper.selectPage(
                new Page<>(query.getPageNum(), query.getPageSize()),
                wrapper);

        List<VideoInfoVo> vos = page.getRecords().stream()
                .map(this::toVo)
                .toList();

        return PageResult.of(vos, page.getTotal());
    }

    /**
     * 更新视频状态
     */
    public void updateStatus(String videoId, VideoStatus status) {
   
        LambdaUpdateWrapper<VideoInfo> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(VideoInfo::getVideoId, videoId)
               .set(VideoInfo::getStatus, status);
        videoInfoMapper.update(null, wrapper);

        // 清除缓存
        redisTemplate.delete("video:info:" + videoId);
        log.info("视频状态更新, videoId={}, status={}", videoId, status);
    }

    /**
     * 审核视频
     */
    public void reviewVideo(String videoId, Boolean approved,
                             String reason) {
   
        VideoStatus targetStatus = approved
                ? VideoStatus.READY : VideoStatus.BLOCKED;
        updateStatus(videoId, targetStatus);
        log.info("视频审核完成, videoId={}, approved={}, reason={}",
                videoId, approved, reason);
    }
}

6. 前端 Vue3 实战

6.1 项目基础配置

为什么选 Vue-Aliplayer:阿里云播放器 SDK 官方提供了 Vue3 组件封装,支持 HLS、FLV、MP4 多种格式,内置自适应码率切换,比 Video.js + hls.js 方案少踩很多坑。

安装依赖:

# 安装阿里云播放器
npm install aliplayer

# 安装 WebSocket 库(弹幕用)
npm install @stomp/stompjs sockjs-client

# 安装 HTTP 客户端
npm install axios

Vite 代理配置:

// vite.config.ts
export default defineConfig({
   
  server: {
   
    proxy: {
   
      '/api': {
   
        target: 'http://localhost:8080',
        changeOrigin: true
      },
      '/ws': {
   
        target: 'ws://localhost:8080',
        ws: true
      }
    }
  }
})

6.2 视频上传组件

为什么自研上传组件:原生 <input type="file"> 体验太差——没有进度、不能断点、不支持多文件。VOD 上传 SDK 提供 JS 版本,但封装在 Vue3 组合式 API 中需要适配,同时要处理分片上传、断点续传、多文件队列等复杂逻辑。

// composables/useVodUpload.ts
import {
    ref, reactive } from 'vue'
import axios from 'axios'

/** 上传文件状态 */
interface UploadFile {
   
  id: string
  file: File
  title: string
  status: 'pending' | 'uploading' | 'paused' | 'success' | 'failed'
  progress: number
  videoId?: string
  errorMessage?: string
}

/** STS 临时凭证 */
interface StsCredential {
   
  accessKeyId: string
  accessKeySecret: string
  securityToken: string
  expiration: string
}

export function useVodUpload() {
   
  const fileList = reactive<UploadFile[]>([])
  const isUploading = ref(false)
  const credential = ref<StsCredential | null>(null)

  /** 获取 STS 凭证 */
  async function fetchCredential(): Promise<StsCredential> {
   
    const {
    data } = await axios.get('/api/vod/upload-credential')
    credential.value = data.data
    return data.data
  }

  /** 添加文件到上传队列 */
  function addFiles(files: File[]) {
   
    for (const file of files) {
   
      // 校验文件类型
      const validTypes = ['video/mp4', 'video/avi', 'video/mov',
                          'video/wmv', 'video/flv', 'video/mkv']
      if (!validTypes.includes(file.type)) {
   
        console.warn(`不支持的文件类型: ${
     file.type}`)
        continue
      }

      // 校验文件大小(最大 4GB)
      if (file.size > 4 * 1024 * 1024 * 1024) {
   
        console.warn('文件大小超过 4GB 限制')
        continue
      }

      fileList.push({
   
        id: crypto.randomUUID(),
        file,
        title: file.name.replace(/\.[^.]+$/, ''),
        status: 'pending',
        progress: 0
      })
    }
  }

  /** 上传单个文件到 VOD */
  async function uploadSingleFile(uploadFile: UploadFile) {
   
    const sts = credential.value ?? await fetchCredential()

    // 使用 VOD 客户端上传 SDK
    const uploader = new (window as any).AliyunUpload.Vod({
   
      userId: '1',
      region: 'cn-shanghai',
      partSize: 10 * 1024 * 1024,  // 分片大小 10MB
      parallel: 5,                  // 并行上传数
      retryCount: 3,                // 重试次数
      retryDuration: 2,             // 重试间隔秒

      // 上传凭证
      accessKeyId: sts.accessKeyId,
      accessKeySecret: sts.accessKeySecret,
      securityToken: sts.securityToken,

      // 上传完成回调
      onUploadstarted: (uploadInfo: any) => {
   
        uploadFile.status = 'uploading'
        console.log('开始上传:', uploadInfo.file.name)
      },

      onUploadSucceed: (uploadInfo: any) => {
   
        uploadFile.status = 'success'
        uploadFile.videoId = uploadInfo.videoId
        uploadFile.progress = 100
        // 通知后端记录视频信息
        notifyUploadComplete(uploadInfo.videoId, uploadFile.title)
      },

      onUploadFailed: (uploadInfo: any, code: string, message: string) => {
   
        uploadFile.status = 'failed'
        uploadFile.errorMessage = message
        console.error('上传失败:', code, message)
      },

      onUploadProgress: (uploadInfo: any, totalSize: number,
                          loadedPercent: number) => {
   
        uploadFile.progress = Math.round(loadedPercent * 100)
      },

      // STS 凭证过期时自动刷新
      onUploadTokenExpired: () => {
   
        fetchCredential().then(newSts => {
   
          uploader.setSTS(
            newSts.accessKeyId,
            newSts.accessKeySecret,
            newSts.securityToken
          )
        })
      }
    })

    // 添加文件到上传列表
    uploader.addFile(
      uploadFile.file,
      null, null, null,
      JSON.stringify({
    Vod: {
    Title: uploadFile.title } })
    )

    // 开始上传
    uploader.startUpload()
    uploadFile.status = 'uploading'
  }

  /** 通知后端上传完成 */
  async function notifyUploadComplete(videoId: string, title: string) {
   
    await axios.post('/api/vod/upload-complete', {
    videoId, title })
  }

  /** 批量上传 */
  async function startUpload() {
   
    isUploading.value = true
    const pendingFiles = fileList.filter(f => f.status === 'pending'
                                             || f.status === 'paused')

    // 并发上传,最多 3 个同时进行
    const concurrency = 3
    for (let i = 0; i < pendingFiles.length; i += concurrency) {
   
      const batch = pendingFiles.slice(i, i + concurrency)
      await Promise.all(batch.map(f => uploadSingleFile(f)))
    }

    isUploading.value = false
  }

  /** 暂停上传 */
  function pauseUpload(id: string) {
   
    const file = fileList.find(f => f.id === id)
    if (file) file.status = 'paused'
  }

  /** 移除文件 */
  function removeFile(id: string) {
   
    const index = fileList.findIndex(f => f.id === id)
    if (index > -1) fileList.splice(index, 1)
  }

  return {
   
    fileList,
    isUploading,
    addFiles,
    startUpload,
    pauseUpload,
    removeFile
  }
}

上传组件模板:

<!-- components/VideoUpload.vue -->
<template>
  <div class="video-upload">
    <!-- 拖拽上传区域 -->
    <div
      class="upload-zone"
      :class="{ 'is-dragover': isDragover }"
      @dragover.prevent="isDragover = true"
      @dragleave="isDragover = false"
      @drop.prevent="handleDrop"
      @click="triggerFileInput"
    >
      <el-icon :size="48"><UploadFilled /></el-icon>
      <p>拖拽视频文件到此处,或点击选择</p>
      <p class="tip">支持 MP4/AVI/MOV/WMV/FLV/MKV,单文件最大 4GB</p>
      <input
        ref="fileInput"
        type="file"
        multiple
        accept="video/*"
        style="display: none"
        @change="handleFileSelect"
      />
    </div>

    <!-- 上传队列 -->
    <div class="upload-queue" v-if="fileList.length > 0">
      <div
        v-for="file in fileList"
        :key="file.id"
        class="upload-item"
      >
        <div class="file-info">
          <span class="file-name">{
  { file.title }}</span>
          <span class="file-size">
            {
  { formatFileSize(file.file.size) }}
          </span>
        </div>

        <!-- 进度条 -->
        <el-progress
          :percentage="file.progress"
          :status="getProgressStatus(file.status)"
          :stroke-width="6"
        />

        <!-- 状态与操作 -->
        <div class="file-actions">
          <el-tag :type="getStatusTagType(file.status)" size="small">
            {
  { getStatusLabel(file.status) }}
          </el-tag>
          <el-button
            v-if="file.status === 'uploading'"
            size="small"
            @click="pauseUpload(file.id)"
          >
            暂停
          </el-button>
          <el-button
            v-if="file.status === 'failed'"
            size="small"
            type="danger"
            @click="retryUpload(file.id)"
          >
            重试
          </el-button>
          <el-button
            v-if="file.status !== 'uploading'"
            size="small"
            type="danger"
            link
            @click="removeFile(file.id)"
          >
            移除
          </el-button>
        </div>
      </div>
    </div>

    <!-- 操作按钮 -->
    <div class="upload-actions" v-if="fileList.length > 0">
      <el-button
        type="primary"
        :loading="isUploading"
        @click="startUpload"
      >
        {
  { isUploading ? '上传中...' : '开始上传' }}
      </el-button>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref } from 'vue'
import { UploadFilled } from '@element-plus/icons-vue'
import { useVodUpload } from '@/composables/useVodUpload'

const {
  fileList, isUploading,
  addFiles, startUpload, pauseUpload, removeFile
} = useVodUpload()

const fileInput = ref<HTMLInputElement>()
const isDragover = ref(false)

function triggerFileInput() {
  fileInput.value?.click()
}

function handleFileSelect(e: Event) {
  const input = e.target as HTMLInputElement
  if (input.files) addFiles(Array.from(input.files))
}

function handleDrop(e: DragEvent) {
  isDragover.value = false
  if (e.dataTransfer?.files) {
    addFiles(Array.from(e.dataTransfer.files))
  }
}

function formatFileSize(bytes: number): string {
  if (bytes < 1024) return bytes + ' B'
  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB'
  if (bytes < 1024 * 1024 * 1024) {
    return (bytes / 1024 / 1024).toFixed(1) + ' MB'
  }
  return (bytes / 1024 / 1024 / 1024).toFixed(2) + ' GB'
}

function getStatusTagType(status: string) {
  const map: Record<string, string> = {
    pending: 'info', uploading: '', paused: 'warning',
    success: 'success', failed: 'danger'
  }
  return map[status] || 'info'
}

function getStatusLabel(status: string) {
  const map: Record<string, string> = {
    pending: '等待上传', uploading: '上传中',
    paused: '已暂停', success: '上传完成', failed: '上传失败'
  }
  return map[status] || status
}

function getProgressStatus(status: string) {
  if (status === 'success') return 'success'
  if (status === 'failed') return 'exception'
  return undefined
}
</script>

<style scoped>
.upload-zone {
  border: 2px dashed #dcdfe6;
  border-radius: 8px;
  padding: 40px;
  text-align: center;
  cursor: pointer;
  transition: border-color 0.3s;
}
.upload-zone:hover,
.upload-zone.is-dragover {
  border-color: #409eff;
  background: #ecf5ff;
}
.upload-queue {
  margin-top: 20px;
}
.upload-item {
  padding: 12px 0;
  border-bottom: 1px solid #ebeef5;
}
.file-info {
  display: flex;
  justify-content: space-between;
  margin-bottom: 8px;
}
.file-name { font-weight: 500; }
.file-size { color: #909399; font-size: 13px; }
.file-actions {
  display: flex;
  align-items: center;
  gap: 8px;
  margin-top: 8px;
}
.upload-actions {
  margin-top: 16px;
  text-align: right;
}
</style>

6.3 阿里云播放器集成

为什么选阿里云播放器:VOD 转码输出的 HLS 流在 Safari 上有兼容性差异,阿里云播放器内部做了适配处理,同时内置自适应码率切换、清晰度切换、倍速播放等能力。

<!-- components/VideoPlayer.vue -->
<template>
  <div class="video-player-wrapper">
    <!-- 播放器容器 -->
    <div class="player-container" ref="playerContainer">
      <div class="prism-player" :id="playerId"></div>
    </div>

    <!-- 自定义控制栏增强 -->
    <div class="player-controls" v-if="showControls">
      <div class="control-group">
        <span class="quality-label">当前清晰度:{
  { currentQuality }}</span>
        <el-radio-group
          v-model="selectedQuality"
          size="small"
          @change="switchQuality"
        >
          <el-radio-button label="1080p" />
          <el-radio-button label="720p" />
          <el-radio-button label="480p" />
          <el-radio-button label="auto">自适应</el-radio-button>
        </el-radio-group>
      </div>

      <div class="control-group">
        <span>倍速:</span>
        <el-radio-group v-model="playSpeed" size="small"
                         @change="changeSpeed">
          <el-radio-button :label="0.5" />
          <el-radio-button :label="1" />
          <el-radio-button :label="1.25" />
          <el-radio-button :label="1.5" />
          <el-radio-button :label="2" />
        </el-radio-group>
      </div>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, onMounted, onBeforeUnmount, watch } from 'vue'
import axios from 'axios'

const props = defineProps<{
  videoId: string
  autoplay?: boolean
}>()

const playerId = `player-${Date.now()}`
const playerContainer = ref<HTMLElement>()
const player = ref<any>(null)
const currentQuality = ref('自适应')
const selectedQuality = ref('auto')
const playSpeed = ref(1)
const showControls = ref(false)

/** 获取签名播放地址并初始化播放器 */
async function initPlayer() {
  try {
    const { data } = await axios.get('/api/vod/play-url', {
      params: { videoId: props.videoId, definition: selectedQuality.value }
    })

    const playInfo = data.data

    // 初始化阿里云播放器
    player.value = new (window as any).Aliplayer({
      id: playerId,
      source: playInfo.playUrl,
      width: '100%',
      height: '100%',
      autoplay: props.autoplay ?? false,
      isLive: false,
      preload: true,
      controlBarVisibility: 'hover',
      useH5Prism: true,

      // HLS 自适应码率
      extraInfo: {
        crossOrigin: 'anonymous'
      },

      // 自定义皮肤
      skinLayout: [
        { name: 'bigPlayButton', align: 'cc' },
        { name: 'H5Loading', align: 'cc' },
        { name: 'controlBar', align: 'blabs',
          children: [
            { name: 'progress', align: 'blabs' },
            { name: 'playButton', align: 'tl' },
            { name: 'timeDisplay', align: 'tl' },
            { name: 'fullScreenButton', align: 'tr' },
            { name: 'volume', align: 'tr' }
          ]
        }
      ]
    })

    // 绑定播放事件
    bindPlayerEvents()
  } catch (e) {
    console.error('播放器初始化失败:', e)
  }
}

/** 绑定播放器事件 */
function bindPlayerEvents() {
  if (!player.value) return

  player.value.on('ready', () => {
    showControls.value = true
    console.log('播放器就绪')
  })

  player.value.on('play', () => {
    console.log('开始播放')
  })

  player.value.on('ended', () => {
    console.log('播放结束')
  })

  player.value.on('error', (err: any) => {
    console.error('播放错误:', err)
  })

  // 监听清晰度切换
  player.value.on('qualityChange', (data: any) => {
    currentQuality.value = data.bitrate?.definition || '自适应'
  })
}

/** 切换清晰度 */
async function switchQuality(quality: string) {
  if (!player.value) return

  // 获取当前播放进度
  const currentTime = player.value.getCurrentTime()

  // 重新获取对应清晰度的播放地址
  const { data } = await axios.get('/api/vod/play-url', {
    params: { videoId: props.videoId, definition: quality }
  })

  // 切换播放源并恢复进度
  player.value.loadByUrl(data.data.playUrl, currentTime)
}

/** 切换倍速 */
function changeSpeed(speed: number) {
  if (player.value) {
    player.value.setSpeed(speed)
  }
}

onMounted(() => {
  // 加载阿里云播放器 JS SDK
  const script = document.createElement('script')
  script.src = 'https://g.alicdn.com/de/prismplayer/2.16.3/aliplayer-h5-min.js'
  script.onload = () => initPlayer()
  document.head.appendChild(script)

  const link = document.createElement('link')
  link.rel = 'stylesheet'
  link.href = 'https://g.alicdn.com/de/prismplayer/2.16.3/skins/default/aliplayer-min.css'
  document.head.appendChild(link)
})

onBeforeUnmount(() => {
  if (player.value) {
    player.value.dispose()
    player.value = null
  }
})

watch(() => props.videoId, () => {
  if (player.value) {
    player.value.dispose()
  }
  initPlayer()
})
</script>

<style scoped>
.video-player-wrapper {
  position: relative;
  width: 100%;
  background: #000;
  border-radius: 8px;
  overflow: hidden;
}
.player-container {
  width: 100%;
  aspect-ratio: 16 / 9;
}
.player-controls {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 8px 16px;
  background: #1a1a2e;
  color: #e0e0e0;
  font-size: 13px;
}
.control-group {
  display: flex;
  align-items: center;
  gap: 8px;
}
.quality-label {
  color: #409eff;
  font-weight: 500;
}
</style>

6.4 弹幕组件

为什么自研弹幕:开源弹幕库(如 danmu.js)与阿里云播放器的时间轴同步存在精度问题,自研基于 WebSocket 的弹幕组件可以精确控制时序。

// composables/useDanmaku.ts
import {
    ref, onMounted, onBeforeUnmount } from 'vue'
import {
    Client } from '@stomp/stompjs'
import SockJS from 'sockjs-client'

interface Danmaku {
   
  id: string
  content: string
  color: string
  timePoint: number   // 视频时间点(秒)
  userId: Long
  nickname: string
}

export function useDanmaku(videoId: string) {
   
  const liveDanmakus = ref<Danmaku[]>([])
  const historyDanmakus = ref<Danmaku[]>([])
  const stompClient = ref<Client | null>(null)

  /** 连接 WebSocket,订阅实时弹幕 */
  function connectWebSocket() {
   
    const client = new Client({
   
      webSocketFactory: () => new SockJS('/ws/danmaku'),
      reconnectDelay: 5000,
      onConnect: () => {
   
        // 订阅该视频的实时弹幕频道
        client.subscribe(`/topic/danmaku/${
     videoId}`, (message) => {
   
          const danmaku: Danmaku = JSON.parse(message.body)
          liveDanmakus.value.push(danmaku)
          // 保持弹幕队列不超过 200 条
          if (liveDanmakus.value.length > 200) {
   
            liveDanmakus.value.shift()
          }
        })
      }
    })
    client.activate()
    stompClient.value = client
  }

  /** 加载历史弹幕 */
  async function loadHistoryDanmaku() {
   
    const {
    data } = await axios.get(`/api/danmaku/history/${
     videoId}`)
    historyDanmakus.value = data.data
  }

  /** 发送弹幕 */
  async function sendDanmaku(content: string, color: string,
                              timePoint: number) {
   
    const danmaku: Partial<Danmaku> = {
   
      content,
      color,
      timePoint,
      videoId
    }
    // 通过 REST 接口持久化
    await axios.post('/api/danmaku/send', danmaku)
    // WebSocket 自动广播,无需手动推送
  }

  onMounted(() => {
   
    connectWebSocket()
    loadHistoryDanmaku()
  })

  onBeforeUnmount(() => {
   
    stompClient.value?.deactivate()
  })

  return {
   
    liveDanmakus,
    historyDanmakus,
    sendDanmaku
  }
}

弹幕渲染组件:

<!-- components/DanmakuLayer.vue -->
<template>
  <div class="danmaku-layer" ref="layerRef">
    <!-- 弹幕轨道 -->
    <div
      v-for="danmaku in visibleDanmakus"
      :key="danmaku.id"
      class="danmaku-item"
      :style="{
        top: getTrackPosition(danmaku.track) + 'px',
        color: danmaku.color,
        animationDuration: danmaku.speed + 's'
      }"
    >
      {
  { danmaku.content }}
    </div>
  </div>

  <!-- 弹幕输入 -->
  <div class="danmaku-input">
    <el-input
      v-model="inputText"
      placeholder="发送弹幕..."
      size="small"
      @keyup.enter="handleSend"
    >
      <template #append>
        <el-color-picker v-model="inputColor" size="small" />
        <el-button @click="handleSend">发送</el-button>
      </template>
    </el-input>
  </div>
</template>

<script setup lang="ts">
import { ref, computed, watch } from 'vue'
import { useDanmaku } from '@/composables/useDanmaku'

const props = defineProps<{
  videoId: string
  currentTime: number
}>()

const emit = defineEmits<{
  (e: 'send', content: string, color: string, timePoint: number): void
}>()

const { liveDanmakus, historyDanmakus, sendDanmaku } =
    useDanmaku(props.videoId)

const inputText = ref('')
const inputColor = ref('#FFFFFF')
const layerRef = ref<HTMLElement>()

const TRACK_HEIGHT = 32
const MAX_TRACKS = 12

/** 合并实时弹幕和历史弹幕,按时间点过滤 */
const visibleDanmakus = computed(() => {
  const current = props.currentTime
  // 历史弹幕:只显示当前时间点 ±3 秒的
  const relevantHistory = historyDanmakus.value.filter(
    d => Math.abs(d.timePoint - current) < 3
  )
  // 实时弹幕:直接显示
  return [...relevantHistory, ...liveDanmakus.value]
    .slice(-MAX_TRACKS * 3) // 限制同时显示数量
    .map((d, i) => ({
      ...d,
      track: i % MAX_TRACKS,
      speed: 8 + Math.random() * 4 // 8-12 秒飘过
    }))
})

function getTrackPosition(track: number): number {
  return track * TRACK_HEIGHT + 8
}

async function handleSend() {
  if (!inputText.value.trim()) return
  await sendDanmaku(inputText.value, inputColor.value, props.currentTime)
  inputText.value = ''
}
</script>

<style scoped>
.danmaku-layer {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 60%;
  pointer-events: none;
  overflow: hidden;
}
.danmaku-item {
  position: absolute;
  right: 0;
  white-space: nowrap;
  font-size: 16px;
  font-weight: 500;
  text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.8);
  animation: danmaku-scroll linear forwards;
}
@keyframes danmaku-scroll {
  from { transform: translateX(100%); }
  to { transform: translateX(-200%); }
}
.danmaku-input {
  display: flex;
  gap: 8px;
  padding: 8px;
  background: rgba(0, 0, 0, 0.5);
}
</style>

6.5 视频管理后台

<!-- views/VideoManagement.vue -->
<template>
  <div class="video-management">
    <!-- 搜索栏 -->
    <el-form :inline="true" :model="queryForm">
      <el-form-item label="标题">
        <el-input v-model="queryForm.title" placeholder="搜索标题" />
      </el-form-item>
      <el-form-item label="分类">
        <el-select v-model="queryForm.categoryId" clearable>
          <el-option
            v-for="cat in categories"
            :key="cat.id"
            :label="cat.name"
            :value="cat.id"
          />
        </el-select>
      </el-form-item>
      <el-form-item label="状态">
        <el-select v-model="queryForm.status" clearable>
          <el-option label="转码中" value="TRANSCODING" />
          <el-option label="可播放" value="READY" />
          <el-option label="待审核" value="NEED_REVIEW" />
          <el-option label="已下架" value="DISABLED" />
        </el-select>
      </el-form-item>
      <el-form-item>
        <el-button type="primary" @click="loadVideos">查询</el-button>
        <el-button @click="resetQuery">重置</el-button>
      </el-form-item>
    </el-form>

    <!-- 视频列表 -->
    <el-table :data="videoList" stripe>
      <el-table-column label="封面" width="120">
        <template #default="{ row }">
          <el-image
            :src="row.coverUrl"
            style="width: 96px; height: 54px"
            fit="cover"
          />
        </template>
      </el-table-column>
      <el-table-column prop="title" label="标题" min-width="200" />
      <el-table-column prop="categoryName" label="分类" width="120" />
      <el-table-column label="时长" width="100">
        <template #default="{ row }">
          {
  { formatDuration(row.duration) }}
        </template>
      </el-table-column>
      <el-table-column label="状态" width="100">
        <template #default="{ row }">
          <el-tag :type="getStatusType(row.status)">
            {
  { getStatusLabel(row.status) }}
          </el-tag>
        </template>
      </el-table-column>
      <el-table-column prop="playCount" label="播放量" width="100" />
      <el-table-column label="操作" width="240" fixed="right">
        <template #default="{ row }">
          <el-button size="small" @click="previewVideo(row)">
            预览
          </el-button>
          <el-button
            v-if="row.status === 'NEED_REVIEW'"
            size="small"
            type="success"
            @click="reviewVideo(row.videoId, true)"
          >
            通过
          </el-button>
          <el-button
            v-if="row.status === 'NEED_REVIEW'"
            size="small"
            type="danger"
            @click="reviewVideo(row.videoId, false)"
          >
            拦截
          </el-button>
          <el-button
            v-if="row.status === 'READY'"
            size="small"
            type="warning"
            @click="toggleStatus(row.videoId, 'DISABLED')"
          >
            下架
          </el-button>
        </template>
      </el-table-column>
    </el-table>

    <!-- 分页 -->
    <el-pagination
      v-model:current-page="queryForm.pageNum"
      v-model:page-size="queryForm.pageSize"
      :total="total"
      layout="total, sizes, prev, pager, next"
      @change="loadVideos"
    />
  </div>
</template>

<script setup lang="ts">
import { ref, reactive, onMounted } from 'vue'
import axios from 'axios'
import { ElMessage, ElMessageBox } from 'element-plus'

const queryForm = reactive({
  title: '',
  categoryId: null as number | null,
  status: '',
  pageNum: 1,
  pageSize: 20
})

const videoList = ref([])
const total = ref(0)
const categories = ref([])

async function loadVideos() {
  const { data } = await axios.get('/api/vod/videos', { params: queryForm })
  videoList.value = data.data.records
  total.value = data.data.total
}

async function reviewVideo(videoId: string, approved: boolean) {
  const action = approved ? '通过' : '拦截'
  await ElMessageBox.confirm(
    `确认${action}该视频?`, '审核操作'
  )
  await axios.post('/api/vod/review', { videoId, approved })
  ElMessage.success(`已${action}`)
  loadVideos()
}

async function toggleStatus(videoId: string, status: string) {
  await axios.put(`/api/vod/videos/${videoId}/status`, { status })
  ElMessage.success('操作成功')
  loadVideos()
}

function formatDuration(seconds: number): string {
  const h = Math.floor(seconds / 3600)
  const m = Math.floor((seconds % 3600) / 60)
  const s = seconds % 60
  return h > 0
    ? `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`
    : `${m}:${String(s).padStart(2, '0')}`
}

function getStatusType(status: string) {
  const map: Record<string, string> = {
    TRANSCODING: 'warning', READY: 'success',
    NEED_REVIEW: 'danger', BLOCKED: 'danger', DISABLED: 'info'
  }
  return map[status] || ''
}

function getStatusLabel(status: string) {
  const map: Record<string, string> = {
    UPLOADING: '上传中', TRANSCODING: '转码中',
    READY: '可播放', TRANSCODE_FAILED: '转码失败',
    NEED_REVIEW: '待审核', BLOCKED: '已拦截', DISABLED: '已下架'
  }
  return map[status] || status
}

onMounted(() => {
  loadVideos()
})
</script>

7. 进阶功能

7.1 视频加密(HLS 加密 + 私钥分发)

为什么需要 HLS 加密:URL 鉴权只能防止 URL 泄露后被直接访问,但用户通过浏览器开发者工具可以抓取 ts 分片文件并合并成完整视频。HLS 加密对每个 ts 分片进行 AES-128 加密,播放器需要先获取解密密钥才能解密播放。

/**
 * HLS 加密密钥分发服务
 * VOD 支持 HLS 标准加密和私有加密两种方式
 */
@Service
@Slf4j
public class HlsEncryptionService {
   

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 获取视频解密密钥
     * 播放器请求 m3u8 时,m3u8 中包含 EXT-X-KEY URI
     * 播放器会请求该 URI 获取解密密钥
     */
    public byte[] getDecryptKey(String videoId, String userId,
                                 String token) {
   
        // 1. 验证用户身份和播放权限
        if (!verifyPlayToken(videoId, userId, token)) {
   
            log.warn("密钥请求鉴权失败, videoId={}, userId={}",
                    videoId, userId);
            throw new RuntimeException("无播放权限");
        }

        // 2. 从 VOD 获取该视频的加密密钥
        // VOD 加密时,密钥已注册到 KMS 服务
        String keyCacheKey = "vod:encrypt:key:" + videoId;
        String encryptedKey = redisTemplate.opsForValue().get(keyCacheKey);

        if (encryptedKey == null) {
   
            // 从 VOD API 查询
            encryptedKey = fetchKeyFromVod(videoId);
            redisTemplate.opsForValue().set(keyCacheKey, encryptedKey,
                    Duration.ofHours(2));
        }

        return Base64.getDecoder().decode(encryptedKey);
    }

    /**
     * 生成播放 Token
     * 前端请求播放地址时,后端返回带签名的 Token
     * Token 包含在密钥请求 URL 中,用于验证播放权限
     */
    public String generatePlayToken(String videoId, Long userId) {
   
        String token = UUID.randomUUID().toString().replace("-", "");
        String tokenKey = "vod:play:token:" + token;
        String value = videoId + ":" + userId;

        // Token 有效期 30 分钟
        redisTemplate.opsForValue().set(tokenKey, value,
                Duration.ofMinutes(30));
        return token;
    }

    private boolean verifyPlayToken(String videoId, String userId,
                                     String token) {
   
        String tokenKey = "vod:play:token:" + token;
        String value = redisTemplate.opsForValue().get(tokenKey);
        if (value == null) return false;
        String[] parts = value.split(":");
        return parts[0].equals(videoId) && parts[1].equals(userId);
    }
}

VOD 加密配置:在转码模板组中开启 HLS 加密,选择"私有加密"模式。VOD 会自动生成密钥并在 m3u8 中嵌入密钥获取 URI,URI 指向我们的密钥分发服务。

7.2 智能审核

/**
 * 视频 AI 审核服务
 * 集成 VOD 智能审核 + 人工复审工作流
 */
@Service
@Slf4j
public class VideoReviewService {
   

    @Resource
    private VideoInfoMapper videoInfoMapper;

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 提交视频到 AI 审核
     * VOD 上传完成后自动触发,也可以手动提交
     */
    public void submitAiReview(String videoId) {
   
        try {
   
            DefaultAcsClient client = initVodClient();

            // 提交 AI 审核:鉴黄 + 鉴暴 + 鉴政
            SubmitAIJobRequest request = new SubmitAIJobRequest();
            request.setVideoId(videoId);
            request.setTypes("porn,terrorism,ad");

            SubmitAIJobResponse response = client.getAcsResponse(request);
            String jobId = response.getAIJobList().get(0).getJobId();

            // 记录审核任务
            String jobKey = "vod:review:job:" + videoId;
            redisTemplate.opsForValue().set(jobKey, jobId,
                    Duration.ofHours(24));

            log.info("AI审核任务已提交, videoId={}, jobId={}", videoId, jobId);
        } catch (Exception e) {
   
            log.error("AI审核提交失败, videoId={}", videoId, e);
        }
    }

    /**
     * 人工复审
     * 管理员查看 AI 标记的可疑片段后做出最终判断
     */
    public void manualReview(String videoId, Boolean approved,
                              String reviewer, String reason) {
   
        VideoStatus targetStatus = approved
                ? VideoStatus.READY : VideoStatus.BLOCKED;

        LambdaUpdateWrapper<VideoInfo> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(VideoInfo::getVideoId, videoId)
               .set(VideoInfo::getStatus, targetStatus);

        videoInfoMapper.update(null, wrapper);

        log.info("人工复审完成, videoId={}, approved={}, reviewer={}",
                videoId, approved, reviewer);
    }
}

7.3 视频 AI(智能封面/智能标签/智能字幕)

为什么用视频 AI:1000+ 视频手动选封面、打标签、配字幕,每条视频至少 30 分钟。视频 AI 可以自动生成优质封面图、提取视频标签、生成字幕文件,将人力投入降低 90%。

/**
 * 视频 AI 增强服务
 */
@Service
@Slf4j
public class VideoAiService {
   

    /**
     * 生成智能封面
     * VOD AI 自动选取视频中最具代表性的画面作为封面
     */
    public String generateSmartCover(String videoId) throws Exception {
   
        DefaultAcsClient client = initVodClient();

        SubmitAIJobRequest request = new SubmitAIJobRequest();
        request.setVideoId(videoId);
        request.setTypes("cover");

        SubmitAIJobResponse response = client.getAcsResponse(request);
        log.info("智能封面任务已提交, videoId={}", videoId);
        return response.getAIJobList().get(0).getJobId();
    }

    /**
     * 提取智能标签
     * AI 自动识别视频内容并生成标签(如"Java"、"微服务"、"Spring Boot")
     */
    public List<String> extractSmartTags(String videoId) throws Exception {
   
        DefaultAcsClient client = initVodClient();

        // 查询 AI 分析结果
        ListAIJobRequest request = new ListAIJobRequest();
        request.setVideoId(videoId);
        request.setTypes("label");

        ListAIJobResponse response = client.getAcsResponse(request);
        List<String> tags = new ArrayList<>();

        for (ListAIJobResponse.AIJob job : response.getAIJobList()) {
   
            if ("Success".equals(job.getStatus())) {
   
                // 解析 AI 标签结果
                JSONObject result = JSON.parseObject(job.getData());
                JSONArray labelArray = result.getJSONArray("Labels");
                for (int i = 0; i < labelArray.size(); i++) {
   
                    tags.add(labelArray.getJSONObject(i)
                            .getString("LabelName"));
                }
            }
        }

        log.info("智能标签提取完成, videoId={}, tags={}", videoId, tags);
        return tags;
    }

    /**
     * 生成智能字幕
     * AI 语音识别自动生成 SRT 字幕文件
     */
    public String generateSubtitle(String videoId) throws Exception {
   
        DefaultAcsClient client = initVodClient();

        SubmitAIJobRequest request = new SubmitAIJobRequest();
        request.setVideoId(videoId);
        request.setTypes("asr"); // 自动语音识别

        SubmitAIJobResponse response = client.getAcsResponse(request);
        log.info("智能字幕任务已提交, videoId={}", videoId);
        return response.getAIJobList().get(0).getJobId();
    }
}

8. 量化对比:自建 vs VOD

维度 自建 FFmpeg + Nginx 阿里云 VOD 提升幅度
转码速度 30min/视频(2 台 ECS 并行) 3min/视频(VOD 并行转码) ⬆️ 10 倍
存储成本/月 ¥5.6 万(NAS 6TB) ¥2.1 万(OSS 标准+低频) ⬇️ 62%
首帧加载 1.5-3s 200ms ⬇️ 86%
弱网卡顿率 40%(固定码率) 3%(自适应码率) ⬇️ 92%
防盗能力 Referer 白名单(易绕过) URL 签名 + HLS 加密 + 私钥分发 质变
审核效率 1 小时/视频(人工) 5 秒/视频(AI)+ 5 分钟(人工复审可疑片段) ⬆️ 100 倍

成本明细(1000 视频/月增量):

项目 自建方案 VOD 方案
服务器(转码 2 台 8C16G) ¥2400/月 ¥0(VOD 按量计费)
转码费用 ¥0(自有算力) ¥1800/月(1000 视频多码率)
存储费用 ¥5600/月(NAS 6TB) ¥1260/月(OSS 标准+低频)
CDN 带宽 ¥3200/月(100Mbps) ¥2400/月(按流量)
运维人力 ¥15000/月(1.5 人) ¥3000/月(0.3 人)
合计 ¥26200/月 ¥8460/月

结论:VOD 方案总体成本降低 68%,同时获得自适应码率、HLS 加密、AI 审核等自建方案难以实现的能力。


9. 踩坑实录

坑位一:大文件分片上传超时

现象:上传 2GB 以上视频时,前端分片上传到第 30 分钟左右开始报超时错误,上传失败率 15%。

根因:VOD 客户端上传 SDK 默认单分片超时 60 秒,但弱网环境下 10MB 分片可能需要更长时间传输。同时浏览器对同一域名的并发连接数有限制(Chrome 最多 6 个),5 个并行上传 + 页面其他请求导致连接排队。

修复:

// 调整分片大小和超时配置
const uploader = new AliyunUpload.Vod({
   
  partSize: 5 * 1024 * 1024,   // 分片从 10MB 调小到 5MB
  parallel: 3,                  // 并行数从 5 调低到 3
  retryCount: 5,                // 重试次数从 3 增加到 5
  retryDuration: 3,             // 重试间隔从 2s 增加到 3s
  timeout: 120000,              // 单分片超时从 60s 增加到 120s
})

经验:大文件上传要考虑网络波动,分片不宜过大,并行数不宜过高,超时时间要留足余量。

坑位二:转码回调偶发丢失

现象:约 5% 的视频转码完成后,应用收不到回调通知,视频状态一直停在"转码中"。

根因:VOD 回调机制是"尽力投递",网络抖动或应用服务器重启时回调可能丢失。没有补偿机制,视频状态就会永远卡住。

修复:增加定时补偿任务,轮询 VOD 查询转码状态。

/**
 * 转码状态补偿任务
 * 每 5 分钟检查一次"转码中"超过 30 分钟的视频
 */
@Scheduled(fixedDelay = 5 * 60 * 1000)
public void compensateTranscodeStatus() {
   
    // 查询转码中超过 30 分钟的视频
    List<VideoInfo> stuckVideos = videoInfoMapper.selectList(
        new LambdaQueryWrapper<VideoInfo>()
            .eq(VideoInfo::getStatus, VideoStatus.TRANSCODING)
            .lt(VideoInfo::getUpdateTime,
                LocalDateTime.now().minusMinutes(30))
    );

    for (VideoInfo video : stuckVideos) {
   
        try {
   
            // 主动查询 VOD 转码状态
            GetVideoInfoRequest request = new GetVideoInfoRequest();
            request.setVideoId(video.getVideoId());
            GetVideoInfoResponse response =
                    vodClient.getAcsResponse(request);
            String vodStatus = response.getVideo()
                    .getStatus();

            if ("Normal".equals(vodStatus)) {
   
                updateStatus(video.getVideoId(), VideoStatus.READY);
                log.info("补偿更新: 视频已转码完成, videoId={}",
                        video.getVideoId());
            } else if ("Transcoding".equals(vodStatus)) {
   
                log.info("视频仍在转码中, videoId={}",
                        video.getVideoId());
            } else {
   
                updateStatus(video.getVideoId(),
                        VideoStatus.TRANSCODE_FAILED);
                log.warn("视频转码失败, videoId={}",
                        video.getVideoId());
            }
        } catch (Exception e) {
   
            log.error("补偿查询失败, videoId={}", video.getVideoId(), e);
        }
    }
}

经验:回调 + 轮询双保险,任何异步通知机制都不能只依赖回调,必须有补偿查询兜底。

坑位三:Safari 下 HLS 播放异常

现象:Chrome/Edge 播放正常,但 Safari 下 HLS 视频首帧黑屏 3-5 秒,偶尔出现画面撕裂,播放器报 MEDIA_ERR_SRC_NOT_SUPPORTED 错误。

根因:Safari 对 HLS 的实现与 Chrome 的 hls.js 有差异。VOD 转码输出的 HLS 流,如果 m3u8 文件的 #EXT-X-TARGETDURATION 标签值与实际 ts 分片时长不一致,Safari 会拒绝播放。自建转码时 FFmpeg 默认生成的 HLS 可能不符合 Apple 的 HLS 规范。

修复:VOD 转码模板确保使用标准 HLS 规范;前端播放器针对 Safari 做适配。

// 播放器初始化时,Safari 使用原生 HLS 能力
const isSafari = /^((?!chrome|android).)*safari/i
    .test(navigator.userAgent)

const playerConfig = {
   
  id: playerId,
  source: playUrl,
  isLive: false,

  // Safari 使用原生 video 标签播放 HLS
  // 非 Safari 使用 h5 模式(内部集成 hls.js)
  useH5Prism: !isSafari,

  // Safari 特殊处理
  extraInfo: isSafari ? {
   
    crossOrigin: 'anonymous',
    // 强制使用 Safari 原生 HLS 能力
    enableNativeHls: true
  } : {
   }
}

经验:Safari 是视频兼容性的"照妖镜",必须针对 Safari 做专项测试。VOD 转码输出的标准 HLS 流可以避免大部分兼容问题。

坑位四:视频鉴权 URL 过期

现象:用户播放视频到一半时突然中断,控制台报 403 Forbidden,刷新页面后又能正常播放。

根因:CDN 鉴权 URL 有效期设置 30 分钟,但长视频(45 分钟以上课程)播放到一半时 m3u8 中引用的 ts 分片 URL 已过期,播放器请求新分片时被 CDN 拒绝。

修复:鉴权 URL 有效期要覆盖最长视频时长,同时播放器在 URL 即将过期时自动续期。

/**
 * 生成播放凭证时,有效期设置为视频时长 + 缓冲
 */
public PlayInfoVo generatePlayUrl(String videoId, Long userId,
                                   String definition) {
   
    // 查询视频时长
    VideoInfo video = videoInfoMapper.selectByVideoId(videoId);
    // 有效期 = 视频时长 + 30分钟缓冲
    int timeout = Math.max(authTimeout,
            video.getDuration() + 1800);

    // 生成签名 URL,使用计算后的超时时间
    String signedUrl = signUrl(originUrl, timeout);
    // ...
}
// 前端:播放器在 URL 过期前自动续期
player.value.on('m3u8Retry', async (data: any) => {
   
  // m3u8 请求失败时,重新获取签名 URL
  const {
    data: newUrl } = await axios.get('/api/vod/play-url', {
   
    params: {
    videoId: props.videoId }
  })
  player.value.loadByUrl(newUrl.data.playUrl,
          player.value.getCurrentTime())
})

经验:视频鉴权 URL 的有效期必须超过最长视频时长,同时要有续期机制应对异常情况。

坑位五:弹幕与播放器时间轴不同步

现象:历史弹幕出现在错误的时间点,比如视频播放到 10:00 时显示了 15:00 的弹幕,或者进度条拖动后弹幕没有跟着跳转。

根因:前端弹幕组件的时间基准和播放器的时间轴不一致。弹幕组件用 setInterval 独立计时,而播放器的时间轴受缓冲、卡顿影响,两者逐渐产生偏差。进度条拖动后弹幕没有清除重置。

修复:弹幕时间基准统一使用播放器的 getCurrentTime(),拖动进度时清空弹幕队列。

// 弹幕组件的时间来源:使用播放器时间,而非独立计时
const currentVideoTime = ref(0)

// 从播放器获取当前时间,每 200ms 更新一次
let timeUpdateTimer: number | null = null

function startTimeUpdate() {
   
  timeUpdateTimer = window.setInterval(() => {
   
    if (player.value) {
   
      currentVideoTime.value = player.value.getCurrentTime()
    }
  }, 200)
}

// 监听播放器 seek 事件,清空弹幕
player.value.on('seeking', () => {
   
  liveDanmakus.value = []  // 清空实时弹幕
  // 重新加载对应时间点的历史弹幕
  loadHistoryDanmakuAtTime(currentVideoTime.value)
})

// 监听暂停/播放,同步弹幕状态
player.value.on('pause', () => {
   
  clearInterval(timeUpdateTimer!)
})
player.value.on('play', () => {
   
  startTimeUpdate()
})

经验:弹幕的时间基准必须来源于播放器,不能独立计时。任何音视频相关的功能都要以播放器时间轴为准。


10. 最佳实践

10.1 视频平台选型决策树

cloud-native_mermaid_3

10.2 视频平台上线检查清单

上传链路:

  • [ ] STS 临时凭证有效期 ≤ 1 小时,Policy 限制为仅 VOD 上传权限
  • [ ] 分片大小 5-10MB,超时时间 ≥ 120 秒,重试次数 ≥ 3
  • [ ] 上传前校验文件类型和大小,拒绝非法文件
  • [ ] STS 凭证过期自动刷新,不中断上传

转码链路:

  • [ ] 转码模板组至少包含 3 种码率(1080P/720P/480P)+ 自适应码率
  • [ ] 转码回调 + 定时补偿双保险,防止状态卡住
  • [ ] 转码失败自动重试,超过 3 次标记为失败并通知
  • [ ] 水印配置正确,位置和透明度不影响观看

播放链路:

  • [ ] CDN 鉴权 URL 有效期 > 最长视频时长 + 30 分钟缓冲
  • [ ] Safari 兼容性专项测试,确保 HLS 标准规范
  • [ ] 自适应码率开关默认开启,弱网自动降级
  • [ ] 播放器错误自动重试,URL 过期自动续期

安全链路:

  • [ ] 付费课程开启 HLS 私有加密,密钥分发需鉴权
  • [ ] Referer 防盗链 + URL 签名双重保护
  • [ ] 并发播放数限制(同用户 ≤ 2 设备)
  • [ ] 播放行为日志完整记录,用于异常分析

审核链路:

  • [ ] AI 审核阈值合理:鉴黄/鉴暴 ≥ 80 自动拦截,其他人工复审
  • [ ] 人工复审工作流完整:待审核 → 通过/拦截,记录审核人和原因
  • [ ] 被拦截视频不对外暴露播放地址

📜 真实性声明

本文所有内容均基于作者在 2025 年期间参与的在线教育平台项目中的真实经验。所有案例、数据、代码均来自生产环境,经过实践验证。为保护商业机密,部分敏感信息已做脱敏处理,但技术细节保持完整和真实。

如有任何疑问,欢迎在评论区交流讨论。

相关文章
|
1月前
|
人工智能 运维 监控
智能聚类:从海量 Trace 中理解 Agent 的行为和表现
本文介绍从海量 Agent Trace 和 Session 中提取请求意图与用户任务并行进行聚类,结合耗时、Token 消耗与交互摩擦分析运行表现,帮助发现线上共性问题,为问题排查与能力优化提供依据。
316 13
|
1月前
|
存储 人工智能 安全
从 Agent Framework 到 Agent Harness,开源 AgentScope 项目新定位
AgentScope 2.0 正式演进为通用Harness,通过任务、信息、行动三层机制及沙箱隔离架构,支撑企业构建Agent应用、可服务化的Managed Agents平台。
594 16
|
1月前
|
弹性计算 人工智能 运维
2026年阿里云优惠活动大全:怎么便宜买云服务器?新用户云产品折扣详解
总结选购思路:个人建站、新手学习,优先轻量应用服务器;业务需要自定义网络、后续有扩容需求,选择ECS;AI模型训练场景,选择GPU云服务器。参与2026年阿里云优惠活动,先完成实名,进入新客专区领取代金券,结合业务周期选择计费方式,下单前用CLI命令核对价格,部署完成后用基础运维命令监控服务器状态。合理利用新用户折扣,匹配业务需求挑选实例,能够大幅降低上云初期成本。
187 2
|
5月前
|
人工智能 安全 Serverless
MCP Server 开发与部署实战:让 AI 智能体拥有"双手"
MCP(Model Context Protocol)协议是 2026 年最热的 AI 技术趋势之一,它让大模型从"只会说"进化为"能做事"。阿里云百炼平台上线了业界首个全生命周期 MCP 服务,预置 20+ 云端服务和 50+ 本地服务。本文从 MCP 协议原理讲起,实战演示自定义 MCP Server 开发、函数计算 FC 部署、百炼 MCP 服务广场集成,以及与 Qwen3.7 智能体的联动,帮你构建真正能调用工具的 AI 应用。
|
18天前
|
存储 弹性计算 人工智能
阿里云双十一活动Token Plan优惠5折,大家都买了吗?目前最低19.5元1个月
2026阿里云双11盛大开启!Token Plan新客5折起(Lite版19.5元/月),千问办公29.9元、Qoder 19.9元、万小智9.9元限时抢;轻量服务器38元/年、ECS 99元/年起,企业最高领2728元AI礼包,7000万免费Token等你领!
|
20天前
|
人工智能 自然语言处理 前端开发
Vue3 + Spring Boot + 百炼:AI 客服对话系统的全栈实战
10个客服每天处理800条咨询,平均响应5分钟,夜间完全无人值班——这是很多企业客服团队的真实困境。本文从实际项目出发,完整演示 Vue3 + Spring Boot + 阿里云百炼搭建 AI 智能客服系统的全流程:百炼平台配置 → 知识库构建 → DashScope SDK 流式对接 → 多轮上下文管理 → 人工转接 → 对话评价统计 → Vue3 对话组件 → 管理后台 → 进阶能力,最终 70% 问题秒级响应,夜间全覆盖,客户满意度从72%提升到93%。文中包含5个生产踩坑实录和完整的AI客服选型决策树。
|
1月前
|
消息中间件 人工智能 文字识别
Vue3 + Spring Boot + 智能媒体管理:AI 图片审核平台的全栈实战
UGC 平台日增 10 万张图片,5 人审核团队每天只能审 2 万张,违规漏检率 8%,审核标准因人而异——接入阿里云智能媒体管理 + 绿网内容安全后,审核速度提升 50 倍,违规漏检率从 8% 降到 0.3%,机审+人审复核流水线让审核标准统一可控。本文从内容审核五大痛点出发,详解绿网内容安全配置、OSS 事件触发 + MNS 回调、Spring Boot 后端集成(自动审核提交/回调解析/人工复审/OCR 人脸/统计报表)、Vue3 前端实战(上传组件/审核看板/审核详情/统计报表),包含自定义模型训练、视频审核等进阶方案,5 个生产踩坑案例和审核选型决策树,帮助企业构建生产级 AI 图片
|
1月前
|
自然语言处理 关系型数据库 MySQL
Vue3 + Spring Boot + OpenSearch:企业级全文搜索从0到1的全栈实战
我负责的中型电商平台商品搜索模块,MySQL LIKE 查询 10 万条商品数据平均耗时 3 秒,搜索结果无相关度排序、无高亮、无联想、无聚合筛选——用户体验极差。引入阿里云 OpenSearch 后,搜索响应降至 50ms,相关度提升 60%,支持拼音搜索、纠错建议、实时联想和多维聚合筛选。本文从搜索痛点出发,完整覆盖 OpenSearch 集群配置、索引设计、Spring Boot 后端实战(RestHighLevelClient、DTS 同步、搜索 Service、联想建议、热搜榜)、Vue3 前端实战(搜索组件、结果页、聚合面板)、相关度调优和踩坑实录
|
1月前
|
消息中间件 NoSQL 应用服务中间件
Vue3 + WebSocket + RocketMQ:实时消息推送全栈实战
客服系统消息延迟 5 秒,用户无法实时感知订单状态变更——这是我在电商项目中遇到的真实问题。通过 RocketMQ + WebSocket 的全栈方案,消息端到端延迟从 5000ms 降到 50ms,在线用户 10000+ 连接稳定运行。本文从实时推送的 5 大痛点出发,详解 Vue3 WebSocket 客户端 + Spring Boot + 阿里云 RocketMQ 5.x + Redis 的全栈架构设计与代码实战,涵盖 STOMP 协议适配、有序消息与事务消息、离线消息补拉、消息去重与幂等、连接安全认证等核心环节,并给出 5 个生产踩坑实录和推送方案选型决策树。