nodejs + express + mssql 封装数据操作（nodejs mysql封装）

25-04-29 1

对于想了解nodejs+express+mssql封装数据操作的读者，本文将是一篇不可错过的文章，我们将详细介绍nodejsmysql封装，并且为您提供关于3Express-NodeJs+Expres

对于想了解nodejs + express + mssql 封装数据操作的读者，本文将是一篇不可错过的文章，我们将详细介绍nodejs mysql封装，并且为您提供关于3 Express-NodeJs+Express+Mysql实战、Express engine 学习笔记 - 工作在反向代理背后的 Express 设置、express express-generator node-dev 自动重新加载重启、Express express-session的有价值信息。

本文目录一览：

nodejs + express + mssql 封装数据操作（nodejs mysql封装）
3 Express-NodeJs+Express+Mysql实战
Express engine 学习笔记 - 工作在反向代理背后的 Express 设置
express express-generator node-dev 自动重新加载重启
Express express-session

nodejs + express + mssql 封装数据操作（nodejs mysql封装）

在网上看到有一些nodejs连接sqlserver的相关教程，但非常少，而且很多都有错，特别是操作数据库的语句，在这里我做了一番整理，搭建一个完整的nodejs后台，并封装sqlserver的操作。

nodejs的安装和express的安装在这里就不多说，网上都有教程，不会的网上一搜都有。

然后安装mssql，在terminal中进入你的项目文件夹，输入命令：npm install mssql，等待片刻，即完成了安装。

这个时候新建一个db.js(名字随便)，开始封装数据操作。我一般会新建一个与routes,views同级的文件夹，放一些公共的js，比如分页函数分封装page.js等等。下面开始封装数据库。

先放代码：

/**
 *sqlserver Model
 **/
const mssql = require("mssql");
const conf = require("../config.js");

const pool = new mssql.ConnectionPool(conf)
const poolConnect = pool.connect()

pool.on(''error'', err => {
    console.log(''error: '', err)
})
/**
 * 自由查询
 * @param sql sql语句，例如: ''select * from news where id = @id''
 * @param params 参数，用来解释sql中的@*，例如： { id: id }
 * @param callBack 回调函数
 */
let querySql = async function (sql, params, callBack) {
    try {
        let ps = new mssql.PreparedStatement(await poolConnect);
        if (params != "") {
            for (let index in params) {
                if (typeof params[index] == "number") {
                    ps.input(index, mssql.Int);
                } else if (typeof params[index] == "string") {
                    ps.input(index, mssql.NVarChar);
                }
            }
        }
        ps.prepare(sql, function (err) {
            if (err)
                console.log(err);
            ps.execute(params, function (err, recordset) {
                callBack(err, recordset);
                ps.unprepare(function (err) {
                    if (err)
                        console.log(err);
                });
            });
        });
    } catch (e) {
        console.log(e)
    }
};

/**
 * 按条件和需求查询指定表
 * @param tableName 数据库表名，例：''news''
 * @param topNumber 只查询前几个数据，可为空，为空表示查询所有
 * @param whereSql 条件语句，例：''where id = @id''
 * @param params 参数，用来解释sql中的@*，例如： { id: id }
 * @param orderSql 排序语句，例：''order by created_date''
 * @param callBack 回调函数
 */
let select = async function (tableName, topNumber, whereSql, params, orderSql, callBack) {
    try {
        let ps = new mssql.PreparedStatement(await poolConnect);
        let sql = "select * from " + tableName + " ";
        if (topNumber != "") {
            sql = "select top(" + topNumber + ") * from " + tableName + " ";
        }
        sql += whereSql + " ";
        if (params != "") {
            for (let index in params) {
                if (typeof params[index] == "number") {
                    ps.input(index, mssql.Int);
                } else if (typeof params[index] == "string") {
                    ps.input(index, mssql.NVarChar);
                }
            }
        }
        sql += orderSql;
        console.log(sql);
        ps.prepare(sql, function (err) {
            if (err)
                console.log(err);
            ps.execute(params, function (err, recordset) {
                callBack(err, recordset);
                ps.unprepare(function (err) {
                    if (err)
                        console.log(err);
                });
            });
        });
    } catch (e) {
        console.log(e)
    }
};

/**
 * 查询指定表的所有数据
 * @param tableName 数据库表名
 * @param callBack 回调函数
 */
