KOA2 + MongoDB 和 MySQL混用的項目 nodejs restful API框架

時間 2019-12-01

標籤 koa2 koa mongodb mysql 混用項目 nodejs restful api 框架欄目 MongoDB 简体版

原文原文鏈接

有時候因項目須要.在koa中須要使用多個數據庫和多種數據庫

此以 MongoDB 和 MySQL爲例

此項目中用到了2個MySQL 和多個MongoDB,其中MongoDB的庫名生成是由時間生成的如2018_11_09,這種採用動態庫名連接的方式進行鏈接.

github地址: github.com/langyuxians…
html

能夠與配套的管理後臺一塊兒使用 github.com/langyuxians…
前端

若是對你有幫助的話,歡迎star,有問題請在此留言vue

也能夠在github Issues提問或者直接聯繫做者 109643291@qq.comnode

歡迎加入做者所在的QQ羣: 46153838 mysql

做者我的網站: www.hao2013.cngit

CSDN: blog.csdn.net/qq_33270001es6

首先建立一個全局的配置 config.js配置以下:github

import path from 'path';
 
// 系統配置
export const System = {
    API_server_type: 'http://', // API服務器協議類型,包含"http://"或"https://"
    API_server_host: 'localhost', // API服務器暴露的域名地址,請勿添加"http://"
    API_server_port: '3000', // API服務器監聽的端口號
    HTTP_server_type: 'http://', // HTTP服務器協議類型,包含"http://"或"https://"
    HTTP_server_host: 'www.haoal.cn', // HTTP服務器地址,請勿添加"http://" （即前端調用使用的服務器地址，若是是APP請設置爲 * ）
    HTTP_server_port: '65534', // HTTP服務器端口號
    System_country: 'zh-cn', // 所在國家的國家代碼
    System_plugin_path: path.join(__dirname, './plugins'), // 插件路徑
    Session_Key: 'RESTfulAPI', // 生產環境務必隨機設置一個值
};
 
//數據庫配置
export const DB = {
    relationalConfs: [{
            DB_type: 'mysql', // 數據庫類型
            dbName: 'db1', //命名爲惟一 調用的時候
            host: '192.168.0.1', // 服務器地址
            port: 3306, // 數據庫端口號
            username: 'test', // 數據庫用戶名
            password: 'test', // 數據庫密碼
            database: 'db1', // 數據庫名稱
            //prefix: 'api_', // 默認"api_"
            dialectOptions: { // MySQL > 5.5，其它數據庫刪除此項
                charset: 'utf8mb4',
                //collate: 'utf8mb4_unicode_520_ci',
                supportBigNumbers: true,
                bigNumberStrings: true,
                //requestTimeout: 60 * 1000 //設置鏈接超時時間
            },
            pool: {
                max: 50, // 鏈接池中最大鏈接數量
                min: 0, // 鏈接池中最小鏈接數量
                idle: 10000 // 若是一個線程 10 秒鐘內沒有被使用過的話，那麼就釋放線程
            }
        },
        
        {
            DB_type: 'mysql', // 數據庫類型
            dbName: 'db2', //命名爲惟一 調用的時候
            host: '192.168.0.1', // 服務器地址
            port: 3306, // 數據庫端口號
            username: 'test', // 數據庫用戶名
            password: 'test', // 數據庫密碼
            database: 'db2', // 數據庫名稱
            dialectOptions: { // MySQL > 5.5，其它數據庫刪除此項
                charset: 'utf8mb4',
                supportBigNumbers: true,
                bigNumberStrings: true,
            },
            pool: {
                max: 50, // 鏈接池中最大鏈接數量
                min: 0, // 鏈接池中最小鏈接數量
                idle: 10000 // 若是一個線程 10 秒鐘內沒有被使用過的話，那麼就釋放線程
            }
        }
    ],
    mongoConf: {
        host: 'mongodb://localhost', // 服務器地址
        port: 27017, // 數據庫端口號
        username: '', // 數據庫用戶名
        password: '', // 數據庫密碼
        database: 'tx', // 數據庫名稱
        prefix: 'api_' // 默認"api_"
    }
};
複製代碼

