当前位置：首页 > 文章列表 > 数据库 > MySQL > 后端用Node+Mysql完成增删改查功能.

后端用Node+Mysql完成增删改查功能.

来源：SegmentFault 2023-02-16 15:25:48 0浏览收藏

大家好，今天本人给大家带来文章《后端用Node+Mysql完成增删改查功能.》，文中内容主要涉及到MySQL、Node.js，如果你对数据库方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

背景:中秋前试着搭建了一下node的环境.简单的跑了一下.归来后开始用node写增删改查.不过我们公司自己封装了很多东西.我也是调用者.可能每个公司的目录结构不太一样,我在这里讲讲我们公司的.

首先介绍下我理解的目录结构:

entry---入口端口号
example----业务服务器,处理代码逻辑,连接数据库等.

controllor---逻辑层
dao----数据库操作层
AppProvider-----加载model层 dao层和 controller层
model--mysql--User ---- 设计数据库表字段的
public --config ---常量池
public ---responseE --- 错误信息
config---app ----连接数据库

运行node项目.entry和example两个文件夹都是需要处于运行状态.命令行指令: node start
example控制台是看业务逻辑错误的.

第一步:首先设计表.

在model层的mysql文件夹下新建User文件
"users"就是表名,我给了字段有name,class,Student_id,age,sex,status,creat_time,update_time.
indexes:这里是唯一索引.我把Student_id设为了唯一字段.
allowNull:意思是不可以为空.
init()方法,和createTable()方法是封装好的,我直接调用的.我也不是特别清楚是我们工时的iot-cloud-core里面封装的还是sequelize里面封装的..原谅我第一天用哈..

第二步:dao层新建UserDao文件

这个文件主要是操作数据库的.增删改查的方法都有.
UserDao.js文件内容:

const DaoBase = require('iot-cloud-core').BASE.DaoBase;
const Sequelize = require('sequelize');
class UserDao extends DaoBase{


    //users表新增数据
    async createUsers(data){
        this.checkKeyExists(data,'name','class','Student_id','age','sex');
        let createData={
            name:data.name,
            class:data.class,
            Student_id:data.Student_id,
            age:data.age,
            sex:data.sex,
            status:1,
        };
        let res=await this.models.mysql.users.create(createData);
        return res;
    }


    //根据学号获取users表数据
    async findUsersInfoByStudentId(data){
        this.checkKeyExists(data,'Student_id');
        let selectData={
           raw:true,
           attributes:[
               ['class','class'],['sex','sex'],['age','age'],
               ['name','name'],
               'status','create_time','update_time'
           ],
            where: {
                Student_id:data.Student_id,
            }
        };
        let res = await this.models.mysql.users.find(selectData);

        console.log(res);
        return res;
    }
        
    //获取users表所有数据
        async findUsersList(data){
            let selectData={
               raw:true,
               attributes:[
                   ['id','Student_id'],['class','class'],['sex','sex'],['age','age'],
                   ['name','name'],'status','create_time','update_time'
               ],
               where:data.where,
               offset:data.offset,
               limit:data.limit
            };
            if(!data.where){
                selectDara.where = {
                    status:1
                };
            }else {
                selectData.where.status = 1;
            }
            let res = await this.models.mysql.users.findAll(selectData);
            return res;
        }

        //获取用户表数据总量
        async countUsersList(data){
            let selectData = {
                where:data.where,
            };
            if(!data.where){
                selectData.where = {
                    status:1
                };
            }else{
                selectData.where.status = 1;
            }
            let res = await this.models.mysql.users.count(selectData);
            return res;
        }

        //根据主键id获取用户表数据
        async findUsersInfoById(data){
            this.checkKeyExists(data,'Student_id');
            let selectData ={
                raw:true,
                attributes:[
                    ['id','Student_id'],['class','class'],['sex','sex'],['age','age'],
                    ['name','name'],'status','create_time','update_time'
                ],
                where:{
                    Student_id:data.Student_id,
                    status:1
                }
            };
            let res =  await this.models.mysql.users.find(selectData);
            return res;
        }

    //逻辑删除users表数据
       async deleteUsersById(data){
        this.checkKeyExists(data,'Student_id');
        let deleteData = {
            status:0
        };
        let condition={
            where:{
                Student_id:data.Student_id,
                status:1
            }
        };
        let res = await this.models.mysql.users.update(deleteData,condition);
        if(res[0] >0){
            return true;
        }else{
            return false;
        }
       }

       //更新用户列表
       async updataUsers(data){
        this.checkKeyExists(data,'update','where');
        let updateData = data.update;
        let condition={
            where:data.where,
        }
        let res =  await this.models.mysql.users.update(updateData,condition);
        if(res[0]>0){
            return true;
        }else{
            return false;
        }
       }

}
module.exports = UserDao;

