Node学习笔记之使用Express框架开发接口

我们利用node+express+mysql开发接口，对数据库数据进行简单增、删、查改等操作。

接口是什么？

接口是 前后端通信的桥梁

简单理解：一个接口就是 服务中的一个路由规则 ，根据请求响应结果 接口的英文单词是 API (Application Program Interface)，所以有时也称之为 API 接口

这里的接口指的是『数据接口』， 与编程语言（Java，Go 等）中的接口语法不同

下面做一个书城商店api案例（大概有个人信息模块，书产品分类模块，购物车模块，信息资讯），利用宝塔工具将api部署到服务器，利用cdn访问图片，富文本编辑器使用等。（vue3）一边做uniapp开发小程序一边写接口，可能会写后台管理系统（看时间）。为了节约时间不用ts😅😅😅，后面有时间再用ts优化ᥬ🌚᭄。

工具

数据库可视化

377ee077acfddce7329f78fe733766bd.png

接口测试工具Postman

6559a752499dd3f0d43283f099e68937.png

1、初始化

我们这里利用node+express+mysql开发一个简单的书城商店API。后面会使用result API规范接口

1、创建项目

新建文件夹server 安装依赖

npm init -y

6e049a1919b7e33f54c7b03f48c60020.png

安装依赖express

npm i express

新建app.js作为入口文件创建服务器实例

// 导入 express 模块

const express = require('express')

// 创建 express 的服务器实例

const app = express()

// write your code here...
// 调用 app.listen 方法，指定端口号并启动web服务器

app.listen(8000, function () {
  console.log('server running at http://127.0.0.1:8000')
})

a3095b9a103c0f3a633d466e98933760.png

安装nodemon

npm i nodemon

2、配置跨域依赖

npm i cors

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

// 导入 cors 中间件

const cors = require('cors')

// 将 cors 注册为全局中间件

app.use(cors())

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

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

app.use(express.urlencoded({ extended: false }))

4、初始化路由

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

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

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

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

47861b750dfa003fcd7e9e1fa394d613.png

例如：新建用户user路由模块

42f21ed7b1abb7f9b4f06961fc107953.png

在入口文件中注册路由

4c8796c565d1a8dbb902ef718f37deab.png

访问接口（确保服务在运行），没有运行访问不了服务

ee382e04e57f2fcaefa136de696a495f.png

f0f2ced84a6f1637735d8eb625ca7c70.png

2.项目初始化

我们需要在数据库进行存储数据，对数据进行操作，这里使用Mysql，后面改进会使用一个更好用的MongoDB

1.配置MySQL

npm i mysql

2.创建数据库book，并创建一个用户users表格

新建数据库

c527afdb523107a7e3227e4e8ab6c02f.png

4db5b662431e36cc1b0236df70e87a34.png

c26a7863de4746667f9cf818e70ea164.png

601ca0d9e7f9c6425c67a092508d2621.png

创建users表格

cc34d3de00b01e49a74a1df60bfb2324.png

d4fbf17a0a36167b341488cf12b757a0.png

2.实现连接数据库功能

新建db文件夹在其创建index.js连接数据库

6754eed062c257f9dd2f5577c282a407.png

// 导入 mysql 模块

const mysql = require('mysql')

// 创建数据库连接对象

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

// 向外共享 db 数据库连接对象

module.exports = db

3.实现注册功能

1.实现步骤

1. 检测表单数据是否合法

2. 检测用户名是否被占用

3. 对密码进行加密处理

4. 插入新用户

2.检测表单数据是否合法

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

// 接收表单数据

const userinfo = req.body

// 判断数据是否合法

if (!userinfo.username || !userinfo.password) {
  return res.send({ status: 1, message: '用户名或密码不能为空！' })
}

2 检测用户名是否被占用

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

const db=require('../db/index')
2. 定义 SQL 语句：

2.定义SQL语句

const sql=`select * from users where username=?`

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

db.query(sql, [userinfo.username], function (err, results) {
  // 执行 SQL 语句失败

  if (err) {
    return res.send({ status: 1, message: err.message })
 }
  // 用户名被占用

  if (results.length > 0) {
    return res.send({ status: 1, message: '用户名被占用，请更换其他用户名！' })
 }
  // TODO: 用户名可用，继续后续流程...

})

