大事件项目实战

guai_guai_guai2024-05-28 15:11

初始化

创建项目

新建api_server文件夹为项目根目录，并在项目中运行如下的命令，初始化管理配置文件：

npm init -y

运行如下的命令，安装特定版本的express:

npm i express@4.17.1

在项目根目录中新建app.js作为整个项目的入口文件，并初始化如下的代码：

javascript 复制代码 
// 导入 express
const express = require('express')
// 创建服务器的实例对象
const app = express()
// 启动服务器
app.listen(3007, () => {
  console.log('api server running at http://127.0.0.1:3007')
})

配置cors跨域（解决接口的跨越问题）

运行如下的命令，安装cors中间件：

javascript 复制代码 
npm i cors@2.8.5

在app.js中导入并配置cors中间件

javascript 复制代码 
// 导入并配置 cors 中间件
const cors = require('cors')
// 将cors注册为全局中间件
app.use(cors())

配置解析表单数据的中间件

通过如下的代码，配置解析application/x-www-form-urlencoded格式的表单数据的中间件：

javascript 复制代码 
// 配置解析表单数据的中间件，注意：这个中间件，只能解析 application/x-www-form-urlencoded 格式的表单数据
app.use(express.urlencoded({ extended: false }))

优化res.send()代码

在处理函数中，需要多次调用res.send()向客户端响应处理失败的结果，为了简化代码，可以受冻封装一个res.cc()函数

在app.js中，所有路由之前，声明一个全局中间件，为res对象挂载一个res.cc()函数

javascript 复制代码 
// 一定要在路由之前，封装 res.cc 函数
app.use((req, res, next) => {
  // status 默认值为 1，表示失败的情况
  // err 的值，可能是一个错误对象，也可能是一个错误的描述字符串
  res.cc = function (err, status = 1) {
    res.send({
      status,
      message: err instanceof Error ? err.message : err,
    })
  }
  next()
})

初始化路由相关的文件夹

在项目根目录中，新建router文件夹，用来存放所有的路由模块

路由模块中，只存放客户端的请求与处理函数之间的映射关系

在项目根目录中，新建router-handler文件夹，用来存放所有的路由处理函数模块

路由处理函数模块中，专门负责存放每个路由对应的处理函数

初始化用户路由模块

在router文件夹中，新建user.js文件，作为用户的路由模块，并初始化代码如下：

javascript 复制代码 
const express=require('express')
//创建路由对象
const router=express.Router()

//注册新用户
router.post('/reguser',(req,res)=>{
    res.send('reguser OK')
})

//登录
router.post('/login',(req,res)=>{
    res.send('login OK')
})
//将路由对象共享出去
module.exports=router

在app.js中，导入并使用用户路由模块

javascript 复制代码 
//导入并注册用户路由模块
const userRouter=require('./router/user')
app.use('/api',userRouter)//访问这个模块的路由时，必须加上前缀/api

抽离用户路由模块中的处理函数

目的:为了保证路由模块的纯粹性，所有的路由处理函数，必须抽离到对应的路由处理函数模块中

在/router_handler/user.js中，使用exports对象，分别向外共享如下两个路由处理函数：

javascript 复制代码 
//在这里定义和用户相关的路由处理函数，供/router/user.js模块进行调用

//注册用户的处理函数
exports.regUser=(req,res)=>{
    res.send('resguser OK')
}

//登录的处理函数
exports.login=(req,res)=>{
    res.send('login OK')
}

将/router/user.js中的代码修改为如下结构:

javascript 复制代码 
const express=require('express')
const router=express.Router()

//导入用户路由处理函数模块
const userHandler=require('../router_handler/user')

//注册新用户
router.post('/reguser',userHandler.regUser)
//登录
router.post('/login',userHandler.login)

module.exports=router

登陆注册

新建ev_users表

在my_db_01数据库中，新建ev_users表如下：

安装并配置mysql模块

在API接口项目中，需要安装mysql这个第三方模

块，来连接和操作MySQL数据库

运行如下命令，安装mysql模块：

javascript 复制代码 
npm i mysql@2.18.1

在项目根目录中创建/db/index.js文件，在此自定义模块中创建数据库的连接对象：

javascript 复制代码 
const mysql = require('mysql')

const db = mysql.createPool({
  host: '127.0.0.1',
  user: 'root',
  password: 'admin123',
  database: 'my_db_01',
})

module.exports = db

注册

实现步骤

检测表单数据是否合法

