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

背景:中秋前试着搭建了一下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)粗枝大叶,不少单词字母写反了,报错没有报的那么详细,找错误一找找半天.其实只是单词写反字母了,或者少打了逗号.要注意呀!!