4.对密码进行加密处理

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

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

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

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

npm i bcryptjs

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

const bcrypt=require('bcryptjs')

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

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

5.插入新用户

  1. 定义插入用户的 SQL 语句：
const sql='insert into users set ?'

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

db.query(sql, { username: userinfo.username, password: userinfo.password }, function 
(err, results) {
  // 执行 SQL 语句失败

  if (err) return res.send({ status: 1, message: err.message })
  // SQL 语句执行成功，但影响行数不为 1

  if (results.affectedRows !== 1) {
    return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
 }
  // 注册成功

  res.send({ status: 0, message: '注册成功！' })
})

全部代码

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

 */
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, message: '用户名或密码不能为空！' })
    }
    const sql = `select * from users where username=?`
    db.query(sql, [userinfo.username], function (err, results) {
        // 执行 SQL 语句失败

        if (err) {
            return res.send({ status: 1, message: err.message })
        }
        // 用户名被占用

        if (results.length > 0) {
            return res.send({ status: 1, message: '用户名被占用，请更换其他用户名！' })
        }
        // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串

        userinfo.password = bcrypt.hashSync(userinfo.password, 10)
        const sql = 'insert into users set ?'
        db.query(sql, { username: userinfo.username, password: userinfo.password }, function
            (err, results) {
            // 执行 SQL 语句失败

            if (err) return res.send({ status: 1, message: err.message })
            // SQL 语句执行成功，但影响行数不为 1

            if (results.affectedRows !== 1) {
                return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
            }
            // 注册成功

            res.send({ status: 0, message: '注册成功！' })
        })



    })

}

// 登录的处理函数

exports.login = (req, res) => {
    res.send('login OK')
}

为了方便测试接口我们允许其他字段为空

04cecc94cba46d5c4eefb5cc2ede5cc2.png

967b62c1c79fef2d377a63e266480ee4.png

一开始表里没有数据

17b6f96eea614a5458b453d26fec0b9b.png

我们去测试注册功能（一定要配置解析表单数据的中间件）

2fd884b8470cc529d18db8e01f94301d.png

9250b17c3b60a7b3ff63a5bfe91a1913.png

7c8f2160658805a65c5221bb87bc439f.png

注册功能完成

4.实现登录功能

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

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

 const userinfo = req.body
    const sql = `select * from users where username=?`
    db.query(sql, userinfo.username, function (err, results) {
        // 执行 SQL 语句失败

        if (err) return res.cc(err)
        // 执行 SQL 语句成功，但是查询到数据条数不等于 1

        if (results.length !== 1) return res.send('登录失败！')
        // TODO：判断用户输入的登录密码是否和数据库中的密码一致
        // 拿着用户输入的密码,和数据库中存储的密码进行对比

        const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)

        // 如果对比的结果等于 false, 则证明用户输入的密码错误

        if (!compareResult) {
            return res.send('登录失败！')
        }
        return res.send('登录成功！')



    })

efa2b7df29334d402d4ff2406e59bccf.png

基础登录接口实现

5、认识JWT

首先我们需要认识token

5.1token 是什么

token 是服务端生成并返回给 HTTP 客户端的一串加密字符串， token 中保存着 用户信息

5.2 token 的作用

实现会话控制，可以识别用户的身份，主要用于移动端 APP

5.3 token 的工作流程

5.4 token 的特点

服务端压力更小 数据存储在客户端 相对更安全 数据加密 可以避免 CSRF（跨站请求伪造） 扩展性更强 服务间可以共享 增加服务节点更简单

5.5生成 JWT 的 Token 字符串

JWT（JSON Web Token ）是目前最流行的跨域认证解决方案，可用于基于token的身份验证 JWT 使 token 的生成与校验更规范

我们可以使用jsonwebtoken 包来操作 token

安装生成 Token 字符串的包：

npm i jsonwebtoken

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

// 用这个包来生成 Token 字符串 
constjwt=require('jsonwebtoken')

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

module.exports= {  jwtSecretKey: 'itheima No1. ^_^', }

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

// 导入配置文件

const config = require('../config')

// 生成 Token 字符串

const tokenStr = jwt.sign(user, config.jwtSecretKey, {
  expiresIn: '10h', // token 有效期为 10 个小时

})

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