判断用户名和密码是否为空

javascript 复制代码 
  // 获取客户端提交到服务器的用户信息
  const userinfo = req.body
  // 对表单中的数据，进行合法性的校验
  // if (!userinfo.username || !userinfo.password) {
  //   return res.send({ status: 1, message: '用户名或密码不合法！' })
  // }

检测用户名是否被占用

导入数据库操作模块

javascript 复制代码 
// 导入数据库操作模块
const db = require('../db/index')

定义SQL语句

javascript 复制代码 
// 定义 SQL 语句，查询用户名是否被占用
  const sqlStr = 'select * from ev_users where username=?'

执行SQL语句并根据结果判断用户名是否被占用：

javascript 复制代码 
  db.query(sqlStr, userinfo.username, (err, results) => {
    // 执行 SQL 语句失败
    if (err) {
      // return res.send({ status: 1, message: err.message })
      return res.cc(err)
    }
    // 判断用户名是否被占用
    if (results.length > 0) {
      // return res.send({ status: 1, message: '用户名被占用，请更换其他用户名！' })
      return res.cc('用户名被占用，请更换其他用户名！')
    }

对密码进行加密处理

为了保证密码的安全性，不建议在数据库以明文的形式保存用户密码，推荐对密码进行加密存储

在当前项目中，使用bcryptjs对用户密码进行加密，优点：

  • 加密之后的密码，无法被逆向破解

  • 同一明文密码多次加密，得到的加密结果各不相同，保证了安全性

运行如下命令，安装指定版本的bcryptjs:

javascript 复制代码 
npm i bcryptjs@2.4.3

在/router_handler/user.js中，导入bcryptjs:

javascript 复制代码 
const bcrypt=require('bcryptjs')

在注册用户的处理函数中，确认用户名可用之后，调用bcrypt.hashSync(明文密码，随机盐的长度)方法，对用户的密码进行加密处理：

javascript 复制代码 
// 调用 bcrypt.hashSync() 对密码进行加密,返回值是加密之后的密码字符串
    userinfo.password = bcrypt.hashSync(userinfo.password, 10)

插入新用户

定义插入用户的SQL语句：

javascript 复制代码 
const sql='insert into ev_users set ?'

调用db.query()执行SQL语句，插入新用户：

javascript 复制代码 
    db.query(sql, { username: userinfo.username, password: userinfo.password }, (err, results) => {
      // 判断 SQL 语句是否执行成功
      // if (err) return res.send({ status: 1, message: err.message })
      if (err) return res.cc(err)
      // 判断影响行数是否为 1
      // if (results.affectedRows !== 1) return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
      if (results.affectedRows !== 1) return res.cc('注册用户失败，请稍后再试！')
      // 注册用户成功
      // res.send({ status: 0, message: '注册成功！' })
      res.cc('注册成功！', 0)
    })

优化表单数据验证

表单验证的原则：前端验证为辅，后端验证为主，后端永远不要相信前端提交过来的任何内容

在实际开发中，前后端都是需要对表单的数据进行合法性的验证，而且，后端作为数据合法性验证的最后一个关卡，在拦截非法数据方面，起到了至关重要的作用。

单纯使用if...else...的形式对数据合法性进行验证，效率低下，出错率高，维护性差，因此，推荐使用第三方数据验证模块 ，来降低出错率，提高验证的效率和可维护性，让后端程序员把更多的精力放在核心业务逻辑的处理上

安装@hapi.joi包，为表单中携带的每个数据项，定义验证规则：

javascript 复制代码 
npm install @hapi/joi@17.1.0

安装@escook/express-joi中间件，来实现自动对表单数据进行验证的功能

javascript 复制代码 
npm i @escook/express-joi

新建/schema/users.js用户信息验证规则模块，并初始化代码如下：

javascript 复制代码 
// 导入定义验证规则的包
const joi = require('@hapi/joi')
/**
 * string()
 * alphanum()值只能是包含a-z A-Z 0-9的字符串
 * min(length)最小长度
 * max(length)最大长度
 * required()值是必填项，不能为undefined
 * pattern(正则表达式)值必须符合正则表达式的规则
 */
// 定义用户名和密码的验证规则
const username = joi.string().alphanum().min(1).max(10).required()
const password = joi
  .string()
  .pattern(/^[\S]{6,12}$/)
  .required()

// 定义验证注册和登录表单数据的规则对象
exports.reg_login_schema = {
  //表示需要对req.body中的数据进行验证
  body: {
    username,
    password,
  },
}

router/usr.js

javascript 复制代码 
const express = require('express')
const router = express.Router()

// 导入用户路由处理函数对应的模块
const user_handler = require('../router_handler/user')

// 1. 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 2. 导入需要的验证规则对象
const { reg_login_schema } = require('../schema/user')

// 注册新用户
router.post('/reguser', expressJoi(reg_login_schema), user_handler.regUser)
// 登录
router.post('/login', user_handler.login)

module.exports = router

app.js

javascript 复制代码 
// 导入 express
const express = require('express')
// 创建服务器的实例对象
const app = express()
const joi = require('@hapi/joi')

// 导入并配置 cors 中间件
const cors = require('cors')
// 将cors注册为全局中间件
app.use(cors())

// 配置解析表单数据的中间件，注意：这个中间件，只能解析 application/x-www-form-urlencoded 格式的表单数据
app.use(express.urlencoded({ extended: false }))

// 一定要在路由之前，封装 res.cc 函数
app.use((req, res, next) => {
  // status 默认值为 1，表示失败的情况
  // err 的值，可能是一个错误对象，也可能是一个错误的描述字符串
  res.cc = function (err, status = 1) {
    res.send({
      status,
      message: err instanceof Error ? err.message : err,
    })
  }
  next()
})

// 导入并使用用户路由模块
const userRouter = require('./router/user')
app.use('/api', userRouter)

// 定义错误级别的中间件
app.use((err, req, res, next) => {
  // 验证失败导致的错误
  if (err instanceof joi.ValidationError) return res.cc(err)
  // 未知的错误
  res.cc(err)
})

// 启动服务器
app.listen(3007, () => {
  console.log('api server running at http://127.0.0.1:3007')
})

登录

实现步骤

检测表单数据是否合法

将/router/user.js中登录的路由代码修改如下：

javascript 复制代码 
// 登录
router.post('/login', expressJoi(reg_login_schema), user_handler.login)

根据用户名查询用户的数据

接收表单数据

javascript 复制代码 
const userinfo=req.body

定义SQL语句

javascript 复制代码 
const sql='select * from ev_users where username=?'

执行SQL语句，查询用户的数据

判断用户输入的密码是否正确

核心实现思路：调用bcrypt.compareSync(用户名提交的密码，数据库中的密码)方法比较密码是否一致

返回值是布尔值（true一致，false不一致）

生成JWT的Token字符串

核心注意点：在生成Token字符串的时候，一定要剔除密码和头像的值

通过ES6的高级语法，快速剔除密码和头像的值：

javascript 复制代码 
//剔除完毕之后，user中只保留了用户的id，username，nickname，email这四个属性的值
const user={...result[0],password:'',user_pic:''}

运行如下的命令，安装生成Token字符串的包：

javascript 复制代码 
npm i jsonwebtoken@8.5.1

在/router_handler/user.js模块的头部区域，导入jsonwebtoken包：

javascript 复制代码 
//用这个包来生成Token字符串
const jwt=require('josnwebtoken')

创建config.js文件，并向外共享加密和还原Token的jwtSecretKey字符串：

javascript 复制代码 
// 这是一个全局的配置文件

module.exports = {
  // 加密和解密 Token 的秘钥
  jwtSecretKey: 'itheima No1. ^_^',
  // token 的有效期
  expiresIn: '10h',
}

将用户信息对象加密成Token字符串：

javascript 复制代码 
// 导入全局的配置文件
const config = require('../config')
const user = { ...results[0], password: '', user_pic: '' }
// 对用户的信息进行加密，生成 Token 字符串
const tokenStr = jwt.sign(user, config.jwtSecretKey, { expiresIn: config.expiresIn })

将生成的Token字符串响应给客户端：

javascript 复制代码 
    res.send({
      status: 0,
      message: '登录成功！',
      token:  'Bearer ' + tokenStr,
    })
javascript 复制代码 
  // 执行 SQL 语句，根据用户名查询用户的信息
  db.query(sql, userinfo.username, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 执行 SQL 语句成功，但是获取到的数据条数不等于 1
    if (results.length !== 1) return res.cc('登录失败！')

    // TODO：判断密码是否正确
    const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)
    if (!compareResult) return res.cc('登录失败！')

    // TODO：在服务器端生成 Token 的字符串
    const user = { ...results[0], password: '', user_pic: '' }
    // 对用户的信息进行加密，生成 Token 字符串
    const tokenStr = jwt.sign(user, config.jwtSecretKey, { expiresIn: config.expiresIn })
    // 调用 res.send() 将 Token 响应给客户端
    res.send({
      status: 0,
      message: '登录成功！',
      token:  'Bearer ' + tokenStr,
    })
  })