let selectAll = async function (tableName, callBack) {
    try {
        let ps = new mssql.PreparedStatement(await poolConnect);
        let sql = "select * from " + tableName + " ";
        ps.prepare(sql, function (err) {
            if (err)
                console.log(err);
            ps.execute("", function (err, recordset) {
                callBack(err, recordset);
                ps.unprepare(function (err) {
                    if (err)
                        console.log(err);
                });
            });
        });
    } catch (e) {
        console.log(e)
    }
};

/**
 * 添加字段到指定表
 * @param addObj 需要添加的对象字段，例：{ name: ''name'', age: 20 }
 * @param tableName 数据库表名
 * @param callBack 回调函数
 */
let add = async function (addObj, tableName, callBack) {
    try {
        let ps = new mssql.PreparedStatement(await poolConnect);
        let sql = "insert into " + tableName + "(";
        if (addObj != "") {
            for (let index in addObj) {
                if (typeof addObj[index] == "number") {
                    ps.input(index, mssql.Int);
                } else if (typeof addObj[index] == "string") {
                    ps.input(index, mssql.NVarChar);
                }
                sql += index + ",";
            }
            sql = sql.substring(0, sql.length - 1) + ") values(";
            for (let index in addObj) {
                if (typeof addObj[index] == "number") {
                    sql += addObj[index] + ",";
                } else if (typeof addObj[index] == "string") {
                    sql += "''" + addObj[index] + "''" + ",";
                }
            }
        }
        sql = sql.substring(0, sql.length - 1) + ") SELECT @@IDENTITY id"; // 加上SELECT @@IDENTITY id才会返回id
        ps.prepare(sql, function (err) {
            if (err) console.log(err);
            ps.execute(addObj, function (err, recordset) {
                callBack(err, recordset);
                ps.unprepare(function (err) {
                    if (err)
                        console.log(err);
                });
            });
        });
    } catch (e) {
        console.log(e)
    }
};

/**
 * 更新指定表的数据
 * @param updateObj 需要更新的对象字段，例：{ name: ''name'', age: 20 }
 * @param whereObj 需要更新的条件，例: { id: id }
 * @param tableName 数据库表名
 * @param callBack 回调函数
 */
let update = async function (updateObj, whereObj, tableName, callBack) {
    try {
        let ps = new mssql.PreparedStatement(await poolConnect);
        let sql = "update " + tableName + " set ";
        if (updateObj != "") {
            for (let index in updateObj) {
                if (typeof updateObj[index] == "number") {
                    ps.input(index, mssql.Int);
                    sql += index + "=" + updateObj[index] + ",";
                } else if (typeof updateObj[index] == "string") {
                    ps.input(index, mssql.NVarChar);
                    sql += index + "=" + "''" + updateObj[index] + "''" + ",";
                }
            }
        }
        sql = sql.substring(0, sql.length - 1) + " where ";
        if (whereObj != "") {
            for (let index in whereObj) {
                if (typeof whereObj[index] == "number") {
                    ps.input(index, mssql.Int);
                    sql += index + "=" + whereObj[index] + " and ";
                } else if (typeof whereObj[index] == "string") {
                    ps.input(index, mssql.NVarChar);
                    sql += index + "=" + "''" + whereObj[index] + "''" + " and ";
                }
            }
        }
        sql = sql.substring(0, sql.length - 5);
        ps.prepare(sql, function (err) {
            if (err)
                console.log(err);
            ps.execute(updateObj, function (err, recordset) {
                callBack(err, recordset);
                ps.unprepare(function (err) {
                    if (err)
                        console.log(err);
                });
            });
        });
    } catch (e) {
        console.log(e)
    }
};

/**
 * 删除指定表字段
 * @param whereSql 要删除字段的条件语句，例：''where id = @id''
 * @param params 参数，用来解释sql中的@*，例如： { id: id }
 * @param tableName 数据库表名
 * @param callBack 回调函数
 */
let del = async function (whereSql, params, tableName, callBack) {
    try {
        let ps = new mssql.PreparedStatement(await poolConnect);
        let sql = "delete from " + tableName + " ";
        if (params != "") {
            for (let index in params) {
                if (typeof params[index] == "number") {
                    ps.input(index, mssql.Int);
                } else if (typeof params[index] == "string") {
                    ps.input(index, mssql.NVarChar);
                }
            }
        }
        sql += whereSql;
        ps.prepare(sql, function (err) {
            if (err)
                console.log(err);
            ps.execute(params, function (err, recordset) {
                callBack(err, recordset);
                ps.unprepare(function (err) {
                    if (err)
                        console.log(err);
                });
            });
        });
    } catch (e) {
        console.log(e)
    }
};

