node.js后台连接mongodb数据库增删查改操作

第一步

使用npm下载 mongodb模块

第二步

后台导入mongodb模块

注意：引入的模块会先去找自己文件夹中的node_modules中的模块，如果没有，再去找全局（node安装目录中的）

let http = require("http");

let mongodb = require('mongodb'); // 导入mongodb的模块

let MongoClient = mongodb.MongoClient;// 创建连接数据库的对象

连接上数据库后就可以在后台对数据库进行操作了

后台服务中原生写法，代码解读

let http = require("http");
// 导入mongodb的模块
let mongodb = require('mongodb');     //引入的模块会先去找自己文件夹中的node_modules中的模块，如果没有，再去找全局（node安装目录中的）
// 创建连接数据库的对象
let MongoClient = mongodb.MongoClient;

let server = http.createServer();

server.on("request",(req,res) => {
    let database_url = "mongodb://localhost:27017/";   //数据库的地址
    let database_name = "school";    //数据库名称
    let url = database_url + database_name;   //数据库的地址加数据库名称

    MongoClient.connect(url, (err, db) => {     //连接数据库
        // err表示错误信息，数据库连接失败的时候err才会有值   db是数据的实例，连接成功以后，所有的操作都是在这个实例进行完成
          if(err){
              console.log('数据库连接失败');
              return;
          }
          console.log('连接成功');
          var obj = {"name":"小明把","age":120,"hobby":["睡觉a","吃饭a"],"score":{"yuwen":590,"shuxue":800}}
          db.collection("student").insertMary(obj, (err, result) => {  //向school数据库中，student的集合中插入一条数据
            if (err){
                console.log('插入失败');
                return;
            }
            console.log(result);  //一个对象，里面有关于数据库，和插入数据的方法和属性           res.end(result.toString())

           db.close();// db.close(); //数据库关闭每一次数据库进行一次操作以后，使用完成，都要关闭

       }); 
    });
 }) server.listen(3000);

相关的增删改查方法

数据库中可以有多个集合，一个集合可以有多个数据，数据一个集合为数组，多条数据为对象的格式（json）存储

 db.collection("集合名")方法，如果数据库中没有该集合，那么在增删查改的时候会默认添加集合

插入多条数据

 db.collection("集合名").insertMany(插入的数据（对象格式）, function(err, result) {
        if (err) throw err;
         
        db.close(); //操作后关闭数据库
    });

插入一条数据

db.collection("集合名").insertOne(插入的数据（对象格式）,function(err, res) { 
    if (err) throw err; console.log("文档插入成功"); 
     db.close(); 
 });

查询数据

 db.collection("集合名"). find(查找的数据（对象）).toArray(function(err, result) { // 返回查找到的数据
        if (err) throw err;
        console.log(result);  //返回查找到符合查找对象的数据，数组包对象
        db.close();
    });

更新数据（修改数据）

更新一条

db.collection("site").updateOne(被替换的数据（对象）, 更新的数据（对象）, function(err, res) {
        if (err) throw err;
        console.log("文档更新成功");
        db.close();
    });

注意：修改数据可以只是修改集合中某条数据的部分数据

更新多条

    var whereStr = {"type":'en'};  // 查询条件
    var updateStr = {$set: { "url" : "https://www.runoob.com" }};
    dbo.collection(集合名).updateMany(whereStr, updateStr, function(err, res) {
        if (err) throw err;
         console.log(res.result.nModified + " 条文档被更新");  //result.nModified 为更新的条数。
        db.close();
    });

$set 如果没有找到，则会创建对应数据，插入集合中

将$set换为 $unset 进行更新，则会删除这个字段

删除数据

删除条件满足的第一条数据

  db.collection(集合名).deleteOne(查找的条件（对象）, function(err, obj) {
        if (err) throw err;
        console.log("文档删除成功");
        db.close();
    });

删除多条数据

删除符合条件的所有数据

  db.collection(集合名).deleteMany(查找条件（对象）, function(err, obj) {
        if (err) throw err;
        console.log(obj.result.n + " 条文档被删除");
        db.close();
    });

