# LiveManager

**Repository Path**: mengyun8/LiveManager

## Basic Information

- **Project Name**: LiveManager
- **Description**: 直播平台
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2025-07-04
- **Last Updated**: 2025-07-30

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 直播内容审核平台

一个基于 React + Go 技术栈的专业直播内容审核平台，支持用户直播的管理与审核。

## 系统架构

### 技术栈
- **前端**：React + Ant Design
- **后端**：Go + Gin
- **数据库**：PostgreSQL
- **消息队列**：RabbitMQ
- **直播服务**：SRS (Simple-RTC-Server)
- **AI 审核**：集成第三方 AI 审核服务

### 系统架构图
```
+-------------------+      +-------------------+      +-------------------+
|                   |      |                   |      |                   |
|  用户控制台 (React) ----> |  后端服务 (Go)    ----> |  直播服务 (SRS)   |
|                   |      |                   |      |                   |
+-------------------+      +-------------------+      +-------------------+
        |                           |                           |
        |                           |                           |
        |                           |                           |
+-------v---------+         +-------v---------+         +-------v---------+
|                |         |                |         |                |
|  PostgreSQL    |         |  RabbitMQ      |         |  阿里云OSS/CDN  |
|                |         |                |         |                |
+----------------+         +----------------+         +----------------+
```

## 功能特性

### 用户管理
- 用户注册与登录
- 用户角色管理（普通用户、主播、管理员）
- 个人资料管理

### 直播管理
- 创建和管理直播流
- 实时直播状态监控
- 直播流推流地址生成

### 内容审核
- AI 自动审核
- 人工审核队列
- 审核结果管理
- 违规内容处理

### 系统管理
- 用户权限管理
- 系统监控
- 审核日志

## 快速开始

### 环境要求
- Docker & Docker Compose
- Go 1.21+
- Node.js 16+
- PostgreSQL 15+
- RabbitMQ 3.8+

### 1. 克隆项目
```bash
git clone <repository-url>
cd LiveManager
```

### 2. 配置环境变量
```bash
cp config.env.example .env
# 编辑 .env 文件，配置数据库、RabbitMQ 等信息
```

### 3. 启动服务
```bash
# 启动所有服务
docker-compose up -d

# 或者分别启动
docker-compose up -d postgres rabbitmq srs
```

### 4. 初始化数据库
```bash
# 数据库会自动初始化，无需手动操作
```

### 5. 启动后端服务
```bash
# 安装依赖
cd backend && go mod tidy

# 运行服务
cd backend && go run main.go
```

### 6. 启动前端服务
```bash
cd frontend

# 安装依赖
npm install

# 启动开发服务器
npm start
```

### 7. 访问系统
- 前端地址：http://localhost:3000
- 后端API：http://localhost:8080
- SRS管理：http://localhost:8080 (SRS HTTP API)
- RabbitMQ管理：http://localhost:15672

## API 文档

### 认证相关
```
POST /api/v1/auth/register - 用户注册
POST /api/v1/auth/login    - 用户登录
POST /api/v1/auth/refresh  - 刷新令牌
```

### 用户管理
```
GET  /api/v1/users/profile     - 获取用户资料
PUT  /api/v1/users/profile     - 更新用户资料
PUT  /api/v1/users/password    - 修改密码
```

### 直播管理
```
POST /api/v1/live/start        - 开始直播
POST /api/v1/live/stop         - 停止直播
GET  /api/v1/live/status/:id   - 获取直播状态
GET  /api/v1/live/list         - 获取直播列表
```

### 内容审核
```
GET  /api/v1/audit/queue       - 获取审核队列
POST /api/v1/audit/review/:id  - 审核内容
GET  /api/v1/audit/logs        - 获取审核日志
```

### 管理员功能
```
GET  /api/v1/admin/users       - 获取所有用户
PUT  /api/v1/admin/users/:id/role - 更新用户角色
GET  /api/v1/admin/streams     - 获取所有直播
POST /api/v1/admin/streams/:id/ban - 封禁直播
```

## 开发指南

### 项目结构
```
LiveManager/
├── backend/                 # 后端代码
│   ├── main.go             # 主程序入口
│   ├── go.mod              # Go 模块文件
│   ├── config/             # 配置管理
│   ├── models/             # 数据模型
│   ├── handlers/           # HTTP 处理器
│   ├── services/           # 业务逻辑服务
│   ├── middleware/         # 中间件
│   ├── database/           # 数据库操作
│   ├── utils/              # 工具函数
│   └── test/               # 测试文件
├── frontend/               # React 前端
│   ├── src/
│   │   ├── components/     # React 组件
│   │   ├── pages/          # 页面组件
│   │   ├── contexts/       # React Context
│   │   └── App.js          # 主应用组件
│   ├── package.json        # 前端依赖
│   ├── Dockerfile          # 前端 Docker 镜像
│   └── nginx.conf          # Nginx 配置
├── docker-compose.yml      # Docker 编排
├── Dockerfile              # 后端 Docker 镜像
├── srs.conf               # SRS 配置
├── config.env.example     # 环境变量示例
└── Makefile               # 构建和运行命令
```

