大事件项目api_server

已于 2024-08-10 15:15:57 修改
阅读量678 收藏 19
点赞数 17
文章标签： node.js
于 2024-08-10 15:14:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_50680057/article/details/140891747
版权

1. 初始化

1.1 创建项目

  1. 新建api_server文件夹作为项目根目录，并在项目根目录中运行如下的命令，初始化包管理配置文件：
npm init -y
  1. 运行如下的命令，安装特定版本的express
npm i express@4.17.1
  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");
});

1.2 配置cors跨域

  1. 运行如下的命令，安装cors中间件：
npm i cors@2.8.5
  1. 在app.js中导入并配置cors中间件：
// 导入cors中间件
const cors = require('cors')
// 将cors注册为全局中间件
app.use(cors())

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

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

1.4 初始化路由相关的文件夹

  1. 在项目根目录中，新建router文件夹，用来存放所有的路由模块
    路由模块中，值存放客户端的请求与处理函数之间映射关系
  2. 在项目根目录中，新建router_handler文件夹，用来存放所有的路由处理函数模块
    路由处理函数模块中，专门负责存放每个路由对应的处理函数

1.5 初始化用户路由模块
3. 在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;

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

  1. 在/router_handler/user.js中，使用exports对象，分别向外共享如下两个路由处理函数：
/**
* 在这里定义和用户相关的路由处理函数，供/router/user.js模块进行调用
*/

// 注册用户的处理函数
exports.regUser = (req, res) => {
  res.send("reguser ok");
};

// 登录的处理函数
exports.login = (req, res) => {
  res.send("login ok");
};
  1. 将/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;

2. 登录注册

2.1 新建ev_users表

  1. 在my_db_01数据库中，新建ev_users表如下：
    在这里插入图片描述
    2.2 安装并配置mysql模块
    在API接口项目中，需要安装并配置mysql这个第三方模块，来连接和操作MySQL数据库
  2. 运行如下命令安装mysql模块
npm i mysql@2.18.1
  1. 在项目根目录中新建/db/index.js文件，在此自定义模块中创建数据库的连接对象：
// 导入mysql模块
const mysql = require('mysql')

// 创建数据库连接对象
const db = mysql.createPool({
    host: '127.0.0.1',
    user: 'root',
    password: 'admin123',
    database: 'my_db_01'
})

// 向外共享db数据库连接对象
module.exports = db

2.3 注册

2.3.0 实现步骤

  1. 检测表单数据是否合法
  2. 检测用户名是否被占用
  3. 对密码进行加密处理
  4. 插入新用户

2.3.1 检测表单数据是否合法
5. 判断用户名和密码是否为空

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

2.3.2 检测用户名是否被占用

  1. 导入数据库从操作模块
const db = require('../db/index')
  1. 定义SQL语句
  const sqlStr = 'select * from ev_users where username = ?'
  1. 执行SQL语句并根据结果判断用户名是否被占用：
 db.query(sqlStr,userinfo.username,(err,results)=>{
    // 执行SQL语句失败
    if(err){
      return res.send({status:1,message:err.message})
    }
    // 判断用户名是否被占用
    if(results.length>0){
      return res.send({status:1,message:'用户名被占用，请更换其他用户名！'})
    }
    // TODO：用户名可以使用
  })

2.3.3 对密码进行加密处理
为了保证密码的安全性，不建议在数据库以明文的形式保存用户密码，推荐对密码进行加密存储
在当前项目中，使用bcrypt对用户密码进行加密，优点：
加密之后的密码，无法被逆向破解
同一明文密码多次加密，得到的加密结果各不相同，保证了安全性

  1. 运行如下命令，安装指定版本的bcryptjs：
npm i bcryptjs@2.4.3
  1. 在/router_handler/user.js中，导入bcrypt.js：
const bcrypt = require('bcryptjs')
  1. 在注册用户的处理函数中，确认用户名可用之后，调用bcrypt.hashSync(明文密码，随机的长度)方法，对用户的密码进行加密处理
userinfo.password = bcrypt.hashSync(userinfo.password,10)

2.3.4 插入新用户

  1. 定义插入用户的SQL语句：
const sql = 'insert into ev_users set ?'
  1. 调用db.query()执行SQL语句，插入新用户：