res.send({
  status: 0,
  message: '登录成功！',
  // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀

  token: 'Bearer ' + tokenStr,
})

5.6配置解析 Token 的中间件

安装解析 Token 的中间件

npm i express-jwt

在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\//]

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

// 错误中间件

app.use(function (err, req, res, next) {
  // 省略其它代码...

  // 捕获身份认证失败的错误

  if (err.name === 'UnauthorizedError') return res.cc('身份认证失败！')
  // 未知错误...

})

分析：

是Express版本和express-jwt的版本不兼容的可能比较大，因为这两个版本都是安装最新版本的，很可能会出现这个问题，通过尝试修改版本并解决了报错问题。
下面附上修改后的版本：

"express": "^4.17.1",
 "express-jwt": "^5.3.3",
 "jsonwebtoken": "^8.5.1",

重新下载依赖

npm i

认识

6、实现数据库命令增删查改的封装

为什么封装？

这样我们一直写数据库操作，代码重复太多，写项目眼花缭乱

封装目的：解决代码冗余

首先我们需要理解ORM （可以在我ORM介绍博客中招） 开发效率快

**先学一下ORM

将db/index.js修改为如下代码

const mysql = require('mysql');
// 数据库连接设置
let db = {
    host: 'localhost',//数据库地址
    port: '3306',
    user: 'root',//用户名，没有可不填
    password: 'root',//密码，没有可不填
    database: 'book'//数据库名称
}

let options = {};
let tableSQL = '';
let isConnect = false;

function Model(name, option) {
    this.name = name;
    this.option = option;
};

/**
* @description: 查询数据
* @param {} options：可选参数
* @param {Function} callback :（req,results）=>{}
*/
Model.prototype.find = function (options, callback) {
    if (!isConnect) {
        console.log(options.constructor);
        this.connect(err => {
            isConnect = true;
            var str = '';
            if (!callback) {
                str = `select * from ${this.name}`;
                callback = options;
            } else if (options.constructor == Array) {
                str = `select ${options.join()} from ${this.name}`;
            } else if (options.constructor == Object) {
                str = `select ${options.arr.join()} from ${this.name} where ${options.where}`;
            } else {
                str = `select * from ${this.name} where ${options}`;
            };
            //console.log(str);
            connection.query(str, (error, results, fields) => {
                callback(error, results, fields);
            });
            return this;
        })
    } else {

        var str = '';
        if (!callback) {
            str = `select * from ${this.name}`;
            callback = options;
        } else if (options.constructor == Array) {
            str = `select ${options.join()} from ${this.name}`;
        } else {
            str = `select * from ${this.name} where ${options}`;
        };
        //console.log(str);
        connection.query(str, (error, results, fields) => {
            callback(error, results, fields);
        });
        return this;
    }

};

/**
* @description: 分页查询
* @param {Object} options :   { where:查询条件, number: 当前页数 , count : 每页数量 }
* @return: 
*/
Model.prototype.limit = function (options, callback) {
    var str = '';
    if (!options.where) {
        str = `select * from ${this.name} limit ${(options.number - 1) * options.count},${options.count}`;
    } else {
        str = str = `select * from ${this.name} where ${options.where} limit ${(options.number - 1) * options.count},${options.count}`;
    };
    console.log(str);
    connection.query(str, (error, results, fields) => {
        callback(error, results, fields);
    });
    return this;
};

/**
* @description: 插入数据
* @param {Object} obj:对象或者数组
* @param {Function} callback :（req,results）=>{}
*/
Model.prototype.insert = function (obj, callback) {
    if (!isConnect) {
        this.connect(err => {
            if (err) {
                throw err;
            } else {
                connection.query(tableSQL, (error, results, fields) => {
                    if (Array.isArray(obj)) {
                        for (var i = 0; i < obj.length; i++) {
                            this.insertObj(obj[i], callback)
                        }
                    } else {
                        this.insertObj(obj, callback)
                    }
                });

            }
        });
    } else {
        if (Array.isArray(obj)) {
            for (var i = 0; i < obj.length; i++) {
                this.insertObj(obj[i], callback)
            }
        } else {
            this.insertObj(obj, callback)
        }
    }

};

