nodejs封装Sequelize库操作mysql数据库实例

暮色音铃Twiyin0 9/30/2023 nodesequelize

# nodejs封装Sequelize库操作mysql数据库实例

用class封装一下以后可能用得到的数据库操作
官方文档Sequelize官方文档(zh-CN) (opens new window)

# 安装依赖

安装两个依赖

yarn add -D sequelize mysql2

或者

npm i sequelize mysql2 --save

测试版本: sequelize@6.33.0 mysql2@3.6.1

# 封装

展开查看更多

以下代码全是自己封装的，泛用性不强。

const { Sequelize } = require('sequelize');

class Database {
    /**
     * 创建一个新的数据库实例
     * @param {string} host           - 数据库地址
     * @param {string | number} port  - 数据库端口
     * @param {string} type           - 数据库类型 {'mysql' | 'postgres' | 'sqlite' | 'mariadb' | 'mssql' | 'db2' | 'snowflake' | 'oracle'}
     * @param {string} databaseName   - 数据库名称
     * @param {string} username       - 用户名
     * @param {string} password       - 密码
     */
    constructor(host, port, type, databaseName, username, password) {
        this.sequelize = new Sequelize(databaseName, username, password, {
            host: host,
            port: port,
            dialect: type,
        });
    }

    /**
     * 初始化
     * @returns {Promise<{ status: boolean; error?: any;}>} 返回一个初始化状态和错误信息的对象
     */
    async initialize() {
      try {
        await this.sequelize.sync();
        return { status: true }
      } catch (error) {
        return { status: false, error}
      }
    }

    /**
     * 数据库连接状态
     * @returns {Promise<{status: boolean, error?: Error}>} - 返回一个连接状态和错误信息的对象
     * - { status: 连接状态, error?: 错误信息 }
     */
    async checkConnection() {
      try {
        await this.sequelize.authenticate();
        return { status: true };
      } catch (error) {
        return { status: false, error };
      }
    }

    /**
     * 数据库关闭状态
     * @returns {Promise<{status: boolean, error?: Error}>} - 返回一个关闭状态和错误信息的对象
     */
    async closeConnection() {
      try {
        await this.sequelize.close();
        return { status: true };
      } catch (error) {
        return { status: false, error };
      }
    }

    /**
     * 在一个表中插入数据
     * @param {*} dataTable - 数据表类(class)
     * @param {*} insertData   - 写入的数据对象
     * @returns {Promise<{ status: boolean; error?: any; }} - 返回一个插入状态和错误信息的对象
     */
    async insertData(dataTable, insertData) {
      try {
        await dataTable.create(insertData);
        return { status: true }
      } catch (error) {
        return { status: false, error: error}
      }
    }

    /**
     * 在一个表中插入数据
     * @param {*} dataTable  - 数据表类(class)
     * @param {*} condition  - 主键对象
     * @param {*} newData    - 新数据对象
     * @returns {Promise<{ status: boolean; error?: any; }} - 返回一个更新状态和错误信息的对象
     */
    async updateData(dataTable, condition, newData) {
      try {
        await dataTable.update(newData, { where: condition });
        return { status: true }
      } catch (error) {
        return { status: false, error: error }
      }
    }

    /**
     * 在一个表中插入数据
     * @param {*} dataTable  - 数据表类(class)
     * @param {*} condition  - 主键对象
     * @returns {Promise<{ status: boolean; error?: any; }} - 返回一个删除状态和错误信息的对象数组
     */
    async deleteData(dataTable, condition) {
      try {
        await dataTable.destroy({ where: condition });
          return { status: true }
      } catch (error) {
        return { status: false, error: error }
      }
    }

    /**
     * 查询所有数据
     * @param {*} dataTable  - 数据表类(class)
     * @returns {Promise<{ status: boolean; data?: any; error?: any; }} - 返回一个查询状态和查询信息的对象数组
     */
    async getAllData(dataTable) {
      try {
        const data = await dataTable.findAll();
        return { status: true, data: data.map(data => data.toJSON()) };
      } catch (error) {
        return { status: false, error: error }
      }
    }

    /**
     * 根据条件查询数据
     * @param {*} dataTable  - 数据表类(class)
     * @param {*} condition  - 查询条件对象
     * @returns {Promise<{ status: boolean; data?: any; error?: any; }}
     * - 返回查询状态和查询信息
     */
    async getByCondition(dataTable, condition) {
      try {
        const data = await dataTable.findAll({ where: condition });
        return { status: true, data: data.map(data => data.toJSON()) };
      } catch (error) {
        return { status: false, error: error }
      }
    }
}

