大事件项目实战

初始化

创建项目

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

npm init -y

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

npm i express@4.17.1

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

// 导入 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中间件：

npm i cors@2.8.5

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

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

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

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

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

 优化res.send()代码

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

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

// 一定要在路由之前，封装 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文件，作为用户的路由模块，并初始化代码如下：

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中，导入并使用用户路由模块

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

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

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

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

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

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

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

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

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模块：

npm i mysql@2.18.1

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

const mysql = require('mysql')

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

module.exports = db

注册

实现步骤

  • 检测表单数据是否合法

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

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

  • 检测用户名是否被占用

导入数据库操作模块

// 导入数据库操作模块
const db = require('../db/index')

定义SQL语句

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

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

  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:

npm i bcryptjs@2.4.3

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

const bcrypt=require('bcryptjs')

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

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

  • 插入新用户

定义插入用户的SQL语句：

const sql='insert into ev_users set ?'

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

    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包，为表单中携带的每个数据项，定义验证规则：

npm install @hapi/joi@17.1.0

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

npm i @escook/express-joi

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

// 导入定义验证规则的包
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

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

// 导入 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中登录的路由代码修改如下：

// 登录
router.post('/login', expressJoi(reg_login_schema), user_handler.login)

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

接收表单数据

const userinfo=req.body

定义SQL语句

const sql='select * from ev_users where username=?'

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

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

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

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

  • 生成JWT的Token字符串

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

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

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

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

npm i jsonwebtoken@8.5.1

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

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

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

// 这是一个全局的配置文件

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

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

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

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

    res.send({
      status: 0,
      message: '登录成功！',
      token:  'Bearer ' + tokenStr,
    })
  // 执行 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的中间件:

npm i express-jwt@5.3.3

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

// 一定要在路由之前配置解析 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路由模块，并初始化如下的代码结构：

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

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

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

  • 初始化路由处理函数模块

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

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

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

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头部导入数据库操作模块：

//导入数据库操作模块
const db=require('../db/index')

定义SQL语句：

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

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

  // 调用 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模块中，新增更新用户基本信息的路由：

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

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

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

验证表单数据

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

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

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

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

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

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

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

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

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

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

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

定义待执行的SQL语句：

const sql='update ev_users set ? where id=?'

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

  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模块中，新增重置密码的路由

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

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

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

验证表单数据

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

// 验证规则对象 - 更新密码
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模块中，导入需要的验证规则对象：

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

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

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

实现重置密码的功能

根据id查询用户是否存在

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

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

// 更新用户密码的处理函数
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模块中，新增更新用户头像的路由：

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

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

验证表单数据

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

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

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

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

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

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

实现更新用户头像的功能

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

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

// 更新用户头像的处理函数
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` 路由模块，并初始化如下的代码结构：

// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()
// 获取文章分类的列表数据
router.get('/cates', (req, res) => {
  res.send('ok')
})
// 向外共享路由对象
module.exports = router

2. 在 `app.js` 中导入并使用文章分类的路由模块：

// 导入并使用文章分类路由模块
const artCateRouter = require('./router/artcate')
// 为文章分类的路由挂载统一的访问前缀 /my/article
app.use('/my/article', artCateRouter)
2. 初始化路由处理函数模块

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

// 获取文章分类列表数据的处理函数
exports.getArticleCates = (req, res) => {
  res.send('ok')
}

2. 修改 `/router/artcate.js` 中的代码如下：

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` 头部导入数据库操作模块：

// 导入数据库操作模块
const db = require('../db/index')

2. 定义 SQL 语句：

// 根据分类的状态，获取所有未被删除的分类列表数据
// is_delete 为 0 表示没有被 标记为删除 的数据
const sql = 'select * from ev_article_cate where is_delete=0 order by id asc'

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

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` 模块中，添加 `新增文章分类` 的路由：

// 新增文章分类的路由
router.post('/addcates', artcate_handler.addArticleCates)

2. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `新增文章分类` 的路由处理函数：

// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  res.send('ok')
}

验证表单数据

1. 创建 `/schema/artcate.js` 文章分类数据验证模块，并定义如下的验证规则：

// 导入定义验证规则的模块
const joi = require('@hapi/joi')
// 定义 分类名称 和 分类别名 的校验规则
const name = joi.string().required()
const alias = joi.string().alphanum().required()
// 校验规则对象 - 添加分类
exports.add_cate_schema = {
  body: {
    name,
    alias,
  },
}

2. 在 `/router/artcate.js` 模块中，使用 `add_cate_schema` 对数据进行验证：

// 导入验证数据的中间件
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 语句：

// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where name=? or alias=?`