MongoDB 的操做使用 mongodb 模塊 web

須要安裝 mongodb npm i mongodb --savesql

mongodb 的文檔在這裏, 貌似只有英文版本的飛機票以下: https: //docs.mongodb.com/manual/reference/method/

新建一個MongoDB工具類 mongoUtil.js 內容以下:

/**
 * mongoDB工具類
 * 封裝mongoDB的增刪改查方法
 * https: //docs.mongodb.com/manual/reference/method/
 */
import {
    DB
} from '../config';
const assert = require('assert');
 
//引入mongoDB組件
const MongoClient = require('mongodb').MongoClient;
//引入mongoDB操做_id的函數
const objectID = require('mongodb').ObjectId;
 
//將全部的方法封裝到類裏
class MongoDBTool {
    constructor() {
        this.objectID = objectID;
    }
 
    /**
     * 連接數據庫與關閉數據庫的方法
     * 參照這個格式： mongoose.connect('mongodb://user:password@127.0.0.1:27017/dbname')， 其中dbname是必選項， 不寫會報錯。 user和password可選。
     * @param {*} callback
     * @param {*} dbName 庫名 不傳則使用默認配置
     */
    connect(callback, dbName) {
        MongoClient.connect(DB.mongoConf.host, {
            useNewUrlParser: true //
        }, (err, client) => {
            assert.strictEqual(null, err);
            console.log(`${DB.mongoConf.host} 數據庫鏈接成功!!!`);
            //拿到數據庫
            const db = client.db(dbName || DB.mongoConf.database);
            //操做數據
            callback(err, db);
            //關閉數據庫
            client.close();
        });
    }
 