db.query(sqlStr,userinfo.username,(err,results)=>{
    // 执行SQL语句失败
    if(err){
      return res.send({status:1,message:err.message})
    }
    // 判断用户名是否被占用
    if(results.length>0){
      return res.send({status:1,message:'用户名被占用，请更换其他用户名！'})
    }
    // TODO：用户名可以使用
    // 调用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})
      }
      // 判断影响行数是否为1
      if(results.affectedRows!==1) return res.send({status:1,message:'注册用户失败，请稍后再试！'})
      // 注册用户成功
      res.send({status:0,message:'注册成功！'})
    })
  })

2.4 优化res.send()代码

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

  1. 在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()
})

在这里插入图片描述
2.5 优化表单数据验证
表单验证的原则：前端验证为辅，后端验证为主，后端永远不要相信前端提交过来的任何内容
在实际开发中，前后端都需要对表单的数据进行合法性的验证，而且，后端作为数据合法性验证的最后一个关口，在拦截非法数据方面，起到了至关重要的作用。
单纯使用if……else……的形式对数据合法性进行验证，效率低下、出错率高、维护性差。因此，推荐使用第三方数据验证模块，来降低出错率、提高验证的效率和可维护性，让后端程序员更多的经历放在核心业务逻辑的处理上。

  1. 安装hapi/joi包，为表单中携带的每个数据项，定义验证规则：https://www.npmjs.com/package/@escook/express-joi
npm install joi
  1. 安装escook/express-joi中间件，来实现自动对表单数据进行验证的功能：
npm i @escook/express-joi
  1. 新建/schma/user.js用户信息验证规则模块，并初始化代码如下：
// 导入定义验证规则的包
// const joi = require('@hapi/joi')
const joi = require('joi')

// 定义用户名和密码的验证规则
const username = joi.string().alphanum().min(1).max(10).required()
const password = joi.string().pattern(/^[\S]{6,12}$/).required()

// 定义验证注册和登录表单数据的规则对象
exports.reg_login_schema = {
    body: {
        username,
        password
    }
}
  1. 修改/router/user.js中的代码如下：
const express = require("express");
// 创建路由对象
const router = express.Router();

// 导入用户路由处理函数模块
const userHandler = 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), userHandler.regUser);

// 登录
router.post("/login", expressJoi(reg_login_schema), userHandler.login);

// 将路由对象共享出去
module.exports = router;
  1. 在app.js的全局错误级别中间件中，捕获验证失败的错误，并把验证失败的结果响应给客户端：
// 定义错误级别的中间件
app.use((err,req,res,next)=>{
  // 验证失败导致的错误
  if(err instanceof joi.ValidationError) return res.cc(err)
  // 未知的错误
  res.cc(err)
})

2.6 登录
2.6.0 实现步骤

  1. 检测表单数据是否合法
  2. 根据用户页面查询用户的数据
  3. 判断用户输入的密码是否正确
  4. 生成JWT的Token字符串

2.6.1 检测登录表单的数据是否合法

  1. 将/router/user.js中登录的路由代码修改如下：
router.post("/login", expressJoi(reg_login_schema), userHandler.login);

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

  1. 接收表单数据：
  const userinfo = req.body
  1. 定义SQL语句
  const sql = 'select * from ev_users where username = ?'
  1. 执行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：判断用户输入的密码是否和数据库中的密码一致
    res.send("login ok");
  })

2.6.3 判断用户输入的密码是否正确
核心实现思路：调用bcrypt.compareSync（用户提交的密码，数据库中的密码）方法比较密码是否一致
返回值是布尔值（true一致，false不一致）
具体的实现代码如下：

const compareResult = bcrypt.compareSync(userinfo.password,results[0].password)
if(!compareResult) return res.cc('登录失败')
res.send('ok')

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

  1. 通过ES6的高级语法，快速删除密码和头像的值：
 const user = {...results[0],password:'',user_pic:''}
  1. 运行如下的命令，安装生成Token字符串的包：
npm i jsonwebtoken@8.5.1
  1. 在/router_handler/user.js模块的头部区域，导入jsonwebtoken包：
const jwt = require('jsonwebtoken')
  1. 创建config.js文件，并向外共享加密和还原的Token的jwtSecret字符串：
// 这是一个全局的配置文件
module.exports = {
    // 加密和解密Token的密钥
    jwtSecretKey: 'itheima No1. ^_^',
    // token的有效期
    expiresIn:'10h'
}
  1. 将生成的Token字符串响应给客户端