Model.prototype.insertObj = function (obj, callback) {
    let keys = [];
    let values = '';
    for (var key in obj) {
        keys.push(key);
        values += `"${obj[key]}",`;
    };
    values = values.replace(/,$/, '');
    let str = `INSERT INTO ${this.name} (${keys.join()}) VALUES (${values})`;
    connection.query(str, (error, results, fields) => {
        callback(error, results);
    });
}

/**
* @description: 更新数据
* @param {Object} option：可选参数 更新条件
* @param {Object} obj： 修改后的数据 
* @param {Function} callback :（req,results）=>{}
*/
Model.prototype.update = function (option, obj, callback) {
    let str = '';
    if (arguments.length == 2) {
        callback = obj;
        obj = option;
        str = `UPDATE ${this.name} SET `;
        for (var key in obj) {
            str += `${key}='${obj[key]}', `;
        };
        str = str.replace(/(, )$/, '');
    } else {
        str = `UPDATE ${this.name} SET `;
        for (var key in obj) {
            str += `${key}='${obj[key]}', `;
        };
        str = str.replace(/(, )$/, '');
        str += ` where ${option}`;
    };

    console.log(str);
    connection.query(str, (error, results, fields) => {
        callback(error, results, fields);
    });
    return this;

};

/**
* @description: 删除数据
* @param {Object} option：可选参数 删除条件
* @param {Function} callback :（req,results）=>{}
*/
Model.prototype.delete = function (option, callback) {
    var str = '';
    if (!callback) {
        str = `delete from ${this.name}`;
        callback = option;
    } else {
        str = `delete from ${this.name} where ${option}`;
    };
    console.log(str);
    connection.query(str, (error, results, fields) => {
        callback(error, results, fields);
    });
    return this;
};

/**
* @description: 执行sql语句
* @param {String} str : sql语句
* @param {Function} callback :（req,results）=>{}
*/
Model.prototype.sql = function (str, callback) {
    connection.query(str, (error, results, fields) => {
        callback(error, results, fields);
    });
    return this;
};

/**
* @description: 删除model表格 （慎用！）
* @param {type} 
* @return: 
*/
Model.prototype.drop = function (callback) {
    connection.query(`DROP TABLE ${this.name}`, (error, results, fields) => {
        callback(error, results, fields);
    });
    return this;
};

//连接检测
Model.prototype.connect = function (callback) {
    let p1 = new Promise((resolve, reject) => {
        connection.connect((err) => {
            if (err) {
                //console.log(err.stack);
                //console.log(err);//42000 数据库不存在  28000账号错误
                //console.log(err.sqlState);//42000 数据库不存在  28000账号错误
                reject(err);
            } else {
                resolve();
            }
        });
    });

    p1.then(() => {
        callback(null);
    }, err => {
        if (err.sqlState == 42000) {
            createDatabase(callback);
        } else if (err.sqlState == 28000) {
            callback('数据库账号或密码错误');
        } else {
            callback(err);
        }
    });
};

//创建数据库
let createDatabase = function (callback) {
    let p2 = new Promise((resolve, reject) => {
        connection = mysql.createConnection({
            host: options.host,//数据库地址
            port: options.port,//端口号
            user: options.user,//用户名，没有可不填
            password: options.password,//密码，没有可不填
        });
        connection.connect((err) => {
            //if (err) throw error;
            if (err) {
                reject(err);
            } else {
                resolve();
            }
        });
    });

    let p3 = new Promise((resolve, reject) => {
        connection.query(`CREATE DATABASE ${options.database}`, (err, results, fields) => {
            //if (error) throw error;
            if (err) {
                reject(err);
            } else {
                resolve();
            }

        });
    });

    let p4 = new Promise((resolve, reject) => {
        connection.query(`use ${options.database}`, (err, results, fields) => {
            if (err) {
                reject(err);
            } else {
                resolve();
            }
        });
    });

    let pAll = Promise.all([p2, p3, p4]);

    pAll.then(() => {
        callback(null);
    }).catch((err) => {
        callback(err);
    });
}