配置解析Token的中间件

运行如下的命令，安装解析Token的中间件:

javascript 复制代码 
npm i express-jwt@5.3.3

在app.js中注册路由之前，配置解析Token的中间件：

javascript 复制代码 
// 一定要在路由之前配置解析 Token 的中间件
const expressJWT = require('express-jwt')
const config = require('./config')

app.use(expressJWT({ secret: config.jwtSecretKey }).unless({ path: [/^\/api/] }))
// 导入并使用用户信息的路由模块
const userinfoRouter = require('./router/userinfo')
app.use('/my', userinfoRouter)

// 定义错误级别的中间件
app.use((err, req, res, next) => {
  // 验证失败导致的错误
  if (err instanceof joi.ValidationError) return res.cc(err)
  // 身份认证失败后的错误
  if (err.name === 'UnauthorizedError') return res.cc('身份认证失败！')
  // 未知的错误
  res.cc(err)
})

个人中心

获取用户的基本信息

实现步骤

初始化路由模块

创建/router/userinfo.js路由模块，并初始化如下的代码结构：

javascript 复制代码 
//导入express
const express=require('express')
//创建路由对象
const router=express.Router()
//获取用户的基本信息
router.get('/userinfo',(req,res)=>{
    res.send('ok')
})
//向外共享路由对象
module.exports=router