// 导入全局的配置文件
const config = require('../config')
const tokenStr = jwt.sign(user,config.jwtSecretKey,{expiresIn:config.expiresIn})
    // 调用res.send将Token响应给客户端
    res.send({
      status: 0,
      message: '登录成功',
      token: tokenStr
    })

2.7 配置解析Token的中间件

  1. 运行如下的命令，安装解析Token的中间件：
npm i express-jwt@5.3.3
  1. 在app.js中注册路由之前，配置解析Token的中间件：
// 一定要在路由之前配置解析的Token的中间件
const expressJWT = require('express-jwt')
const config = require('./config')
app.use(expressJWT({secret:config.jwtSecretKey}).unless({path:[/^\/api/]}))
  1. 在app.js中的错误级别中间件里面，捕获并处理Token认证失败后的错误：
// 身份认证失败后的错误
  if(err.name === 'UnauthorizedError') return res.cc('身份认证失败！')

3. 个人中心

3.1 获取用户的基本信息
3.1.0 实现步骤

  1. 初始化路由模块
  2. 初始化路由处理函数模块
  3. 获取用户的基本信息

3.1.1 初始化路由模块

  1. 创建/router/userinfo.js路由模块，并初始化如下的代码结构：
const express = require('express')
const router = express.Router()

// 挂载路由

// 获取用户基本信息的路由
router.get('/userinfo',(req,res)=>{
    res.send('userinfo ok')
})

module.exports = router
  1. 在app.js中导入并使用个人中心的路由模块
// 导入并使用用户信息的路由模块
const userinfoRouter = require('./router/userinfo')
app.use('/my', userinfoRouter)

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

  1. 创建/router_handler/userinfo.js路由处理函数模块，并初始化如下的代码结构：
// 获取用户基本信息的处理函数
exports.getUserInfo = (req,res)=>{
    res.send('userinfo ok')
}
  1. 修改/router/userinfo.js中的代码如下：
// 导入路由处理函数模块
const userinfo_handler = require('../router_handler/userinfo') 

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

3.1.3 获取用户的基本信息

  1. 在/router_handler/userinfo.js头部导入数据库操作模块：
// 导入数据库操作模块
const db = require('../db/index')
  1. 定义SQL语句：
const sql = `select id, username, nickname, email, user_pic from ev_users where id = ?`
  1. 调用db.query()执行SQL语句：
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]
        })
    })
}

3.2 更新用户的基本信息
3.2.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现更新用户基本信息的功能

3.2.1 定义路由和处理函数

  1. 在/router/userinfo.js模块中，新增更新用户基本信息的路由
router.post('/userinfo',userinfo_handler.updateUserInfo)
  1. 在/router_handler/userinfo.js模块中，定义并向外共享更新用户基本信息的路由处理函数：
// 更新用户基本信息的处理函数
exports.updateUserInfo=(req,res)=>{
    res.send('ok')
}

3.2.2 验证表单数据

  1. 在/schema/user.js验证规则模块中，定义id, nickname, email的验证规则如下：
// 定义id, nickname, email的验证规则
const id = joi.number().integer().min(1).required()
const nickname = joi.string().required()
const email = joi.string().email().required()
  1. 并使用exports向外共享如下的验证规则对象：
// 验证规则对象 - 更新用户基本信息
exports.update_userinfo_schema = {
    // 需要对req.body里面的数据进行验证
    body: {
        id,
        nickname,
        email:user_email
    }
}
  1. 在/router/userinfo.js模块中，导入需要的验证规则对象：
// 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 导入需要的验证规则对象
const {update_userinfo_schema} = require('../schema/user')
  1. 在/router/userinfo.js模块中，更新用户基本信息的路由如下：
router.post('/userinfo',expressJoi(update_userinfo_schema),userinfo_handler.updateUserInfo)

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

  1. 定义待执行的SQL语句
const sql = `update ev_users set ? where id = ?`
  1. 调用db.query()执行SQL语句并传参：
// 更新用户基本信息的处理函数
exports.updateUserInfo=(req,res)=>{
    // 定义待执行的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)
    })
}

3.3 重置密码
3.3.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现重置密码的功能