let orm = {
    /**
    * @description:连接数据库
    * @param {String} host: 主机名 默认localhost
    * @param {Number} port: 端口号 默认3306
    * @param {String} user: 用户名 
    * @param {String} password: 密码 
    * @param {String} database: 数据库名称 默认og
    * @return: 
    */
    connect: function ({ host = 'localhost', port = 3306, user = '', password = '', database = 'og' }) {
        databaseName = database;//全局存储当前数据库名称

        options = {
            host,//数据库地址
            port,//端口号
            user,//用户名，没有可不填
            password,//密码，没有可不填
            database//数据库名称
        };
        connection = mysql.createConnection(options);

    },
    /**
    * @description:创建model (表格模型对象)
    * @param {String} name:表格名称
    * @param {Object} options:表格数据结构
    * @return: Model对象：负责数据库增删改查
    */
    model: function (name, options) {
        let str = 'id int primary key auto_increment, ';
        for (var key in options) {
            if (options[key] == Number) {
                str += `${key} numeric,`;
            } else if (options[key] == Date) {
                str += `${key} timestamp,`;
            } else {
                str += `${key} varchar(255),`;
            }
        };
        str = str.replace(/,$/, '');
        //console.log(`CREATE TABLE ${name} (${str})`);
        //console.log(str);
        tableSQL = `CREATE TABLE ${name} (${str})`;
        return new Model(name, options);
    }
};

orm.connect(db);



module.exports = orm;

新建文件夹handleDB/index.js数据库操作进行封装

const db = require('../db/index')

function handleDB(res, tableName, methodName, errorMsg, n1, n2) {
    //数据库操作
    let Model = db.model(tableName);  // 表映射为模型, 参数是要操作的这个表的表名
    let results;  //results就收查询到的数据
    try {
        results = new Promise((resolve, reject) => {
            // Model.find("id>=15",(err,data)=>{   //直接调用不封装
            if (!n1) {
                Model[methodName]((err, data) => {    //封装的时候使用这种格式 
                    if (err) reject(err);   // 失败的时候调用reject()
                    resolve(data);    //成功的时候调用resolve() 
                });
                return
            }
            //能够给执行到这里说明n1已经传进来了！
            if (!n2) {
                Model[methodName](n1, (err, data) => {    //封装的时候使用这种格式 
                    if (err) reject(err);   // 失败的时候调用reject()
                    resolve(data);    //成功的时候调用resolve() 
                });
                return
            }
            //能够给执行到这里说明n1和n2已经传进来了！
            Model[methodName](n1, n2, (err, data) => {    //封装的时候使用这种格式 
                if (err) reject(err);   // 失败的时候调用reject()
                resolve(data);    //成功的时候调用resolve() 
            });

        })
    } catch (err) {
        console.log(err); // 给后台看到的
        res.send({ errMsg: errorMsg }); //给前端送过去的
        return
    }

    return results
}

module.exports = handleDB

完善获取数据库数据的写法

async+await版本

app.get("/",(req, res)=>{

    (async function(){
        let Student = db.model("students");  //获取学生表模型
        let results = await new Promise((resolve,reject)=>{
            Student.find('id>3',(err,data)=>{
                if(err)reject(err);
                resolve(data);
            });    
        })

        res.send(results);
    })();
})

带捕获异常的版本

(async function(){
    let Student = db.model("students");  //获取学生表模型
    let results 
    try{
        results = await new Promise((resolve,reject)=>{
            Student.find('id>3',(err,data)=>{
                if(err)reject(err);
                resolve(data);
            });    
        })
    }catch(err){
        console.log(err);
        res.send({errmsg:"数据库查询出错"})
        return
    }
    res.send(results);
})();

测试（注意先把登录和注册接口注释掉）

7、注册和登录功能的优化

对注册逻辑代码进行修改

修改代码为

// 注册用户的处理函数

exports.regUser = (req, res) => {
    (async function () {
        // 1.接收表单数据
        console.log(req);
        const userinfo = req.body
        console.log(userinfo);
        // 2.判断数据是否合法
        if (!userinfo.username || !userinfo.password) {
            return res.send({ status: 1, message: '用户名或密码不能为空！' })
        }
        // 3.查询数据库，看看是否存在这个用户名
        let result = await handleDB(res, "users", "find", "users数据库查询出错", `username="${userinfo.username}"`)
        //username="${userinfo.username}"这里注意加引号！！！
        // 4.如果已经存在，返回用户名已经被注册 return
        if (result.length > 0) {
            res.send({ status: 1, message: "用户名已经被注册,请更换其他用户名！" });
            return
        }
        // 5、不存在，则往数据库中新增加一条记录
        // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
        userinfo.password = bcrypt.hashSync(userinfo.password, 10)
        let result2 = await handleDB(res, "users", "insert", "users数据库新增出错", {
            username: userinfo.username,
            password: userinfo.password,
        })
        // SQL 语句执行成功，但影响行数不为 1
        if (result2.affectedRows !== 1) {
            return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
        }
        res.send({ status: 0, message: '注册成功！' })
    })();
}

