短剧（APP+小程序）源码+教程|快速搭建专属短剧平台方案

　    短剧源码是一套针对移动端视频内容分发场景的完整解决方案，涵盖用户端APP和小程序，内容管理后台及后端服务，支持短剧的上传、播放、互动。以下小编将从技术架构、核心功能等方面展开说明。

　　技术架构设计

　　源码及演示：v.dyedus.top

　　前端框架

　　APP端：采用Flutter或React Native实现跨平台开发，支持iOS/Android双端统一代码，降低维护成本。Flutter的Material Design组件库可快速构建原生级UI，React Native则适合已有React生态的团队。

　　小程序端：基于微信小程序原生框架开发，利用其双线程架构（视图层与逻辑层分离）确保流畅体验。同时，通过条件编译支持H5端适配，实现一套代码多端运行。

　　后端框架

　　Node.js+Express：轻量级框架，适合快速开发API接口，与前端JavaScript生态无缝衔接。

　　Spring Boot：若需高并发处理或复杂业务逻辑（如支付、分销），Spring Boot是更稳妥的选择，结合Spring Cloud可构建微服务架构。

　　数据库

　　MySQL：存储结构化数据（如用户信息、短剧元数据），支持复杂查询（如按分类筛选短剧）。

　　MongoDB：存储非结构化数据（如用户行为日志、弹幕内容），便于横向扩展。

　　Redis：缓存热门短剧列表、用户会话，降低数据库压力。例如，将播放量TOP100的短剧ID存入Redis，设置1小时过期时间。

　　视频处理与存储

　　FFmpeg：将上传的MP4文件转码为HLS格式（.m3u8+.ts切片），支持多码率自适应（如360p/720p/1080p）。

　　云服务：使用阿里云OSS/腾讯云COS存储视频文件，配合CDN加速全球分发。例如，短剧封面图存储路径可设计为/dramas/{id}/cover.jpg。

　　核心功能模块实现

　　用户系统（注册/登录、个人中心、历史记录）

　　1.数据库表设计（MySQL）

-- 用户表
CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  username VARCHAR(50) UNIQUE NOT NULL,
  password VARCHAR(255) NOT NULL, -- 存储加密后的密码（如 bcrypt）
  email VARCHAR(100) UNIQUE,
  avatar_url VARCHAR(255),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 用户历史记录表
CREATE TABLE watch_history (
  id INT AUTO_INCREMENT PRIMARY KEY,
  user_id INT NOT NULL,
  drama_id INT NOT NULL, -- 短剧ID
  watch_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  progress INT, -- 观看进度（秒）
  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

　　2.后端代码（Node.js+Express）

　　2.1用户注册/登录（JWT鉴权）

const express = require('express');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');
const router = express.Router();
const db = require('./db'); // 假设已配置 MySQL 连接

// 用户注册
router.post('/register', async (req, res) => {
  try {
    const { username, password, email } = req.body;
    const hashedPassword = await bcrypt.hash(password, 10);
    const user = await db.query(
      'INSERT INTO users (username, password, email) VALUES (?, ?, ?)',
      [username, hashedPassword, email]
    );
    res.status(201).json({ id: user.insertId, username, email });
  } catch (error) {
    res.status(500).json({ error: '注册失败' });
  }
});

// 用户登录
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    const user = await db.query('SELECT * FROM users WHERE username = ?', [username]);
    if (!user || !await bcrypt.compare(password, user.password)) {
      return res.status(401).json({ error: '用户名或密码错误' });
    }
    const token = jwt.sign({ id: user.id }, 'your_secret_key', { expiresIn: '1h' });
    res.json({ token, user: { id: user.id, username } });
  } catch (error) {
    res.status(500).json({ error: '登录失败' });
  }
});

　　2.2个人中心（获取用户信息）

// 中间件：验证 JWT
const authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: '未授权' });
  jwt.verify(token, 'your_secret_key', (err, decoded) => {
    if (err) return res.status(401).json({ error: '无效的 Token' });
    req.user = decoded;
    next();
  });
};

// 获取用户信息
router.get('/profile', authenticate, async (req, res) => {
  try {
    const user = await db.query('SELECT id, username, email, avatar_url FROM users WHERE id = ?', [req.user.id]);
    res.json(user);
  } catch (error) {
    res.status(500).json({ error: '获取用户信息失败' });
  }
});