3.3.1 定义路由和处理函数

  1. 在/router/userinfo.js模块中，新增重置密码的路由：
router.post('/updatepwd',userinfo_handler.updatePassword)
  1. 在/router_handler/userinfo.js模块中，定义并向外共享重置密码的路由处理函数：
// 更新用户密码的处理函数
exports.updatePassword=(req,res)=>{
    res.send('ok')
}

3.3.2 验证表单数据
核心验证思路：旧密码与新密码，必须符合密码的验证规则，并且新密码不能与旧密码一致！

  1. 在/schema/user.js模块中，使用exports向外共享如下的验证规则对象：
// 验证规则对象 - 更新密码
exports.update_password_schema = {
    body: {
        oldPwd:password,
        newPwd:joi.not(joi.ref('oldPwd')).concat(password)
    }
}
  1. 在/router/userinfo.js模块中，导入需要的验证规则对象：
const {update_userinfo_schema, update_password_schema} = require('../schema/user')
router.post('/updatepwd',expressJoi(update_password_schema),userinfo_handler.updatePassword)

3.3.3 实现重置密码的功能

  1. 根据id查询用户是否存在：
// 更新用户密码的处理函数
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('用户不存在！')
        // 判断用户输入的旧密码是否正确
        res.cc('ok')
    })
}
  1. 判断提交的旧密码是否正确：
// 导入处理密码的模块
const bcrypt = require('bcryptjs')
// 更新用户密码的处理函数
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)
        // 检查指定 id 的用户是否存在
        if (results.length !== 1) return res.cc('用户不存在！')
        // TODO：判断提交的旧密码是否正确
        const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
        if (!compareResult) return res.cc('原密码错误！')
    })
}
  1. 对新密码进行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)
        // 检查指定 id 的用户是否存在
        if (results.length !== 1) return res.cc('用户不存在！')
        // TODO：判断提交的旧密码是否正确
        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)
        })
    })
}

3.4 更新用户头像
3.4.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单的数据
  3. 实现更新用户头像的功能

3.4.1 定义路由和处理函数

  1. 在/router/userinfo.js模块中，新增更新用户头像的路由：
router.post('/update/avatar',userinfo_handler.updateAvatar)
  1. 在/router_handler/userinfo.js模块中，定义并向外共享更新用户头像的路由处理函数：
exports.updateAvatar = (req, res) => {
    res.send('ok')
}

3.4.2 验证表单数据

  1. 在/schema/user.js验证规则模块中，定义avatar的验证规则如下：
const avatar = joi.string().dataUri().required()
  1. 并使用exports向外共享如下的验证规则对象：
// 验证规则对象 - 更新头像
exports.update_avatar_schema = {
    body: {
        avatar
    }
}
  1. 在/router/userinfo.js模块中，导入需要的验证规则对象：
const {update_userinfo_schema, update_password_schema, update_avatar_schema} = require('../schema/user')
  1. 在 /router/userinfo.js 模块中，修改 更新用户头像 的路由如下：
router.post('/update/avatar',expressJoi(update_avatar_schema),userinfo_handler.updateAvatar)

3.4.3 实现更新用户头像的功能

  1. 定义更新用户头像的SQL语句
const sql = `update ev_users set user_pic=? where id=?`
  1. 调用db.query()执行SQL语句，更新对应用户的头像：
// 更新用户头像的处理函数
exports.updateAvatar = (req, res) => {
    // 定义更新用户头像的SQL语句
    const sql = `update ev_users set user_pic=? where id=?`
    // 调用db.query()执行SQL语句
    db.query(sql,[req.body.avatar,req.user.id],(err,results)=>{
        if(err) return res.cc(err)
        if(results.affectedRows!==1) return res.cc('更新头像失败!')
        res.cc('更新头像成功！',0)
    })
}

4.2 获取文章分类列表
4.2.0 实现步骤

  1. 初始化路由模块
  2. 初始化路由处理函数模块
  3. 获取文章分类列表数据

4.2.1 初始化路由模块

  1. 创建/router/artcate.js路由模块，并初始化如下的代码结构：
// 这是文章分类的路由模块
const express = require('express')
const router = express.Router()

// 获取文章分类列表数据的路由
router.get('/cates',(req,res)=>{
    res.send('ok')
})

module.exports = router
  1. 在app.js中导入并使用文章分类的路由模块