2. 调用 `db.query()` 执行查重的操作：

// 执行查重操作
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 语句：

const sql = `insert into ev_article_cate set ?`

2. 调用 `db.query()` 执行新增文章分类的 SQL 语句：

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` 模块中，添加 `删除文章分类` 的路由：

// 删除文章分类的路由
router.get('/deletecate/:id', artcate_handler.deleteCateById)

2. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `删除文章分类` 的路由处理函数：

// 删除文章分类的处理函数
exports.deleteCateById = (req, res) => {
  res.send('ok')
}

验证表单数据

1. 在 `/schema/artcate.js` 验证规则模块中，定义 id 的验证规则如下：

// 定义 分类Id 的校验规则
const id = joi.number().integer().min(1).required()

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

// 校验规则对象 - 删除分类
exports.delete_cate_schema = {
  params: {
    id,
  },
}

3. 在 `/router/artcate.js` 模块中，导入需要的验证规则对象，并在路由中使用：

// 导入删除分类的验证规则对象
const { delete_cate_schema } = require('../schema/artcate')
// 删除文章分类的路由
router.get('/deletecate/:id', expressJoi(delete_cate_schema), artcate_handler.deleteCateById)

实现删除文章分类的功能

1. 定义删除文章分类的 SQL 语句：

const sql = `update ev_article_cate set is_delete=1 where id=?`

2. 调用 `db.query()` 执行删除文章分类的 SQL 语句：

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 获取文章分类` 的路由：

router.get('/cates/:id', artcate_handler.getArticleById)

2. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `根据 Id 获取文章分类` 的路由处理函数：

// 根据 Id 获取文章分类的处理函数
exports.getArticleById = (req, res) => {
  res.send('ok')
}

验证表单数据

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

// 校验规则对象 - 根据 Id 获取分类
exports.get_cate_schema = {
  params: {
    id,
  },
}

2. 在 `/router/artcate.js` 模块中，导入需要的验证规则对象，并在路由中使用：

// 导入根据 Id 获取分类的验证规则对象
const { get_cate_schema } = require('../schema/artcate')
// 根据 Id 获取文章分类的路由
router.get('/cates/:id', expressJoi(get_cate_schema), artcate_handler.getArticleById)

实现获取文章分类的功能

1. 定义根据 Id 获取文章分类的 SQL 语句：

const sql = `select * from ev_article_cate where id=?`

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

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` 模块中，添加 `更新文章分类` 的路由：

// 更新文章分类的路由
router.post('/updatecate', artcate_handler.updateCateById)

2. 在 `/router_handler/artcate.js` 模块中，定义并向外共享 `更新文章分类` 的路由处理函数：

// 更新文章分类的处理函数
exports.updateCateById = (req, res) => {
  res.send('ok')
}

验证表单数据

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

// 校验规则对象 - 更新分类
exports.update_cate_schema = {
  body: {
    Id: id,
    name,
    alias,
  },
}

2. 在 `/router/artcate.js` 模块中，导入需要的验证规则对象，并在路由中使用：

// 导入更新文章分类的验证规则对象
const { update_cate_schema } = require('../schema/artcate')
// 更新文章分类的路由
router.post('/updatecate', expressJoi(update_cate_schema), artcate_handler.updateCateById)

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

1. 定义查重的 SQL 语句：

// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where Id<>? and (name=? or alias=?)`

2. 调用 `db.query()` 执行查重的操作：

// 执行查重操作
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 语句：

const sql = `update ev_article_cate set ? where Id=?`

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

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)
})

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/649798.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

深入探索C++模板进阶：掌握非类型参数、特化技巧与分离编译的艺术

深入探索C++模板进阶：掌握非类型参数、特化技巧与分离编译的艺术

目录 非类型模板参数 类模板的特化 概念 函数模板特化 类模板特化 全特化 偏特化 类模板特化应用示例 模板的分离编译 分离编译概念 模板的分离编译 解决方法 模板总结 非类型模板参数 模板参数可分为类型形参和非类型形参。 类型形参&#xff1a; 出现在模板参数列表中&am…
阅读更多...
韬光养晦的超绝项目

韬光养晦的超绝项目