　　2.3历史记录（增删查改）

// 添加观看记录
router.post('/history', authenticate, async (req, res) => {
  try {
    const { drama_id, progress } = req.body;
    await db.query(
      'INSERT INTO watch_history (user_id, drama_id, progress) VALUES (?, ?, ?)',
      [req.user.id, drama_id, progress]
    );
    res.status(201).json({ message: '记录已添加' });
  } catch (error) {
    res.status(500).json({ error: '添加记录失败' });
  }
});

// 获取用户历史记录
router.get('/history', authenticate, async (req, res) => {
  try {
    const history = await db.query(
      `SELECT h.id, h.drama_id, h.watch_time, h.progress, d.title AS drama_title
       FROM watch_history h
       JOIN dramas d ON h.drama_id = d.id
       WHERE h.user_id = ?
       ORDER BY h.watch_time DESC`,
      [req.user.id]
    );
    res.json(history);
  } catch (error) {
    res.status(500).json({ error: '获取历史记录失败' });
  }
});

　　3.前端调用示例（小程序/APP）

　　3.1登录请求（小程序）

wx.request({
  url: 'https://your-api.com/api/login',
  method: 'POST',
  data: { username: 'user123', password: 'pass123' },
  success: (res) => {
    wx.setStorageSync('token', res.data.token); // 存储 Token
  }
});

　　3.2获取用户信息（APP）

fetch('https://your-api.com/api/profile', {
  headers: { Authorization: `Bearer ${localStorage.getItem('token')}` }
})
  .then(response => response.json())
  .then(data => console.log(data));

　　短剧分类与推荐（标签系统、算法推荐逻辑）

　　1.标签系统设计

　　标签系统用于对短剧进行分类，方便用户检索和推荐算法使用。

# 短剧标签系统示例
class DramaTagSystem:
    def __init__(self):
        # 初始化标签数据，模拟数据库中的标签表
        self.tags = {
            1: {"name": "喜剧", "parent_id": None},
            2: {"name": "悬疑", "parent_id": None},
            3: {"name": "爱情", "parent_id": None},
            4: {"name": "古装", "parent_id": 1},  # 喜剧的子标签
            5: {"name": "科幻", "parent_id": 2}   # 悬疑的子标签
        }
        # 短剧与标签的关联关系，模拟关联表
        self.drama_tags = {
            101: [1, 4],  # 短剧101关联喜剧和古装标签
            102: [2, 5],  # 短剧102关联悬疑和科幻标签
            103: [3]      # 短剧103关联爱情标签
        }

    def get_drama_tags(self, drama_id):
        """获取短剧的标签列表"""
        return self.drama_tags.get(drama_id, [])

    def get_related_tags(self, tag_id):
        """获取与指定标签相关的标签（如子标签）"""
        related_tags = []
        for t_id, tag_info in self.tags.items():
            if tag_info["parent_id"] == tag_id:
                related_tags.append(t_id)
        return related_tags

# 使用示例
tag_system = DramaTagSystem()
print("短剧101的标签:", tag_system.get_drama_tags(101))  # 输出: [1, 4]
print("喜剧标签的子标签:", tag_system.get_related_tags(1))  # 输出: [4]

　　2.推荐算法逻辑

　　推荐算法基于用户行为和短剧标签进行推荐，这里实现一个简单的基于标签的推荐算法。

import random