exports.config = conf;
exports.del = del;
exports.select = select;
exports.update = update;
exports.querySql = querySql;
exports.selectAll = selectAll;
exports.add = add;

在这里还需要一个config.js:

let app = {
    user: ''sa'',
    password: '''',
    server: ''localhost'',
    database: ''database'',
    port: 1433,
    options: {
        encrypt: true // Use this if you''re on Windows Azure
        enableArithAbort: true,
    },
    pool: {
        min: 0,
        max: 10,
        idleTimeoutMillis: 3000
    }
};

module.exports = app;

这就完成了封装，网上很多教程都是用的mssql.Connection()但是会发现有些会报错并没有这个函数，还有些改成mssql.connect(),虽然可以了，但是在第二次用到数据库的地方就会报错大致是你的数据库已经连接，需要关闭后才可以再连接。而用mssql.ConnectionPool()就没有这些问题,下面是使用，以index.js为例：

const express = require(''express'');
const db = require(''../utils/db.js'');
const moment = require(''moment'');
const router = express.Router();

/* GET home page. */
router.get(''/'', function (req, res, next) {
    db.selectAll(''news'', function (err, result) {//查询所有news表的数据
        res.render(''newsList'', {results:records.recordset, moment:moment});
    });
});
router.get(''/delete/:id'', function (req, res, next) {//删除一条id对应的news表的数据
    var id = req.params.id;
    db.del("where id = @id", {id:id}, "news", function(err, result){
        res.redirect(''back'');//返回前一个页面
    });
});
router.post(''/update/:id'', function (req, res, next) {//更新一条对应id的news表的数据
    var id = req.params.id;
    var content = req.body.content;
    db.update({content:content}, {id:id}, "news", function(err, result){
        res.redirect(''back'');
    });
});

module.exports = router;

这样就实现了nodejs和mssql的使用

3 Express-NodeJs+Express+Mysql实战

Express新手入门：基于 Node.js 平台的 web 应用开发框架
http://www.expressjs.com.cn/

本章节主要参考 nswbmw教程已经写的很棒了，直接将其教程地址为大家转载过来

- [初始化一个 Express 项目](https://github.com/nswbmw/N-blog/blob/master/book/3.1%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%B8%80%E4%B8%AA%20Express%20%E9%A1%B9%E7%9B%AE.md)
    - [supervisor](https://github.com/nswbmw/N-blog/blob/master/book/3.1%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%B8%80%E4%B8%AA%20Express%20%E9%A1%B9%E7%9B%AE.md#311-supervisor)
- [路由](https://github.com/nswbmw/N-blog/blob/master/book/3.2%20%E8%B7%AF%E7%94%B1.md)
    - [express.Router](https://github.com/nswbmw/N-blog/blob/master/book/3.2%20%E8%B7%AF%E7%94%B1.md#321-expressrouter)
- [模板引擎](https://github.com/nswbmw/N-blog/blob/master/book/3.3%20%E6%A8%A1%E6%9D%BF%E5%BC%95%E6%93%8E.md)
    - [ejs](https://github.com/nswbmw/N-blog/blob/master/book/3.3%20%E6%A8%A1%E6%9D%BF%E5%BC%95%E6%93%8E.md#331-ejs)
    - [includes](https://github.com/nswbmw/N-blog/blob/master/book/3.3%20%E6%A8%A1%E6%9D%BF%E5%BC%95%E6%93%8E.md#332-includes)
- [Express 浅析](https://github.com/nswbmw/N-blog/blob/master/book/3.4%20Express%20%E6%B5%85%E6%9E%90.md)
    - [中间件与 next](https://github.com/nswbmw/N-blog/blob/master/book/3.4%20Express%20%E6%B5%85%E6%9E%90.md#341-中间件与-next)
    - [错误处理](https://github.com/nswbmw/N-blog/blob/master/book/3.4%20Express%20%E6%B5%85%E6%9E%90.md#342-错误处理)

Express engine 学习笔记 - 工作在反向代理背后的 Express 设置

第22行的 express，返回的是一个 express Application 实例。

再看该实例的 set 方法：

app.set(name, value)

将设置名称分配给值。您可以存储您想要的任何值，但某些名称可用于配置服务器的行为。这些特殊名称列在应用程序设置表中。

为布尔属性调用 app.set(‘foo’, true) 与调用 app.enable(‘foo’) 相同。同样，为布尔属性调用 app.set(‘foo’, false) 与调用 app.disable(‘foo’) 相同。

使用 app.get() 检索设置的值。

Express behind proxies

在反向代理后面运行 Express 应用程序时，某些 Express API 可能返回与预期不同的值。为了对此进行调整，可以使用 trust proxy 应用程序设置来公开 Express API 中反向代理提供的信息。

最常见的问题是公开客户端 IP 地址的 express API 可能会显示反向代理的内部 IP 地址。这并不是我们期望的。

server.set(''trust proxy'', ''loopback'');

trust proxy 的属性可以设置成以下几种类型：

设置成 boolean

如果为 true，则客户端的 IP 地址被理解为 X-Forwarded-For 标头中最左侧的条目。

如果为 false，则应用程序被理解为直接面向客户端，并且客户端的 IP 地址来自 req.socket.remoteAddress。这是默认设置。

设置为 true 时，确保最后一个受信任的反向代理删除/覆盖以下所有 HTTP 标头很重要：X-Forwarded-For、X-Forwarded-Host 和 X-Forwarded-Proto，否则的话，客户可能为这几个字段提供任何价值。

设置成 ip 地址

作为反向代理信任的 IP 地址、子网或一组 IP 地址和子网。以下列表显示了预配置的子网名称：

loopback - 127.0.0.1/8, ::1/128
linklocal - 169.254.0.0/16, fe80::/10
uniquelocal - 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fc00::/7

一些例子：

app.set(''trust proxy'', ''loopback'') // specify a single subnet
app.set(''trust proxy'', ''loopback, 123.123.123.123'') // specify a subnet and an address
app.set(''trust proxy'', ''loopback, linklocal, uniquelocal'') // specify multiple subnets as CSV
app.set(''trust proxy'', [''loopback'', ''linklocal'', ''uniquelocal'']) // specify multiple subnets as an array

指定时，IP 地址或子网将被排除在地址确定过程之外，并且离应用服务器最近的不受信任的 IP 地址被确定为客户端的 IP 地址。这通过检查 req.socket.remoteAddress 是否可信来工作。如果是，则从右到左检查 X-Forwarded-For 中的每个地址，直到第一个不可信地址。

启用信任代理将产生以下影响：

req.hostname 的值来自 X-Forwarded-Host 头中设置的值，可以由客户端或代理设置。
X-Forwarded-Proto 可以由反向代理设置来告诉应用程序是 https 还是 http 甚至是无效名称。该值由 req.protocol 反映。
req.ip 和 req.ips 值基于套接字地址和 X-Forwarded-For 标头填充，从第一个不受信任的地址开始。

更多Jerry的原创文章，尽在：“汪子熙”:

本文同步分享在博客“汪子熙”（CSDN）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

express express-generator node-dev 自动重新加载重启

如果是express-generator创建的项目，创建完成时会提示：

run the app:
  $ DEBUG=myapp:* npm start

也就是建议你以npm start方式来启动应用。

其实npm start对应的是package.json中的：

  "scripts": {
    "start": "node ./bin/www"
  },

所以呢，如果你用node-dev来实现自动重启，
一种方式是DEBUG=myapp:* node-dev ./bin/www
另一种方式是修改package.json

  "scripts": {
    "start": "node-dev ./bin/www"
  },

然后还是运行DEBUG=myapp:* npm start来启动应用。

而不是其它文章里写的node-dev app.js，
因为你的应用是最新版express-generator创建的。

（注意：请将myapp改成你的项目名称）

另外收录几个常用的重启或者说进程管理的包：
生产环境用：pm2，forever
开发环境用：node-dev，nodemon，supervisor
这些都只是听说，我也只是刚开始用node.js做网站开发。

Express express-session

会话是什么?

会话是一种持久的网络协议，用于完成服务器和客户端之间的一些交互行为。会话是一个比连接粒度更大的概念，一次会话可能包含多次连接，每次连接都被认为是会话的一次操作。http会话是无状态的, 解决http无状态的方法有cookie和session;

Session一般译作会话，牛津词典对其的解释是进行某活动连续的一段时间。在web应用的用户看来，session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而session保存在服务器上。

客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上.客户端浏览器再次访问时只需要从该Session中查找该客户的状态就可以了。

关于nodejs + express + mssql 封装数据操作和nodejs mysql封装的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于3 Express-NodeJs+Express+Mysql实战、Express engine 学习笔记 - 工作在反向代理背后的 Express 设置、express express-generator node-dev 自动重新加载重启、Express express-session的相关信息，请在本站寻找。

本文标签：