第三步:在controllor层新建UsersControllor文件

这里的文件名就是接口地址后的方法名.待会详细介绍下接口地址的组成.
UsersControllor.js文件内容:

const ControllerBase = require('iot-cloud-core').BASE.ControllerBase;
const NoAuth = require('iot-cloud-core').BASE.ControllerDecorator.NoAuth;
const responseE = require('../public/responseE');
const config = require('../public/config');
const ServiceManager = require('iot-cloud-fs');
class UsersController extends ControllerBase {

    /**
     * addUsers
     * @description 添加用户
     * @param {string} name 名字 
     * @param {string} class 班级 
     * @param {string} Student_id 学号 
     * @param {int} age 年龄 
     * @param {string} sex 性别 
     */
    @NoAuth
    async addUsersAction(data){
        //检查参数
        let param=data.params;
        this.checkKeyExists(param,'name','class','Student_id','age','sex');
        //检查相应的数据是否存在
        let findUsersInfoRes = await this.dao.get('users').findUsersInfoByStudentId({
            Student_id:param.Student_id,
        });
        if(!findUsersInfoRes){
            //数据不存在时,新增数据
            let creatData={
                name:param.name,
                class:param.class,
                Student_id:param.Student_id,
                age:param.age,
                sex:param.sex,
            };
            let res =await this.dao.get('users').createUsers(creatData);
            if(!res){
                responseE.error.call(this,'Sql_Error');
            }
            return { success: true }
        }else if(findUsersInfoRes && findUsersInfoRes.status == 0){
            //数据已逻辑删除,更新数据
            let updataData ={
                update:{
                    status:1,
                    name:param.name,
                    class:param.class,
                    sex:param.sex,
                    age:param.age,
                },
                where:{
                    Student_id:param.Student_id,
                },
            };
            let res = await this.dao.get('users').updataUsers(updataData);
            if(!res){
                responseE.error.call(this,'Sql_Error');
            }
            return { success: true }
        }else if(findUsersInfoRes && findUsersInfoRes.status ==1){
            //数据已存在,返回错误
            responseE.error.call(this,'User_Is_Exist');
        }
    }

    /**
     * delUsers
     * @description 删除用户
     * @param {int} Student_id 学号  
     */
    @NoAuth
    async delUsersAction(data){
        //检查参数
        let param = data.params;
        this.checkKeyExists(param,'Student_id');
        //检查学号是否存在
        let findUsersInfoRes = await this.dao.get('users').findUsersInfoById({
            Student_id:param.Student_id
        });
        if(!findUsersInfoRes){
            responseE.error.call(this,'Users_Is_Not_Exist');
        }
        //删除用户数据
        let res = await this.dao.get('users').deleteUsersById({
            Student_id:param.Student_id
        });
        if(!res){
            responseE.error.call(this,'Sql_Error');
        }
        return {success :true}
    }

    /**
     * updateUsers
     * @description 更新用户
     * @param {string} name 名字 
     * @param {string} class 班级 
     * @param {string} Student_id 学号 
     * @param {int} age 年龄 
     * @param {string} sex 性别 
     */
    @NoAuth
    async updateUsersAction(data){
        //检查参数
        let param = data.params;
        this.checkKeyExists(param,'Student_id','sex','age','class','name');
        //检查学号是否存在
        let findUsersInfoRes = await this.dao.get('users').findUsersInfoById({
            Student_id:param.Student_id
        });
        if(!findUsersInfoRes){
            responseE.error.call(this,'Users_Is_Not_Exist');
        }
        //更新数据
        let updateData = {
            update:{
                name:param.name,
                sex:param.sex,
                age:param.age,
                class:param.class,
            },
            where:{
                Student_id:param.Student_id,
                status:1
            }
        };
        let res =  await this.dao.get('users').updataUsers(updateData);
        if(!res){
            responseE.error.call(this,'Sql_Error');
        }
        return {success:true};
    }

    /**
     * getUsersInfo
     * @description 查询用户详情
     * @param {int} Student_id 学号 
     */
    @NoAuth
    async getUsersInfoAction(data){
        //检查参数
        let param =data.params;
        this.checkKeyExists(param,'Student_id');
        let findUsersInfoRes = await this.dao.get('users').findUsersInfoById({
            Student_id:param.Student_id
        });
        if(!findUsersInfoRes){
            responseE.error.call(this,'Users_Is_Not_Exist');
        }
        return findUsersInfoRes;
    }