### 开发环境设置
1. 确保安装了所有必要的开发工具
2. 配置 IDE 的 Go 和 Node.js 环境
3. 设置数据库连接
4. 配置环境变量

### 代码规范
- Go 代码遵循 Go 官方代码规范
- React 代码使用 ESLint 和 Prettier
- 提交信息使用 Conventional Commits 规范

## 部署

### 生产环境部署
1. 配置生产环境变量
2. 构建 Docker 镜像
3. 使用 Docker Compose 或 Kubernetes 部署
4. 配置反向代理（Nginx）
5. 设置 SSL 证书

### 监控和日志
- 使用 Prometheus + Grafana 监控系统
- 配置 ELK 栈进行日志管理
- 设置告警机制

## 故障排除

### 常见问题
1. **数据库连接失败**
   - 检查数据库服务是否启动
   - 验证连接参数是否正确

2. **RabbitMQ 连接失败**
   - 检查 RabbitMQ 服务状态
   - 验证连接 URL 格式

3. **SRS 推流失败**
   - 检查 SRS 配置
   - 验证端口是否被占用

4. **前端无法连接后端**
   - 检查 CORS 配置
   - 验证 API 地址是否正确

## 贡献指南

1. Fork 项目
2. 创建功能分支
3. 提交更改
4. 推送到分支
5. 创建 Pull Request

## 许可证

本项目采用 MIT 许可证 - 查看 [LICENSE](LICENSE) 文件了解详情。

## 联系方式

如有问题或建议，请通过以下方式联系：
- 提交 Issue
- 发送邮件
- 参与讨论

---

**注意**：这是一个演示项目，生产环境使用前请进行充分的安全测试和性能优化。

设计一套专业的直播内容审核平台，支持用户直播的管理与审核，需要从系统架构、功能模块、技术选型等多个方面进行详细规划。以下是基于 React + Go 技术栈和 SRS/FFmpeg 底层直播服务的设计方案：

### 1. 系统架构设计

#### 1.1 技术栈
- **前端**：React（用于控制台）
- **后端**：Go（用于业务逻辑处理）
- **直播服务**：SRS（Simple-RTC-Server）用于流媒体处理，FFmpeg 用于流处理和转码
- **数据库**：PostgreSQL（关系型数据库）
- **消息队列**：RabbitMQ（用于异步任务处理）
- **存储**：阿里云OSS（用于存储直播回放和用户头像等静态资源）
- **CDN**：阿里云CDN（用于内容分发）
- **AI 审核服务**：集成第三方 AI 审核服务（如阿里云绿网、腾讯云内容安全等）

#### 1.2 系统架构图
```
+-------------------+      +-------------------+      +-------------------+
|                   |      |                   |      |                   |
|  用户控制台 (React) ----> |  后端服务 (Go)    ----> |  直播服务 (SRS)   |
|                   |      |                   |      |                   |
+-------------------+      +-------------------+      +-------------------+
        |                           |                           |
        |                           |                           |
        |                           |                           |
+-------v---------+         +-------v---------+         +-------v---------+
|                |         |                |         |                |
|  PostgreSQL    |         |  RabbitMQ      |         |  阿里云OSS/CDN  |
|                |         |                |         |                |
+----------------+         +----------------+         +----------------+
        |                           |                           |
        |                           |                           |
        |                           |                           |
+-------v---------+         +-------v---------+         +-------v---------+
|                |         |                |         |                |
|  AI 审核服务    |         |  FFmpeg        |         |  第三方服务     |
|                |         |                |         |                |
+----------------+         +----------------+         +----------------+
```

### 2. 功能模块设计

#### 2.1 用户管理
- **用户注册**：用户通过控制台注册账号，填写基本信息（如用户名、密码、邮箱等）。
- **用户登录**：用户通过用户名和密码登录。
- **用户信息管理**：用户可以编辑个人资料、上传头像、修改密码等。
- **用户权限管理**：管理员可以为用户分配不同的权限，如普通用户、主播、管理员等。

#### 2.2 直播管理
- **直播流录入**：
  - 用户申请开播，后端服务生成推流地址并返回给前端。
  - 用户调用摄像头，通过 SRS 推流到直播服务。
- **直播检测**：
  - 使用 FFmpeg 对直播流进行实时转码和处理。
  - 集成 AI 审核服务，对直播内容进行实时审核。
- **直播敏感信息预警**：
  - 对检测到的敏感信息（如暴力、色情、广告等）进行实时预警。
  - 提供违规内容的截图和日志记录。
  - 支持人工审核，管理员可以对 AI 无法准确判断的内容进行二次审核。

#### 2.3 审核管理
- **审核队列**：实时审核任务进入审核队列，AI 审核服务进行初步审核。
- **人工审核**：对于 AI 无法准确判断的内容，提交人工审核。
- **违规处理**：对违规直播进行警告、封禁、下线等处理。
- **审核日志**：记录审核操作日志，便于追溯和分析。

### 3. 技术实现

