大前端 - nodejs - egg.js 企业级框架实战 - eggJS综合案例
案例介绍
- 模仿实现 youTube clone项目。
- 在线体验地址：https://utubeclone.netlify.app
- 后端：https://github.com/manikandanraji/youtubeclone-frontend
- 客户端：https://github.com/manikandanraji/youtubeclone-backend
前后端架构分离
-
先做服务接口，再做客户端应用
-
后端技术选型：
web框架：eggjs
数据库：MongoDB
ORM框架：mongoose
身份认证：JWT -
客户端选型：vue3系列技术栈
接口设计
https://www.yuque.com/books/share/6eb0a508-d745-4e75-8631-8eb127b7b7ca?#
使用 Yapi 管理接口
项目初始化
npm i create-egg -g
create-egg youtube-clone-eggjs (smaple)
cd youtube-clone-eggjs
npm install
npm run dev
初始化mongoose配置
npm i egg-mongoose --save
/config/config.default.js
/* eslint valid-jsdoc: "off" */
'use strict';
/**
* @param {Egg.EggAppInfo} appInfo app info
*/
module.exports = appInfo => {
/**
* built-in config
* @type {Egg.EggAppConfig}
**/
const config = exports = {};
// use for cookie sign key, should change to your own and keep security
config.keys = appInfo.name + '_1649334278876_9943';
// add your middleware config here
config.middleware = [];
// add your user config here
const userConfig = {
// myAppName: 'egg',
};
// 加入mongoose
+ config.mongoose = {
client: {
url: 'mongodb://127.0.0.1/youtube-clone',
options: {},
plugins: [],
},
};
return {
...config,
...userConfig,
};
};
/config/plugin.js
'use strict';
/** @type Egg.EggPlugin */
// module.exports = {
// // had enabled by egg
// // static: {
// // enable: true,
// // }
// };
+ exports.mongoose = {
enable: true,
package: 'egg-mongoose'
}
数据模型设计
// app/model/user.js
module.exports = app => {
const mongoose = app.mongoose
const Schema = mongoose.Schema
const userSchema = new Schema({
username: { // 用户名
type: String,
required: true
},
email: { // 邮箱
type: String,
required: true
},
password: { // 密码
type: String,
select: false, // 查询中不包含该字段
required: true
},
avatar: { // 头像
type: String,
default: null
},
cover: {
type: String, // 封面
default: null
},
channelDescription: { // 频道介绍
type: String,
default: null
},
subscribersCount: {
type: Number,
default: 0
},
createdAt: { // 创建时间
type: Date,
default: Date.now
},
updatedAt: { // 更新时间
type: Date,
default: Date.now
}
})
return mongoose.model('User', userSchema)
}
视频：
// app/model/video.js
module.exports = app => {
const mongoose = app.mongoose
const Schema = mongoose.Schema
const videoSchema = new Schema({
title: { // 视频标题
type: String,
required: true
},
description: { // 视频介绍
type: String,
required: true
},
vodVideoId: { // VOD 视频 ID
type: String,
required: true
},
cover: { // 视频封面
type: String,
required: true
},
user: {
type: mongoose.ObjectId, // 视频作者
required: true,
ref: 'User'
},
commentsCount: { // 评论数量
type: Number,
default: 0
},
dislikesCount: { // 不喜欢数量
type: Number,
default: 0
},
likesCount: { // 喜欢数量
type: Number,
default: 0
},
viewsCount: { // 观看次数
type: Number,
default: 0
},
createdAt: { // 创建时间
type: Date,
default: Date.now
},
updatedAt: { // 更新时间
type: Date,
default: Date.now
}
})
return mongoose.model('Video', videoSchema)
}
视频点赞：
// app/model/video_like.js
module.exports = app => {
const mongoose = app.mongoose
const Schema = mongoose.Schema
const likeSchema = new Schema({
like: { // 点赞状态
type: Number,
enum: [1, -1], // 喜欢 1，不喜欢 -1
required: true
},
user: { // 点赞用户
type: mongoose.ObjectId,
ref: 'User', // 关联到User表
required: true
},
video: { // 点赞视频
type: mongoose.ObjectId,
ref: 'Video',
required: true
},
createdAt: { // 创建时间
type: Date,
default: Date.now
},
updatedAt: { // 更新时间
type: Date,
default: Date.now
}
})
return mongoose.model('VideoLike', likeSchema)
}
视频评论：
// app/model/video_comment.js
module.exports = app => {
const mongoose = app.mongoose
const Schema = mongoose.Schema
const commentSchema = new Schema({
content: { // 评论内容
type: String,
required: true
},
user: { // 评论用户
type: mongoose.ObjectId,
ref: 'User',
required: true
},
video: { // 评论视频
type: mongoose.ObjectId,
ref: 'Video',
required: true
},
createdAt: { // 创建时间
type: Date,
default: Date.now
},
updatedAt: { // 更新时间
type: Date,
default: Date.now
}
})
return mongoose.model('Comment', commentSchema)
}
频道（用户）订阅
// app/model/subscription.js
module.exports = app => {
const mongoose = app.mongoose
const Schema = mongoose.Schema
const subscriptionSchema = new Schema({
user: { // 订阅用户
type: mongoose.ObjectId,
ref: 'User',
required: true
},
channel: { // 订阅频道
type: mongoose.ObjectId,
ref: 'User',
required: true
},
createdAt: { // 创建时间
type: Date,
default: Date.now
},
updatedAt: { // 更新时间
type: Date,
default: Date.now
}
})
return mongoose.model('Subscription', subscriptionSchema)
}
观看历史：
// app/model/video_view.js
module.exports = app => {
const mongoose = app.mongoose
const Schema = mongoose.Schema
const viewSchema = new Schema({
user: { // 用户
type: mongoose.ObjectId,
ref: 'User',
required: true
},
video: { // 视频
type: mongoose.ObjectId,
ref: 'Video',
required: true
},
createdAt: { // 创建时间
type: Date,
default: Date.now
},
updatedAt: { // 更新时间
type: Date,
default: Date.now
}
})
return mongoose.model('View', viewSchema)
}
用户注册-准备
app/router.js
'use strict';
/**
* @param {Egg.Application} app - egg application
*/
module.exports = app => {
const { router, controller } = app;
router.prefix('/api/v1') // 设置基础路由
router.get('/users', controller.user.create)
};
app/controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
async create() {
const { ctx } = this;
ctx.body = 'UserController'
}
}
module.exports = UserController;
config/config.default.js
/* eslint valid-jsdoc: "off" */
'use strict'
/**
* @param {Egg.EggAppInfo} appInfo app info
*/
module.exports = appInfo => {
/**
* built-in config
* @type {Egg.EggAppConfig}
**/
const config = {}
// use for cookie sign key, should change to your own and keep security
config.keys = appInfo.name + '_1611716016238_6422'
// add your middleware config here
config.middleware = ['errorHandler']
// add your user config here
const userConfig = {
// myAppName: 'egg',
}
config.mongoose = {
client: {
url: 'mongodb://127.0.0.1/youtube-clone',
options: {
useUnifiedTopology: true
},
// mongoose global plugins, expected a function or an array of function and options
plugins: []
}
}
// 解决403问题，没有权限问题。关闭权限的验证
+ config.security = {
csrf: {
enable: false
}
}
return {
...config,
...userConfig
}
}
用户注册-数据验证介绍
参数校验 ：https://www.eggjs.org/zh-CN/basics/controller#%E5%8F%82%E6%95%B0%E6%A0%A1%E9%AA%8C
https://github.com/eggjs/egg-validate
用户注册-数据验证
npm i egg-validate --save
// config/plugin.js
exports.validate = {
enable: true,
package: 'egg-validate',
};
// controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
async create() {
const { ctx } = this;
// 1.数据验证
+ this.ctx.validate({
username: { type: string },
email: { type: email },
})
// 2.保存用户
// 3.生成token
// 4.发送响应
}
}
module.exports = UserController;
用户注册-自定义异常处理
2种方式
1.try catch
2.框架层统一处理异常：https://www.eggjs.org/zh-CN/core/error-handling
或 https://www.eggjs.org/zh-CN/tutorials/restful#%E7%BB%9F%E4%B8%80%E9%94%99%E8%AF%AF%E5%A4%84%E7%90%86
通一错误处理
// app/middleware/error_handler.js
// 外层函数负责接收参数
module.exports = () => {
// 返回一个中间件处理函数
return async function errorHandler(ctx, next) {
try {
await next();
} catch (err) {
// 所有的异常都在 app 上触发一个 error 事件，框架会记录一条错误日志
ctx.app.emit('error', err, ctx);
const status = err.status || 500;
// 生产环境时 500 错误的详细错误内容不返回给客户端，因为可能包含敏感信息
const error =
status === 500 && ctx.app.config.env === 'prod'
? 'Internal Server Error'
: err.message;
// 从 error 对象上读出各个属性，设置到响应中
ctx.body = { error };
if (status === 422) {
ctx.body.detail = err.errors;
}
ctx.status = status;
}
};
};
config/config.default.js
/* eslint valid-jsdoc: "off" */
'use strict';
/**
* @param {Egg.EggAppInfo} appInfo app info
*/
module.exports = appInfo => {
+ // 配置errorHandler中间件
+ config.middleware = ['errorHandler'];
return {
...config,
...userConfig,
};
};
// controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
async create() {
const { ctx } = this;
// 1.数据验证
this.ctx.validate({
username: { type: string },
email: { type: email },
password: { type: string },
})
// 2.保存用户
// 3.生成token
// 4.发送响应
}
}
module.exports = UserController;
用户注册-将数据保存到数据库
// controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
async index() {
const { ctx } = this;
// 1.数据验证
const body = this.ctx.request.body // 获取请求体
this.ctx.validate({
username: { type: string },
email: { type: email },
password: { type: string },
})
if(await this.service.user.findByUsername(body.username)) {
this.ctx.throw(422, '用户已经存在')
}
if(await this.service.user.findByEmail(body.username)) {
this.ctx.throw(422, '邮箱已经存在')
}
// 2.保存用户
const user = await this.service.user.createUser(body)
// 3.生成token
// 4.发送响应
this.ctx.body = {
user: {
// token
email: user.email,
username: user.username,
avator: user.username,
}
}
ctx.body = 'UserController'
}
}
module.exports = UserController;
service/user.js 专门处理数据库的操作
const Service = require('err').Service
class UserService extends Service {
get User() {
return this.app.model.User // 获取User的数据模型
}
// 查找username
findByUsername(username) {
return this.User.findOne({ username })
}
// 查找邮箱
findByEmail(email) {
return this.User.findOne({ email })
}
// 创建用户
async createUser(data) {
data.password = this.ctx.helper.md5(data.password)
const user = await this.User(data) // 获取User的实例
await user.save() // 保存到数据库中
return user
}
}
app/entend/htlper.js
const crypto = require('crypto')
const _ = require('lodash')
exports.md5 = str => {
return crypto.createHash('md5').update(str).digest('hex')
}
exports._ = _
用户注册-处理Token
npm i jsonwebtoken
config/config.default.js
/* eslint valid-jsdoc: "off" */
'use strict'
/**
* @param {Egg.EggAppInfo} appInfo app info
*/
module.exports = appInfo => {
// 添加jwt的secret
+ config.jwt = {
secret: 'a6e8561e-58df-4715-aa21-b5d1a091e71a',
expiresIn: '1d'
}
return {
...config,
...userConfig
}
}
service/user.js
const Service = require('err').Service
+ const jwt = require('jsonwebtoken')
class UserService extends Service {
get User() {
return this.app.model.User // 获取User的数据模型
}
// 查找username
findByUsername(username) {
return this.User.findOne({ username })
}
// 查找邮箱
findByEmail(email) {
return this.User.findOne({ email })
}
// 创建用户
async createUser(data) {
data.password = this.ctx.helper.md5(data.password)
const user = await this.User(data) // 获取User的实例
await user.save() // 保存到数据库中
return user
}
// 生成token
+ createToken (data) {
const token = jwt.sign(data, this.app.config.jwt.secret, {
expiresIn: this.app.config.jwt.expiresIn
})
return token
}
}
controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
// 创建用户
async create() {
const { ctx } = this;
// 1.数据验证
const body = this.ctx.request.body // 获取请求体
this.ctx.validate({
username: { type: string },
email: { type: email },
password: { type: string },
})
const userService = this.service.user
if(await userService.findByUsername(body.username)) {
this.ctx.throw(422, '用户已经存在')
}
if(await userService.findByEmail(body.username)) {
this.ctx.throw(422, '邮箱已经存在')
}
// 2.保存用户
const user = await userService.createUser(body)
// 3.生成token
+ const token = await userService.createToken({ userId: user._id })
// 4.发送响应
this.ctx.body = {
user: {
+ token,
email: user.email,
username: user.username,
avator: user.username,
}
}
}
}
module.exports = UserController;
用户登录
获取当前登录用户
router.js
'use strict';
/**
* @param {Egg.Application} app - egg application
*/
module.exports = app => {
const { router, controller } = app;
+ const auth = app.middleware.auth()
router.prefix('/api/v1') // 设置基础路由
// 创建用户
router.post('/users', controller.user.index)
// 登录
router.get('/users/login', controller.user.login)
// 获取当前用户
+ router.get('/user', auth, controller.user.getCurrentUser)
};
middleware/auth.js
module.exports = () => {
return async (ctx, next) => {
// 1. 获取请求头中的token数据
const token = ctx.headers['authorzation']
token = token ? ctx.headers['authorzation'].split('Bearer ')[1] : null // Bearer空格token数据
// 2。验证token，无效401
if (!token) {
ctx.throw(401)
}
// 3.token有效，根据userId,获取用户数据挂载到ctx对象中，后续中间件都可以使用
try {
const data = ctx.service.user.veriftToken(token)
ctx.user = ctx.module.User.findById(data.user)
} catch (error) {
ctx.throw(error)
}
// 4.next执行后续中间件
await next()
}
}
controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
// 获取当前用户
+ async getCurrentUser() {
// 1.验证token
// 2.获取用户
// 3.发送响应
const user = this.ctx.user
this.ctx.body = {
user: {
email: user.email,
token: this.ctx.headers['authorzation'],
username: user.username,
avator: user.avator,
}
}
}
}
module.exports = UserController;
service/user.js
const Service = require('err').Service
const jwt = require('jsonwebtoken')
class UserService extends Service {
get User() {
return this.app.model.User // 获取User的数据模型
}
// 查找username
findByUsername(username) {
return this.User.findOne({ username })
}
// 查找邮箱
findByEmail(email) {
return this.User.findOne({ email })
}
// 创建用户
async createUser(data) {
data.password = this.ctx.helper.md5(data.password)
const user = await this.User(data) // 获取User的实例
await user.save() // 保存到数据库中
return user
}
// 生成token
createToken (data) {
const token = jwt.sign(data, this.app.config.jwt.secret, {
expiresIn: this.app.config.jwt.expiresIn
})
return token
}
// 验证token
+ veriftToken(token) {
return jwt.verify(token, this.app.config.jwt.secret)
}
}
更新当前登录用户资料
router.js
'use strict';
/**
* @param {Egg.Application} app - egg application
*/
module.exports = app => {
const { router, controller } = app;
const auth = app.middleware.auth()
router.prefix('/api/v1') // 设置基础路由
// 创建用户
router.post('/users', controller.user.index)
// 登录
router.get('/users/login', controller.user.login)
// 获取当前用户
router.get('/user', auth, controller.user.getCurrentUser)
// 更新用户
+ router.patch('/user', auth, controller.user.update)
};
service/user.js
const Service = require('err').Service
const jwt = require('jsonwebtoken')
class UserService extends Service {
// 更新用户信息
+ updaetUser(data) {
// findByIdAndUpdate: 默认返回更新之前的信息，需要配置 { new: true },返回更新之后的数据
return this.User.findByIdAndUpdate(this.ctx.user._id, data, { new: true })
}
}
controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
// 更新用户信息
+ async update() {
// 1.基本数据验证
// 1.数据验证
const body = this.ctx.request.body // 获取请求体
this.ctx.validate({
username: { type: 'string', required: false }, // required：flase：传了就验证，不传就不验证。
email: { type: 'email', required: false },
password: { type: 'string', required: false},
})
// 2.校验用户是否已经存在
this.userService = this.service.user
if (body.username) {
if (body.username !== this.ctx.user.username && await userService.findByUsername(body.username)) {
this.ctx.throw(422, '用户已经存在')
}
}
if (body.password) {
body.password = this.ctx.header.md5(password)
}
// 3.校验邮箱是否已经存在
if (body.email) {
if (body.email !== this.ctx.user.email && await userService.findByUsername(body.email)) {
this.ctx.throw(422, '邮箱已经存在')
}
}
// 4.更新用户信息
const user = await userService.updaetUser(body)
// 5.返回更新之后的用户信息
this.ctx.body = {
user: {
email: user.email,
username: user.username,
avator: user.avator,
}
}
}
}
module.exports = UserController;
订阅频道
router.js
'use strict';
/**
* @param {Egg.Application} app - egg application
*/
module.exports = app => {
const { router, controller } = app;
const auth = app.middleware.auth()
router.prefix('/api/v1') // 设置基础路由
// 创建用户
router.post('/users', controller.user.index)
// 登录
router.get('/users/login', controller.user.login)
// 获取当前用户
router.get('/user', auth, controller.user.getCurrentUser)
// 更新用户
router.patch('/user', auth, controller.user.update)
// 用户订阅
+ router.post('/users/:userId/subscribe', auth, controller.user.subscribe)
};
service/user.js
const Service = require('err').Service
const jwt = require('jsonwebtoken')
class UserService extends Service {
+ async subscribe(channelId, userId) {
const { Subscription } = this.app.model
// 1.检查是否已经订阅
const record = Subscription.findOne({ user: userId, channelId: channelId })
// 2。没有订阅添加订阅
const user = User.findById(channelId)
if (!record) {
await new Subscription({ user: userId, channelId: channelId }).save()
}
user.subscribesCount++
await user.save() // 更新到数据库中。
// 3.返回用户信息
return user
}
}
controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
// 用户订阅
+ async subscribe() {
const userId = this.ctx.user._id
const channelId = this.ctx.params.userId // 获取路径参数的userId
// 1.用户不能订阅自己
if(userId.equals(channelId)) {
this.ctx.throw(422, '用户不能订阅自己')
}
// 2.添加订阅
const user = await this.service.user.subscribe(userId, channelId)
// 3.发送响应
this.ctx.body = {
user: {
...user.toJson()
isSubscribe: true,
}
}
}
}
module.exports = UserController;
使用lodash-pick处理返回的数据
npm install lodash
extend/helper.js
const crypto = require('crypto')
+ const _ = require('lodash')
exports.md5 = str => {
return crypto.createHash('md5').update(str).digest('hex')
}
//直接挂载到helper上，可以直接在ctx上使用
+ exports._ = _
controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
// 用户订阅
async subscribe() {
const userId = this.ctx.user._id
const channelId = this.ctx.params.userId // 获取路径参数的userId
// 1.用户不能订阅自己
if(userId.equals(channelId)) {
this.ctx.throw(422, '用户不能订阅自己')
}
// 2.添加订阅
const user = await this.service.user.subscribe(userId, channelId)
// 3.发送响应
this.ctx.body = {
user: {
+ ...this.ctx.helper._.pick(user, ['username', 'email', 'avator', 'cover', 'channelDescription', 'subscribersCount']),
isSubscribe: true,
}
}
}
}
module.exports = UserController;
消订阅频道
router.js
'use strict';
/**
* @param {Egg.Application} app - egg application
*/
module.exports = app => {
const { router, controller } = app;
const auth = app.middleware.auth()
router.prefix('/api/v1') // 设置基础路由
// 创建用户
router.post('/users', controller.user.index)
// 登录
router.get('/users/login', controller.user.login)
// 获取当前用户
router.get('/user', auth, controller.user.getCurrentUser)
// 更新用户
router.patch('/user', auth, controller.user.update)
// 用户订阅
router.post('/users/:userId/subscribe', auth, controller.user.subscribe)
// 取消订阅
+ router.delete('/users/:userId/subscribe', auth, controller.user.unsubscribe)
};
service/user.js
const Service = require('err').Service
const jwt = require('jsonwebtoken')
class UserService extends Service {
// 取消订阅
+ async unsubscribe(channelId, userId) {
const { Subscription } = this.app.model
// 1.检查是否已经订阅
const record = Subscription.findOne({ user: userId, channelId: channelId })
// 2。没有订阅添加订阅
const user = User.findById(channelId)
if (record) {
await record.remove() // 删除用户订阅
}
user.subscribesCount--
await user.save() // 更新到数据库中。
// 3.返回用户信息
return user
}
}
controller/user.js
'use strict';
const Controller = require('egg').Controller;
class UserController extends Controller {
// 取消用户订阅
+ async unsubscribe() {
const userId = this.ctx.user._id
const channelId = this.ctx.params.userId // 获取路径参数的userId
// 1.用户不能取消订阅自己
if(userId.equals(channelId)) {
this.ctx.throw(422, '用户不能订阅自己')
}
// 2.取消订阅
const user = await this.service.user.unsubscribe(userId, channelId)
// 3.发送响应
this.ctx.body = {
user: {
...this.ctx.helper._.pick(user, ['username', 'email', 'avator', 'cover', 'channelDescription', 'subscribersCount']),
isSubscribe: false,
}
}
}
}
module.exports = UserController;
获取用户资料
router.js
'use strict';
/**
* @param {Egg.Application} app - egg application
*/
module.exports = app => {
const { router, controller } = app;
const auth = app.middleware.auth()
router.prefix('/api/v1') // 设置基础路由
// 创建用户
router.post('/users', controller.user.index)
// 登录
router.get('/users/login', controller.user.login)
// 获取当前用户
router.get('/user', auth, controller.user.getCurrentUser)
// 更新用户
router.patch('/user', auth, controller.user.update)
// 用户订阅
router.post('/users/:userId/subscribe', auth, controller.user.subscribe)
// 取消订阅
router.delete('/users/:userId/subscribe', auth, controller.user.unsubscribe)
// 获取用户资料
+ router.get('/user/:userid', app.middleware.auth({ require: true }), controller.user.getUser)
};
middleware/auth.js
+ module.exports = (options = { require: true }) => {
return async (ctx, next) => {
// 1. 获取请求头中的token数据
const token = ctx.headers['authorzation']
token = token ? ctx.headers['authorzation'].split('Bearer ')[1] : null// Bearer空格token数据
// 2。验证token，无效401
if (!token) {
ctx.throw(401)
}
+ if (token) {
// 3.token有效，根据userId,获取用户数据挂载到ctx对象中，后续中间件都可以使用
try {
const data = ctx.service.user.veriftToken(token)
ctx.user = ctx.module.User.findById(data.user)
} catch (error) {
ctx.throw(error)
}
+ } else if (options.required) {
ctx.throw(401)
}
// 4.next执行后续中间件
await next()
}
}
controller/user.js
// 获取用户资料
async getUser() {
// 1.获取订阅状态
let isSubscribe = false
if (this.ctx.user) {
// 获取订阅记录
const record = await this.app.model.Subscription({
user: this.ctx.user._id,
cancel: this.ctx.params.userId
})
if (record) {
isSubscribe = true
}
}
// 2.获取用户信息
const user = await this.app.model.User.findById(this.ctx.params.userId)
// 3.发送响应
this.ctx.body = {
...this.ctx.helper._.pick(user, ['username', 'email', 'avator', 'cover', 'channelDescription', 'subscribersCount']),
}
}
获取用户订阅的频道列表
router.js
// 获取用户订阅的频道列表
router.get('/users/:userId/subscriptions', auth, controller.user.getSubscriptions)
controller/user.js
// 获取用户订阅的频道列表
async getSubscriptions() {
const Subscription = this.app.model.Subscription
const subscription = await Subscription.find({ user: this.ctx.params.userId }).populate('channel')
subscription = subscription.map (item => {
return this.ctx.helper._.pick(item.channel, ['_id', 'username', 'avtor'])
})
this.ctx.body = {
subscription
}
}
阿里云视频点播服务介绍
视频上传-获取上传地址和凭证
npm i @alicloud/pop-core --save
router.js
// 阿里云 VOD
router.get('/vod/CreateUploadVideo', auth, controller.vod.createUploadvideo)
controller/vod.js
'use strict';
const Controller = require('egg').Controller;
const RPCClient = require('@alicloud/pop-core').RPCClient
function initVodClient (accessKeyId, accessKeySecret) {
const regionId = 'cn-shanghai' // 点播服务接入区域
const client = new RPCClient({
accessKeyId: accessKeyId,
accessKeySecret: accessKeySecret,
endpoint: 'http://vod.' + regionId + '.aliyuncs.com',
apiVersion: '2017-03-21'
})
class VodController extends Controller {
// 获取上传地址和凭证
async createUploadvideo() {
const query = this.ctx.query
this.ctx.validate({ title: { type: 'string' }, FilName: { type: 'string' } })
const vodClient = initVodClient('LTAI4FzgRRRN2MjwBzc3xQtp', 'xAllGuORtBDVcrTQpTOWu4HfjYgN1p')
// 发送响应
this.ctx.body = await vodClient.request('CreateUploadVideo',query, {})
}
}
module.exports = VodController;
视频上传-上传完成
先解决跨域的问题。
npm i egg-cors --save
plugin.js
+ exports.cors = {
enable: true,
package: 'egg-cors'
}
config.default.js
+ config.cors = {
origin: '*'
// {string|Function} origin: '*',
// {string|Array} allowMethods: 'GET,HEAD,PUT,POST,DELETE,PATCH'
}
视频上传-刷新视频上传凭证
extend/application.js
const RPCClient = require('@alicloud/pop-core').RPCClient
function initVodClient (accessKeyId, accessKeySecret) {
const regionId = 'cn-shanghai' // 点播服务接入区域
const client = new RPCClient({
accessKeyId: accessKeyId,
accessKeySecret: accessKeySecret,
endpoint: 'http://vod.' + regionId + '.aliyuncs.com',
apiVersion: '2017-03-21'
})
return client
}
let vodClient = null
module.exports = {
// get访问器的方法。
get vodClient () {
if (!vodClient) {
vodClient = initVodClient('LTAI4FzgRRRN2MjwBzc3xQtp', 'xAllGuORtBDVcrTQpTOWu4HfjYgN1p')
}
return vodClient
}
}
conroller/vod.js
'use strict';
const Controller = require('egg').Controller;
class VodController extends Controller {
// 获取上传地址和凭证
async createUploadVideo() {
const query = this.ctx.query
this.ctx.validate({ title: { type: 'string' }, FilName: { type: 'string' } }, query)
// 发送响应
+ this.ctx.body = await this.app.vodClient.request('CreateUploadVideo', query, {})
}
// 视频上传-刷新视频上传凭证
+ async refreshUploadvideo() {
const query = this.ctx.query
this.ctx.validate({ VideoId: { type: 'string' } }, query)
// 发送响应
this.ctx.body = await this.app.vodClient.request('RefreshUploadvideo', query, {})
}
}
module.exports = VodController;
视频上传-优化配置信息
config/config.local.js 只针对本地开发的文件
/**
* 本地开发的配置文件
*/
// 本地如果还是根据环境变量读取有点麻烦,直接硬编码写死。
const secret = require('./secret')
exports.vod = {
...secret.vod
}
ignore.js
exports.vod = {
accessKeyId: 'LTAI4FzgRRRN2MjwBzc3xQtp',
accessKeySecret: 'xAllGuORtBDVcrTQpTOWu4HfjYgN1p'
}
config/config.prod.js 只针对生产环境的文件
/**
* 生产环境的配置文件
*/
exports.vod = {
// 通过环境变量设置
accessKeyId: process.env.accessKeyId,
accessKeySecret: process.env.accessKeySecret
}
extend/application.js
const RPCClient = require('@alicloud/pop-core').RPCClient
function initVodClient (accessKeyId, accessKeySecret) {
const regionId = 'cn-shanghai' // 点播服务接入区域
const client = new RPCClient({
accessKeyId: accessKeyId,
accessKeySecret: accessKeySecret,
endpoint: 'http://vod.' + regionId + '.aliyuncs.com',
apiVersion: '2017-03-21'
})
return client
}
let vodClient = null
module.exports = {
// get访问器的方法。
get vodClient () {
if (!vodClient) {
+ const { accessKeyId, accessKeySecret } = this.config.vod
+ vodClient = initVodClient(accessKeyId, accessKeySecret)
}
return vodClient
}
}
创建视频-接口实现
// 创建视频
router.post('/videos', auth, controller.vod.createVideo)
controller/video.js
const Controller = require('egg').Controller
class VideoController extends Controller {
async createVideo () {
const body = this.ctx.request.body
const { Video } = this.app.model
this.ctx.validate({
title: { type: 'string' },
description: { type: 'string' },
vodVideoId: { type: 'string' }
// cover: { type: 'string' }
}, body)
// 默认视频封面
body.cover = 'http://vod.lipengzhou.com/image/default/A806D6D6B0FD4D118F1C824748826104-6-2.png'
body.user = this.ctx.user._id
const video = await new Video(body).save()
this.ctx.status = 201
this.ctx.body = {
video
}
const setVideoCover = async (video) => {
// 获取视频信息
const vodVideoInfo = await this.app.vodClient.request('GetVideoInfo', {
VideoId: video.vodVideoId
})
if (vodVideoInfo.Video.CoverURL) {
// 使用自动生成的封面
video.cover = vodVideoInfo.Video.CoverURL
// 将修改保存到数据库中
await video.save()
} else {
await new Promise(resolve => {
setTimeout(() => {
resolve()
}, 3000)
})
await setVideoCover(video)
}
}
setVideoCover(video)
}
}
module.exports = VideoController
获取视频详情-接口实现
// 获取视频详情
router.get('/videos/:videoId', auth, controller.vod.getVideo)
controller/Video.js
// 获取视频详情
async getVideo() {
// 获取数据模型
const { Video, VideoLike, Subscription } = this.app.model
const { videoId } = this.ctx.params // 获取路径中的videoId
// 在数据库的Video表中根据videoId查询记录
let video = await Video.findById(videoId).populate('user', '_id username avatar subscribersCount')
// 没有查到抛出异常
if (!video) {
this.ctx.throw(404, 'Video Not Found')
}
// 转换成普通的js对象
video = video.toJSON()
// 在video中添加自定义数据
video.isLiked = false // 是否喜欢
video.isDisliked = false // 是否不喜欢
video.user.isSubscribed = false // 是否已订阅视频作者
// 如果用户登录
if(this.ctx.user) {
// 喜欢: 1， 不喜欢: -1
// 查询记录
const userId = this.ctx.user._id
if (await VideoLike.findOne({ user: userId, video: videoId, like: 1 })) {
video.isLiked = true
}
if (await VideoLike.findOne({ user: userId, video: videoId, like: -1 })) {
video.isDisliked = true
}
if (await Subscription.findOne({ user: userId, channel: video.user._id })) {
video.user.isSubscribed = true
}
}
// 查询的结果video直接发送到客户端
this.ctx.body = {
video
}
}
获取视频列表-接口实现
router.js
// 获取视频列表
router.get('/videos', controller.vod.getVideos)
controller/video.js
async getVideos() {
const { Video } this.app.model
const { pageNum = 1, pageSize = 10 } = this.ctx.query
pageNum = Number.parseInt(pageNum)
pageSize = Number.parseInt(pageSize)
// 按条件在数据库中查询
const getVideos = Video.find().popupate('user')
.sort({ createdAt: -1 })
.skip((pageNum -1)) * pageSize)
.limit(pageSize)
const getVideosCount = Video.countDocuments() // 获取视频总数量
const [videos, videosCount] = await Promise.all([
getVideos,
getVideosCount
])
// 查询到的数据返回给客户端。
this.ctx.body = {
videos,
videosCount
}
}
获取用户发布的视频列表-接口实现
router.js
// 获取用户发布的视频列表
router.get('/users/:userId/videos', controller.video.getUserVideos)
controller/video.js
async getUserVideos () {
const { Video } = this.app.model
let { pageNum = 1, pageSize = 10 } = this.ctx.query
const userId = this.ctx.params.userId
pageNum = Number.parseInt(pageNum)
pageSize = Number.parseInt(pageSize)
const getVideos = Video
.find({
user: userId
})
.populate('user')
.sort({
createdAt: -1
})
.skip((pageNum - 1) * pageSize)
.limit(pageSize)
const getVideosCount = Video.countDocuments({
user: userId
})
const [videos, videosCount] = await Promise.all([
getVideos,
getVideosCount
])
this.ctx.body = {
videos,
videosCount
}
}
获取用户关注的频道视频列表-接口实现
router.js
// 获取用户关注的频道视频列表-接口实现
router.get('/user/videos/feed', auth, controller.video.getUserFeedVideos)
controller/video.js
async getUserFeedVideos () {
const { Video, Subscription } = this.app.model
let { pageNum = 1, pageSize = 10 } = this.ctx.query
const userId = this.ctx.user._id
pageNum = Number.parseInt(pageNum)
pageSize = Number.parseInt(pageSize)
const channels = await Subscription.find({ user: userId }).populate('channel')
const getVideos = Video
.find({
user: {
$in: channels.map(item => item.channel._id) // 用户关注的列表
}
})
.populate('user')
.sort({
createdAt: -1
})
.skip((pageNum - 1) * pageSize)
.limit(pageSize)
const getVideosCount = Video.countDocuments({
user: {
$in: channels.map(item => item.channel._id)
}
})
const [videos, videosCount] = await Promise.all([
getVideos,
getVideosCount
])
this.ctx.body = {
videos,
videosCount
}
}
修改视频-接口实现
router.js
// 更新视频
router.patch('/videos/:videoId', auth, controller.video.updateVideo)
controller/video.js
async updateVideo () {
const { body } = this.ctx.request
const { Video } = this.app.model
const { videoId } = this.ctx.params
const userId = this.ctx.user._id
// 数据验证
this.ctx.validate({
title: { type: 'string', required: false },
description: { type: 'string', required: false },
vodVideoId: { type: 'string', required: false },
cover: { type: 'string', required: false }
})
// 查询视频
const video = await Video.findById(videoId)
if (!video) {
this.ctx.throw(404, 'Video Not Found')
}
// 视频作者必须是当前登录用户
if (!video.user.equals(userId)) {
this.ctx.throw(403)
}
Object.assign(video, this.ctx.helper._.pick(body, ['title', 'description', 'vodVideoId', 'cover']))
// 把修改保存到数据库中
await video.save()
// 发送响应
this.ctx.body = {
video
}
}
删除视频-接口实现
router.js
// 删除视频
router.delete('/videos/:videoId', auth, controller.video.deleteVideo)
controller/video.js
async deleteVideo () {
const { Video } = this.app.model
const { videoId } = this.ctx.params
const video = await Video.findById(videoId)
// 视频不存在
if (!video) {
this.ctx.throw(404)
}
// 视频作者不是当前登录用户
if (!video.user.equals(this.ctx.user._id)) {
this.ctx.throw(403)
}
await video.remove()
this.ctx.status = 204
}
添加视频评论-接口实现
router.js
// 添加视频评论
router.post('/videos/:videoId/comments', auth, controller.video.createComment)
controller/video.js
async createComment () {
const body = this.ctx.request.body
const { Video, VideoComment } = this.app.model
const { videoId } = this.ctx.params
// 数据验证
this.ctx.validate({
content: 'string'
}, body)
// 获取评论所属的视频
const video = await Video.findById(videoId)
if (!video) {
this.ctx.throw(404)
}
// 创建评论
const comment = await new VideoComment({
content: body.content,
user: this.ctx.user._id,
video: videoId
}).save()
// 更新视频的评论数量
video.commentsCount = await VideoComment.countDocuments({
video: videoId
})
await video.save()
// 映射评论所属用户和视频字段数据
await comment.populate('user').populate('video').execPopulate()
this.ctx.body = {
comment
}
}
获取视频评论列表-接口实现
router.js
// 获取视频评论列表
router.get('/videos/:videoId/comments', controller.video.getVideoComments)
controller/video.js
async getVideoComments () {
const { videoId } = this.ctx.params
const { VideoComment } = this.app.model
let { pageNum = 1, pageSize = 10 } = this.ctx.query
pageNum = Number.parseInt(pageNum)
pageSize = Number.parseInt(pageSize)
const getComments = VideoComment
.find({
video: videoId
})
.skip((pageNum - 1) * pageSize)
.limit(pageSize)
.populate('user')
.populate('video')
const getCommentsCount = VideoComment.countDocuments({
video: videoId
})
const [comments, commentsCount] = await Promise.all([
getComments,
getCommentsCount
])
this.ctx.body = {
comments,
commentsCount
}
}
删除视频评论-接口实现
router.js
// 删除视频评论
router.delete('/videos/:videoId/comments/:commentId', auth, controller.video.deleteVideoComment)
controller/video.js
async deleteVideoComment () {
const { Video, VideoComment } = this.app.model
const { videoId, commentId } = this.ctx.params
// 校验视频是否存在
const video = await Video.findById(videoId)
if (!video) {
this.ctx.throw(404, 'Video Not Found')
}
const comment = await VideoComment.findById(commentId)
// 校验评论是否存在
if (!comment) {
this.ctx.throw(404, 'Comment Not Found')
}
// 校验评论作者是否是当前登录用户
if (!comment.user.equals(this.ctx.user._id)) {
this.ctx.throw(403)
}
// 删除视频评论
await comment.remove()
// 更新视频评论数量
video.commentsCount = await VideoComment.countDocuments({
video: videoId
})
await video.save()
this.ctx.status = 204
}
喜欢视频和不喜欢视频-接口实现
router.js
// 喜欢视频
router.post('/videos/:videoId/like', auth, controller.video.likeVideo)
// 不喜欢视频
router.post('/videos/:videoId/dislike', auth, controller.video.dislikeVideo)
controller/video.js
// 喜欢视频
async likeVideo () {
const { Video, VideoLike } = this.app.model
const { videoId } = this.ctx.params
const userId = this.ctx.user._id
const video = await Video.findById(videoId)
if (!video) {
this.ctx.throw(404, 'Video Not Found')
}
const doc = await VideoLike.findOne({
user: userId,
video: videoId
})
let isLiked = true
if (doc && doc.like === 1) {
await doc.remove() // 取消点赞
isLiked = false
} else if (doc && doc.like === -1) {
doc.like = 1
await doc.save()
} else {
await new VideoLike({
user: userId,
video: videoId,
like: 1
}).save()
}
// 更新喜欢视频的数量
video.likesCount = await VideoLike.countDocuments({
video: videoId,
like: 1
})
// 更新不喜欢视频的数量
video.dislikesCount = await VideoLike.countDocuments({
video: videoId,
like: -1
})
// 将修改保存到数据库中
await video.save()
this.ctx.body = {
video: {
...video.toJSON(),
isLiked
}
}
}
// 不喜欢视频
async dislikeVideo () {
const { Video, VideoLike } = this.app.model
const { videoId } = this.ctx.params
const userId = this.ctx.user._id
const video = await Video.findById(videoId)
if (!video) {
this.ctx.throw(404, `No video found for ID - ${videoId}`)
}
const doc = await VideoLike.findOne({
user: userId,
video: videoId
})
let isDisliked = true
if (doc && doc.like === -1) {
await doc.remove()
isDisliked = false
} else if (doc && doc.like === 1) {
doc.like = -1
await doc.save()
} else {
await new VideoLike({
user: userId,
video: videoId,
like: -1
}).save()
}
// 更新视频喜欢和不喜欢的数量
video.likesCount = await VideoLike.countDocuments({
video: videoId,
like: 1
})
video.dislikesCount = await VideoLike.countDocuments({
video: videoId,
like: -1
})
this.ctx.body = {
video: {
...video.toJSON(),
isDisliked
}
}
}