查询分页

 dbo.collection(集合名).find().skip(2).limit(2).toArray(function(err, result) {
        if (err) throw err;
        console.log(result);  //result返回查询到经过分页处理的数据
        db.close();
  });

skip（num）查询到的所有数据中，跳过num条数据后返回查询结果

limit（num）查询到的所有数据中，返回num条数据

分页查询可以用于当数据过于庞大，进行部分查找

DAO层理解及封装

DAO层缘由

起源于java，java的dao可以写的非常大

做专门连接数据库的层，然后暴露接口给后台进行访问

DAO逻辑

DAO层的设计首先是设计DAO的接口，然后就可在模块中调用此接口来进行数据业务的处理，

而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，DAO层的数据源配置。

DAO层作用

主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此

简而言之：它是通过引入模块，将对数据库操作的方法封装，然后暴露接口，供后台操作，就是在后天与数据库中间的中间层

在node 中，DAO层也是可以写的非常大。

以下是node连接mongodb的DAO层

var mongodb = require("mongodb");
var MongoClient = mongodb.MongoClient;

function _connectDB(callback){
    let database_url = "mongodb://localhost:27017/";   //数据库的地址
    let database_name = "data";    //数据库名称
    let url = database_url + database_name;
    MongoClient.connect(url,function(err,db){
        if(err){
            callback(err,null);
            return;
        }
        callback(err,db);
    })
}

// 暴露接口   // 插入数据
exports.insertOne = function(collectionName,json,callback){
    _connectDB(function(err,db){
        db.collection(collectionName).insertOne(json, (err, result) => {
            // if(err){
            //     callback(err,null)
            //     return;
            // }
            callback(err,result);
            db.close();
        });
    })
}

// 删除的接口
exports.deleteMany = function(collectionName,json,callback){
    _connectDB(function(err,db){
        db.collection(collectionName).deleteMany(json,function(err,result){
            callback(err,result);
            db.close();
        })
    })
}

// 更新数据
exports.updateMany = function(collectionName,json1,json2,callback){
    _connectDB(function(err,db){
        db.collection(collectionName).updateMany(json1,json2,function(err,result){
            callback(err,result);
            db.close();
        })
    })
}






// 假设说我不需要分页，page参数就可以不需要传递
exports.find = function(collectionName,json,C,D){
    var result = [];
    if(arguments.length == 3){   //这个时候就是不需要分页的
        var callback = C;
        var limitnum = 0;
        var skipnum = 0;
    }else if(arguments.length == 4){
        // 假设传递进来c的参数为一个对象{
        //     pageamount : 10,
        //     page : 0
        // }
        var callback = D;   //最后一位就为回调函数
        var args = C;       //分页的条件
        // 省略的条数
        var skipnum = args.pageamount * args.page || 0;
        // 找到的条数
        var limitnum = args.pageamount || 0;
        // 排序
        var sort = args.sort || {};
    }else{
        throw new Error('find函数参数的个数必须为三个或者四个')
        return;
    }
    _connectDB(function(err,db){
        var cursor = db.collection(collectionName).find(json).skip(skipnum).limit(limitnum).sort(sort)
        cursor.each(function(err,doc){
            if(err){
                callback(err,null);
                db.close();
                return
            }
            if(doc!=null){
                result.push(doc);
            }else{
                callback(null,result);
                db.close()
            }
        })
    })
}

解读分页查询封装

collectionName：需要查询数据的集合名

json ：查找条件的对象

C,D：  两种情况
 1. 如果不需要分页查询，则D参数不需要，而C参数传入的是回调
 2.需要分页查询，则传入的C，就是查询分页的对象，D为回调函数
   此时的c应是一个对象的形式传入，而不是数值

//C对象模板
C = {

pageamount : 10, //跳过的条数
page : 0 //显示的条数

分页查询区分

前台假分页后台把所有的数据全部从数据库中获取过来，然后在原封不动的给前台，前台在根据所有数据来进行分页。
后台假分页后台把所有的数据全部从数据库中获取过来，然后根据前端传递过来的参数，返回给前端几条数据。
真的分页，让事情给数据库来做，降低传输的内容。