使用Nodejs操作mysql的简单封装

本文详细介绍如何在Node.js环境中封装MySQL数据库操作,包括安装mysql包、配置数据库连接、实现CRUD操作等,并提供示例代码,便于快速上手。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1. 安装mysql包

npm i mysql -s

2. 创建一个 database.config.js 用于mysql配置

/**
 * Database config.
 * 
 */
module.exports = {
    host: 'localhost',
    port: '3306',
    user: 'root',
    password: 'xxxxxxx.',
    database: ''
    ...
}

详细配置请参考:https://www.npmjs.com/package/mysql

3.创建一个db.js 写封装的逻辑

const mysql = require('mysql'); //mysql包
const config = require('./config/database.config'); //数据库配置

class CustomDB {
    /**
     * config一些配置文件,例如主机、端口、用户、密码....
     */
    constructor(config={}) {
        this.config = config;
    }
    
    /**
     * 执行sql
     */
    query(sql, params) {
        let me = this;
        return new Promise((resolve, reject) => {
            const connection = mysql.createConnection(me.config);
            connection.connect(err => {
                if (err) reject('DATABASE ERROR:connection failed!')
            });

            //Execute SQL statement
            connection.query(sql, params, (err, results, fileds) => {
                if (err) reject(`DATABASE ERROR:${err.message}`);
                resolve(results, fileds);

                //Close the connection
                connection.end(err => {
                    reject('DATABASE ERROR:close connection failed!')
                });
            });           
        });   
    }

    /**
     * 插入数据,单行插入
     * @param table
     * @param datas
     */
    insert({table, datas}) {
        return new Promise(async(resolve, reject) => {
            try {
                let fields = ''; //字段名
                let values = []; //字段值
                for(let key in datas) {
                    fields += key + ','
                    values.push(datas[key]);
                }
                fields = fields.slice(0, -1);
                values = JSON.stringify(values).slice(1, -1);
                const insertSql = `INSERT INTO ${table} (${fields}) VALUES (${values})`;
                let insertResult = await this.query(insertSql); //写入结果

                //是否成功写入
                if (insertResult.affectedRows > 0) {
                    resolve(insertResult)
                } else {
                    reject(`INSERT ERROR: ${insertResult.message}`);
                }
            } catch (error) {
                reject(typeof error === 'object' ? `ABNORMAL PRGORAM:${error.message}` : error);
            }            
        });
    }

    /**
     * 更新
     */
    update({table, sets, where}) {
        return new Promise(async(resolve, reject) => {
            try {
                let setData = '';
                for (let key in sets) {
                    let value = typeof sets[key] === 'string' ? `"${sets[key]}"` : `${sets[key]}`;
                    setData += `${key}=${value}, `;
                }
                setData = setData.slice(0, -2);
                const updateSql = `UPDATE ${table} SET ${setData} WHERE ${where}`;
                console.log(updateSql);
                let updateResult = await this.query(updateSql);
                if (updateResult.changedRows === 0) {
                    reject(`UPDATE ERROR: ${updateResult.message}`, updateResult);
                } else {
                    resolve(updateResult);
                }
            } catch (error) {
                reject && reject(typeof error === 'object' ? `ABNORMAL PRGORAM:${error.message}` : error);
            }
        });
    }

    /**
     * 删除
     * @param table
     */
    delete({table, where}) {
        return new Promise(async (resolve, reject) => {
            try {
                const deleteSql = `DELETE FROM ${table} WHERE ${where}`;
                let deleteResult = await this.query(deleteSql);
                if (deleteResult.affectedRows === 0) {
                    reject(`DELETE ERROR: ${deleteResult.message}`, deleteResult);
                } else {
                    resolve(deleteResult);
                }
            } catch (error) {
                console.log(error);
                reject && reject(typeof error === 'object' ? `ABNORMAL PRGORAM:${error.message}` : error);
            }
        });       
    }
}

//导出模块
module.exports = new CustomDB(config); //初始化实例,传入配置文件

4. 外部调用

const db = require('./libs/db.js'); //引入封装的db模块

//新增一个用户
let userData = {
   table: 'sys_user',
   datas: {
        ID: 'b57ce5e8-a2ff-45f8-b92e-97e136d9187d',
        ACCOUNT: 'admin1',
        PASSWORD: '123456',
        NICK_NAME: '管理员1',
        SYS_ID: 'b67ce5e8-a2ff-45f8-b92e-97e136d9187d',
        STATUS: 1,
        CREATE_TIME: '2019-07-06 14:20:30'
    }
};

db.insert(userData).then(res => {
    console.log(res);
}).catch(err => {
    console.log(err);
});

OR

let addUser = async() => {
    try {
        let addResult = await db.insert(userData);
          
        //success do sth...
    } catch (error) {
        //error do sth...
    }
}

Tip: 由于是基于Promise封装,代码调用中会出现 .then().catch(), 作者建议使用 async,await 来处理回调问题哦~

以下是封装nodejs使用mysql2的连接池的写法: ```javascript const mysql = require('mysql2/promise'); class MysqlPool { constructor(config) { this.pool = mysql.createPool(config); } async execute(sql, values) { const connection = await this.pool.getConnection(); try { const [rows] = await connection.execute(sql, values); return rows; } catch (err) { throw err; } finally { connection.release(); } } async beginTransaction() { const connection = await this.pool.getConnection(); try { await connection.beginTransaction(); return connection; } catch (err) { connection.release(); throw err; } } async commitTransaction(connection) { try { await connection.commit(); connection.release(); } catch (err) { await connection.rollback(); connection.release(); throw err; } } async rollbackTransaction(connection) { try { await connection.rollback(); connection.release(); } catch (err) { connection.release(); throw err; } } } module.exports = MysqlPool; ``` 在上面的代码中,我们使用了 `mysql2/promise` 模块创建了一个连接池,然后封装了一些常用的方法,包括 `execute`、 `beginTransaction`、 `commitTransaction` 和 `rollbackTransaction`。其中,`execute` 方法用于执行 SQL 语句,`beginTransaction` 方法用于开启事务,`commitTransaction` 方法用于提交事务,`rollbackTransaction` 方法用于回滚事务。 使用时,只需要实例化 `MysqlPool` 类,然后调用相应的方法即可。例如: ```javascript const MysqlPool = require('./mysql-pool'); const config = { host: 'localhost', user: 'root', password: '123456', database: 'test', waitForConnections: true, connectionLimit: 10, queueLimit: 0, }; const pool = new MysqlPool(config); async function getUsers() { const sql = 'SELECT * FROM users'; const result = await pool.execute(sql); return result; } getUsers().then((result) => { console.log(result); }).catch((err) => { console.error(err); }); ``` 上面的代码中,我们首先创建了一个 `config` 对象,包含了数据库连接的配置信息。然后实例化了一个 `MysqlPool` 对象,并且调用了 `execute` 方法执行了一条 SQL 查询语句。最后输出查询结果或者错误信息。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值