在app.js中导入并使用个人中心的路由模块：

javascript 复制代码 
//导入并使用用户信息路由模块
const userinfoRouter=require('./router/userinfo')
//注意：以/my开头的接口，都是有权限的接口，需要进行Token身份认证
app.use('/my',userinfoRouter)

初始化路由处理函数模块

创建/router_handler/userinfo.js路由处理函数模块，并初始化如下的代码结构：

javascript 复制代码 
//获取用户基本信息的处理函数
exports.getUserInfo=(req,res)=>{
    res.send('ok')
}

修改/router/userinfo.js 中的代码如下：

javascript 复制代码 
const express=require('express')
const router=express.Router()

//导入用户信息的处理函数模块
const userInfo_handler=require('../router_handler/userinfo')

//获取用户的基本信息
router.get('/userinfo',userinfo_handler.getUserInfo)
module.exports=router

获取用户的基本信息

在/router_handler/userinfo.js头部导入数据库操作模块：

javascript 复制代码 
//导入数据库操作模块
const db=require('../db/index')

定义SQL语句：

javascript 复制代码 
//根据用户的id，查询用户的基本信息
//注意：为了防止用户的密码泄露，需要排除password字段
const sql='select id,username,nickname,email,user_pic from ev_users where id=?'

调用db.query()执行SQL语句：

javascript 复制代码 
  // 调用 db.query() 执行 SQL 语句
  //注意：req对象上的user属性，是Token解析成功，express-jwt中间件帮我们挂载上去的
  db.query(sql, req.user.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 执行 SQL 语句成功，但是查询的结果可能为空
    if (results.length !== 1) return res.cc('获取用户信息失败！')

    // 用户信息获取成功
    res.send({
      status: 0,
      message: '获取用户信息成功！',
      data: results[0],
    })
  })

更新用户的基本信息

实现步骤

定义路由和处理函数

在/router/userinfo.js模块中，新增更新用户基本信息的路由：

javascript 复制代码 
//更新用户的基本信息
router.post('/userinfo',userinfo_handler.updateUserInfo)

在/router_handler/userinfo.js模块中，定义并向外共享更新用户基本信息的路由处理函数：

javascript 复制代码 
//更新用户基本信息的处理函数
exports.updateUserInfo=(req,res)=>{
    res.send('ok')
}

验证表单数据

在/schema/user.js验证规则模块中，定义id,nickname,email的验证规则如下：

javascript 复制代码 
// 定义 id, nickname, email 的验证规则
const id = joi.number().integer().min(1).required()
const nickname = joi.string().required()
const user_email = joi.string().email().required()

并使用exports向外共享如下的验证规则对象：

javascript 复制代码 
// 验证规则对象 - 更新用户基本信息
exports.update_userinfo_schema = {
  // 需要对 req.body 里面的数据进行验证
  body: {
    id,
    nickname,
    email: user_email,
  },
}