    /**
     * 增
     * @param {* string} table  表名
     * @param {* arr or obj} data  數據
     * @param {*} dbName 庫名
     * @return 結果
     */
    insert({
        table,
        data,
        dbName
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                //取到想要的表
                const collection = db.collection(table);
                if (Array.isArray(data)) { //判斷數據是不是數組
                    //插入多條數據
                    const result = await collection.insertMany(data);
                    console.log(`插入${result.n}條數據`, result);
                    resolve(result.n);
                } else {
                    //插入一條數據
                    const result = await collection.insertOne(data);
                    console.log(`插入${result.n}條數據`, result);
                    resolve(result.n);
                }
            }, dbName);
        });
    }
 
    /**
     * 刪除一條
     * @param {* string} table 集合名
     * @param {* obj} filters 刪除的條件
     * @param {*} dbName 庫名
     * @return {* function} 返回結果
     */
    deleteOne({
        table,
        filters,
        dbName
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                const result = await collection.deleteOne(filters);
                console.log(`刪除${result.n}條數據`, result);
                resolve(result.n);
            }, dbName);
        });
    }
 
    /**
     * 刪除多條
     * @param {* string} table 集合名
     * @param {* obj} filters 刪除的條件
     * @param {*} dbName 庫名
     * @return {*} 返回結果
     */
    deleteMany({
        table,
        filters,
        dbName
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                const result = await collection.deleteMany(filters);
                console.log(`刪除${result.n}條數據`, result);
                resolve(result.n);
            }, dbName);
        });
    }
 
    /**
     * 修改一條
     * @param {* string} table  集合名
     * @param {* obj} filters 更新的條件
     * @param {* obj} data  更新數據
     * @param {*} dbName 庫名
     * @return { Number} 返回結果
     */
    upadteOne({
        table,
        filters,
        data,
        dbName
    }) {
        if (typeof table != 'string' && arguments.length === 3) throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                const result = await collection.updateOne(filters, {
                    $set: data
                });
                console.log(`修改${result.n}條數據`, result);
                resolve(result.n);
            }, dbName);
        });
    }
 
    /**
     * 改多條
     * @param {* string} table  集合名
     * @param {* obj} filters 更新的條件
     * @param {* obj} data  更新數據
     * @param {*} dbName 庫名
     * @return { Number} 返回結果
     */
    updateMany({
        table,
        filters,
        data,
        dbName
    }) {
        if (typeof table != 'string' && arguments.length === 3) throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect((err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                collection.updateMany(filters, {
                    $set: data
                }).then(({
                    result
                }) => {
                    console.log(`修改${result.n}條數據`, result);
                    resolve(result.n);
                });
            }, dbName);
        });
    }
 
    /**
     * 查詢數據
     * @param {* string} table  表名
     * @param {* obj} filters  條件
     * @param {*} attributes 輸出指定列
     * @param {*} dbName 庫名
     * @return {* Array} 返回結果集列表
     */
    findAll({
        table,
        filters,
        attributes,
        dbName
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect((err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                collection.find(filters, {
                    projection: attributes
                }).toArray((err, result) => {
                    assert.strictEqual(err, null);
                    console.log(`查詢數據${result.length}條數據`, result);
                    resolve(result);
                });
            }, dbName);
        });
    }
 
    /**
     * 查詢數據
     * @param {*} collectionName
     * @param {*} filters
     * @param {*} attributes 輸出指定列
     * @param {*} database 庫名
     * @return {Object} 返回結果對象
     */
    findOne({
        table,
        filters,
        attributes,
        dbName
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                const result = await collection.findOne(filters, {
                    projection: attributes
                });
                assert.strictEqual(err, null);
                console.log(`查詢數據`, result);
                resolve(result);
            }, dbName);
        });
    }
 
    /**
     * 獲取總條數
     * @param {*} collectionName
     * @param {*} database 庫名
     * @return {* Number} 返回數量
     */
    getAllCount({
        table,
        filters,
        dbName
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                //取到想要的表
                const collection = db.collection(table);
                const result = await collection.count(filters);
                console.log(`查詢數據${result}條數據`, result);
                resolve(result);
            }, dbName);
        });
    }
 
    /**
     * 分頁查詢數據
     * @param {* string} table  表名
     * @param {* obj} filters  條件
     * @param {*} dbName 庫名
     * @param {*} attributes 輸出指定列
     * @param {*} page 分頁參數 當前索引
     * @param {*} limit 每頁大小
     * @return {* Array} 返回結果集列表
     */
    findAndCount({
        table,
        filters,
        attributes,
        dbName,
        page,
        limit
    }) {
        if (typeof table != 'string') throw new Error('請檢查傳入的參數是否正確');
        return new Promise((resolve, reject) => {
            this.connect(async(err, db) => {
                if (err) reject(err);
                const collection = db.collection(table);
                let queryData = {
                        projection: attributes
                    }
                    //分頁查詢
                if (page && limit) {
                    queryData.skip = Number((page - 1) * limit);
                    queryData.limit = Number(limit);
                }
                collection.find(filters, queryData).toArray((err, result) => {
                    assert.strictEqual(err, null);
                    console.log(`分頁查詢數據${result.length}條數據`, result);
                    resolve(result);
                });
            }, dbName);
        });
    }
 
}
 
//導出對象
export default new MongoDBTool();
複製代碼

MySQL的操做使用 sequelize.js 模塊,這基本上是傻瓜式的操做方式了.

sequelize 須要安裝 npm i sequelize --save

這裏是 sequelize 的中文文檔飛機票: itbilu.com/nodejs/npm/…

由於要導出 Sequelize 和 Sequelize的實例,便用了Object.assign() 方法,可能有疑問,爲啥不用 es6 展開運算符(...),我用過了,當時有個莫名其妙的bug.......

新建一個sequelize.js 的文件內容以下:

/**
 * Sequelize.js api說明文檔
 * https: //itbilu.com/nodejs/npm/V1PExztfb.html
 */
import Sequelize from 'sequelize';
import {
    DB
} from '../config';
 
/**
 * 掛載多個mysql
 */