    /**
     * getUsersList
     * @description 获取用户列表
     * @param {json} where 条件json 
     * 
     */
    @NoAuth
    async getUsersListAction(data){
        let param = data.params;
        this.checkKeyExists(param,'where','page');
        //传入参数转换为数据库查询字段
        let findListData = {
            where:{}
        };
        if(param.page.hasOwnProperty('currentPage')&& param.page.hasOwnProperty('pageSize')){
            findListData.offset = (parseInt(param.page.currentPage) - 1 ) * parseInt(param.page.pageSize);
            findListData.limit = parseInt(param.page.pageSize);
        }
        for(const key in param.where){
            let newKey = '';
            if(param.where.hasOwnProperty(key) && config.USERS_LIST_WHERE_MAP.hasOwnProperty(key)){
                newKey = config.USERS_LIST_WHERE_MAP[key];
                findListData.where[newKey]= param.where[key];
            }
            if(param.where.hasOwnProperty(key) && config.USERS_LIST_WHERE_LIKE_MAP.hasOwnProperty(key)){
                newKey =config.USERS_LIST_WHERE_LIKE_MAP[key];
                findListData.where[newKey] = { $like:`%${param.where[key]}%`};
            }
        }
        let findListDataRes = await this.dao.get('users').findUsersList(findListData);
        let countUsersListRes = await this.dao.get('users').countUsersList(findListData);
        return {
            list:findListDataRes,
            total:countUsersListRes
        }
    }
}
module.exports = UsersController;

第四步:设置常量池和错误信息

在public文件夹下分别信息config和responseE文件
config.js文件内容:

var config ={
    USERS_LIST_WHERE_MAP:{
        'StudentId':'id',
        'name':'name',
        'sex':'sex',
        'age':'age',
        'class':'class',
    },
    USERS_LIST_WHERE_LIKE_MAP:{
        'name':'name',
    }
}
module.exports =config;

responseE.js内容:

var errorconfig={
    'Sql_Error':[10001,'sql操作失败'],

    'Users_Is_Exist':[40107,'用户已存在'],

    'Users_Is_Not_Exist':[40108,'用户不存在'],
}

class ErrorTemplate{
    static error(data){
        let mb = errorconfig[data];
        this.error(mb[1],mb[0]);
    }
}
module.exports =  ErrorTemplate;

我把AppProvider.js内容也一并贴出来
AppProvider.js:

const Provider = require('iot-cloud-core').BASE.Provider;

const controller_test = require('./controller/TestController');
const controller_users = require('./controller/UsersController');

const dao_test = require('./dao/TestDao');
const dao_users = require('./dao/UserDao');

const db_test = require('./model/mysql/Test');
const db_users = require('./model/mysql/User');


class TestProvider extends Provider{
    constructor(dbManager){
        super("test",dbManager);

        this.registerModel(db_test);
        this.registerModel(db_users);

        this.registerDao("test",dao_test);
        this.registerDao("users",dao_users);

        this.registerController("test",controller_test);
        this.registerController("users",controller_users);
    }
}
module.exports = TestProvider;

第五步:下载Postman测试接口是否能用

注意了这里都是json数据.所以一定要加{},都是双引号.最后一条数据不要加逗号,不然会报错

第六步:打开Navicat,看自己的表里数据的变化

我就不一一截图了,这是我一个个方法测试完后最后的表结果.

介绍下接口地址的组成:

举个例子,比如调用添加用户的方法的接口地址:

http://localhost:3000/openapi/custom/10002/users/addUsers

localhost:本地

3000:entry文件夹运行后得到的端口号.在entry/config.js里可以更改

openapi:固定的

custom:自己的 custom/public custom:项目自己的接口 public:公共接口(用户,设备等)

10002:appId,在example/app/config/app.js里可以更改appId.(如果这里更改了,那么entry/start.js里的appId也要记得更改.)

users:是example/app/model/AppProvider.js里的 this.registerController("users",controller_users); "users"这里的这个users

addUsers:是example/app/controller/UsersController.js 里的 addUsersAction的addUsers.(Action必须加上.)

总结:
今天只是简单的用node连接mysql数据库完成了增删改查.中间也遇到了很多问题:
(1)已经删除的用户,只是逻辑删除,数据库状态由1改为了0,没有真实删掉.在查询用户列表的时候,就要把状态为0的数据避开.
(2)更改用户信息,Student_id已经存在,但是状态为0.那么就要把状态改为1,其他字段更新为更新后的信息.
(3)粗心大意,很多单词字母写反了,报错没有报的那么详细,找错误一找找半天.其实只是单词写反字母了,或者少打了逗号.要注意呀!!

本篇关于《后端用Node+Mysql完成增删改查功能.》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于数据库的相关知识，请关注golang学习网公众号！

mysql MySQL Node.js

版本声明

本文转载于：SegmentFault 如有侵犯，请联系study_golang@163.com删除