在/router/userinfo.js模块中，导入验证数据合法性的中间件：

javascript 复制代码 
//导入验证数据合法性的中间件
const expressJoi=require('@escook/express-joi')

在/router/userinfo.js模块中，导入需要的验证规则对象：

javascript 复制代码 
//导入需要的验证规则对象
const {update_userinfo_schema}=require('../schema/user')

在/router/userinfo.js模块中，修改更新用户的基本信息的路由如下：

javascript 复制代码 
//更新用户的基本信息
router.post('userinfo',expressJoi(update_userinfo_schema),userinfo_handler_updateUserInfo)

实现更新用户基本信息的功能

定义待执行的SQL语句：

javascript 复制代码 
const sql='update ev_users set ? where id=?'

调用db.query()执行SQL语句并传参：

javascript 复制代码 
  db.query(sql, [req.body, req.body.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 执行 SQL 语句成功，但是影响行数不等于 1
    if (results.affectedRows !== 1) return res.cc('更新用户的基本信息失败！')
    // 成功
    res.cc('更新用户信息成功！', 0)
  })

重置密码

定义路由和处理函数

在/router/userinfo.js模块中，新增重置密码的路由

javascript 复制代码 
//重置密码的路由
router.post('.updatepwd',userinfo_handler.updatePassword)

在/router_handler/userinfo.js模块中，定义并向外共享重置密码的路由处理函数

javascript 复制代码 
//重置密码的处理函数
exports.updatePassword=(req,res)=>{
    res.send('ok')
}

验证表单数据

在/schema/user.js模块中，使用exports向外共享如下的验证规则对象：

javascript 复制代码 
// 验证规则对象 - 更新密码
exports.update_password_schema = {
  body: {
    // 使用password这个规则，验证req.body.oldPwd的值
    oldPwd: password,
    // 使用joi.not(joi.ref('oldPwd')).concat(password)规则，验证req.body.newPwd的值
    // 解读：
    // joi.ref('oldPwd')表示newPwd的值必须和oldPwd的值保持一致
    // joi.not(joi.ref('oldPwd'))表示newPwd的值不能等于oldPwd的值
    // .concat()用于合并joi.not(joi.ref('oldPwd'))和password这两条验证规则
    newPwd: joi.not(joi.ref('oldPwd')).concat(password),
  },
}

在/router/userinfo.js模块中，导入需要的验证规则对象：

javascript 复制代码 
// 导入需要的验证规则对象
const { update_userinfo_schema, update_password_schema, update_avatar_schema } = require('../schema/user')

并在重置密码的路由中，使用update_pas sword_schema规则验证表单的数据，示例代码如下：

javascript 复制代码 
// 更新密码的路由
router.post('/updatepwd', expressJoi(update_password_schema), userinfo_handler.updatePassword)

实现重置密码的功能

根据id查询用户是否存在

判断提交的旧密码是否正确

对新密码进行bcrypt加密之后，更新到数据库中

javascript 复制代码 
// 更新用户密码的处理函数
exports.updatePassword = (req, res) => {
  // 根据 id 查询用户的信息
  const sql = `select * from ev_users where id=?`
  // 执行根据 id 查询用户的信息的 SQL 语句
  db.query(sql, req.user.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 判断结果是否存在
    if (results.length !== 1) return res.cc('用户不存在！')

    // 判断密码是否正确
    const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
    if (!compareResult) return res.cc('旧密码错误！')

    // 定义更新密码的 SQL 语句
    const sql = `update ev_users set password=? where id=?`
    // 对新密码进行加密处理
    const newPwd = bcrypt.hashSync(req.body.newPwd, 10)
    // 调用 db.query() 执行 SQL 语句
    db.query(sql, [newPwd, req.user.id], (err, results) => {
      // 执行 SQL 语句失败
      if (err) return res.cc(err)
      // 判断影响的行数
      if (results.affectedRows !== 1) return res.cc('更新密码失败！')
      // 成功
      res.cc('更新密码成功', 0)
    })
  })
}

更换头像

定义路由和处理函数

在/router/userinfo.js模块中，新增更新用户头像的路由：

javascript 复制代码 
//更新用户头像的路由
router.post('/update/avatar',userinfo_handler.updateAvatar)

在/route_handler/userinfo.js模块中，定义并向外共享更新用户头像的路由处理函数

验证表单数据