#### 3.1 前端（React）
- **用户注册与登录**：
  ```javascript
  // src/components/AuthForm.js
  import React, { useState } from 'react';
  import { useDispatch } from 'react-redux';
  import { registerUser, loginUser } from '../actions/authActions';

  const AuthForm = () => {
    const [formData, setFormData] = useState({ username: '', password: '' });
    const dispatch = useDispatch();

    const handleSubmit = async (e) => {
      e.preventDefault();
      if (formData.username && formData.password) {
        dispatch(registerUser(formData));
      }
    };

    return (
      <form onSubmit={handleSubmit}>
        <input
          type="text"
          placeholder="Username"
          value={formData.username}
          onChange={(e) => setFormData({ ...formData, username: e.target.value })}
        />
        <input
          type="password"
          placeholder="Password"
          value={formData.password}
          onChange={(e) => setFormData({ ...formData, password: e.target.value })}
        />
        <button type="submit">Register</button>
      </form>
    );
  };

  export default AuthForm;
  ```

- **直播管理**：
  ```javascript
  // src/components/LiveStream.js
  import React, { useState, useEffect } from 'react';
  import { useDispatch, useSelector } from 'react-redux';
  import { requestStreamUrl } from '../actions/liveActions';

  const LiveStream = () => {
    const [streamUrl, setStreamUrl] = useState('');
    const dispatch = useDispatch();
    const user = useSelector((state) => state.auth.user);

    useEffect(() => {
      if (user) {
        dispatch(requestStreamUrl(user.id)).then((url) => setStreamUrl(url));
      }
    }, [dispatch, user]);

    const handleStartStream = () => {
      // 调用摄像头进行推流
      // 使用 WebRTC 或其他库进行推流
    };

    return (
      <div>
        <h1>Start Live Stream</h1>
        <button onClick={handleStartStream}>Start Streaming</button>
        <p>Stream URL: {streamUrl}</p>
      </div>
    );
  };

  export default LiveStream;
  ```

#### 3.2 后端（Go）
- **用户注册与登录**：
  ```go
  // handlers/auth.go
  package handlers

  import (
    "encoding/json"
    "net/http"
    "github.com/gorilla/mux"
    "your_project/database"
    "your_project/models"
  )

  func RegisterUser(w http.ResponseWriter, r *http.Request) {
    var user models.User
    err := json.NewDecoder(r.Body).Decode(&user)
    if err != nil {
      http.Error(w, err.Error(), http.StatusBadRequest)
      return
    }

    // Save user to database
    err = database.SaveUser(&user)
    if err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
    }

    w.WriteHeader(http.StatusCreated)
  }

  func LoginUser(w http.ResponseWriter, r *http.Request) {
    var credentials models.Credentials
    err := json.NewDecoder(r.Body).Decode(&credentials)
    if err != nil {
      http.Error(w, err.Error(), http.StatusBadRequest)
      return
    }

    user, err := database.GetUser(credentials.Username, credentials.Password)
    if err != nil {
      http.Error(w, "Invalid credentials", http.StatusUnauthorized)
      return
    }

    // Generate JWT token
    token, err := GenerateToken(user)
    if err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"token": token})
  }
  ```

- **获取推流地址**：
  ```go
  // handlers/live.go
  package handlers

  import (
    "encoding/json"
    "net/http"
    "github.com/gorilla/mux"
    "your_project/database"
    "your_project/models"
  )

  func RequestStreamUrl(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userId := vars["userId"]

    user, err := database.GetUserById(userId)
    if err != nil {
      http.Error(w, err.Error(), http.StatusNotFound)
      return
    }

    // Generate stream URL
    streamUrl := GenerateStreamUrl(user)

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"streamUrl": streamUrl})
  }

  func GenerateStreamUrl(user models.User) string {
    // Logic to generate stream URL
    return "rtmp://your-srs-server/live/" + user.Username
  }
  ```

- **直播审核**：
  ```go
  // handlers/audit.go
  package handlers

  import (
    "encoding/json"
    "net/http"
    "github.com/gorilla/mux"
    "your_project/database"
    "your_project/models"
    "your_project/audit"
  )

  func AuditStream(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    streamId := vars["streamId"]

    stream, err := database.GetStreamById(streamId)
    if err != nil {
      http.Error(w, err.Error(), http.StatusNotFound)
      return
    }

    // Call AI audit service
    auditResult, err := audit.AuditStream(stream)
    if err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
    }

    // Handle audit result
    if auditResult.IsSensitive {
      // Send alert to admin
      audit.SendAlert(stream, auditResult)
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(auditResult)
  }
  ```

#### 3.3 直播服务（SRS）
- **SRS 配置**：
  ```ini
  # srs.conf
  listen 1935;
  max_connections 1000;

  vhost __defaultVhost__ {
    hls {
      enabled on;
      hls_path ./objs/hls;
    }

    http_server {
      enabled on;
      listen 8080;
      api {
        enabled on;
      }
    }

    application live {
      enabled on;
      publish {
        enabled on;
      }
      play {
        enabled on;
      }
    }
  }
  ```

#### 3.4 FFmpeg 使用
- **实时转码**：
  ```bash
  ffmpeg -i rtmp://your-srs-server/live/stream -c:v libx264 -preset veryfast -maxrate 3000k -bufsize