Node.js仿知乎服务端-深入理解RESTful|Node.js仿知乎服务端-深入理解RESTful API2020-01-13
【Node.js仿知乎服务端-深入理解RESTful|Node.js仿知乎服务端-深入理解RESTful API2020-01-13】课程地址： https://coding.imooc.com/learn/list/354.html
跟着GitHub认识RESTful API
REST是什么？
- 万维网软件架构风格
- 用来创建网络服务的
- Representational State Transfer
- Representational：数据的表现形式（json、xml...）
- State：当前状态或者数据
- Transfer：数据传输
- 关注点分离
- 服务端专注于数据存储，提升了简单性
- 前端专注于用户界面，提升了可移植性
- 所有用户会话信息都保存在客户端
- 每次请求必须包括所有信息，不能依赖上下文信息
- 服务端不用保存会话，提升了简单性、可靠性、可见性
- 所有服务端相应都要被标为可缓存或不可缓存
- 减少前后端的交互，提升了性能
- 接口设计尽可能统一通用，提升了简单性、可见性
- 接口与实现解耦，使前后端可以独立开发迭代
- 每层只知道相邻的一层，后面隐藏的就不知道了
- 客户端不知道是和代理还是真实服务器通信
- 其他层、负载均衡、缓存层等
- 客户端可以下载运行服务端传来的代码（比如JS）
- 通过减少一些功能，简化了客户端
- 资源是任何可以命名的事物，比如用户、评论等
- 每个资源可以通过URI被唯一地标识
- https://api.github.com/users
- https://api.github.com/users/lewis617
- 表述就是Representation，比如JSON、XML等
- 客户端不能直接操作（如sql）服务端资源
- 客户端应该通过表述（如json）来操作资源
- 每个消息（请求或相应）必须提供足够的信息让接受者理解
- 媒体类型（application/json、application/xml）
- HTTP方法：GET（查）、POST（增）、DELETE（删）
- 是否缓存：（Cache-Control）
- 超媒体： 带文字的链接
- 应用状态： 一个网页
- 引擎：驱动、跳转
- 合起来：点击链接跳转到另一个网页
- 符合REST架构风格的API
- 基本的URI，如： https://api.github.com/users
- 标准HTTP方法，如： GET,POST,PUT,PATCH,DELETE
- 传输的数据媒体类型，如JSON,XML
- GET /users 获取user列表
- GET /users/12 查看某个具体的user
- POST /users 新建一个user
- put
- delete
- URI使用名词，尽量用复数，如：/users
- URI使用嵌套表示关联关系，如: /users/12/repos/5
- 使用正确的HTTP方法，如：GET/POST/PUT/DELETE
- 不符合CRUD的情况：POST /action/子资源
- 查询
- 分页
- 字段过滤
- 状态码
- 错误处理
- HTTPS
- 鉴权
- 限流
- 文档
- 超媒体
- 基于Node.js：Node.js 模块
- 下一代：蚕食第一代Web框架Express的市场
- Web框架： 不是命令行工具，不是算法
- 由 Express 幕后的原班人马打造
- Web应用和API开发领域
- 更小、更富有表现力、更健壮
- 利用 async 函数，丢弃回调函数
- 增强错误处理， try catch
- 没有捆绑任何中间件
- 初始化项目
- 安装Koa
- 编写 Hello World
- 学习自动重启
nodemon index.jsKoa 中间件与洋葱模型 操作步骤
- 学习 async await
- 学习编写 Koa 中间件
- 学习洋葱模型
- 决定了不同的URL是如何被不同地执行的
- 在 Koa 中，是一个中间件
- 如果没有路由，会怎么样？
- 路由存在的意义
- 所有的请求都做了相同的事
- 所有的请求都会返回相同的值
- 处理不同的URL
- 处理不同的HTTP方法
- 解析URL上的参数
- 处理不同的URL
- 处理不同的HTTP方法
- 解析URL上的参数
app.use(async (ctx, next) => {
if (ctx.url === '/') {
ctx.body = '这是主页'
} else if (ctx.url === '/users') {
if (ctx.method === 'GET') {
ctx.body = '这是用户列表页'
} else if (ctx.method === 'POST') {
ctx.body = '创建用户'
} else {
ctx.status = 405
}
} else if (ctx.url.match(/\/users\/\w+/)) {
const userId = ctx.url.match(/\/users\/(\w+)/)[1]
ctx.body = `这是用户${userId}`
} else {
ctx.status = 404
}
})
使用 koa-router 实现路由 操作步骤
- 更优雅地实现路由基本功能
- 演示一些高级的路由功能， 如前缀、多中间件
const usersRouter = new Router({ prefix: '/users' })const auth = (ctx, next) => {
if (ctx.url === '/users') {
ctx.throw(401)
}
next()
}router.get('/', auth, (ctx) => {
ctx.body = '这是主页'
})usersRouter.get('/', auth, ctx => {
ctx.body = '这是用户列表页'
})
usersRouter.post('/', auth, ctx => {
ctx.body = '创建用户'
})usersRouter.get('/:id', auth, ctx => {
ctx.body = `这是用户${ctx.params.id}`
})app.use(router.routes())
app.use(usersRouter.routes())
HTTP options 方法的作用是什么？ 为何要了解 options 方法的作用？
- 这是一道面试题
- 帮助理解 koa-router 的 allowedMethods 的作用
- 检测服务器支持的请求方法
- CORS 中的预检请求
- 响应 options 方法，告诉它所支持的请求方法
- 相应地返回405（不允许）和501（没实现）
app.use(usersRouter.allowedMethods())
RESTful API 最佳实践——增删改查应该返回什么响应 操作步骤
- 实现增删改查
- 返回正确的响应
- 拿到路由分配的任务，并执行
- 在 Koa 中，是一个中间件
- 获取HTTP请求参数
- 处理业务逻辑
- 处理 HTTP 响应
- Query String，如： ?q=keyword
- Router Params， 如： /users/:id
- Body， 如： { name: "lilei" }
- Header， 如：Accept、Cookie
- 发送 Status， 如： 200/400 等
- 发送Body， 如： { name: "123" }
- 发送Header， 如： Allow、Content-Type
- 每个资源的控制器放在不同的文件里
- 尽量使用类+类方法的形式编写控制器
- 严谨的错误处理
- 学习断点调试
- 获取query // ctx.query
- 获取rotuer params
- 获取 body
- 获取header
- 发送status
- 发送body
- 发送header
- 实现用户的增删改查
- 将路由单独放在一个目录
- 将控制器单独放在一个目录
- 使用 类+类方法 的方式组织控制器
- 编程语言或计算机硬件里的一种机制
- 处理软件或信息系统中出现的异常状况
- 运行时错误，都返回 500
- 逻辑错误，如找不到（404）、先决条件失败（412）、如法处理的实体（参数格式不对， 422）等
- 防止程序挂掉
- 告诉用户错误信息
- 便于开发者调试
- 制造 404/412/500 三种错误
- 了解 Koa 自导的错误处理做了什么
- 自己编写错误处理中间件
- 制造 404/412/500 三种错误来测试
- 安装 koa-json-error
- 使用 koa-json-error 的默认配置处理错误
- 修改配置使其在生产环境下禁用错误堆栈的返回
const error = require('koa-json-error')
app.use(error({
postFormat: (e, { stack, ...rest }) => {
process.env.NODE_ENV === 'production' ? rest : { stack, rest }
}
}))
使用 koa-parameter 校验参数 操作步骤
- 安装 koa-parameter
- 使用 koa-parameter 校验参数
- 制造 422 错误来测试校验结果
- 对不同于传统的关系型数据库的数据库管理系统的统称
- 列存储（HBase）
- 文档存储（MongoDB）
- Key-value 存储（Redis）
- 图存储（FlockDB）
- 对象存储（db4o）
- XML 存储（BaseX）
- 简单（没有原子性、一致性、隔离性等复杂规范）
- 便于横向拓展
- 适合超大规模数据的存储
- 灵活地存储复杂结构的数据（Schema Free）
- 来自于英文单词 “Humongous”， 中文含义为“庞大”
- 面向文档存储的开源数据库
- 由 C++ 编写而成
- 性能好（内存计算）
- 大规模数据存储（可拓展性）
- 可靠安全（本地复制、自动故障转移）
- 方便存储复杂数据结构（Schema Free）
- 官网下载
- 支持常见平台（Windows、Linux、OSX）
- 阿里云、腾讯云（收费）
- MongoDB 官方的 MongoDB Atlas（免费+收费）
- 注册用户
- 创建集群
- 添加数据库用户
- 设置IP地址白名单
- 获取连接地址
- 安装 Mongoose
- 用 Mongoose 连接 MongoDB
- 分析用户模块的属性
- 编写用户模块的 Schema
- 使用 Schema 生成用户 Model
const mongoose = require('mongoose')const { Schema, model } = mongoose;
const userSchema = new Schema({
name: {
type: String,
required: true
}
})module.exports = model('User', userSchema)
用MongoDB 实现用户的增删改查 操作步骤
- 用 Mongoose 实现增删改查接口
- 用 Postman 测试增删改查接口
文章图片
Session 工作原理 Session 的优势
- 相比JWT，最大的优势就在于可以主动清除session
- session 保存在服务器端，相对较为安全
- 结合 cookie 使用，较为灵活，兼容性好
- cookie + session 在跨域场景表现并不好
- 如果是分布式部署，需要做多机共享 session 机制
- 基于 cookie 的机制很容易被 CSRF
- 查询 session 信息可能会有数据库查询操作
- session：主要存放在服务器端，相对安全
- cookie：主要存放在客户端，并且不是很安全
- sessionStorage：仅在当前会话有效，关闭页面或浏览器后被清除
- localStorage：除非被清除，否则永久保存
- JSON Web Token 是一个开放标准（RFC 7519）
- 定义了一种紧凑且独立的方式，可以将各方之间的信息作为JSON对象进行安全传输
- 该信息可以验证和信任，因为是经过数字签名的
- 头部（Header）
- 有效载荷（Payload）
- 签名（Signature）
Header
- typ：token的类型，这里固定为JWT
- alg：使用的hash算法，例如： HMAC SHA256或者RSA
base64 编码
Payload
- 存储需要传递的信息，如用户ID、用户名等
- 还包含元数据，如过期时间、发布人等
- 与Header不同，Payload可以加密
Signature
- 对 Header 和 Payload 部分进行签名
- 保证 Token 在传输的过程中没有被篡改或损坏
- 可拓展性
- 安全性
- RESTful API
- 性能，以空间换时间
- 时效性， 比session差
- jsonwebtoken
- 签名
- 验证
- 设计用户 Schema
select：false 不查询某个字段 - 编写保证唯一性的逻辑
- 登陆接口设计
- 使用 jsonwebtoken 生成 token
- 认证：验证token，并获取用户信息
- 授权：使用中间件保护接口
- 安装 koa-jwt
- 使用中间件保护接口
- 使用中间件获取用户信息
- 用户头像
- 封面图片
- 问题和回答中的图片
- 话题图片
- ......
- 基础功能：上传图片、生成图片链接
- 附加功能：限制上传图片的大小与类型、生成高中低三种分辨率的图片链接、生成CDN
- 阿里云 OSS 等云服务，推荐生产环境下使用
- 直接上传到服务器，不推荐在生产环境下使用
- 安装 koa-body，替换 koa-bodyparser
- 设置图片上传的目录
- 使用 Postman 上传文件
- 安装 koa-static
- 设置静态文件目录
- 生成图片链接
- 编写上传文件的前端页面
- 与后端接口联调测试
- 不同类型（如字符串、数组）的属性
- 字段过滤
- 分析个人资料的数据结构
- 设计个人资料的 schema
- 分析个人资料的数据结构
- 编写代码校验个人资料的参数
- 使用 Postman 测试
- 设计 schema 默认隐藏部分字段
- 通过查询字符串显示隐藏字段
- 使用 Postman 测试
- 关注、取消关注
- 获取关注人、粉丝列表（用户-用户多对多关系）
- 分析关注与粉丝的数据结构
- 设计关注与粉丝 schema
following: {
type: [{ type: Schema.Types.ObjectId, ref: 'User' }],
select: false
}
RESTful 风格的关注与粉丝接口 操作步骤
- 实现获取关注人和粉丝列表接口
- 实现关注和取消关注接口
- 使用 Postman 测试
async listFollowing (ctx) {
const user = await User.findById(ctx.params.id).select('+following').populate('following')
if (!user) {
ctx.throw(404)
}
ctx.body = user.following
}
async listFollowers (ctx) {
const users = await User.find({ following: ctx.params.id })
ctx.body = users
}
async follow (ctx) {
const me = await User.findById(ctx.state.user._id).select('+following')
if (!me.following.map(id => id.toString()).includes(ctx.params.id)) {
me.following.push(ctx.params.id)
me.save()
}
ctx.status = 204
}
async unfollow (ctx) {
const me = await User.findById(ctx.state.user._id).select('+following')
const index = me.following.map(id => id.toString()).indexOf(ctx.params.id)
if (index > -1) {
me.following.splice(index, 1)
me.save()
}
ctx.status = 204
}
编写校验用户存在与否的中间件 操作步骤
- 编写校验用户是否存在的中间件
- 使用 Postman 测试
// controllers/users.js
async checkUserExist (ctx, next) {
const user = await User.findById(ctx.params.id)
if (!user) {
ctx.throw(404, '用户不存在！')
}
await next()
}项目实战之话题模块（足够完整！！） 话题模块需求分析 浏览知乎的话题模块功能
话题模块功能点
- 话题的增改查
- 分页、模糊搜索
- 用户属性中的话题引用
- 关注/取消关注话题、用户关注的话题列表
- 设计 Schema
- 实现 RESTful 风格的增改查接口
- 使用 Postman 测试
// models/topics.js
const mongoose = require('mongoose')const { Schema, model } = mongoose;
const topicSchema = new Schema({
__v: { type: Number, select: false },
name: { type: String, required: true },
avatar_url: { type: String },
introduction: { type: String, select: false }
})module.exports = model('Topic', topicSchema)
// controllers/topics.js
const Topic = require('../models/topics')class TopicsCtl {
async find (ctx) {
ctx.body = await Topic.find()
}
async findById (ctx) {
const { fields = '' } = ctx.query
const selectFields = fields.split(';
').filter(f => f).map(f => '+' + f).join('')
const topic = await Topic.findById(ctx.params.id).select(selectFields)
ctx.body = topic
}
async create (ctx) {
ctx.verifyParams({
name: { type: 'string', required: true },
avatar_url: { type: 'string', required: false },
introduction: { type: 'string', required: false }
})
const topic = await new Topic(ctx.request.body).save()
ctx.body = topic
}
async update (ctx) {
ctx.verifyParams({
name: { type: 'string', required: false },
avatar_url: { type: 'string', required: false },
introduction: { type: 'string', required: false }
})
const topic = await Topic.findByIdAndUpdate(ctx.params.id, ctx.request.body)
ctx.body = topic
}
}module.exports = new TopicsCtl()
// routes/topics.js
const jwt = require('koa-jwt')
const Router = require('koa-router')
const router = new Router({ prefix: '/topics' })
const { find, findById, create, update } = require('../controllers/topics')
const { secret } = require('../config')const auth = jwt({ secret })router.get('/', find)
router.post('/', auth, create)
router.get('/:id', findById)
router.patch('/:id', auth, update)module.exports = router
RESTful API 最佳实践——分页 操作步骤
- 实现分页逻辑
- 使用 Postman 测试
const page = Math.max((ctx.query.page || 1) * 1, 1) - 1
const perPage = Math.max((ctx.query.per_page || 1) * 1, 1)
ctx.body = await User.find().limit(perPage).skip(page * perPage)
RESTful API 最佳实践——模糊搜索 操作步骤
- 实现模糊搜索逻辑
- 使用 Postman 测试
// 在find查询条件中加上正则表达式
ctx.body = await Topic.find({ name: new RegExp(ctx.query.q) })
12-6 用户属性中的话题引用 操作步骤
- 使用话题引用替代部分用户属性
- 使用Postman测试
- 将locations、business、employments.company、employments.job、educations.school、educations.major等字段设置为Schema.Types.ObjectID类型绑定为Topic
async findById (ctx) {
const { fields = '' } = ctx.query
+const populateStr = fields.split(';
').filter(f => f).map(f => {
+if (f === 'employments') {
+return 'employments.company employments.job'
+}
+if (f === 'educations') {
+return 'educations.school educations.major'
+}
+return f
+}).join(' ');
const user = await User.findById(ctx.params.id).select('+' + fields.split(';
').filter(f => f).join('+'))
+.populate(populateStr);
if (!user) {
ctx.throw(404, '用户不存在！')
}
ctx.body = user
}
12-7 RESTful 风格的关注话题接口 操作步骤
- 实现关注话题逻辑（用户-话题多对多关系）
- 使用Postman 测试
async listFollowingTopics (ctx) {
const user = await User.findById(ctx.params.id).select('+followingTopics').populate('followingTopics')
if (!user) {
ctx.throw(404, '用户不存在')
}
ctx.body = user.followingTopics
}
async followTopic (ctx) {
const me = await User.findById(ctx.state.user._id).select('+followingTopics')
if (!me.followingTopics.map(id => id.toString()).includes(ctx.params.id)) {
me.followingTopics.push(ctx.params.id)
me.save()
}
ctx.status = 204
}
async unfollowTopic (ctx) {
const me = await User.findById(ctx.state.user._id).select('+followingTopics')
const index = me.followingTopics.map(id => id.toString()).indexOf(ctx.params.id)
if (index > -1) {
me.followingTopics.splice(index, 1)
me.save()
}
ctx.status = 204
}
第13章 项目实战之问题模块——复杂的数据库设计 问题模块需求分析 浏览知乎的问题模块功能
文章图片
image.png 问题模块功能点
- 问题的增删改查
- 用户的问题列表
- 话题的问题列表+问题的话题列表（话题-问题多读多关系）
- 关注、取消关注问题
- 实现增删改查接口
- 实现用户的问题列表接口
- 使用Postman测试
// controller/questions.js
const Question = require('../models/questions')class QuestionsCtl {
async find (ctx) {
const page = Math.max((ctx.query.page || 1) * 1, 1) - 1
const perPage = Math.max((ctx.query.per_page || 2) * 1, 1)
const q = new RegExp(ctx.query.q)
ctx.body = await Question.find({ $or: [{ title: q }, { description: q }] }).limit(perPage).skip(page * perPage)
}
async checkQuestionExist (ctx, next) {
const question = await Question.findById(ctx.params.id).select('+questioner')
if (!question) {
ctx.throw(404, '问题不存在！')
}
ctx.state.question = question
await next()
}
async findById (ctx) {
const { fields = '' } = ctx.query
const selectFields = fields.split(';
').filter(f => f).map(f => '+' + f).join('')
const question = await Question.findById(ctx.params.id).select(selectFields).populate('questioner')
ctx.body = question
}
async create (ctx) {
ctx.verifyParams({
title: { type: 'string', required: true },
description: { type: 'string', required: false },
introduction: { type: 'string', required: false }
})
const question = await new Question({ ...ctx.request.body, questioner: ctx.state.user._id }).save()
ctx.body = question
}
async update (ctx) {
ctx.verifyParams({
title: { type: 'string', required: false },
description: { type: 'string', required: false }
})
await ctx.state.question.update(ctx.request.body)
ctx.body = ctx.state.question
}
async checkQuestioner (ctx, next) {
const { question } = ctx.state
if (question.questioner.toString() !== ctx.state.user._id) { ctx.throw(403, '没有权限') }
await next()
}
async delete (ctx) {
await Question.findByIdAndRemove(ctx.params.id)
ctx.status = 204
}
}module.exports = new QuestionsCtl()// model/questions.js
const mongoose = require('mongoose')const { Schema, model } = mongoose;
const questionSchema = new Schema({
__v: { type: Number, select: false },
title: { type: String, required: true },
description: { type: String },
questioner: { type: Schema.Types.ObjectId, ref: 'User', required: true, select: false }
})module.exports = model('Question', questionSchema)// router/question.js
const jwt = require('koa-jwt')
const Router = require('koa-router')
const router = new Router({ prefix: '/questions' })
const { find, findById, create, update, delete: del, checkQuestionExist, checkQuestioner } = require('../controllers/questions')
const { secret } = require('../config')const auth = jwt({ secret })router.get('/', find)
router.post('/', auth, create)
router.get('/:id', checkQuestionExist, findById)
router.patch('/:id', auth, checkQuestionExist, checkQuestioner, update)
router.delete('/:id', auth, checkQuestionExist, checkQuestioner, del)module.exports = router
// router/users.js 中新增一个列出问题列表的接口
13-3 话题-问题多对多关系设计与实现 操作步骤
- 实现问题的话题列表接口
- 实现话题的问题列表接口
- 使用 Postman 测试
// model
topics: {
type: [{ type: Schema.Types.ObjectId, ref: 'Topic' }],
select: false
}
// controller
async listQuestions (ctx) {
const questions = await Question.find({ topics: ctx.params.id })
ctx.body = questions
}
// router
router.get('/:id/questions', checkTopicExist, listQuestions)
答案模块需求分析 浏览知乎的答案模块功能
- 答案的增删改查
- 问题-答案/用户-答案一对多
- 赞/踩答案
- 收藏答案
文章图片
知乎答案界面截图 问题-答案模块二级嵌套的增删改查接口 操作步骤
- 设计数据库的Schema
- 实现增删改查接口
- 使用 Postman 测试
// model
const mongoose = require('mongoose')const { Schema, model } = mongoose;
const answerSchema = new Schema({
__v: { type: Number, select: false },
content: { type: String, required: true },
answerer: { type: Schema.Types.ObjectId, ref: 'User', required: true, select: false },
questionId: { type: String, required: true }
})module.exports = model('Answer', answerSchema)// controller
const Answer = require('../models/answers')class AnswersCtl {
async find (ctx) {
const page = Math.max((ctx.query.page || 1) * 1, 1) - 1
const perPage = Math.max((ctx.query.per_page || 2) * 1, 1)
const q = new RegExp(ctx.query.q)
ctx.body = await Answer.find({ content: q, questionId: ctx.params.questionId }).limit(perPage).skip(page * perPage)
}
async checkAnswerExist (ctx, next) {
const answer = await Answer.findById(ctx.params.id).select('+answerer')
if (!answer) {
ctx.throw(404, '答案不存在！')
}
if (answer.questionId !== ctx.params.questionId) {
ctx.throw(404, '该问题下没有此答案')
}
ctx.state.answer = answer
await next()
}
async findById (ctx) {
const { fields = '' } = ctx.query
const selectFields = fields.split(';
').filter(f => f).map(f => '+' + f).join('')
const answer = await Answer.findById(ctx.params.id).select(selectFields).populate('answerer')
ctx.body = answer
}
async create (ctx) {
ctx.verifyParams({
content: { type: 'string', required: true }
})
const answerer = ctx.state.user._id
const questionId = ctx.params.questionId
const answer = await new Answer({ ...ctx.request.body, answerer, questionId }).save()
ctx.body = answer
}
async checkAnswerer (ctx, next) {
const { answer } = ctx.state
if (answer.answerer.toString() !== ctx.state.user._id) { ctx.throw(403, '没有权限') }
await next()
}
async update (ctx) {
ctx.verifyParams({
content: { type: 'string', required: false }
})
await ctx.state.answer.update(ctx.request.body)
ctx.body = ctx.state.answer
}
async delete (ctx) {
await Answer.findByIdAndRemove(ctx.params.id)
ctx.status = 204
}
}module.exports = new AnswersCtl()// router
const jwt = require('koa-jwt')
const Router = require('koa-router')
const router = new Router({ prefix: '/questions/:questionId/answers' })
const { find, findById, create, update, delete: del, checkAnswerExist, checkAnswerer } = require('../controllers/answers')
const { secret } = require('../config')const auth = jwt({ secret })router.get('/', find)
router.post('/', auth, create)
router.get('/:id', checkAnswerExist, findById)
router.patch('/:id', auth, checkAnswerExist, checkAnswerer, update)
router.delete('/:id', auth, checkAnswerExist, checkAnswerer, del)module.exports = router
14-3 互斥关系的赞/踩答案接口设计与实现 操作步骤
- 设计数据库Schema
- 实现接口
- 使用 Postman 测试
// users model
likingAnswers: {
type: [{ type: Schema.Types.ObjectId, ref: 'Answer' }],
select: false
},
dislikingAnswers: {
type: [{ type: Schema.Types.ObjectId, ref: 'Answer' }],
select: false
}// answers model 增加字段
voteCount: { type: Number, required: true, default: 0 }// 修改 checkAnswerExist
async checkAnswerExist (ctx, next) {
const answer = await Answer.findById(ctx.params.id).select('+answerer')
if (!answer) {
ctx.throw(404, '答案不存在！')
}
// 只有在删改查答案时才检查此逻辑，赞、踩答案时不检查
if (ctx.params.questionId && answer.questionId !== ctx.params.questionId) {
ctx.throw(404, '该问题下没有此答案')
}
ctx.state.answer = answer
await next()
}// users controller
async listLikingAnswers (ctx) {
const user = await User.findById(ctx.params.id).select('+likingAnswers').populate('likingAnswers')
if (!user) {
ctx.throw(404, '用户不存在')
}
ctx.body = user.likingAnswers
}
async likeAnswer (ctx, next) {
const me = await User.findById(ctx.state.user._id).select('+likingAnswers')
if (!me.likingAnswers.map(id => id.toString()).includes(ctx.params.id)) {
me.likingAnswers.push(ctx.params.id)
me.save()
await Answer.findByIdAndUpdate(ctx.params.id, { $inc: { voteCount: 1 }})
}
ctx.status = 204
await next()
}
async unlikeAnswer (ctx) {
const me = await User.findById(ctx.state.user._id).select('+likingAnswers')
const index = me.likingAnswers.map(id => id.toString()).indexOf(ctx.params.id)
if (index > -1) {
me.likingAnswers.splice(index, 1)
me.save()
await Answer.findByIdAndUpdate(ctx.params.id, { $inc: { voteCount: -1 }})
}
ctx.status = 204
}
async listDislikingAnswers (ctx) {
const user = await User.findById(ctx.params.id).select('+dislikingAnswers').populate('dislikingAnswers')
if (!user) {
ctx.throw(404, '用户不存在')
}
ctx.body = user.dislikingAnswers
}
async dislikeAnswer (ctx, next) {
const me = await User.findById(ctx.state.user._id).select('+dislikingAnswers')
if (!me.dislikingAnswers.map(id => id.toString()).includes(ctx.params.id)) {
me.dislikingAnswers.push(ctx.params.id)
me.save()
}
ctx.status = 204
await next()
}
async undislikeAnswer (ctx) {
const me = await User.findById(ctx.state.user._id).select('+dislikingAnswers')
const index = me.dislikingAnswers.map(id => id.toString()).indexOf(ctx.params.id)
if (index > -1) {
me.dislikingAnswers.splice(index, 1)
me.save()
}
ctx.status = 204
}// users router
router.get('/:id/likingAnswers', listLikingAnswers)
router.put('/likingAnswers/:id', auth, checkAnswerExist, likeAnswer, undislikeAnswer)
router.delete('/likingAnswers/:id', auth, checkAnswerExist, unlikeAnswer)
router.get('/:id/dislikingAnswers', listDislikingAnswers)
router.put('/dislikingAnswers/:id', auth, checkAnswerExist, dislikeAnswer, unlikeAnswer)
router.delete('/dislikingAnswers/:id', auth, checkAnswerExist, undislikeAnswer)
14-4 RESTful 风格的收藏答案接口 操作步骤
- 设计数据库Schema
- 实现接口
- 使用 Postman 测试
// user Schema 新增一个字段
collectingAnswers: {
type: [{ type: Schema.Types.ObjectId, ref: 'Answer' }],
select: false
}
// user controller
async listCollectingAnswers (ctx) {
const user = await User.findById(ctx.params.id).select('+collectingAnswers').populate('collectingAnswers')
if (!user) {
ctx.throw(404, '用户不存在')
}
ctx.body = user.collectingAnswers
}
async collectingAnswer (ctx, next) {
const me = await User.findById(ctx.state.user._id).select('+collectingAnswers')
if (!me.collectingAnswers.map(id => id.toString()).includes(ctx.params.id)) {
me.collectingAnswers.push(ctx.params.id)
me.save()
}
ctx.status = 204
await next()
}
async uncollectingAnswer (ctx) {
const me = await User.findById(ctx.state.user._id).select('+collectingAnswers')
const index = me.collectingAnswers.map(id => id.toString()).indexOf(ctx.params.id)
if (index > -1) {
me.collectingAnswers.splice(index, 1)
me.save()
}
ctx.status = 204
}
// user routes
router.get('/:id/collectingAnswers', listCollectingAnswers)
router.put('/collectingAnswers/:id', auth, checkAnswerExist, collectingAnswer)
router.delete('/collectingAnswers/:id', auth, checkAnswerExist, uncollectingAnswer)
第15章 评论模块 15-1 评论模块需求分析 浏览知乎的评论模块功能
文章图片
知乎评论界面截图 评论模块功能点
- 评论的增删改查
- 答案-评论/问题-评论/用户-评论一对多
- 一级评论与二级评论
- 赞/踩评论（自行实现）
// comment model
const mongoose = require('mongoose')const { Schema, model } = mongoose;
const commentSchema = new Schema({
__v: { type: Number, select: false },
content: { type: String, required: true },
commentator: { type: Schema.Types.ObjectId, ref: 'User', required: true, select: false },
questionId: { type: String, required: true },
answerId: { type: String, required: true }
})module.exports = model('Comment', commentSchema)// comment controller
const Comment = require('../models/comments')class CommentsCtl {
async find (ctx) {
const page = Math.max((ctx.query.page || 1) * 1, 1) - 1
const perPage = Math.max((ctx.query.per_page || 2) * 1, 1)
const q = new RegExp(ctx.query.q)
const { questionId, answerId } = ctx.params;
ctx.body = await Comment.find({ content: q, questionId, answerId }).limit(perPage).skip(page * perPage).populate('commentator')
}
async checkCommentExist (ctx, next) {
const comment = await Comment.findById(ctx.params.id).select('+commentator')
if (!comment) {
ctx.throw(404, '评论不存在！')
}
// 只有在删改查答案时才检查此逻辑，赞、踩答案时不检查
if (ctx.params.questionId && comment.questionId !== ctx.params.questionId) {
ctx.throw(404, '该问题下没有此评论')
}
if (ctx.params.answerId && comment.answerId !== ctx.params.answerId) {
ctx.throw(404, '该答案下没有此评论')
}
ctx.state.comment = comment
await next()
}
async findById (ctx) {
const { fields = '' } = ctx.query
const selectFields = fields.split(';
').filter(f => f).map(f => '+' + f).join('')
const comment = await Comment.findById(ctx.params.id).select(selectFields).populate('commentator')
ctx.body = comment
}
async create (ctx) {
ctx.verifyParams({
content: { type: 'string', required: true }
})
const commentator = ctx.state.user._id
const { questionId, answerId } = ctx.params
const comment = await new Comment({ ...ctx.request.body, commentator, questionId, answerId }).save()
ctx.body = comment
}
async checkCommentator (ctx, next) {
const { comment } = ctx.state
if (comment.commentator.toString() !== ctx.state.user._id) { ctx.throw(403, '没有权限') }
await next()
}
async update (ctx) {
ctx.verifyParams({
content: { type: 'string', required: false }
})
await ctx.state.comment.update(ctx.request.body)
ctx.body = ctx.state.comment
}
async delete (ctx) {
await Comment.findByIdAndRemove(ctx.params.id)
ctx.status = 204
}
}module.exports = new CommentsCtl()// comment routes
const jwt = require('koa-jwt')
const Router = require('koa-router')
const router = new Router({ prefix: '/questions/:questionId/answers/:answerId/comments' })
const { find, findById, create, update, delete: del, checkCommentExist, checkCommentator } = require('../controllers/comments')
const { secret } = require('../config')const auth = jwt({ secret })router.get('/', find)
router.post('/', auth, create)
router.get('/:id', checkCommentExist, findById)
router.patch('/:id', auth, checkCommentExist, checkCommentator, update)
router.delete('/:id', auth, checkCommentExist, checkCommentator, del)module.exports = router
15-3 一级评论与二级评论接口的设计与实现 操作步骤
- 设计数据库的Schema
- 实现接口
- 使用 Postman 测试
// 修改comment.find
async find (ctx) {
const page = Math.max((ctx.query.page || 1) * 1, 1) - 1
const perPage = Math.max((ctx.query.per_page || 2) * 1, 1)
const q = new RegExp(ctx.query.q)
const { questionId, answerId } = ctx.params;
const { rootCommentId } = ctx.query
ctx.body = await Comment.find({ content: q, questionId, answerId, rootCommentId }).limit(perPage).skip(page * perPage).populate('commentator replyTo')
}
// 修改 comment.create
async create (ctx) {
ctx.verifyParams({
content: { type: 'string', required: true },
rootCommentId: { type: 'string', required: false },
replyTo: { type: 'string', required: false },
})
const commentator = ctx.state.user._id
const { questionId, answerId } = ctx.params
const comment = await new Comment({ ...ctx.request.body, commentator, questionId, answerId }).save()
ctx.body = comment
}
// 修改 comment.update
async update (ctx) {
ctx.verifyParams({
content: { type: 'string', required: false }
})
// 只允许更新content属性
const { content } = ctx.request.body
await ctx.state.comment.update({ content })
ctx.body = ctx.state.comment
}
// Comment Schema增加两个字段：
{
rootCommentId: { type: String },
replyTo: { type: Schema.Types.ObjectId, ref: 'User'}
}15-4 添加日期 操作步骤
- 设计数据库Schema
- 实现接口
- 使用 Postman 测试
{ timestamps: true }
第16章 丑媳妇终要见公婆：项目上线、部署与配置 16-1 在服务器上安装Git与Node.js 操作步骤
- ssh登陆到服务器
工具：gitbash
ssh username@ipAddress - 安装Git，下载代码到服务器
ubuntu:
apt-get install git
git clone 代码仓库地址 - 安装 Node.js，运行程序
curl -SL https://deb.nodesource.com/setup_11.x | sudo -E bash -
sudo apt-get install -y nodejsnpm i
npm run dev
16-2 用NGINX实现端口转发 操作步骤
- 安装NGINX(Ubuntu)
apt-get install nginx
nginx -t //测试配置文件
vim 配置文件地址 - 配置NGINX，把外网 80 端口转到内网 3000 端口
server {
listen 80;
server_name: localhost;
location / {
proxy_pass http://127.0.0.1:3000
}
}
配置完后，重启NGINX：
service nginx restart或：
service nginx reload- 使用 Postman 测试外网接口
设置Postman环境变量
- 安装 PM2
npm i pm2 -g - 使用 PM2 启动、停止、重启、重载程序
启动进程：pm2 start app
停止进程：pm2 stop app
停止所有进程：pm2 stop all
重启进程：pm2 restart app
重载程序：pm2 reload app - 使用 PM2 的日志、环境变量管理功能
加环境变量：NODE_ENV=product pm2 start app --update-env
查看日志：pm2 log app
日志加上日期：NODE_ENV=product pm2 start app --update-env --log-date-format "YYYY-MM-DD HH:mm:ss"
- REST 理论与最佳实践（REST 的六个限制）
- Koa2、MongoDB、JWT简介与实践
- 仿知乎REST API实战
- REST 理论与实践
- JWT 原理及 Node.js 实现
- MongoDB Schema 设计
- RESTful API 设计参考 GitHub API v3
- 使用 GitHub 搜索 Koa2 资源
- 使用 Stack Overflow 搜索问题
- 使用企业级 Node.js 框架 —— Egg.js
- 掌握多进程编程知识
- 学习使用日志和性能监控
推荐阅读
- Node.js中readline模块实现终端输入
- Day10_要想看起来毫不费力，必须付出超乎常人的努力
- 我只在乎你（2019185）
- 孩子|孩子 的承受力超乎想象
- 开始你的第一个Echarts图表（分享自知乎网）
- 日久见人心
- 你最在乎的到底是什么（）
- 伏龙潭
- （17）20181月20日
- 起