在/schema/user.js验证规则模块中，定义avatar的验证规则如下：

javascript 复制代码 
// 定义验证 avatar 头像的验证规则
// dataUri()指的值如下格式的字符串数据
// data:image/png;base64,VE9PTFOWVNFQ1JFVFM=
const avatar = joi.string().dataUri().required()

并使用exports向外共享如下的验证规则对象：

javascript 复制代码 
// 验证规则对象 - 更新头像
exports.update_avatar_schema = {
  body: {
    avatar
  }
}

在/router/userinfo.js模块中，导入需要的验证规则对象

javascript 复制代码 
// 更换头像的路由
router.post('/update/avatar', expressJoi(update_avatar_schema), userinfo_handler.updateAvatar)

实现更新用户头像的功能

定义更新用户头像的SQL语句

调用db.query()执行SQL语句，更新对应用户的头像

javascript 复制代码 
// 更新用户头像的处理函数
exports.updateAvatar = (req, res) => {
  // 1. 定义更新头像的 SQL 语句
  const sql = `update ev_users set user_pic=? where id=?`
  // 2. 调用 db.query() 执行 SQL 语句
  db.query(sql, [req.body.avatar, req.user.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 影响的行数是否等于 1
    if (results.affectedRows !== 1) return res.cc('更换头像失败！')
    // 成功
    res.cc('更换头像成功！', 0)
  })
}

文章分类管理

新建 ev_article_cate 表

创建表结构

新增两条初始数据

获取文章分类列表

实现步骤

1. 初始化路由模块
  1. 创建 `/router/artcate.js` 路由模块，并初始化如下的代码结构：
javascript 复制代码 
// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()
// 获取文章分类的列表数据
router.get('/cates', (req, res) => {
  res.send('ok')
})
// 向外共享路由对象
module.exports = router
  1. 在 `app.js` 中导入并使用文章分类的路由模块：
javascript 复制代码 
// 导入并使用文章分类路由模块
const artCateRouter = require('./router/artcate')
// 为文章分类的路由挂载统一的访问前缀 /my/article
app.use('/my/article', artCateRouter)
2. 初始化路由处理函数模块
  1. 创建 `/router_handler/artcate.js` 路由处理函数模块，并初始化如下的代码结构：
javascript 复制代码 
// 获取文章分类列表数据的处理函数
exports.getArticleCates = (req, res) => {
  res.send('ok')
}
  1. 修改 `/router/artcate.js` 中的代码如下：
javascript 复制代码 
const express = require('express')
const router = express.Router()
// 导入文章分类的路由处理函数模块
const artcate_handler = require('../router_handler/artcate')
// 获取文章分类的列表数据
router.get('/cates', artcate_handler.getArticleCates)
module.exports = router
3. 获取文章分类列表数据
  1. 在 `/router_handler/artcate.js` 头部导入数据库操作模块：
javascript 复制代码 
// 导入数据库操作模块
const db = require('../db/index')
  1. 定义 SQL 语句：
javascript 复制代码 
// 根据分类的状态，获取所有未被删除的分类列表数据
// is_delete 为 0 表示没有被 标记为删除 的数据
const sql = 'select * from ev_article_cate where is_delete=0 order by id asc'
  1. 调用 `db.query()` 执行 SQL 语句：
javascript 复制代码 
db.query(sql, (err, results) => {
  // 1. 执行 SQL 语句失败
  if (err) return res.cc(err)
  // 2. 执行 SQL 语句成功
  res.send({
    status: 0,
    message: '获取文章分类列表成功！',
    data: results,
  })
})

新增文章分类

实现步骤

  1. 定义路由和处理函数

  2. 验证表单数据

  3. 查询 `分类名称` 与 `分类别名` 是否被占用

  4. 实现新增文章分类的功能

定义路由和处理函数

  1. 在 `/router/artcate.js` 模块中，添加 `新增文章分类` 的路由：
javascript 复制代码 
// 新增文章分类的路由
router.post('/addcates', artcate_handler.addArticleCates)
  1. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `新增文章分类` 的路由处理函数：
javascript 复制代码 
// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 创建 `/schema/artcate.js` 文章分类数据验证模块，并定义如下的验证规则：
javascript 复制代码 
// 导入定义验证规则的模块
const joi = require('@hapi/joi')
// 定义 分类名称 和 分类别名 的校验规则
const name = joi.string().required()
const alias = joi.string().alphanum().required()
// 校验规则对象 - 添加分类
exports.add_cate_schema = {
  body: {
    name,
    alias,
  },
}
  1. 在 `/router/artcate.js` 模块中，使用 `add_cate_schema` 对数据进行验证：