const artCateRouter = require('./router/artcate')
app.use('/my/article',artCateRouter)

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

  1. 创建/router_handler/artcate.js路由处理函数模块，并初始化如下的代码结构：
// 获取文章分类列表数据的处理函数
exports.getArticleCates=(req,res)=>{
    res.send('ok')
}
  1. 修改/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

4.2.3 获取文章分类列表数据

  1. 在/router_handler/artcate.js头部导入数据库操作模块
// 导入数据库操作模块
const db = require('../db/index')
const sql = `select * from ev_article_cate where is_delete=0 order by id asc`
  1. 定义SQL语句：
在这里插入代码片
  1. 调用db.query()执行SQL语句：
db.query(sql,(err,results)=>{
        if(err) return res.cc(err)
        res.send({
            status: 0,
            message: '获取分类数据成功！',
            data: results
        })
    })

4.3 新增文章分类
4.3.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 查询分类名称与分类别名是否被占用
  4. 实现新增文章分类的功能

4.3.1 定义路由和处理函数

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

4.3.2 验证表单

  1. 创建/schema/artcate.js文章分类数据验证模块，并定义如下的验证规则：
// 导入定义验证规则的模块
const joi = require('joi')

// 定义name和alias的验证规则
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对数据进行验证：
// 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 导入需要验证的规则对象
const {add_cate_schema} = require('../schema/artcate')
// 新增文章分类的路由
router.post('/addcates',expressJoi(add_cate_schema),artcate_handler.addArticleCates)

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

  1. 定义查重的SQL语句：
const sql = `select * from ev_article_cate where name=? or alias=?`
  1. 调用db.query()执行查重的操作
 db.query(sql,[req.body.name,req.body.alias],(err,results)=>{
        // 判断是否执行SQL语句失败
        if(err) return res.cc(err)
        // 判断数据的length
        if(results.length ===2) return res.cc('分类名称与分类别名被占用，请更换后重试！')
        // length等于1的三种情况
        if(results.length === 1 && results[0].name === req.body.name && results[0].alias === req.body.alias) 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：分类名称和分类别名都可用，执行添加的动作
    })

4.3.4 实现文章分类的功能

  1. 定义新增文章分类的SQL语句：
const sql = `insert into ev_article_cate set ?`
  1. 调用db.query()执行新增文章分类的SQL语句：
db.query(sql, req.body, (err, results) => {
      if (err) return res.cc(err);
      if (results.affectedRows !== 1) return res.cc("新增文章分类失败！");
      res.cc("新增文章分类成功！", 0);
    });

4.4 根据Id删除文章分类
4.4.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现删除文章分类的功能

4.4.1 定义路由和处理函数

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

4.4.2 验证表单数据

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

4.4.3 实现删除文章分类的功能

  1. 定义删除文章分类的SQL语句：
const sql = `update ev_article_cate set is_delete=1 where id=?`
  1. 调用db.query()执行删除文章分类的SQL语句：
exports.deleteCateById=(req,res)=>{
    // 定义标记删除的SQL语句
    const sql = `update ev_article_cate set is_delete=1 where id=?`
    // 调用db.query()执行SQL语句
    db.query(sql,req.params.id,(err,results)=>{
        if(err) return res.cc(err)
        if(results.affectedRows!==1) return res.cc('删除文章分类失败！')
        res.cc('删除文章分类成功！',0)
    })
}

4.5 根据Id获取文章分类的数据
4.5.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现获取文章分类的功能

4.5.1 定义路由和处理函数

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

4.5.2 验证表单数据

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

4.5.3 实现获取文章分类的功能

  1. 定义根据id获取文章分类的SQL语句：
const sql = `select * from ev_article_cate where id=?`
  1. 调用db.query()执行SQL语句：
exports.getArtById = (req, res) => {
  // 定义根据ID获取文章分类数据的SQL语句
  const sql = `select * from ev_article_cate where id=?`
  db.query(sql,req.params.id,(err,results)=>{
    if(err) return res.cc(err)
    if(results.length !==1) return res.cc('获取文章分类数据失败！')
    res.send({
        status:0,
        message:'获取文章分类数据成功！',
        data:results[0]
    })
  })
};

4.6 根据Id更新文章分类数据
4.6.0 实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现更新文章分类的功能

4.6.1 定义路由和处理函数

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

4.6.2 验证表单数据

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

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

  1. 定义查重的SQL语句：
const sql = `select * from ev_article_cate where Id<>? and (name=? or alias=?)`;
  1. 调用db.query()执行查重的操作：
db.query(sql,[req.body.Id,req.body.name,req.body.alias],(err,results)=>{
    if(err) return res.cc(err)
    // 判断名称和别名被占用的4种情况
    if(results.length===2) return res.cc('分类名称与别名被占用，请更换后重试！')
    if(results.length===1 && results[0].name===req.body.name && results[0].alias===req.body.alias) 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：名称和别名都可用，可以执行更新的操作
    res.send('ok')
  })

4.6.4 实现更新文章分类的功能

  1. 定义更新文章分类的SQL语句：
const sql = `update ev_article_cate set ? where Id=?`
  1. 调用db.query()执行SQL语句：
db.query(sql,[req.body.Id,req.body.name,req.body.alias],(err,results)=>{
    if(err) return res.cc(err)
    // 判断名称和别名被占用的4种情况
    if(results.length===2) return res.cc('分类名称与别名被占用，请更换后重试！')
    if(results.length===1 && results[0].name===req.body.name && results[0].alias===req.body.alias) 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('分类别名被占用，请更换后重试！')
    // 定义更新文章分类的SQL语句
    const sql = `update ev_article_cate set ? where Id=?`
    // 执行更新文章分类的SQL语句
    db.query(sql,[req.body,req.body.Id],(err,results)=>{
        if(err) return res.cc(err)
        if(results.affectedRows !==1) return res.cc('更新文章分类失败！')
        res.cc('更新文章分类成功！',0)
    })
  })

5.2 发布新文章
5.2.0 实现步骤

  1. 初始化路由模块
  2. 初始化路由处理函数模块
  3. 使用multer解析表单数据
  4. 验证表单数据
  5. 实现发布文章的功能

5.2.1 初始化路由模块

  1. 创建/router/article.js路由模块，并初始化如下的代码结构：
// 文章的路由模块
const express = require("express");
const router = express.Router();

// 发布文章的路由
router.post('/add',(req,res)=>{
    res.send('ok')
})

module.exports = router;
  1. 在app.js中导入并使用文章的路由模块
const articleRouter = require('./router/article')
app.use('/my/article',articleRouter)

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

  1. 创建/router_handler/article.js路由处理函数模块，并初始化如下的代码结构：
// 发布新文章的处理函数
exports.addArticle=(req,res)=>{
    res.send('ok')
}
  1. 修改/router/article.js中的代码如下：
// 文章的路由模块
const express = require("express");
const router = express.Router();

// 导入需要的处理函数模块
const article_handler = require('../router_handler/article')

// 发布文章的路由
router.post('/add',article_handler.addArticle)

module.exports = router;
Camille_7
关注
后台服务器（api_server）开发详解
←か淡定☆ ヾ 的博客
10-17 212
Headline 大事件后台 API 项目，API 接口文档请参考 https://www.showdoc.cc/escook?page_id=3707158761215217 1. 初始化 1.1 创建项目 新建 api_server 文件夹作为项目根目录，并在项目根目录中运行如下的命令，初始化包管理配置文件： npm init -y 运行如下的命令，安装特定版本的 express： npm i express@4.17.1 在项目根目录中新建 app.js 作为整个项目的入口文件，并初
大事件后台API项目笔记
Hxmang的博客
08-29 456
表单验证规则：前端验证为辅，后端验证为主，在实际开发中，前后端都需要对表单的数据进行合法性验证，使用第三方数据模块joi包，为表单中携带的每个数据项，定义验证规则。所有的路由处理函数写到user.js中。为简化res.send(),手动封装一个res.cc函数,在 app.js 中，所有路由之前，声明一个全局中间件，为 res 对象挂载一个 res.cc() 函数。在根目录中新建db文件夹，db文件夹内新建index.js文件，用于连接数据库对象，在/db/index.js中创建数据库的连接对象。...
springboot3+vue3融合项目实战-大事件文章管理系统-接口文档
qq_44721704的博客
04-14 913
请求路径：/user/register请求方式：POST接口描述：该接口用于注册新用户。
大事件项目api_server源代码
08-14
大事件项目api_server源代码
nodejs——后端项目实战(后台基础框架)
wy313622821的博客
03-19 8970
3、数据库：mysql username:wangyao password:wy123 4、使用postman进行post请求访问 能获取到数据，代表登录功能完成。
Nodejs服务端开发实战——大事件后台API项目（获取文章的列表数据功能待完善...）
SongD1114的博客
04-03 2862
Nodejs服务端开发实战之大事件后台API项目
基于Node.js的sports_api_server体育人生接口设计源码
02-15
基于Node.js的sports_api_server体育人生接口设计源码的知识点涵盖多个方面，从基础的Node.js应用结构、API设计原则到具体的文件类型与项目布局等都有所涉及。首先，Node.js作为一种广泛应用于服务器端的JavaScript...
ev_api_server.zip
01-02
在本项目"ev_api_server.zip"中，我们深入探讨了使用Node.js进行后端开发的实践，特别是关于用户注册、登录、数据验证、数据库连接以及JWT（JSON Web Token）的生成与验证。以下是对这些核心知识点的详细阐述。 ...
大事件项目-API服务器
最新发布
05-06
本项目，即“大事件项目-API服务器”，是一个采用Node.js语言开发的后端服务系统。Node.js以其高效、异步I/O和事件驱动的特点而广受欢迎，尤其适合于构建需要处理大量并发连接的网络应用。 项目在安全性方面尤为...
超详细讲解大事件项目api接口
一个前端开发者
06-20 2535
​ 2. 运行如下的命令，安装特定版本的 ： 在项目根目录中新建 作为整个项目的入口文件，并初始化如下的代码： 1.2 配置 cors 跨域 运行如下的命令，安装 中间件： 在 中导入并配置 中间件： 1.3 配置解析表单数据的中间件 通过如下的代码，配置解析 格式的表单数据的中间件： 1.4 初始化路由相关的文件夹 在项目根目录中，新建 router 文件夹，用来存放所有的路由模块 在项目根目录中，新建 文件夹，用来存放所有的 1.5 初始化用户路由模块
【项目实战】nodejs 实战-图书管理系统
热门推荐
weixin_41033048的博客
04-05 1万+
第一步：新建js文件先安装这两个指令
big_event：大事件项目
02-08
big_event：大事件项目
nodejs + express + ejs + mongodb 一个非常简单的前后端开发的实例
06-04
nodejs + express + ejs + mongodb 一个非常简单的前后端开发的实例
nodejs简单搭建前端后端网站demo
06-14
nodejs简单搭建前端后端网站demo，慕课网上scott老师课程的imooc网站，自己学习中demo练习源码
从0到1使用NodeJS编写后端接口的实战案例（仅供参考）
不怕麻烦的鹿丸的博客
06-18 7882
基于vue和node.js来开发的一个在线商城管理系统。
大事件后台API项目01
weixin_43599321的博客
12-31 557
这篇博客记一下编写大事件项目的后台API的基本步骤，其中很多都是属于后端的知识，提前了解一下，为以后工作打基础。这个项目跟的课程是黑马刘龙彬老师的这篇博客参考了刘龙彬老师的。
[菜鸟试水]关于Nodejs搭建后台API服务(Mysql-Restify)
狗仔很忙的博客
06-03 4560
尝试一下写些技术的东西, 之前在公司一直是用C#写的WCF后台. 对于跨域调用API虽然也支持, 但是需要做的配置也挺繁琐, 所以试下不一样的后台技术, NodeJs . 由于只做API调用, 所以用了Restify 插件而不是Express . 所以先全局安装下 restify  : npm install restify -g  (-g就是全局,不然就是当前路径下安装).​
NODE.JS项目实战
07-26 3525
一、项目框架的搭建 1.建立项目文件夹 （1）手动在本地建立 （2）在远程仓库创建项目（私有），创建后，将项目文件夹克隆至本地 2.用VSCODE打开项目文件夹 3. 在VSCODE终端执行以下命令 npm init -y npm install koa (基于koa的项目） 4.需求分析 （1） 项目功能描述：文章内容...
大事件项目api_server源代码深入解析
资源摘要信息:"大事件项目API服务器源代码是用于处理与大事件相关联的网络请求的后端程序，它能够接收、处理并响应来自用户或其他系统组件的HTTP或HTTPS请求。这份源代码为开发者提供了搭建和维护事件驱动型应用后端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值