let mysqls = {};
DB.relationalConfs.forEach(item => {
    if (!mysqls[`${item.dbName}Util`]) {
        // console.log(database);
        mysqls[`${item.dbName}Util`] = new Sequelize(item.database, item.username, item.password, {
            host: item.host, // 數據庫地址
            dialect: item.DB_type, // 指定鏈接的數據庫類型
            dialectOptions: item.dialectOptions, //mysql專用
            pool: item.pool //鏈接池對象
        });
        mysqls[`${item.dbName}Util`].authenticate().then(() => {
            console.log(`${item.dbName} 鏈接成功!`);
        }).catch(err => {
            console.error(`${item.dbName} 鏈接出錯`, err);
        });
    }
});
 
//配置關係型數據庫ORM
export default Object.assign(Sequelize, mysqls);
複製代碼

而後列舉一下MongoDB的使用方法:

假設有個Service類,以下 TestService.js

import result from '../tools/Result';
import mongoUtil from '../lib/mongoUtil';
import {
    testModel
} from '../models';
 
/**
 * test TestService
 * 本頁面處理業務邏輯 接收參數與返回處理結果
 */
class TestService {
 
    /**
     * get
     * @param {*} ctx
     */
    async getTest({
        date
    }) {
        try {
            const res = await mongoUtil.findAll('user', null, '2018-11-05');
            return result.pageData(null, null, res, res.length, 10, 1);
        } catch (error) {
            console.log(error);
            return result.failed();
        }
    }
 
    /**
     * post
     * @param {*} ctx
     */
    async postTest(data) {
        try {
            const res = await mongoUtil.insert('user', data, '2018-11-06');
            if (res > 0) {
                return result.success();
            } else {
                return result.failed();
            }
        } catch (error) {
            console.log(error);
            return result.failed(error.toString());
        }
    }
 
    /**
     * put
     * @param {*} ctx
     */
    async putTest(id, data) {
        try {
            const res = await mongoUtil.upadteOne('user', {
                _id: mongoUtil.objectID(id)
            }, data);
            if (res > 0) {
                return result.success();
            } else {
                return result.failed(`修改失敗!`);
            }
        } catch (error) {
            console.log(error);
            return result.failed(error.toString());
        }
    }
 
    /**
     * delete
     */
    async deleteTest(id) {
        try {
            const res = await mongoUtil.deleteOne('user', {
                _id: mongoUtil.objectID(id)
            });
            if (res > 0) {
                return result.success();
            } else {
                return result.failed(`刪除失敗!`);
            }
        } catch (error) {
            console.log(error);
            return result.failed(error.toString());
        }
    }
}
 
module.exports = new TestService();
複製代碼

下面是sequelize.js 的使用方法

首先新建一個數據模型 UsersModel.js 內容以下:

/**
 * 測試表數據模型
 * @param {*} sequelize
 * @param {*} DataTypes
 * 此模型僅限關係型數據庫使用
 */
