ORM框架

ORM，对象关系映射——数据表映射（对应）一个类，数据表中的数据行（记录）对应一个对象，数据表字段对应对象的属性；数据表的操作对应对象的方法。

Sequelize，基于promise的ORM框架。地址：https://www.sequelize.com.cn/，Sequelize框架，初步体验，Sequelize具有强大的事务支持, 关联关系, 预读和延迟加载,读取复制等功能。

安装

npm i dotenv
npm i mysql2 sequelize

版本

"dotenv": "^16.0.1",
"mysql2": "^2.3.3",
"sequelize": "^6.20.1"

生成数据库表案例

.env

MYSQL_HOST=127.0.0.1
MYSQL_PORT=3306
MYSQL_DB=demo
MYSQL_USER=root
MYSQL_PWD=root1234

src\config\config.default.js

const dotenv = require('dotenv');

dotenv.config();

module.exports = process.env;

src\db\sequelize.js

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

const {
  MYSQL_HOST,
  MYSQL_PORT,
  MYSQL_USER,
  MYSQL_PWD,
  MYSQL_DB,
} = require('../config/config.default')

const sequelize = new Sequelize(MYSQL_DB, MYSQL_USER, MYSQL_PWD, {
  host: MYSQL_HOST,
  port: MYSQL_PORT,
  dialect: 'mysql',
});

sequelize.authenticate()
  .then(() => {
    console.log('数据库连接成功')
  })
  .catch((err) => {
    console.log('数据库连接失败', err)
  });

module.exports = sequelize;

src\model\user.model.js

const { DataTypes } = require('sequelize');
const sequelize = require('../db/sequelize.js');

// 创建模型
const User = sequelize.define('system_user', {
  // id会被sequelize自动创建, 管理
  username: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    comment: '用户名',
  },
  password: {
    type: DataTypes.CHAR(64),
    allowNull: false,
    comment: '密码',
  },
  status: {
    type: DataTypes.BOOLEAN,
    allowNull: false,
    defaultValue: 1,
    comment: '状态：1、可用；0、不可用',
  },
},{
  // 其他模型参数
});

// node src/model/user.model.js
// 创建数据表(强制同步数据库)
User.sync({ force: true })

module.exports = User;

执行命令： node src/model/user.model.js

说明：

1、id会被sequelize自动创建及管理。

2、sequelize根据模型创建表时，会?动将指定的表名变成复数。

3、sequelize根据模型创建表时，会?动增加两个字段：createdAt和updatedAt，这两个字段?于记录数据创建的时间与数据更新的时间。

4、User.sync({ force: true })，创建数据表（强制同步数据库）。

增、删、改、查代码案例

service层，业务逻辑层

src\service\user.service.js

const { Op } = require("sequelize");
const User = require('../model/user.model');

class UserService{

  /**
   * 创建用户
   */
  async createUser(username,password){
    const res = await User.create({ username, password, status:1 });
    return res.dataValues;
  }

  /**
   * 查找用户
   */
  async getUser({ id, username, password, status }) {
    const whereOpt = {}

    id && Object.assign(whereOpt, { id })
    username && Object.assign(whereOpt, { username })
    password && Object.assign(whereOpt, { password })
    status && Object.assign(whereOpt, { status })

    const res = await User.findOne({
      attributes: ['id', 'username', 'password', 'status'],
      where: whereOpt,
    })

    return res ? res.dataValues : null
  }

  /**
   * 修改用户
   */
  async modifyUser({ id, username, password, status }) {
    const whereOpt = { id }
    const newUser = {}

    username && Object.assign(newUser, { username })
    password && Object.assign(newUser, { password })
    status && Object.assign(newUser, { status })

    const res = await User.update(newUser, { where: whereOpt })
    return res[0] > 0 ? true : false;
  }

  /**
   * 删除用户
   */
  async deleteUser(id) {
    const res = await User.destroy({ where: { id } })
    return res > 0 ? true : false;
  }

  /**
   * 统计
   */
  async countUsers(){
    const res = await User.count();
    return res;
  }

  /**
   * 查询
   */
  async queryUsers(pageNum=1, pageSize=10){
    const offset = (pageNum - 1) * pageSize;
    const res = await User.findAll({ offset: offset, limit: pageSize * 1 });
    return res;
  }

  /**
   * 分页
   */
  async pageUsers(pageNum=1, pageSize=10){
    const offset = (pageNum - 1) * pageSize;
    const { count, rows } = await User.findAndCountAll({offset: offset, limit: pageSize * 1})
    return {count,rows};
  }

  /**
   * 分页查询（带条件）
   */
  async pageUsers2(pageNum=1, pageSize=10, { id, username, password, status }){
    const whereOpt = {}

    id && Object.assign(whereOpt, { id })
    username && Object.assign(whereOpt, { username:{[Op.like]: '%' + username + '%' }})
    password && Object.assign(whereOpt, { password })
    status && Object.assign(whereOpt, { status })

    const offset = (pageNum - 1) * pageSize;
    const { count, rows } = await User.findAndCountAll(
      {
        offset: offset, 
        limit: pageSize,
        attributes: ['id', 'username', 'password', 'status'],
        where: whereOpt,
      })
    return {count,rows};
  }
}

module.exports = new UserService();

测试

src\test\user.test.js

const userService = require('../service/user.service');

// node src/test/user.test.js

async function createUserTest(){
  const res = await userService.createUser('user10','123456');
  console.log("result",res);
  // result {
  //   id: 4,
  //   username: 'admin',
  //   password: '1234',
  //   status: true,
  //   updatedAt: 2022-06-05T08:52:11.958Z,
  //   createdAt: 2022-06-05T08:52:11.958Z
  // }
}
// createUserTest();


async function  getUserTest(){
  const res = await userService.getUser({username:'zhangsan'});
  console.log("result",res);
  // result { id: 1, username: 'zhangsan', password: '1234', status: true }
}
// getUserTest();


async function modifyUserTest(){
  const res = await userService.modifyUser({ id:2, password: '12345678'});
  console.log("result", res);
  // result true
}
// modifyUserTest();


async function deleteUserTest(){
  const res = await userService.deleteUser(4);
  console.log("result", res);
  // result true
}
//deleteUserTest();


async function countUsersTest(){
  const count = await userService.countUsers(1,10);
  console.log("count", count);
  // 12
}
// countUsersTest();


async function queryUsersTest(){
  const users = await userService.queryUsers(1,10);
  console.log("users", users);
  console.log("users", users.length); 
  // 10
}
// queryUsersTest();


async function pageUsersTest(){
  const { count, rows } = await userService.pageUsers(1,10);
  console.log("count", count);
  console.log("rows", rows.length); 
  // 10
}
// pageUsersTest();


async function pageUsers2Test(){
  const { count, rows } = await userService.pageUsers2(2,10,{username:"user"});
  console.log("count", count);
  console.log("rows", rows.length); 
}
pageUsers2Test();