javascript 复制代码 
// 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 导入文章分类的验证模块
const { add_cate_schema } = require('../schema/artcate')
// 新增文章分类的路由
router.post('/addcates', expressJoi(add_cate_schema), artcate_handler.addArticleCates)

查询分类名称与别名是否被占用

  1. 定义查重的 SQL 语句：
javascript 复制代码 
// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where name=? or alias=?`
  1. 调用 `db.query()` 执行查重的操作：
javascript 复制代码 
// 执行查重操作
db.query(sql, [req.body.name, req.body.alias], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // 判断 分类名称 和 分类别名 是否被占用
  if (results.length === 2) return res.cc('分类名称与别名被占用，请更换后重试！')
  // 分别判断 分类名称 和 分类别名 是否被占用
  if (results.length === 1 && results[0].name === req.body.name) return res.cc('分类名称被占用，请更换后重试！')
  if (results.length === 1 && results[0].alias === req.body.alias) return res.cc('分类别名被占用，请更换后重试！')
  // TODO：新增文章分类
})

实现新增文章分类的功能

  1. 定义新增文章分类的 SQL 语句：
javascript 复制代码 
const sql = `insert into ev_article_cate set ?`
  1. 调用 `db.query()` 执行新增文章分类的 SQL 语句：
javascript 复制代码 
db.query(sql, req.body, (err, results) => {
  // SQL 语句执行失败
  if (err) return res.cc(err)
  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('新增文章分类失败！')
  // 新增文章分类成功
  res.cc('新增文章分类成功！', 0)
})

根据 Id 删除文章分类

实现步骤

  1. 定义路由和处理函数

  2. 验证表单数据

  3. 实现删除文章分类的功能

定义路由和处理函数

  1. 在 `/router/artcate.js` 模块中，添加 `删除文章分类` 的路由：
javascript 复制代码 
// 删除文章分类的路由
router.get('/deletecate/:id', artcate_handler.deleteCateById)
  1. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `删除文章分类` 的路由处理函数：
javascript 复制代码 
// 删除文章分类的处理函数
exports.deleteCateById = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 `/schema/artcate.js` 验证规则模块中，定义 id 的验证规则如下：
javascript 复制代码 
// 定义 分类Id 的校验规则
const id = joi.number().integer().min(1).required()
  1. 并使用 `exports` 向外共享如下的 `验证规则对象`：
javascript 复制代码 
// 校验规则对象 - 删除分类
exports.delete_cate_schema = {
  params: {
    id,
  },
}
  1. 在 `/router/artcate.js` 模块中，导入需要的验证规则对象，并在路由中使用：
javascript 复制代码 
// 导入删除分类的验证规则对象
const { delete_cate_schema } = require('../schema/artcate')
// 删除文章分类的路由
router.get('/deletecate/:id', expressJoi(delete_cate_schema), artcate_handler.deleteCateById)

实现删除文章分类的功能

  1. 定义删除文章分类的 SQL 语句：
javascript 复制代码 
const sql = `update ev_article_cate set is_delete=1 where id=?`
  1. 调用 `db.query()` 执行删除文章分类的 SQL 语句：
javascript 复制代码 
db.query(sql, req.params.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('删除文章分类失败！')
  // 删除文章分类成功
  res.cc('删除文章分类成功！', 0)
})

根据 Id 获取文章分类数据

实现步骤

  1. 定义路由和处理函数

  2. 验证表单数据

  3. 实现获取文章分类的功能

定义路由和处理函数

  1. 在 `/router/artcate.js` 模块中，添加 `根据 Id 获取文章分类` 的路由：
javascript 复制代码 
router.get('/cates/:id', artcate_handler.getArticleById)
  1. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `根据 Id 获取文章分类` 的路由处理函数：
javascript 复制代码 
// 根据 Id 获取文章分类的处理函数
exports.getArticleById = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 `/schema/artcate.js` 验证规则模块中，使用 `exports` 向外共享如下的 `验证规则对象`：
javascript 复制代码 
// 校验规则对象 - 根据 Id 获取分类
exports.get_cate_schema = {
  params: {
    id,
  },
}
  1. 在 `/router/artcate.js` 模块中，导入需要的验证规则对象，并在路由中使用：