export default (sequelize, DataTypes) => {
    return sequelize.define('users', {
        id: {
            type: DataTypes.INTEGER(11),
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        username: {
            type: DataTypes.STRING(32),
            allowNull: false
        },
        password: {
            type: DataTypes.STRING(32),
            allowNull: false
        },
        createdAt: {
            type: DataTypes.INTEGER(32),
            allowNull: false,
            defaultValue: Date.parse(new Date())
        },
        updatedAt: {
            type: DataTypes.INTEGER(32),
            allowNull: false,
            defaultValue: Date.parse(new Date())
        }
    }, {
        tableName: 'users'
    });
};
複製代碼

接下來新建一個 UserService.js 類以下:

import result from '../tools/Result';
import sequelize from '../lib/sequelize';
const {
    database1Util
} = sequelize;
const userModel = database1Util.import(`../models/userModel`);
 
/**
 * test TestService
 * 本頁面處理業務邏輯 接收參數與返回處理結果
 */
module.exports = class UserService {
 
    /**
     * 用戶註冊
     * @param {*} user
     */
    async userRegister(user) {
        try {
            const res = await userModel.create(user);
            return result.success(null, res);
        } catch (error) {
            console.log(error);
            return result.failed();
        }
    }
 
    /**
     * 用戶登陸
     * @param {*} user
     */
    async userLogin({
        username,
        password
    }) {
        try {
             const res = await userModel.findOne({
                 where: {
                     username,
                     password
                 }
             });
             if (res) {
                //res要生成jwt的編碼串這裏就不詳細細解釋了
                 return result.success('簽發token', res);
             } else {
                 return result.failed(`用戶名或密碼錯誤`);
             }
          
        } catch (error) {
            console.log(error);
            return result.failed();
        }
    }
 
    /**
     * 獲取用戶列表
     * @param {*} ctx
     */
    async getUserList({
        authorization
    }) {
        try {
            const res = await userModel.findAll({
                where: {},
                attributes: ['id', 'username', 'password']
            });
            return result.pageData(null, null, res, res.length, 10, 1);
        } catch (error) {
            console.log(error);
            return result.failed();
        }
    }
 
    /**
     * 事務demo
     * @param {*} data
     */
    async demoTest({userName}) {
        // 建立事務
        database1Util.transaction((t) => {
            // 在事務中執行操做
            return userModel.create({
                userName
            }, { transaction: t }).then((user) => {
                return AgentIpListModel.findAndCount(user, { transaction: t })
            });
        }).then((results) => {
            console.log(`操做成功，事務會自動提交`, results);
            /* 操做成功，事務會自動提交 */
        }).catch((err) => {
            console.log(`操做失敗，事件會自動回滾`, err);
            /* 操做失敗，事件會自動回滾 */
        });
    }
 
    /**
     * 事務demo
     * @param {*} data
     */
    async demoTest1(data) {
        try {
            // 建立事務
            /* 操做成功，事務會自動提交 */
            /* 操做失敗，事件會自動回滾 */
            const results = await database1Util.transaction(async(t) => {
                // 在事務中執行操做
                const a = await a.create( /* {} */ , { transaction: t });
                const b = await b.create( /* {} */ , { transaction: t });
                const c = await c.create( /* {} */ , { transaction: t });
                return c;
            });
            return result.success();
        } catch (error) {
            return result.failed();
        }
    }
};
複製代碼

最後再分享一個 restful API的返回類 Result.js 統一數據返回的格式

/**
 * 返回數據實體對象
 */
class Result {
 
    constructor() {
        this.CODE = {
            SUCCESS: 200, //成功
            OTHER: 204, //其它狀態
            FAILED: 400, //操做失敗
            AUTHORITIES: 401, //身份驗證失敗
            NO_AUTHORITY: 403 //無權限
        };
 
        //返回提示
        this.MESSAGE = {
            SUCCESS: `SUCCESS`,
            FAILED: `操做失敗!`,
            PARAMS_LACK: `參數不齊!`,
            AUTHORITIES: `登錄失效或身份過時!` //身份驗證失敗
        };
    }
 
    /**
     * 返回成功結果
     */
    success(msg, data) {
        return {
            code: this.CODE.SUCCESS,
            data,
            msg: msg || this.MESSAGE.SUCCESS
        };
    }
 
    /**
     * 請求操做失敗
     */
    failed(msg, code, data) {
        return {
            code: code || this.CODE.FAILED,
            data,
            msg: msg || this.MESSAGE.FAILED
        };
    }
 
    /**
     * 參數不齊
     * @param {*} msg
     * @param {*} code
     * @param {*} data
     */
    paramsLack(msg, code, data) {
        return {
            code: code || this.CODE.FAILED,
            data,
            msg: msg || this.MESSAGE.PARAMS_LACK
        };
    }
 
    /**
     * 身份過時
     * @param {*} msg
     * @param {*} code
     * @param {*} data
     */
    authorities(msg, code, data) {
        return {
            code: code || this.CODE.AUTHORITIES,
            data,
            msg: msg || this.MESSAGE.AUTHORITIES
        };
    }
 
    /**
     * 帶分頁的數據對象
     * @param {*} msg
     * @param {*} code
     * @param {*} data
     * @param {*} total
     * @param {*} limit
     * @param {*} page
     */
    pageData(msg, code, data, total, limit, page) {
        return {
            code: code || this.CODE.SUCCESS,
            data,
            total,
            limit,
            page,
            msg: msg || this.MESSAGE.SUCCESS
        };
    }
 
    /**
     * 代碼分頁(非數據庫分頁)
     * @param {*} msg
     * @param {*} code
     * @param {*} data 數據列表
     * @param {*} page 當前頁
     * @param {*} limit 每頁大小
     */
    totalPageData(msg, code, data, page, limit) {
        let result = {
            code: code || this.CODE.SUCCESS,
            data: [],
            limit,
            page,
            total: 0,
            msg: msg || this.MESSAGE.SUCCESS
        };
 
        //分頁
        if (data && limit && page) {
            if (data && data.length > 0) {
                //索引
                let index = (page - 1) * limit;
                for (let i = index; i < page * limit; i++) {
                    if (data[i]) result.data.push(data[i]);
                }
            }
            //總大小
            result.total = data.length;
        } else {
            result.data = data;
        }
        return result;
    }
}
 
module.exports = new Result();
複製代碼

還有個JWT 加密解密驗證的工具類 ValidateTools.js 內容以下:

jsonwebtoken 是第三方模塊須要安裝 npm i jsonwebtoken --save

import jwt from 'jsonwebtoken';import fs from 'fs';import path from 'path';
const publicKey = fs.readFileSync(path.join(__dirname, '../../publicKey.pub'));
/** * 驗證工具類 */export class ValidateTools {
    /**     * 驗證解密JWT返回處理結果     * @param {*} authorities     */    validateJWT(authorities) {        try {            console.log(`validateJWT======`, authorities.substr(7));            return jwt.verify(authorities.substr(7), publicKey);        } catch (err) {            console.log(`JWT驗證結果`, err);            return false;        }    }
    /**     * 獲取jwttoken     * @param {*} data     * @param {*} expiresIn     */    getJWT(data, expiresIn) {        try {            return jwt.sign({                data // 你要保存到token的數據            }, publicKey, {                expiresIn //秒到期時間            });        } catch (err) {            console.log(`JWT加密錯誤`, err);            throw err;        }    }
}複製代碼

固然若是喜歡寫原生SQL的話 mysql-db.js 也是能夠的

npm i mysql --save

不建議 mysql-db 和 sequelize.js 混合使用 ,在這裏提出來是方便一些須要的小夥伴.

/**
 * MySQL鏈接池工具
 */
import mysql from 'mysql';
import {
    DB
} from '../config';
 
class DBUtil {
 
    /**
     * 配置文件
     */
    constructor() {
        this.mysqls = {};
        this.dbNames = {};
        DB.relationalConfs.forEach(item => {
            if (!this.mysqls[`${item.dbName}Util`]) {
                this.mysqls[`${item.dbName}Pool`] = mysql.createPool({
                    connectionLimit: item.pool.max,
                    host: item.host,
                    user: item.username,
                    password: item.password,
                    database: item.database,
                    multipleStatements: true //是否容許執行多條sql語句
                });
 
                //多個鏈接池
                this.mysqls[`${item.dbName}Pool`].getConnection((err, connection) => {
                    if (err) throw new Error(err);
                    this[`${item.dbName}Con`] = connection;
                    console.log(`數據庫 ${item.dbName} 鏈接成功!`);
                });
                this.dbNames[item.dbName] = item.dbName;
            }
        });
    }
 
    /**
     * 多條件查詢列表
     * @param {*} dbName
     * @param {*} sql
     * @param  {Array} params
     */
    queryList(dbName, sql, ...params) {
        if (dbName) throw new Error(`參數不齊!!!`);
        console.log(`查詢數據SQL:${sql},參數:`, params);
        return new Promise((resolve, reject) => {
            this[`${dbName}Con`].query(sql, params, (error, res) => {
                if (error) throw new Error(error);
                console.log(`查詢結果:`, res);
                resolve(res);
            });
            this[`${dbName}Con`].release();
        });
    }
 
    /**
     * 查詢對象
     * @param {*} sql
     * @param {*} params
     */
    queryObject(dbName, sql, params) {
        if (dbName) throw new Error(`參數不齊!!!`);
        console.log(`查詢數據SQL:${sql},參數:`, params);
        return new Promise((resolve, reject) => {
            this[`${dbName}Con`].query(sql, params, (error, res) => {
                if (error) throw new Error(error);
                console.log(`查詢結果:`, res);
                if (res && res.length > 0) {
                    resolve(res[0]);
                } else {
                    resolve(null);
                }
            });
            this[`${dbName}Con`].release();
        });
    }
 
    /**
     * 單條件查詢列表數據
     * @param {*} sql SQL語句
     * @param {*} params  數據條件
     */
    queryListSingle(dbName, sql, params) {
        if (dbName) throw new Error(`參數不齊!!!`);
        console.log(`查詢數據SQL:${sql},參數:`, params);
        return new Promise((resolve, reject) => {
            this[`${dbName}Con`].query(sql, params, (error, res) => {
                if (error) throw new Error(error);
                console.log(`查詢結果:`, res);
                resolve(res);
            });
            this[`${dbName}Con`].release();
        });
    }
 
    /**
     * 操做數據(批量)
     * @param {*} sql
     * @param {*} params
     */
    operateMultiple(dbName, sql, ...params) {
        if (dbName) throw new Error(`參數不齊!!!`);
        console.log(`操做數據SQL:${sql},參數:`, params);
        return new Promise((resolve, reject) => {
            this[`${dbName}Con`].query(sql, params, (error, res) => {
                if (error) throw new Error(error);
                console.log(`操做結果:`, res);
                resolve(res);
            });
            this[`${dbName}Con`].release();
        });
    }
 
    /**
     * 操做單個數據
     * @param {*} sql
     * @param  {Array} params
     */
    operateSingle(dbName, sql, params) {
        if (dbName) throw new Error(`參數不齊!!!`);
        console.log(`操做數據SQL:${sql},參數:`, params);
        return new Promise((resolve, reject) => {
            this[`${dbName}Con`].query(sql, params, (error, res) => {
                if (error) throw new Error(error);
                console.log(`操做結果:`, res);
                resolve(res);
            });
            this[`${dbName}Con`].release();
        });
    }
}
 
module.exports = new DBUtil();
 
/*
relationalConfs: [{
    DB_type: 'mysql', // 數據庫類型
    dbName: 'database1', //命名爲惟一 調用的時候
    host: 'localhost', // 服務器地址
    port: 3306, // 數據庫端口號
    username: 'root', // 數據庫用戶名
    password: 'root', // 數據庫密碼
    database: 'database1', // 數據庫名稱
    //prefix: 'api_', // 默認"api_"
    dialectOptions: { // MySQL > 5.5，其它數據庫刪除此項
      charset: 'utf8mb4',
      collate: 'utf8mb4_unicode_520_ci',
      supportBigNumbers: true,
      bigNumberStrings: true
    },
    pool: {
      max: 50, // 鏈接池中最大鏈接數量
      min: 0, // 鏈接池中最小鏈接數量
      idle: 10000 // 若是一個線程 10 秒鐘內沒有被使用過的話，那麼就釋放線程
    }
  },
  {
    DB_type: 'mysql', // 數據庫類型
    dbName: 'database2', //命名爲惟一 調用的時候
    host: 'localhost', // 服務器地址
    port: 3306, // 數據庫端口號
    username: 'root', // 數據庫用戶名
    password: 'root', // 數據庫密碼
    database: 'database2', // 數據庫名稱
    //prefix: 'api_', // 默認"api_"
    dialectOptions: { // MySQL > 5.5，其它數據庫刪除此項
      charset: 'utf8mb4',
      collate: 'utf8mb4_unicode_520_ci',
      supportBigNumbers: true,
      bigNumberStrings: true
    },
    pool: {
      max: 50, // 鏈接池中最大鏈接數量
      min: 0, // 鏈接池中最小鏈接數量
      idle: 10000 // 若是一個線程 10 秒鐘內沒有被使用過的話，那麼就釋放線程
    }
  }
],
 */
複製代碼