发展方向 竞技闯关类 可以加入对战系统积累积分&#xff0c;竞技类的接受程度更高&#xff0c;小孩&#xff08;我和我身边大多数人小时候&#xff09;都喜欢玩王者吃鸡这种经济类游戏&#xff0c;开放世界探索&#xff08;本项目、一梦江湖、逆水寒&#xff09;的受众群体年…
阅读更多...
8. C++通过epoll+fork的方式实现高性能网络服务器

8. C++通过epoll+fork的方式实现高性能网络服务器

epollfork 实现高性能网络服务器 一般在服务器上&#xff0c;CPU是多核的&#xff0c;上述epoll实现方式只使用了其中的一个核&#xff0c;造成了资源的大量浪费。因此我们可以将epoll和fork结合来实现更高性能的网络服务器。 创建子进程函数–fork( ) 要了解线程我们先来了解…
阅读更多...
Linux下Qt Creator无法输入中文（已解决）

Linux下Qt Creator无法输入中文（已解决）

1. 首先确保安装了搜狗输入法&#xff0c;且能正常运行。 2.克隆源码到本地。 git clone https://gitcode.com/fcitx/fcitx-qt5.git 3.检查Qt Creator版本&#xff0c;如下图所示&#xff0c;为基于Qt6的。 4. 进入源码目录&#xff0c;建立build文件夹&#xff0c;修改CMak…
阅读更多...
COD20使命召唤20新赛季免费玩 COD20免费体验在哪下

COD20使命召唤20新赛季免费玩 COD20免费体验在哪下

使命召唤20&#xff08;COD20&#xff09;的免费周已经正式启动&#xff0c;这是一个为期一周的特别活动&#xff0c;为玩家们带来了前所未有的游戏体验。在这个特殊的周期里&#xff0c;多人模式和僵尸模式将向公众免费开放&#xff0c;玩家们可以尽情地探索和体验游戏的精彩内…
阅读更多...
2022全国大学生数学建模竞赛ABC题（论文+代码）

2022全国大学生数学建模竞赛ABC题（论文+代码）

文章目录 &#xff08;1&#xff09;2022A波浪能最大输出功率&#xff08;2&#xff09;2022B无人机定位&#xff08;3&#xff09;2022C古代玻璃制品成分分析&#xff08;4&#xff09;论文和代码链接 &#xff08;1&#xff09;2022A波浪能最大输出功率 &#xff08;2&#x…
阅读更多...
3D开发工具HOOPS在BIM系统中的应用

3D开发工具HOOPS在BIM系统中的应用

建筑信息模型是一种革命性的建筑设计、施工和管理方法。它通过创建和利用数字信息来优化建筑项目的设计、施工和运营过程。在这个过程中&#xff0c;3D开发工具HOOPS扮演着至关重要的角色&#xff0c;为BIM系统提供了强大的技术支持和丰富的功能。HOOPS中文网http://techsoft3d…
阅读更多...
Linux如何在目录下灵活创建、浏览、删除百万个文件

Linux如何在目录下灵活创建、浏览、删除百万个文件

文章目录 一、创建百万级小文件1、单核CPU情况2、多核CPU情况3、执行效率对比3.1、单核的顺序执行3.2、多核的并发执行 二、如何列出/浏览这些文件1、查看目录下文件的数量2、列出&#xff1f;3、ls -f&#xff08;关闭排序功能&#xff09;3.1、执行效率对比 4、通过重定向导入…
阅读更多...
探索Python函数参数的奥秘

探索Python函数参数的奥秘

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、揭开函数参数的神秘面纱 1. 位置参数&#xff1a;按序传值的基石 2. 关键字参数&#…
阅读更多...
作业-day-240527

作业-day-240527

Cday1思维导图 定义自己的命名空间my_sapce&#xff0c;在my_sapce中定义string类型的变量s1&#xff0c;再定义一个函数完成对字符串的逆置 #include <iostream>using namespace std;namespace my_space {string s1"abc123";string recover(string s){int i0…
阅读更多...
C语言基础——数组

C语言基础——数组

{\▁/} ( / 。\ ) / ⊃&#x1f494;\⊃ 为什么我那么努力还是得不到那么多赞 ʕ • ᴥ • ʔ づ♡ど &#x1f389; 欢迎点赞支持&#x1f389; 个人主页&#xff1a;励志不掉头发的内向程序员&#xff1b; 专栏主页&#xff1a;C语言基础&#xff1b; 文章目录 前言…
阅读更多...
Spring AOP失效的场景事务失效的场景