module.exports = Database;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

# 使用示例

const { DataTypes, Model } = require('sequelize');  // 引入所需的库
const Database = require('./sequelize');            // 导入封装好的类

// 创建一个数据库实例
const db = new Database('databaseHost', databasePort, 'mysql', 'databaseName', 'username', 'password');

// 声明/创建一个表
class Device extends Model {}
// 初始化模型(表)
Device.init(
    {
        id: {
            type: DataTypes.INTEGER,    // 表示存储类型喂整型数据
            autoIncrement: true,        // 数据库管理系统会自动为每个新插入的行分配一个唯一的整数值，通常是递增的。这个自动递增的值通常用于作为主键，以确保每行都有一个唯一的标识符。
            primaryKey: true,           // 是否作为主键
        },
        name: {
            type: DataTypes.STRING,     // 表示字符串存储类型
            allowNull: false,           // 是否允许为空
        },
        host: {
            type: DataTypes.STRING,     // 表示字符串存储类型
            allowNull: false,           // 是否允许为空
        },
    },
    {
        sequelize: db.sequelize,        // sequelize实例
        modelName: 'Device',            // 模型(表)名称
        timestamps: false,              // 如果不需要 createdAt 和 updatedAt 列，可以设置为 false
    }
);

// 使用异步函数
async function main() {
    // 检查连接
    const result = await db.checkConnection();
    // 连接成功
    if (result.status) {
        console.log('数据库连接成功！');
        // 数据库初始化
        let init = await db.initialize();
        console.log(init.status? '初始化成功！':('初始化失败',init.error))
        // 往表中插入数据
        // let device = await db.insertData(Device, { id: 3, name: "ADAD", host: "172.12.6.1" })
        // console.log(device.status? '数据写入成功!': ('写入失败: \n',device.error))
        // 往表中更新(修改)数据
        // let device = await db.updateData(Device, {"id": 13251}, { name: "ACDADAD主站", host: "114.514" })
        // console.log(device.status? '数据更新成功!': ('更新失败: \n',device.error))
        // 删除表中数据
        // let device = await db.deleteData(Device, {"id": 13251})
        // console.log(device.status? '数据删除成功!': ('删除失败: \n',device.error))
        // 查询表内所有数据
        // let device = await db.getAllData(Device);
        // console.log(device.status? `数据查询成功!\n${device.data}`: ('查询失败: \n',device.error))
        // 按条件查询表中数据
        let device = await db.getByCondition(Device, { "id": 1 });
        console.log(device.status? `数据查询成功!\n${device.data}`: ('查询失败: \n',device.error))
        // 关闭数据库
        var close = await db.closeConnection();
        console.log(close.status? '数据库连接关闭成功！':('数据库关闭失败',close.error))
    }
    // 连接失败
    else console.log('数据库连接失败：',result.error);
}

main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# api说明

# initialize()

初始化，异步函数，返回值为初始化状态和错误信息的对象
@return { status: boolean, error?: any }

# checkConnection()

检查连接，异步函数，返回值为连接状态和错误信息的对象
@return { status: boolean, error?: any }

# closeConnection()

关闭连接，异步函数，返回值为关闭状态和错误信息的对象
@return { status: boolean, error?: any }

# insertData(dataTable, insertData)

插入数据，异步函数，返回一个插入状态和错误信息的对象
@param dataTable:模型(表), insertData: 插入的数据对象(与模型内的对象一致)
@return { status: boolean, error?: any }

# updateData(dataTable, condition, newData)

更新(修改)数据，异步函数，返回一个更新状态和错误信息的对象
@param dataTable:模型(表), condition: 主键对象, newData: 修改的数据对象(与模型内的对象一致)
@return { status: boolean, error?: any }

# deleteData(dataTable, condition)

删除数据，异步函数，返回一个删除状态和错误信息的对象
@param dataTable:模型(表), condition: 主键对象
@return { status: boolean, error?: any }

# getAllData(dataTable)

获取表内所有数据，异步函数，返回一个查询状态和查询信息的对象数组
@param dataTable:模型(表)
@return { status: boolean; data?: any; error?: any; }

# getByCondition(dataTable, condition)

按条件查询，异步函数，返回一个查询状态和查询信息的对象数组
@param dataTable:模型(表), condition: 条件对象
@return { status: boolean; data?: any; error?: any; }

# 展望

未来会把这个封装好的玩意儿做在物联网后端项目中，用来做数据存储的接口

音铃的博客

Choose mode