class DramaRecommendationSystem:
    def __init__(self, tag_system):
        self.tag_system = tag_system
        # 模拟用户观看历史，记录用户看过的短剧
        self.user_watch_history = {
            1001: [101, 103],  # 用户1001看过短剧101和103
            1002: [102]       # 用户1002看过短剧102
        }
        # 模拟短剧库
        self.drama_library = {
            101: {"title": "搞笑古装剧1", "tags": [1, 4]},
            102: {"title": "悬疑科幻剧1", "tags": [2, 5]},
            103: {"title": "浪漫爱情剧1", "tags": [3]},
            104: {"title": "搞笑古装剧2", "tags": [1, 4]},  # 新短剧
            105: {"title": "悬疑科幻剧2", "tags": [2, 5]}   # 新短剧
        }

    def get_user_tag_preferences(self, user_id):
        """根据用户观看历史获取用户偏好的标签"""
        tag_preferences = {}
        watch_history = self.user_watch_history.get(user_id, [])
        for drama_id in watch_history:
            tags = self.tag_system.get_drama_tags(drama_id)
            for tag_id in tags:
                tag_preferences[tag_id] = tag_preferences.get(tag_id, 0) + 1
        # 按标签出现次数排序
        sorted_tags = sorted(tag_preferences.items(), key=lambda x: x[1], reverse=True)
        return [tag[0] for tag in sorted_tags]

    def recommend_dramas(self, user_id, top_n=3):
        """为用户推荐短剧"""
        user_tags = self.get_user_tag_preferences(user_id)
        if not user_tags:
            # 如果没有观看历史，随机推荐
            return random.sample(list(self.drama_library.keys()), top_n)
        
        # 根据用户标签偏好推荐短剧
        recommended = []
        for drama_id, drama_info in self.drama_library.items():
            drama_tags = drama_info["tags"]
            # 计算短剧与用户标签的匹配度（简单实现：标签交集数量）
            match_score = len(set(user_tags) & set(drama_tags))
            if match_score > 0:
                recommended.append((-match_score, drama_id))  # 用负数方便排序
        
        # 按匹配度排序并返回前top_n个短剧
        recommended.sort()
        return [drama_id for (score, drama_id) in recommended[:top_n]]

# 使用示例
recommendation_system = DramaRecommendationSystem(tag_system)
user_id = 1001
print("用户{}偏好的标签:".format(user_id), recommendation_system.get_user_tag_preferences(user_id))  # 输出用户偏好的标签
print("为用户{}推荐的短剧:".format(user_id), recommendation_system.recommend_dramas(user_id))  # 输出推荐的短剧

　　视频播放器（倍速、缓存、弹幕集成）

import 'package:flutter/material.dart';
import 'package:ijkplayer/ijkplayer.dart';

class VideoPlayerWithSpeed extends StatefulWidget {
  final String videoUrl;

  const VideoPlayerWithSpeed({Key? key, required this.videoUrl}) : super(key: key);

  @override
  State<VideoPlayerWithSpeed> createState() => _VideoPlayerWithSpeedState();
}

class _VideoPlayerWithSpeedState extends State<VideoPlayerWithSpeed> {
  late IjkMediaController _controller;
  double _playbackSpeed = 1.0; // 默认倍速为1.0（正常速度）

  @override
  void initState() {
    super.initState();
    _controller = IjkMediaController();
    _controller.setNetworkDataSource(widget.videoUrl, autoPlay: true);
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  void _changePlaybackSpeed(double speed) {
    setState(() {
      _playbackSpeed = speed;
      _controller.setSpeed(_playbackSpeed); // 设置倍速
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        // 视频播放器
        AspectRatio(
          aspectRatio: 16 / 9,
          child: IjkPlayer(
            mediaController: _controller,
          ),
        ),
        // 倍速控制按钮
        Row(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            ElevatedButton(
              onPressed: () => _changePlaybackSpeed(0.5),
              child: const Text("0.5x"),
            ),
            ElevatedButton(
              onPressed: () => _changePlaybackSpeed(1.0),
              child: const Text("1.0x"),
            ),
            ElevatedButton(
              onPressed: () => _changePlaybackSpeed(1.5),
              child: const Text("1.5x"),
            ),
            ElevatedButton(
              onPressed: () => _changePlaybackSpeed(2.0),
              child: const Text("2.0x"),
            ),
          ],
        ),
      ],
    );
  }
}

　　关键点说明

　　倍速控制：通过_controller.setSpeed(double speed)实现，支持0.5x、1.0x、1.5x、2.0x等倍速。

　　ijkplayer：基于FFmpeg的开源播放器，支持多种视频格式和协议（HLS/DASH/RTMP）。

　　跨平台：Flutter实现，可同时支持iOS和Android。

　　小程序与APP端适配

　　小程序API封装（微信登录、分享、订阅消息）

　　APP端原生插件集成（如推送SDK、OCR识别）

　　多端数据同步方案（JWT token验证）

　　部署与运维指南

　　服务器环境搭建（Nginx配置、HTTPS证书）

　　自动化部署脚本（Docker Compose或Jenkins）

　　性能监控与优化（ELK日志分析、CDN加速）