Spring AOP失效的场景事务失效的场景

场景一&#xff1a;使用this调用被增强的方法 下面是一个类里面的一个增强方法 Service public class MyService implements CommandLineRunner {private MyService myService;public void performTask(int x) {System.out.println("Executing performTask method&quo…
阅读更多...
【软件测试】bug篇|软件测试的生命周期|描述bug的要素|bug的级别|bug的生命周期|高频面试题：与开发产⽣争执怎么处理

【软件测试】bug篇|软件测试的生命周期|描述bug的要素|bug的级别|bug的生命周期|高频面试题：与开发产⽣争执怎么处理

目录 一、软件测试的⽣命周期 二、BUG 2.1 bug的概念 2.2 描述bug的要素 2.3 bug级别 2.4 bug的⽣命周期 &#x1f4a1;2.5 与开发产⽣争执怎么办&#xff08;⾼频考题&#xff09; &#x1f4a1; 推荐 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&…
阅读更多...
java对象的比较

java对象的比较

一.PriorityQueue中插入对象 优先级队列在插入元素时有个要求&#xff1a;插入的元素不能是null或者元素之间必须要能够进行比较&#xff0c;那优先级队列中能否插入自定义类型对象呢&#xff1f; 堆中插入元素时&#xff0c;必须要进行元素的比较&#xff0c;而此时Card是没有…
阅读更多...
Java入门-java的集合框架

Java入门-java的集合框架

集合概念 集合&#xff0c;有时也称作容器(Container), 是对象的持有者&#xff0c;它们可以有助于高效访问的方式存储的组织对象。以生活中的案例为例&#xff1a; 集合就像装衣服的柜子&#xff0c;衣服就是集合中的元素。 集合框架图 Collection中每次操作的都是一个对象&a…
阅读更多...
智慧林业云巡平台 客户端和移动端（支持语音和视频）自动定位巡护，后端离线路线监测

智慧林业云巡平台 客户端和移动端（支持语音和视频）自动定位巡护，后端离线路线监测

目前现状 无法客观、方便地掌握护林员的到位情况&#xff0c;因而无法有效地保证巡护人员按计划要求&#xff0c;按时按周期对所负责的林区开展巡护&#xff0c;使巡护工作的质量得不到保证。遇到火情、乱砍滥伐等灾情时无法及时上报处理&#xff0c;现场状况、位置等信息描述…
阅读更多...
pycharm打开服务器（linux）上的项目

pycharm打开服务器（linux）上的项目

先在本地打开项目 一、项目文件配置 tools-deployment-configuration 新增一个sftp连接 测试服务器是否可以连通 mappings中设置本地路径和服务器上的路径 二、环境配置 先参考文章 复现论文的conda环境&#xff08;win和联网、离线linux&#xff09;_conda复现环境-CSDN博…
阅读更多...
Qt pro工程文件编写汇总（区分debug和release、32位和64位的方法，编译输出目录等）

Qt pro工程文件编写汇总（区分debug和release、32位和64位的方法，编译输出目录等）

前言&#xff1a; 从事qt开发已经好几年了&#xff0c;但有关pro编写的一些细节问题一直没有一个很好的梳理汇总——因为实际工作开发中&#xff0c;往往只需要编译特定版本的软件&#xff08;例如32位release版本&#xff09;&#xff0c;项目创建好后并设置好编译路径&#x…
阅读更多...
美团Java社招面试题真题，最新面试题

美团Java社招面试题真题，最新面试题

如何处理Java中的内存泄露&#xff1f; 1、识别泄露&#xff1a; 使用内存分析工具&#xff08;如Eclipse Memory Analyzer Tool、VisualVM&#xff09;来识别内存泄露的源头。 2、代码审查&#xff1a; 定期进行代码审查&#xff0c;关注静态集合类属性和监听器注册等常见内…
阅读更多...
逻辑分析仪的调试使用

逻辑分析仪的调试使用

调试软件下载&#xff1a;点击跳转 一、接线 逻辑分析仪 设备 GND --- GND CHX&#xff08;数据通道&#xff09; --- 通信引脚 二、数据采集 图中两个可以选择数字大小的地方分别表示 采样深度 &#xff08;10M Samples&a…
阅读更多...
最新文章

Copyright @ 2022~2023