对登录逻辑代码进行修改

原来代码

  db.query(sql, userinfo.username, function (err, results) {
        // 执行 SQL 语句失败
        if (err) return res.cc(err)
        // 执行 SQL 语句成功，但是查询到数据条数不等于 1
        if (results.length !== 1) return res.send('登录失败！')
        // TODO：判断用户输入的登录密码是否和数据库中的密码一致
        // 拿着用户输入的密码,和数据库中存储的密码进行对比
        const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)
        // 生成 Token 字符串
        // 剔除完毕之后，user 中只保留了用户的 id, username, nick_name, email等 属性的值
        const user = { ...results[0], password: '', }
        const tokenStr = jwt.sign(user, config.jwtSecretKey, {
            expiresIn: '10h', // token 有效期为 10 个小时

        })
        // 如果对比的结果等于 false, 则证明用户输入的密码错误
        if (!compareResult) {
            return res.send('登录失败！')
        }
        return res.send({
            status: 0,
            message: '登录成功！',
            // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀

            token: 'Bearer ' + tokenStr,
        })




    })

修改后代码

// 登录的处理函数

exports.login = (req, res) => {
    (async function () {
        // 1、获取参数，判空  （用户名、密码）
        let { username, password } = req.body
        if (!username || !password) {
            res.send({ status: 1, message: "缺少必传参数" });
            return
        }
        // 2、查询数据库,验证手机号码是不是已经注册了
        let result = await handleDB(res, "users", "find", "users数据库查询出错", `username="${username}"`);
        // 3、如果没有注册，则返回用户名未注册，登录失败 return
        if (result.length == 0) {
            res.json({ status: 1, message: "用户名未注册，无法登录" });
            return
        }
        // 4、校验密码是否正确,如果不正确 就return
        // 拿着用户输入的密码,和数据库中存储的密码进行对比
        const compareResult = bcrypt.compareSync(password, result[0].password)
        // 如果对比的结果等于 false, 则证明用户输入的密码错误
        if (!compareResult) {
            return res.send({ status: 1, message: '用户名或者密码错误，登录失败！' })
        }
        // 剔除完毕之后，user 中只保留了用户的 id, username, 等 属性的值
        const user = { ...result[0], password: '', }
        const tokenStr = jwt.sign(user, config.jwtSecretKey, {
            expiresIn: '10h', // token 有效期为 10 个小时

        })
        return res.send({
            status: 0,
            message: '登录成功！',
            // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀
            token: 'Bearer ' + tokenStr,
        })

    })();


}

在配置cookie和session获取登录用户id，保存在会话之中差不多登录和注册接口功能基本完成了。

8.添加cookie和session的配置

这样写太长了我靠，我得一个一个模块去写才行，拉得真长

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

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

相关文章

[FSCTF 2023] web题解

[FSCTF 2023] web题解

文章目录 源码&#xff01;启动!webshell是啥捏细狗2.0ez_php1Hello,youEZ_eval 源码&#xff01;启动! 打开题目&#xff0c;发现右键被禁了 直接ctrlu查看源码得到flag webshell是啥捏 源码 <?php highlight_file(__FILE__); $&#x1f600;"a"; $&#x…
阅读更多...
CE-LVD证书跟CE-EMC证书有什么区别？

CE-LVD证书跟CE-EMC证书有什么区别？

CE-LVD证书跟CE-EMC证书有什么区别&#xff1f; CE-LVD证书跟CE-EMC证书有什么区别&#xff1f; 近日&#xff0c;TEMU平台电器需提交CE-LVD证书&#xff0c;不再接受EMC证书---玩具产品需提交满足玩具法规的CE证书&#xff0c;法规总是多变的&#xff0c;卖家也是很苦恼&…
阅读更多...
html web前端，登录，post请求提交 json带参