javascript 复制代码 
// 导入根据 Id 获取分类的验证规则对象
const { get_cate_schema } = require('../schema/artcate')
// 根据 Id 获取文章分类的路由
router.get('/cates/:id', expressJoi(get_cate_schema), artcate_handler.getArticleById)

实现获取文章分类的功能

  1. 定义根据 Id 获取文章分类的 SQL 语句：
javascript 复制代码 
const sql = `select * from ev_article_cate where id=?`
  1. 调用 `db.query()` 执行 SQL 语句：
javascript 复制代码 
db.query(sql, req.params.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // SQL 语句执行成功，但是没有查询到任何数据
  if (results.length !== 1) return res.cc('获取文章分类数据失败！')
  // 把数据响应给客户端
  res.send({
    status: 0,
    message: '获取文章分类数据成功！'
    data: results[0],
  })
})

根据 Id 更新文章分类数据

实现步骤

  1. 定义路由和处理函数

  2. 验证表单数据

  3. 查询 `分类名称` 与 `分类别名` 是否被占用

  4. 实现更新文章分类的功能

定义路由和处理函数

  1. 在 `/router/artcate.js` 模块中，添加 `更新文章分类` 的路由：
javascript 复制代码 
// 更新文章分类的路由
router.post('/updatecate', artcate_handler.updateCateById)
  1. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `更新文章分类` 的路由处理函数：
javascript 复制代码 
// 更新文章分类的处理函数
exports.updateCateById = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 `/schema/artcate.js` 验证规则模块中，使用 `exports` 向外共享如下的 `验证规则对象`：
javascript 复制代码 
// 校验规则对象 - 更新分类
exports.update_cate_schema = {
  body: {
    Id: id,
    name,
    alias,
  },
}
  1. 在 `/router/artcate.js` 模块中，导入需要的验证规则对象，并在路由中使用：
javascript 复制代码 
// 导入更新文章分类的验证规则对象
const { update_cate_schema } = require('../schema/artcate')
// 更新文章分类的路由
router.post('/updatecate', expressJoi(update_cate_schema), artcate_handler.updateCateById)

查询分类名称与别名是否被占用

  1. 定义查重的 SQL 语句：
javascript 复制代码 
// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where Id<>? and (name=? or alias=?)`
  1. 调用 `db.query()` 执行查重的操作：
javascript 复制代码 
// 执行查重操作
db.query(sql, [req.body.Id, req.body.name, req.body.alias], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // 判断 分类名称 和 分类别名 是否被占用
  if (results.length === 2) return res.cc('分类名称与别名被占用，请更换后重试！')
  if (results.length === 1 && results[0].name === req.body.name) return res.cc('分类名称被占用，请更换后重试！')
  if (results.length === 1 && results[0].alias === req.body.alias) return res.cc('分类别名被占用，请更换后重试！')
  // TODO：更新文章分类
})

实现更新文章分类的功能

  1. 定义更新文章分类的 SQL 语句：
javascript 复制代码 
const sql = `update ev_article_cate set ? where Id=?`
  1. 调用 `db.query()` 执行 SQL 语句：
javascript 复制代码 
db.query(sql, [req.body, req.body.Id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新文章分类失败！')
  // 更新文章分类成功
  res.cc('更新文章分类成功！', 0)
})
相关推荐
余生H33 分钟前
前端的全栈混合之路Meteor篇：关于前后端分离及与各框架的对比
前端·javascript·node.js·全栈
Ink1 小时前
从底层看 path.resolve 实现
前端·node.js
奔跑吧邓邓子4 小时前
npm包管理深度探索：从基础到进阶全面教程！
前端·npm·node.js
笑非不退10 小时前
前端框架对比和选择
前端框架
知否技术15 小时前
为什么nodejs成为后端开发者的新宠？
前端·后端·node.js
ZhongruiRao16 小时前
Springboot+PostgreSQL+MybatisPlus存储JSON或List、数组（Array）数据
spring boot·postgresql·json
华农第一蒟蒻16 小时前
Java中JWT（JSON Web Token）的运用
java·前端·spring boot·json·token
王小二(海阔天空)17 小时前
个人文章合集 - 前端相关
前端·css·vue·jquery
胡耀超17 小时前
知识图谱入门——8: KG开发常见数据格式：OWL、RDF、XML、GraphML、JSON、CSV。
xml·json·知识图谱·csv·owl·graphml·gml
谢尔登20 小时前
【Node.js】worker_threads 多线程
node.js
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache