从0开发一个完整的node.js后台api接口项目

一、项目初始化

1.1 创建项目

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

npm init -y

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

npm i express@4.17.1

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

//导入express
const express = require("express");

// 创建express服务器实例
const app = express();

// 启动服务器
app.listen(3007, function () {
  console.log("api server running at 127.0.0.1:3007");
});

1.2 配置 cors 跨域

1.运行如下的命令，安装`cors`中间件:

npm i cors@2.8.5

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

CORS是基于http1.1的一种跨域解决方案，它的全称是Cross-Origin Resource Sharing，跨域资源共享。

// 导入cors中间件
const cors = require("cors");
// 将cors注册为全局中间件
app.use(cors()); //不传参默认允许简单跨域和预检跨域

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

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

// 配置解析 application/x-www-form-urlencoded 格式的表单数据的中间件
app.use(express.urlencoded({ extended: false }));

1.1-1.3完整代码

//导入express
const express = require("express");
// 导入cors中间件
const cors = require("cors");

// 创建express服务器实例
const app = express();
// 将cors注册为全局中间件
app.use(cors()); //不传参默认允许简单跨域和预检跨域
// 配置解析 application/x-www-form-urlencoded 格式的表单数据的中间件
app.use(express.urlencoded({ extended: false }));

// 启动服务器
app.listen(3007, function () {
  console.log("api server running at 12.0.0.1:3007");
});

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

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

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

2.在项目根目录中，新建 `router_handler` 文件夹，用来存放所有的路由处理函数模块

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

1.5 初始化用户路由模块

1.在 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;

2.在app.js内导入并使用用户路由模块

// 导入用户路由模块
const userRouter = require("./router/user");
// 注册用户模块用户路由模块
app.use("/api", userRouter); //每次访问用户模块的接口都要添加/api前缀

测试接口

右键`app.js`打开终端--输入`node .\app.js`启动服务

image.png

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

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

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

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

// exports === module.exports

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

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