html web前端，登录，post请求提交 json带参

html web前端&#xff0c;登录&#xff0c;post请求提交 json带参 3ca9855b3fd279fa17d46f01dc652030.jpg <!DOCTYPE html> <html><head><meta http-equiv"Content-Type" content"text/html; charsetutf-8" /><title></t…
阅读更多...
Redis 主从复制和哨兵监控，实现Redis高可用配置

Redis 主从复制和哨兵监控，实现Redis高可用配置

文章目录 一、概述二、主从复制模拟说明三、准备配置文件四、启动Redis实例五、主从复制配置5.1 命令方式启用和取消主从复制5.2 配置文件方式启用和取消主从复制5.3 测试主从复制5.4 有其主从复制的其他参数配置 六、Sentinel 配置6.1 Sentinel 的作用6.2 Sentinel 监控说明6.…
阅读更多...
mysql-linux归档版安装

mysql-linux归档版安装

什么是归档版安装&#xff1f;简单来说就是编译好的软件压缩打包版。 说明&#xff1a;我这里服务器之前已经装过一个不同版本的mysql&#xff0c;已经占用了3306端口&#xff0c;所以这里我用3307端口来演示&#xff0c;命令和官方的稍有不同&#xff0c;不过步骤都是差不多的…
阅读更多...
RobotFramework+Eclispe环境安装篇

RobotFramework+Eclispe环境安装篇

环境安装是学习任何一个新东西的第一步&#xff0c;这一步没走舒坦&#xff0c;那后面就没有心情走下去了。 引用名句&#xff1a;工欲善其事必先利其器&#xff01;&#xff01; Robotframework&#xff1a;一款 自动化测试框架。 Eclipse&#xff1a;一款编辑工具。可以编…
阅读更多...
HugeGraph Hubble 配置 https 协议的操作步骤

HugeGraph Hubble 配置 https 协议的操作步骤

背景 HugeGraph 图数据库的 Server 端支持 https 配置&#xff0c;官方文档中有说明相对比较容易&#xff0c;而 Hubble 部署过程都是 http的。 我们有一个应用要嵌入 hubble 页面&#xff0c;而且部署为 https &#xff0c;那么 Hubble 是否支持配置 https 呢&#xff1f;网…
阅读更多...
windows 设置nginx、redis、jar包开机自启、mysql自动备份

windows 设置nginx、redis、jar包开机自启、mysql自动备份

1、--------------设置nginx------------------- cd到nginx 根目录与nginx.exe平齐 1.1下载WinSW.NET4.exe 放入nginx.exe平齐目录命名为nginx-servier.exe 链接: https://pan.baidu.com/s/1obKTinD1Z9BKgMJxZMtk2Q?pwdg47u 提取码: g47u 复制这段内容后打开百度网盘手机App…
阅读更多...
计算机网络【CN】IPV4报文格式

计算机网络【CN】IPV4报文格式

版本&#xff08;4bit&#xff09;&#xff1a;IPV4/IPV6首部长度&#xff08;4bit&#xff09;&#xff1a;标识首部的长度 单位是4B最小为&#xff1a;20B最大为&#xff1a;60&#xff08;15*4&#xff09;B总长度&#xff08;16bit&#xff09;&#xff1a;整个数据报&…
阅读更多...
为什么自动驾驶需要5G？

为什么自动驾驶需要5G？

什么叫自动驾驶&#xff1f; 自动驾驶分为6个等级&#xff1a; Level 0&#xff1a;人工驾驶&#xff0c;无驾驶辅助系统&#xff0c;仅提醒。 Level 1&#xff1a;辅助人工驾驶&#xff0c;可实现单一的车速或转向控制自动化&#xff0c;仍由人工驾驶&#xff08;如定速巡航…
阅读更多...
[Database] MySQL 8.x Window / Partition Function (窗口/分区函数)

[Database] MySQL 8.x Window / Partition Function (窗口/分区函数)

&#x1f9f2;相关文章 [1] MySQL 系统表解析以及各项指标查询 [2] MySQL 5.7 JSON 字段的使用的处理 [3] MySQL经典练习50题 简介 MySQL 8.0版本开始支持窗口函数 官方文档 在之前的版本中已存在的大部分聚合函数&#xff0c;在MySQL 8 中也可以作为窗口函数来使用 方法 / …
阅读更多...
day11力扣打卡