2.将`/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.1新建 ev_users 表

1.在 my_db_01 数据库中，新建 ev_users 表如下:

TEXT没有长度限制的字符串

image.png

2.2安装并配置mysql模块

在API接口项目中，需要安装并配置mysql这个第三方模块，来连接和操作 MySQL 数据库

1.运行如下命令，安装 `mysql` 模块:

npm i mysql@2.18.1

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

// 导入mysql模块
const mysql = require("mysql");

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

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

2.3 注册

2.3.0实现步骤

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

2.3.1检测表单数据是否合法

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

// 注册用户的处理函数
exports.regUser = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 判断是否合法
  if (!userinfo.username || !userinfo.password) {
    return res.send({
      status: 1,
      msg: "用户名或密码不能为空",
    });
  }
  res.send("reguser OK");
};

image.png

2.3.2检测用户名是否被占用

1.导入数据库操作模块:

// 导入数据库连接对象
const db = require("../db/index");

定义sql语句

// 定义sql语句
  const sqlStr = "SELECT * FROM ev_users WHERE username=?";

判断用户是否被占用

// 导入数据库连接对象
const db = require("../db/index");

// 注册用户的处理函数
exports.regUser = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 判断是否合法
  if (!userinfo.username || !userinfo.password) {
    return res.send({
      status: 1,
      msg: "用户名或密码不能为空",
    });
  }
  // 定义sql语句
  const sqlStr = "SELECT * FROM ev_users WHERE username=?";
  db.query(sqlStr, userinfo.username, (err, results) => {
    if (err) return res.send({ status: 1, message: err.message }); //sql执行出错
    // // 判断用户是否被占用
    if (results.length > 0) {
      return res.send({
        status: 1,
        message: "用户名已被占用，请更换其他用户名",
      });
    }
    // 用户名可用
    // TODO Others
  });
  res.send("reguser OK");
};

image.png

2.3.3 对密码进行加密处理

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

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

加容之后的容码，无法被逆向破解
同一明文密码多次加查，得到的加密结果各不相同，保证了安全性

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

npm i bcryptjs@2.4.3

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

// 导入密码加密工具
const bcrypt = require("bcryptjs");

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

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

2.3.4插入新用户

1.定义插入用户的SOL 语句:

  // 定义插入用户的sql语句
    const sql = "insert into ev_users set ?";

2.调用 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.3.1-2.3.4完整代码

// 导入数据库连接对象
const db = require("../db/index");
// 导入密码加密工具
const bcrypt = require("bcryptjs");

// 注册用户的处理函数
exports.regUser = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 判断是否合法
  if (!userinfo.username || !userinfo.password) {
    return res.send({
      status: 1,
      msg: "用户名或密码不能为空",
    });
  }
  // 定义sql语句
  const sqlStr = "SELECT * FROM ev_users WHERE username=?";
  db.query(sqlStr, userinfo.username, (err, results) => {
    if (err) return res.send({ status: 1, message: err.message }); //sql执行出错
    // // 判断用户是否被占用
    if (results.length > 0) {
      return res.send({
        status: 1,
        message: "用户名已被占用，请更换其他用户名",
      });
    }
    // 用户名可用
      // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
      userinfo.password = bcrypt.hashSync(userinfo.password, 10);
    // 定义插入用户的sql语句
    const sql = "insert into ev_users set ?";
    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() 函数:

// 响应数据的中间件
app.use(function (req, res, next) {
  // status =0为成功 status = 1 为失败 默认将 status 的值设置为 1，方便处理失败的情况
  res.cc = function (err, status = 1) {
    res.send({
      // 状态
      status,
      // 状态描述：判断err是错误对象还是字符串
      message: err instanceof Error ? err.message : err,
    });
  };
  next();
});

2.4.1优化用户注册接口

// 注册用户的处理函数
exports.regUser = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 判断是否合法
  if (!userinfo.username || !userinfo.password) {
    return res.send({
      status: 1,
      msg: "用户名或密码不能为空",
    });
  }
  // 定义sql语句
  const sqlStr = "SELECT * FROM ev_users WHERE username=?";
  db.query(sqlStr, userinfo.username, (err, results) => {
    if (err) {
      // return res.send({ status: 1, message: err.message }); //sql执行出错
      return res.cc(err); //优化后
    }
    // // 判断用户是否被占用
    if (results.length > 0) {
      // return res.send({
      //   status: 1,
      //   message: "用户名已被占用，请更换其他用户名",
      // });
      return res.cc("用户名已被占用，请更换其他用户名"); //优化后
    }
    // 用户名可用
    // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
    userinfo.password = bcrypt.hashSync(userinfo.password, 10);
    // 定义插入用户的sql语句
    const sql = "insert into ev_users set ?";
    db.query(
      sql,
      { username: userinfo.username, password: userinfo.password },
      (err, results) => {
        // 判断sql语句是否执行成功
        if (err) {
          // return res.send({ status: 1, message: err.message });
          res.cc(err); //优化后
        }
        // 判断影响行为是否为1
        if (results.affectedRows !== 1) {
          // return res.send({
          //   status: 1,
          //   message: "注册用户失败，请稍后再试！",
          // });
          res.cc("注册用户失败，请稍后再试！"); //优化后
        }
        // 注册用户成功
        // res.send({
        //   status: 0,
        //   message: "注册成功",
        // });
        res.cc("注册成功", 0); //优化后
      }
    );
  });
};

2.5优化表单数据验证

表单验证的原则:

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

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

单纯的使用if...else...的形式对数据合法性进行验证，效率低下、出错率高、维护性差。

因此，推荐使用第三方数据验证模块，来降低出错率、提高验证的效率与可维护性，让后端程序员把更多的情力放在核心业务逻辑的处理上

1.安装 @escook/express-joi中间件，来实现自动对表单数据进行验证的功能:
参考地址：@escook/express-joi - npm (npmjs.com)

npm install @escook/express-joi

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

npm install joi@17.4.0

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

// 导入 Joi 来定义验证规则
const Joi = require("joi");

// 2. 定义验证规则
// 注意：如果客户端提交的某些参数项未在 schema 中定义，
// 此时，这些多余的参数项默认会被忽略掉
const userSchema = {
  // 2.1 校验 req.body 中的数据
  body: {
    username: Joi.string().alphanum().min(3).max(12).required(),
    password: Joi.string()
      .pattern(/^[\S]{6,15}$/)
      .required(),
  },
};

exports.reg_login_schema = userSchema;

4.router/user.js文件中

// 1. 导入 @escook/express-joi
const expressJoi = require("@escook/express-joi");
// 2，导入需要的验证规则对象
const { reg_login_schema } = require("../schema/user");

// 注册新用户
//在注册新用户的路由中，声明局部中间件，对当前请求中携带的数据进行验证
//数据验证通过后，会把这次请求流转给后面的路由处理函数
//数据验证失败后，终止后续代码的执行，并抛出一个全局的 Error 错误，进入全局错误级别中间件中进行处理
router.post("/reguser", expressJoi(reg_login_schema), userHandler.regUser);

5.app.js中添加全局错误捕获

// 导入 Joi 来定义验证规则
const Joi = require("joi");

// 4.1 错误级别中间件
app.use(function (err, req, res, next) {
  // 4.1 Joi 参数校验失败
  if (err instanceof Joi.ValidationError) {
    return res.cc(err.message);
  }
  // 4.2 未知错误
  res.cc(err.message);
});

6.注释掉用户注册接口的自定义验证

// 接收表单数据
 const userinfo = req.body;
 // 判断是否合法
 // console.log(userinfo);
 // if (!userinfo.username || !userinfo.password) {
 //   return res.send({
 //     status: 1,
 //     msg: "用户名或密码不能为空",
 //   });
 // }

image.png

2.6 登录

2.6.0 实现步骤

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

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

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

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

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

// 登录处理函数
exports.login = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 定义sql语句
  const sqlStr = "SELECT * FROM ev_users where username=?";
  // 执行sql语句查询用户数据
  db.query(sqlStr, [userinfo.username], (err, results) => {
    // 执行sql语句失败
    if (err) return res.cc(err.message);
    // 执行sql语句成功但是查询到数据条数不等于1
    if (results.length !== 1) return res.cc("登录失败");
    // TODO 判断用户输入的密码是否和数据库中的密码一致
  });
};

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

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

返回值是布尔值 (true 一致、false 不一致)

// 登录处理函数
exports.login = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 定义sql语句
  const sqlStr = "SELECT * FROM ev_users where username=?";
  // 执行sql语句查询用户数据
  db.query(sqlStr, [userinfo.username], (err, results) => {
    // 执行sql语句失败
    if (err) return res.cc(err.message);
    // 执行sql语句成功但是查询到数据条数不等于1
    if (results.length !== 1) return res.cc("登录失败");
    // TODO 判断用户输入的密码是否和数据库中的密码一致

    // 拿着用户输入的密码,和数据库中存储的密码进行对比
    const compareResult = bcrypt.compareSync(
      userinfo.password,
      results[0].password
    );
    // 如果比对结果为false，证明用户数日密码错误
    if (!compareResult) {
      return res.cc("密码输入错误");
    }
    // TODO 登录成功生成token字符串
  });
};

2.6.4生成`JWT的 Token` 字符串

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

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

const user = { ...results[0], password: "", user_pic: "" };

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

npm i jsonwebtoken@8.5.1

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

// 用这个包来生成 Token 字符串
const jwt = require("jsonwebtoken");

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

module.exports = {
  jwtSecretKey: "ywb-ssg", //加密解密的秘钥
  expiresIn: "10h", //token的有效期
};

5.将用户信息对象加密成 Token 字符串并发送给客户端

// 剔除完毕之后，user 中只保留了用户的 id，username，nickname，
    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: tokenStr,
    });

2.6.1-2.6.4完整代码

// 登录处理函数
exports.login = (req, res) => {
  // 接收表单数据
  const userinfo = req.body;
  // 定义sql语句
  const sqlStr = "SELECT * FROM ev_users where username=?";
  // 执行sql语句查询用户数据
  db.query(sqlStr, [userinfo.username], (err, results) => {
    // 执行sql语句失败
    if (err) return res.cc(err.message);
    // 执行sql语句成功但是查询到数据条数不等于1
    if (results.length !== 1) return res.cc("登录失败");
    // TODO 判断用户输入的密码是否和数据库中的密码一致

    // 拿着用户输入的密码,和数据库中存储的密码进行对比
    const compareResult = bcrypt.compareSync(
      userinfo.password,
      results[0].password
    );
    // 如果比对结果为false，证明用户数日密码错误
    if (!compareResult) {
      return res.cc("密码输入错误");
    }
    // TODO 登录成功生成token字符串

    // 剔除完毕之后，user 中只保留了用户的 id，username，nickname，
    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: tokenStr,
    });
  });
};

image.png

2.7、配置解析token的中间件

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

npm i express-jwt@5.3.3

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

// 导入配置文件
const config = require("./config");
// 解析token中间件
const expressJWT = require("express-jwt");

// 使用.unless({ path: [/^\/api\//] }) 指定哪些接口不需要token认证
app.use(
  expressJWT({ secret: config.jwtSecretKey }).unless({ path: [/^\/api\//] })
);

3.在 app.js 中的误级别中间件里面，捕获并处理 Token 认证失败后的误误:

app.use(function (err, req, res, next) {
  // 4.1 错误级别中间件---表单验证
  if (err instanceof Joi.ValidationError) {
    return res.cc(err.message);
  }
  // 捕获身份认证失败的中间件
  if (err.name === "UnauthorizedError") {
    return res.cc("身份认证失败");
  }
  // 4.2 未知错误
  res.cc(err.message);
});

image.png

三、个人中心

3.1获取用户的基本信息

3.1.0 实现步骤

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

3.1.1 初始化路由模块

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

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

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

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

image.png

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

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

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

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

// 导入 express
const express = require("express"); // 创建路由对象
const router = express.Router();
// 导入用户信息的处理函数模块
const userinfo_handler = require("../router_handler/userinfo");
// 获取用户的基本信息
router.get("/userinfo", userinfo_handler.getUserInfo);
// 向外共享路由对象
module.exports = router;

image.png

3.1.3获取用户信息处理函数

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

// 获取用户信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意:为了防止用户的密码泄露，需更排除 password 字段
  const sqlStr =
   "select id,username,nickname,email,user_pic from ev_users where id=?";
  // 注意: req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  db.query(sqlStr, [req.user.id], (err, results) => {
    // sql执行失败
    if (err) res.cc(err);
    // // 执行sql成功，但查询到的数据条数不等于1
    if (results.length !== 1) return res.cc("获取用户信息失败");
    // 将用户信息响应给客户端
    res.send({
      status: 0,
      mesage: "用户信息获取成功",
      data: results[0],
    });
  });
};

3.2修改用户基本信息

3.2.1定义路由和处理函数

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

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

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

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

3.2.2 验证表单数据

1.在schima/user.js 验证规则模块中，新增id ， nickname ， email的验证规则如下:

const userInfoSchema = {
  body: {
    id: Joi.number().integer().min(1).required(),
    nickname: Joi.string().required(),
    email: Joi.string().email().required(),
  },
};

exports.update_userinfo_schema = userInfoSchema;

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

// 导入验证数据合法性的中间件
const expressJoi = require("@escook/express-joi");
// 导入需要的验证规则对象
const { update_userinfo_schema } = require("../schema/user");
// 更新用户的基本信息
router.post(
  "/userinfo",
  expressJoi(update_userinfo_schema),
  userinfo_handler.updateUserInfo
);

3.2.3 更新用户信息接口

// 更新用户信息的处理函数
exports.updateUserInfo = (req, res) => {
  // 定义待执行的 SOL 语句:
  const sqlStr = "update ev_users set ? where id=?";
  // 调用 db.query() 执行 SQL 语句并传参:
  db.query(sqlStr, [req.body, req.body.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);
    // 执行 SQL 语句成功，但影响行数不为 1
    if (results.affectedRows !== 1) return res.cc("修改用户基本信息失败!");
    // 修改用户信息成功
    return res.cc("修改用户基本信息成功!", 0);
  });
};

image.png

3.3 重置密码

3.3.0 实现步骤

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

3.3.1 定义路由和处理函数

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

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

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

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

3.3.2 验证表单数据

核心验证思路:旧密码与新密码，必须符合密码的验证规则，并且新密码不能与旧密码一致!

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

const password = Joi.string()
  .pattern(/^[\S]{6,15}$/)
  .required();
const passwordSchema = {
  // 2.1 校验 req.body 中的数据
  body: {
    //用 password 这个规则，验证 req.body.oldPwd 的值
    oldPwd: password,
    // 使用 jol.not(jol.ref('oldPwd')).concat(password) 规则，验证 req.body.newPwd 的值
    // 解读:
    // 1.Joi.ref("oldPwd') 表示 newPwd 的值必须和 oldPwd 的值保持一致
    // 2.Joi.not(Joi.ref('oldPwd')) 表示 newPwd 的值不能等于 oldPwd 的值
    // 3..concat() 用于合并 Joi.not(Joi.ref('oldPwd')) 和 password 这两条验证规则
    newPwd: Joi.not(Joi.ref("oldPwd")).concat(password),
  },
};

exports.update_password_schema = passwordSchema;

2.在router/userinfo.js导入密码重置的验证规则

const { update_password_schema } = require("../schema/user");
// 重置密码的路由
router.post(
  "/updatepwd",
  expressJoi(update_password_schema),
  userinfo_handler.updatePassword
);

image.png

3.3.3.实现重置密码的功能

// 重置密码的处理函数
exports.updatePassword = (req, res) => {
  // 定义根据 id 查询用户数据的 SQL 语句
  const sqlStr = "select * from ev_users where id=?";
  // 调用 db.query() 执行 SQL 语句并传参:
  db.query(sqlStr, req.user.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);
    // 执行 SQL 语句成功，但影响行数不为 1
    if (results.length !== 1) return res.cc("用户不存在!");
    // 判断提交的旧密码是否正确
    // 在头部区域导入 bcryptjs 后，
    // 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
    const bcrypt = require("bcryptjs");
    // 判断提交的旧密码是否正确
    const compareResult = bcrypt.compareSync(
      req.body.oldPwd,
      results[0].password
    );
    if (!compareResult) return res.cc("原密码错误");
    // 对新密码加密后更新到数据库
    // 定义更新密码的sql
    const updateSqlStr = "update ev_users set password=? where id=?";
    // 对新密码进行 bcrypt 加密处理
    const newPwd = bcrypt.hashSync(req.body.newPwd, 10);
    db.query(updateSqlStr, [newPwd, req.user.id], (err, results) => {
      // 执行 SQL 语句失败
      if (err) return res.cc(err);
      // 执行 SQL 语句成功，但影响行数不为 1
      if (results.affectedRows !== 1) return res.cc("更新密码失败!");
      res.cc("更新密码成功!", 0);
    });
  });
};

image.png

3.4 更新用户头像

3.4.0 实现步骤

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

3.4.1定义路由和处理函数

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

// 更新用户头像
router.post("/update/avatar", userinfo_handler.updateAvatar);

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

// 更新用户头像
exports.updateAvatar = (req, res) => {
  res.send("OK");
};

3.4.2 验证表单数据

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

const avatarSchema = {
  // 2.1 校验 req.body 中的数据
  body: {
    // dataUri() 指的是如下格式的字符串数据:
    // data :image/png :base64,VE9PTUFOWVNFQ1JFVFM-
    avatar: Joi.string().dataUri().required(),
  },
};

exports.reg_avatar_schema = avatarSchema;

2.在router/userinfo.js导入更新头像的验证规则

const { reg_avatar_schema } = require("../schema/user");

2.更新用户头像路由注入中间件

// 更新用户头像
router.post(
  "/update/avatar",
  expressJoi(reg_avatar_schema),
  userinfo_handler.updateAvatar
);

image.png

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

// 更新用户头像
exports.updateAvatar = (req, res) => {
  // 定义更新头像的sql语句
  const sqlStr = "update ev_users set user_pic=? where id=?";
  db.query(sqlStr, [req.body.avatar, req.user.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);
    // 执行 SQL 语句成功，但影响行数不为 1
    if (results.length !== 1) return res.cc("更新头像失败!");
    // 更新头像成功
    return res.cc("更新头像成功!", 0);
  });
};

4.文章的增删改查

4.1新建ev_article_cate 表

4.1.1 创建表结构

image.png

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("/article/cates", (req, res) => {
  res.send("OK");
});
// 将路由对象共享出去
module.exports = router;

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

// 导入并使用文章分类路由模块
const artCateRouter = require("./router/artcate");
app.use("/my", artCateRouter);

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

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

// 查询文章分类的处理函数
exports.getArtCates = (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("/article/cates", artCate_handler.getArtCates);

// 将路由对象共享出去
module.exports = router;

4.2.3 获取文章分类列表数据

// 导入数据库连接对象
const db = require("../db/index");

// 注册用户的处理函数
exports.getArtCates = (req, res) => {
  const sqlStr =
    "select * from ev_article_cate where is_delete=0 order by id asc";
  db.query(sqlStr, (err, results) => {
    if (err) return res.cc(err);
    res.send({
      status: 0,
      message: "获取文章分类数据成功",
      data: results,
    });
  });
};

image.png

4.3 新增文章分类

4.3.0 实现步骤

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

4.3.1 定义路由和处理函数

1.在 /router/artcate.js 模块中，添加新增文章分类的路由:

// 新增文章分类的列表数据
router.post("/addcates", artCate_handler.addArtCate);

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

// 新增文章分类的处理函数
exports.addArtCate = (req, res) => {
  res.send("OK");
};

4.3.2验证表单数据

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

// 导入 Joi 来定义验证规则
const Joi = require("joi");
const artcateAddSchema= {
  // 2.1 校验 req.body 中的数据
  body: {
    // alphanum只能包含字母和数字
    name: Joi.string().required(),
    alias: Joi.string().alphanum(),
  },
};
exports.reg_artcate_add_schema= artcateAddSchema;

2.创建/router/artcate.js 导入校验规则:

// 导入验证数据的中间件
const expressJoi = require("@escook/express-joi");
// 导入验证规则
const { reg_artcate_add_schema } = require("../schema/artcate");
// 新增文章分类的列表数据
router.post(
 "/article/addcates",
  expressJoi(reg_artcate_add_schema),
  artCate_handler.addArtCate
);

4.3.3新增文章分类

// 新增文章分类的处理函数
exports.addArtCate = (req, res) => {
  const sqlStr = "select * from ev_article_cate where name=? or alias=?";
  // 执行查重的sql语句
  db.query(sqlStr, [req.body.name, req.body.alias], (err, results) => {
    if (err) return res.cc(err);
    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: 分类名称和分类别名都可用，执行添加的动作
    const sqlAdd = "insert into ev_article_cate set ?";
    db.query(sqlAdd, req.body, (err, results) => {
      if (err) return res.cc(err);
      if (results.affectedRows !== 1) {
        return res.cc("新增文章分类失败!");
      }
      res.cc("新增文章分类成功!");
    });
  });
};

4.4删除文章分类

4.4.0实现步骤

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

4.4.1 定义路由和处理函数

1.在 /router/artcate.js 模块中，添加删除文章分类的路由:

// 删除文章分类
router.get("/deletecate/:id", artCate_handler.deleteArtCate);

2.在 /router_handler/artcate.js 模块中，添加删除文章分类的路由:

// 删除文章分类处理函数
exports.deleteArtCate = (req, res) => {};

4.4.2 验证表单数据

1.在验证规则模块中，定义 id 的验证规则如下

const artcateIdSchema = {
  // 2.1 校验 req.body 中的数据
  params: {
    id: Joi.number().integer().min(1).required(),
  },
};
/* 删除 */
exports.reg_artcate_id_schema = artcateIdSchema;

2. 删除文章分类接口添加校验中间件

// 导入验证规则
const { reg_artcate_id_schema } = require("../schema/artcate");
// 删除文章分类
router.get(
  "/deletecate/:id",
  expressJoi(reg_artcate_id_schema),
  artCate_handler.deleteArtCate
);

3.删除文章分类处理函数

// 删除文章分类处理函数
exports.deleteArtCate = (req, res) => {
  const sqlStr = "update ev_article_cate set is_delete=1 where id=?";
  db.query(sqlStr, req.params.id, (err, results) => {
    console.log(req.params.id);
    if (err) return res.cc(err);
    if (results.affectedRows !== 1) return res.cc("删除文章分类失败");
    return 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.getArtCateById);

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

// 根据id获取文章分类的处理函数
exports.getArtCateById = (req, res) => {
  res.send("ok");
};

4.5.2验证表单数据

// 根据id获取文章分类的路由
router.get(
  "/cates/:id",
  expressJoi(reg_artcate_id_schema),
  artCate_handler.getArtCateById
);

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

exports.getArtCateById = (req, res) => {
  const sqlStr = "select * from ev_article_cate where id=?";
  db.query(sqlStr, [req.params.id], (err, results) => {
    if (err) return res.cc(err);
    if (results.length !== 1) return res.cc("获取文章分类数据失败");
    return res.send({
      status: 0,
      message: "获取文章分类数据成功",
      data: results,
    });
  });
};

4.6更新文章分类信息

4.6.0实现步骤

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

4.6.1定义路由和处理函数

1.在 /router/artcate.js模块中，添加

// 更新文章分类的处理函数
router.post(
  "/updatecate",
  expressJoi(reg_artcate_update_schema),
  artCate_handler.updateArtCate
);

2.在 /router_handler/artcate.js模块中，添加

// 更新文章分类的处理函数
exports.updateArtCate = (req, res) => {
  res.send("Ok");
};

4.5.2 表单验证

const artcateUpdateSchema = {
 // 2.1 校验 req.body 中的数据
 body: {
   // alphanum只能包含字母和数字
   name: Joi.string().required(),
   alias: Joi.string().alphanum(),
   id: Joi.number().integer().min(1).required(),
 },
};
/* 更新 */
exports.reg_artcate_update_schema = artcateUpdateSchema;

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

// 更新文章分类的处理函数
exports.updateArtCate = (req, res) => {
  const sqlStr = "select * from ev_article_cate where name=? or alias=?";
  // 执行查重的sql语句
  db.query(sqlStr, [req.body.name, req.body.alias], (err, results) => {
    if (err) return res.cc(err);
    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: 分类名称和分类别名都可用，执行添加的动作
    const sqlAdd = "update ev_article_cate set ?";
    db.query(sqlAdd, req.body, (err, results) => {
      if (err) return res.cc(err);
      if (results.affectedRows !== 1) {
        return res.cc("修改文章分类失败!");
      }
      res.cc("修改文章分类成功!");
    });
  });
};

image.png

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,457评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,837评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,696评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,183评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,057评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,105评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,520评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,211评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,482评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,574评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,353评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,213评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,576评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,897评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,174评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,489评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,683评论 2赞 335

从0开发一个完整的node.js后台api接口项目

一、项目初始化

1.1 创建项目

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

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

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

1.2 配置 cors 跨域

1.运行如下的命令，安装cors中间件:

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

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

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

1.1-1.3完整代码

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

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

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

1.5 初始化用户路由模块

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

2.在app.js内导入并使用用户路由模块

测试接口

右键app.js打开终端--输入node .\app.js启动服务

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

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

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

二、登录注册

2.1新建 ev_users 表

1.在 my_db_01 数据库中，新建 ev_users 表如下:

2.2安装并配置mysql模块

1.运行如下命令，安装 mysql 模块:

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

2.3 注册

2.3.0实现步骤

2.3.1检测表单数据是否合法

2.3.2检测用户名是否被占用

2.3.3 对密码进行加密处理

2.3.4插入新用户

2.3.1-2.3.4完整代码

2.4.优化res.send()代码

2.4.1优化用户注册接口

2.5优化表单数据验证

2.6 登录

2.6.0 实现步骤

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

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

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

2.6.4生成JWT的 Token 字符串

2.6.1-2.6.4完整代码

2.7、配置解析token的中间件

三、个人中心

3.1获取用户的基本信息

3.1.0 实现步骤

3.1.1 初始化路由模块

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

3.1.3获取用户信息处理函数

3.2修改用户基本信息

3.2.1定义路由和处理函数

3.2.2 验证表单数据

3.2.3 更新用户信息接口

3.3 重置密码

3.3.0 实现步骤

3.3.1 定义路由和处理函数

3.3.2 验证表单数据

3.3.3.实现重置密码的功能

3.4 更新用户头像

3.4.0 实现步骤

3.4.1定义路由和处理函数

3.4.2 验证表单数据

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

4.文章的增删改查

4.1新建ev_article_cate 表

4.1.1 创建表结构

4.2 获取文章分类列表

4.2.0 实现步骤

4.2.1初始化路由模块

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

4.2.3 获取文章分类列表数据

4.3 新增文章分类

4.3.0 实现步骤

4.3.1 定义路由和处理函数

4.3.2验证表单数据

4.3.3新增文章分类

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

1.运行如下的命令，安装`cors`中间件:

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

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

2.在项目根目录中，新建 `router_handler` 文件夹，用来存放所有的路由处理函数模块

右键`app.js`打开终端--输入`node .\app.js`启动服务

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

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

1.运行如下命令，安装 `mysql` 模块:

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

2.4.优化`res.send()`代码

2.6.4生成`JWT的 Token` 字符串