day11力扣打卡

打卡记录 避免洪水泛滥&#xff08;贪心 Map Set&#xff09; 链接 将晴天的日期全部记录到 set 中。 使用 unordered_map 来记录每个湖泊上一次下雨的日期。 当下雨时&#xff0c;湖泊已经水满了时&#xff0c;查询到上次下雨的日期。 通过这个日期在晴天记录中查找对应的…
阅读更多...
第2篇 机器学习基础 —（2）分类和回归

第2篇 机器学习基础 —（2）分类和回归

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。机器学习中的分类和回归都是监督学习的问题。分类问题的目标是将输入数据分为不同的类别&#xff0c;而回归问题的目标是预测一个连续的数值。分类问题输出的是物体所属的类别&#xff0c;而回归问题输出的是数值。本节课就…
阅读更多...
对mysql的联合索引的深刻理解

对mysql的联合索引的深刻理解

背景 对mysql的联合索引的考察是Java程序员面试高频考点&#xff01;必须深刻理解掌握否则容易丢分非常可惜。 技术难点 考察对最左侧匹配原理理解。 原理 暂且不表。网上讲这非常多。我理解就是&#xff0c;B树每个非叶子节点的值都是有序存放索引的值。 比如对A、B、C …
阅读更多...
Unity中国、Cocos为OpenHarmony游戏生态插上腾飞的翅膀

Unity中国、Cocos为OpenHarmony游戏生态插上腾飞的翅膀

2023年是OpenHarmony游戏生态百花齐放的一年&#xff01;为了扩展OpenHarmony游戏生态&#xff0c;OpenHarmony在基金会成立了游戏SIG小组&#xff0c;游戏SIG小组联合cocos&#xff0c;从cocos2dx入手一周内快速适配了cocos2.2.6的MVP版本&#xff0c;随后又分别适配了cocos2d…
阅读更多...
【Leetcode】200. 岛屿数量

【Leetcode】200. 岛屿数量

给你一个由 1&#xff08;陆地&#xff09;和 0&#xff08;水&#xff09;组成的的二维网格&#xff0c;请你计算网格中岛屿的数量。 岛屿总是被水包围&#xff0c;并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外&#xff0c;你可以假设该网格的四条边…
阅读更多...
体外循环手术中循环管路灌注流量精密自动控制解决方案

体外循环手术中循环管路灌注流量精密自动控制解决方案

摘要&#xff1a;在目前的体外循环手术过程中&#xff0c;需要灌注师快速而精确地操作使得血液流速调节到期望的目标值。基于国外文献报道的血流量自动控制方法和装置&#xff0c;本文提出了技术改进且国产化解决方案。通过本解决方案中增加的国产系列电控夹管阀、电控针阀和具…
阅读更多...
css属性clip-path的使用说明

css属性clip-path的使用说明

前言 当ui设计上的图片、div等的形状不是长方形&#xff0c;而是多边形的时候&#xff0c;就可以借助clip-path这个css属性来实现。 clip-path CSS 属性使用裁剪方式创建元素的可显示区域。区域内的部分显示&#xff0c;区域外的隐藏。【from: MDN】 clip-path可以理解为一把剪…
阅读更多...
一种基于Redis时间和权重关联的分布式优先级队列方法

一种基于Redis时间和权重关联的分布式优先级队列方法

技术背景&#xff1a; 深度学习平台&#xff08;或存在异步任务调度的平台&#xff09;&#xff0c;存在不同的操作用户&#xff0c;用户存在不同的部门&#xff0c;调度的硬件服务器资源&#xff0c;按照不同的资源类型&#xff0c;操作系统&#xff0c;GPU卡的型号区分成不同…
阅读更多...
Jenkins入门级安装部署

Jenkins入门级安装部署

前言 Jenkins是一个开源软件项目&#xff0c;是基于Java开发的一种持续集成工具&#xff0c;用于监控持续重复的工作&#xff0c;旨在提供一个开放易用的软件平台&#xff0c;使软件项目可以进行持续集成。通常&#xff0c;项目中常用Jenkins作为编译打包项目的工具&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023