一、Node.js 访问MongoDB 数据库

MongoDB 对许多平台都提供驱动可以访问数据库，如C#、Java、Node.js等。

1.1、安装MongoDB访问驱动

命令如下：

  1. 全局安装驱动：npm install mongodb -g
  2.  
  3. 在当前项目中引入：npm install mongodb --save

1.2、连接数据库

  1. const { MongoClient } = require("mongodb");  //导入依赖对象mongo客户端
  2.  
  3. let url="mongodb://127.0.0.1:27017";  //数据库连接字符串
  4.  
  5. let client=new MongoClient(url);  //实例化一个mongo客户端
  6.  
  7. async function run(){
  8.     try{
  9.         await client.connect();  //连接
  10.         await client.db("nfit").command({ping:1});  //向数据库nfit发送命令
  11.         console.log("连接数据库成功！");
  12.     }
  13.     finally{
  14.         await client.close();
  15.     }
  16. }
  17.  
  18. run().catch(console.log);

1.3、添加数据

  1. const { MongoClient } = require("mongodb");  //依赖MongoClient
  2.  
  3. let client=new MongoClient("mongodb://127.0.0.1:27017");  //实例化一个客户端
  4.  
  5. async function run(){
  6.     try{
  7.         let db=await client.db("nfit");  //获取数据库
  8.         let students=await db.collection("students");  //获取集合，表
  9.         let doc={id:202201,name:"tom",age:19};  //将添加的数据对象
  10.         let result=await students.insertOne(doc);  //执行向数据库中添加数据并等待响应结果
  11.         console.log(result);
  12.     }
  13.     finally{
  14.         await client.close();  //关闭数据库
  15.     }
  16. }
  17.  
  18. run().catch(console.log);

1.4、添加多条数据

  1. const { MongoClient } = require("mongodb");  //依赖MongoClient
  2.  
  3. let client=new MongoClient("mongodb://127.0.0.1:27017");  //实例化一个客户端
  4.  
  5. async function run(){
  6.     try{
  7.         let db=await client.db("nfit");  //获取数据库
  8.         let students=await db.collection("students");  //获取集合，表
  9.         let docs=[{id:202202,name:"rose",age:17},{id:202203,name:"mark",age:18}];  //将添加的数据对象
  10.         let result=await students.insertMany(docs);  //执行向数据库中添加数据并等待响应结果
  11.         console.log(result);
  12.     }
  13.     finally{
  14.         await client.close();  //关闭数据库
  15.     }
  16. }
  17.  
  18. run().catch(console.log);

1.5、修改数据

  1. const { MongoClient } = require("mongodb");
  2. let client=new MongoClient("mongodb://127.0.0.1:27017");
  3.  
  4. async function run(){
  5.     try{
  6.         let db=await client.db("nfit"); //获取数据库
  7.         let students=await db.collection("students");  //获取集合
  8.         let filter={id:202201};  //要更新的数据的过滤条件
  9.         let result=await students.updateOne(filter,{$set:{name:"汤姆"}});  //执行更新单条数据
  10.         console.log(result);
  11.     }
  12.     finally{
  13.         await client.close();  //关闭
  14.     }
  15. }
  16.  
  17. run().catch(console.log);

1.6、查询数据

1.6.1、查询单条记录

  1. const { MongoClient } = require("mongodb");
  2. let client=new MongoClient("mongodb://127.0.0.1:27017");
  3.  
  4. async function run(){
  5.     try{
  6.         let db=await client.db("nfit"); //获取数据库
  7.         let students=await db.collection("students");  //获取集合
  8.  
  9.         let filter={id:202201};  //过滤条件
  10.         let obj=await students.findOne(filter);  //根据过滤条件查找单条数据
  11.         console.log(obj);
  12.     }
  13.     finally{
  14.         await client.close();  //关闭
  15.     }
  16. }
  17.  
  18. run().catch(console.log);

1.6.2、查询多条记录

  1. const { MongoClient } = require("mongodb");
  2. let client=new MongoClient("mongodb://127.0.0.1:27017");
  3.  
  4. async function run(){
  5.     try{
  6.         let db=await client.db("nfit"); //获取数据库
  7.         let students=await db.collection("students");  //获取集合
  8.  
  9.         let query={id:{$gte:202201}};  //查询条件是id大于等于202201
  10.         let cursor=await students.find(query);  //执行查询并返回游标对象
  11.  
  12.         let result=[];  //学生数组，返回包装用
  13.  
  14.         await cursor.forEach(data=>result.push(data));  //遍历游标，取出数据
  15.  
  16.         console.log(result);
  17.     }
  18.     finally{
  19.         await client.close();  //关闭
  20.     }
  21. }
  22.  
  23. run().catch(console.log);

1.7、删除数据

  1. const { MongoClient } = require("mongodb");
  2. let client=new MongoClient("mongodb://127.0.0.1:27017");
  3.  
  4. async function run(){
  5.     try{
  6.         let db=await client.db("nfit"); //获取数据库
  7.         let students=await db.collection("students");  //获取集合
  8.         let filter={id:202201};  //要删除的数据的过滤条件
  9.         let result= await students.deleteOne(filter);  //执行删除
  10.         console.log(result);
  11.     }
  12.     finally{
  13.         await client.close();  //关闭
  14.     }
  15. }
  16.  
  17. run().catch(console.log);

1.8、连接MongoDB数据库，实现curd、图片上传（使用element-ui框架）功能的完整代码如下：

路由 Api 接口：

  1. // 导入模块
  2. var express = require('express');
  3. var router = express.Router();
  4. var _ = require("lodash");
  5. var path = require("path");
  6. var multer = require('multer');
  7.  
  8. // 图片上传
  9. // 文件上传的内置方法
  10. var imgName = ""; // 这个是保存在路径里的名称
  11. const storage = multer.diskStorage({
  12.     // 文件存储路径
  13.     destination(req, file, callback) {
  14.         // 上传的图片放到本地的文件夹里面
  15.         let imgUrl = "E:/qd/11. node.js/练习/test05_mongoDB/public/images"
  16.         // 回调函数
  17.         callback(null, imgUrl)
  18.     },
  19.     filename(req, file, callback) {
  20.         // 后缀名，到时候添加数据的时候，先把它设为空，然后进入图片上传页，然后做修改的操作
  21.         imgName = _.random(0, 9999999999999) + path.extname(file.originalname);
  22.         callback(null, imgName); // 把生成的名称放在这里
  23.  
  24.     }
  25. });
  26.  
  27. // 也是内置函数
  28. const addfild = multer({
  29.     storage
  30. });
  31.  
  32. // 连接数据库
  33. const {
  34.     MongoClient,
  35.     ObjectId
  36. } = require("mongodb");
  37.  
  38. let url = "mongodb://127.0.0.1:27017";
  39.  
  40. let client = new MongoClient(url);
  41.  
  42. // 传参数：需要的数据，i(如果它为1，就查询，2就添加...)，res：返回给客户端的数据
  43. async function run(bookDate, i, res, req) {
  44.     try {
  45.         await client.connect();
  46.         let db = await client.db("book"); // 连接数据库的
  47.         let book = db.collection("bookInfo"); // 连接集合的
  48.         let result = ""; // SQL语句
  49.         // 执行哪个执行语句
  50.         if (i == 1) {
  51.             result = await book.find().toArray(); // 查询所有数据的
  52.         }
  53.         if (i == 2) {
  54.             // 获取图书编号
  55.             let id = parseInt(req.params.id);
  56.             // 查看id是什么类型的
  57.             console.log(typeof id);
  58.             // 执行语句
  59.             result = await book.deleteOne({
  60.                 id: id
  61.             });
  62.         }
  63.         if (i == 3) {
  64.             // 获取通过post请求传递过来的参数
  65.             let inputText = req.body;
  66.             // 获取编号最大的图书，实现编号自动增长
  67.             let maxObj = await (book.find().sort({_id:-1}).limit(1)).toArray();
  68.             // 获取id和图片名称，把id 和 图片名称存进数据库里面
  69.             inputText.id = parseInt(maxObj[0].id) + 1;
  70.             inputText.picture = imgName;
  71.  
  72.             // // 执行语句
  73.             result = await book.insertOne(inputText);
  74.  
  75.             console.log(inputText);
  76.             console.log(maxObj);
  77.             console.log(inputText.id);
  78.         }
  79.         if (i == 4) {
  80.             console.log(parseInt(req.params.id));
  81.             result = await book.find({
  82.                 id: parseInt(req.params.id)
  83.             }).toArray();
  84.             console.log(result);
  85.  
  86.         }
  87.         if (i == 5) {
  88.             let inputText = req.body;
  89.  
  90.             result = await book.updateOne({id:inputText.id}, {$set: {name: inputText.name,picture: imgName,author: inputText.author,price: inputText.price}});
  91.             console.log(result);
  92.         }
  93.  
  94.         // 返回客户端的信息
  95.         res.json({
  96.             status: "成功！",
  97.             data: result
  98.         });
  99.  
  100.     } finally {
  101.         // 通常写关闭数据库的，但是，目前还不需要，因为只能查询一次，之后就关闭了！
  102.         // await client.close();
  103.     }
  104. }
  105.  
  106. // 查询所有数据
  107. router.get("/", (req, res, next) => {
  108.     // 调用run 方法，传参数
  109.     run("", 1, res, req);
  110. });
  111.  
  112. // 删除
  113. router.delete("/:id", (req, res, next) => {
  114.     run("", 2, res, req);
  115. });
  116.  
  117. // 上传图片的
  118. // 在这里传内置函数过去
  119. router.post("/file", addfild.single('file'), (req, res, next) => {
  120.  
  121. })
  122.  
  123. // 添加
  124. router.post("/", (req, res, next) => {
  125.     run("", 3, res, req);
  126. })
  127.  
  128. // 渲染数据
  129. router.get("/:id", (req, res, next) => {
  130.     run("", 4, res, req);
  131. })
  132.  
  133. // 修改数据
  134. router.put("/", (req, res, next) => {
  135.     run("", 5, res, req);
  136. })
  137.  
  138. module.exports = router;

ejs 页面：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>Document</title>
  9.     <link rel="stylesheet" href="stylesheets/book.css">
  10.     <link rel="stylesheet" href="stylesheets/index.css">
  11. </head>
  12.  
  13. <body>
  14.     <div id="app">
  15.         <h3>图书管理系统</h3>
  16.         <div id="addbtn">
  17.             <!-- <div id="sort">
  18.                 <button id="sortId" @click="sortId">按id倒序</button>
  19.             </div>
  20.             <div id="search">
  21.                 <input type="text" name="" id="searchText">
  22.                 <button id="searchbtn" @click="search">搜索</button>
  23.             </div> -->
  24.             <button id="appBook">新增图书&nbsp;+&nbsp;</button>
  25.         </div>
  26.         <table>
  27.             <tr>
  28.                 <th>编号</th>
  29.                 <th>书名</th>
  30.                 <th>封面</th>
  31.                 <th>作者</th>
  32.                 <th>价格</th>
  33.                 <th>操作</th>
  34.             </tr>
  35.             <tr v-for="(b, i) in book" :key="b.id">
  36.                 <td>{{ b.id }}</td>
  37.                 <td>{{ b.name }}</td>
  38.                 <td>
  39.                     <div id="picture" :style="{backgroundImage: 'url(/images/' + b.picture + ')'}"></div>
  40.                 </td>
  41.                 <td>{{ b.author }}</td>
  42.                 <td>{{ b.price }}</td>
  43.                 <td>
  44.                     <button id="update" @click="edit(b.id)">编辑</button>
  45.                     <button id="delete" @click="del(b.id)">删除</button>
  46.                 </td>
  47.             </tr>
  48.         </table>
  49.  
  50.         <!-- 模态框 -->
  51.         <div id="modal_box">
  52.             <!--修改or添加  -->
  53.             <div id="mdinfo">
  54.                 <table>
  55.                     <tr>
  56.                         <td colspan="2" id="td">新增图书信息</td>
  57.                     </tr>
  58.                     <tr>
  59.                         <td>书名：</td>
  60.                         <td>
  61.                             <input type="text" id="name" class="text" v-model="bookObj.name" />
  62.                         </td>
  63.                     </tr>
  64.                     <tr>
  65.                         <td>作者：</td>
  66.                         <td>
  67.                             <input type="text" id="author" class="text" v-model="bookObj.author" />
  68.                         </td>
  69.                     </tr>
  70.                     <tr>
  71.                         <td>价格：</td>
  72.                         <td>
  73.                             <input type="text" id="price" class="text" v-model="bookObj.price" />
  74.                         </td>
  75.                     </tr>
  76.                     <tr>
  77.                         <td>封面：</td>
  78.                         <td style="display: flex;">
  79.                             <el-upload ref="mYupload" action="string" :http-request="handleChange"
  80.                                 list-type="picture-card" :on-preview="handlePictureCardPreview"
  81.                                 :on-remove="handleRemove" :on-change="handleChange">
  82.                                 <i class="el-icon-plus"></i>
  83.                             </el-upload>
  84.                             <el-dialog :visible.sync="dialogVisible">
  85.                                 <img width="100%" :src="dialogImageUrl" alt="">
  86.                             </el-dialog>
  87.                             <!-- <div class="Browse" :style="{backgroundImage: 'url(/images/' +  + ')'}"></div> -->
  88.                         </td>
  89.                     </tr>
  90.                     <tr>
  91.                         <td colspan="2">
  92.                             <button id="btn1" class="btn" @click="save">提交</button>
  93.                             <button id="btn2" class="btn" @click="cancel">取消</button>
  94.                         </td>
  95.                     </tr>
  96.                 </table>
  97.             </div>
  98.         </div>
  99.     </div>
  100. </body>
  101. <script src="javascripts/jquery-1.12.4.js"></script>
  102. <script src="javascripts/axios.js"></script>
  103. <script src="javascripts/vue.js"></script>
  104. <script src="javascripts/index.js"></script>
  105. <script>
  106.     var path = "http://127.0.0.1:8082/bookApi/";
  107.     var app = new Vue({
  108.         el: "#app",
  109.         data: {
  110.             book: [],
  111.             bookObj: { "id": 0, "name": "", "picture": "", "author": "", "price": "" },
  112.             // 文件上传
  113.             dialogImageUrl: '',
  114.             dialogVisible: false,
  115.             rawName: ""
  116.         },
  117.         created() {
  118.             // 查询所有的数据
  119.             this.selectData();
  120.             // 把图片的名称赋值
  121.             this.bookObj.picture = this.rawName;
  122.         },
  123.         methods: {
  124.             // 查询
  125.             selectData() {
  126.                 axios
  127.                     .get(path)
  128.                     .then((res) => {
  129.                         this.book = res.data.data;
  130.                     })
  131.             },
  132.             // 删除
  133.             del(id) {
  134.                 if (confirm("您确定要删除这数据吗？")) {
  135.                     axios
  136.                         .delete(path + id)
  137.                         .then((res) => {
  138.                             console.log(id);
  139.                             console.log(res);
  140.                             alert("删除成功！");
  141.                             // 调用查询全部的数据
  142.                             this.selectData();
  143.                         })
  144.                 }
  145.             },
  146.             // 文件上传的样式
  147.             // 删除
  148.             handleRemove(file, fileList) { },
  149.             // 放大
  150.             handlePictureCardPreview(file) {
  151.                 this.dialogImageUrl = file.url;
  152.                 this.dialogVisible = true;
  153.             },
  154.             // 添加封面图
  155.             handleChange(file) {
  156.                 // 如果缩略图这个元素在的话，就删除这个这个，然后重新上传一个（其实就是为了方便修改图片）
  157.                 if ($('.el-upload-list__item').length > 0) {
  158.                     // 删除缩略图图片
  159.                     $(".el-upload-list__item").remove();
  160.                 }
  161.                 let formDate = new FormData();
  162.                 formDate.append('file', file.raw);
  163.                 // console.log(file.raw.name);
  164.                 formDate.append("file", file);
  165.                 axios
  166.                     .post(path + "file", formDate)
  167.                     .then((data) => {
  168.                     });
  169.                 this.rawName = file.raw.name;
  170.             },
  171.             // 添加图书与修改图书
  172.             save() {
  173.                 if (this.bookObj.id) {
  174.                     // 修改
  175.                     axios
  176.                         .put(path, this.bookObj)
  177.                         .then((data) => {
  178.                             if (data.data.status === "成功！") {
  179.                                 // console.log(data.data.data);
  180.                                 alert("修改成功！");
  181.                                 this.bookObj = { id: 0, name: "", picture: "", author: "", price: "" };
  182.                                 $("#modal_box").css("display", "none");
  183.                                 // 删除缩略图图片
  184.                                 $(".el-upload-list__item").remove();
  185.                                 //  重新查询一次数据
  186.                                 this.selectData();
  187.                             }
  188.                         })
  189.  
  190.                 } else {
  191.                     // 添加
  192.                     axios
  193.                         .post(path, this.bookObj)
  194.                         .then((data) => {
  195.                             if (data.data.status === "成功！") {
  196.                                 // console.log(data.data.data);
  197.                                 alert("添加成功！");
  198.                                 this.book.id = 0; // 因为是添加，所以id要重置为0
  199.                                 this.bookObj = { id: 0, name: "", picture: "", author: "", price: "" };
  200.                                 $("#modal_box").css("display", "none");
  201.                                 // 删除缩略图图片
  202.                                 $(".el-upload-list__item").remove();
  203.                                 //  重新查询一次数据
  204.                                 this.selectData();
  205.                             }
  206.                         })
  207.                 }
  208.             },
  209.             // 编辑图书
  210.             edit(id) {
  211.                 $("#td").html("修改图书信息");
  212.                 $("#modal_box").slideToggle();
  213.                 axios
  214.                     .get(path + id)
  215.                     .then((data) => {
  216.                         this.bookObj = data.data.data[0];
  217.                         // 寻找ul节点，然后创建li节点，并给li节点添加一个类，最后把li添加到ul里面
  218.                         var ul = document.querySelector('ul');
  219.                         var li = document.createElement("li");
  220.                         li.className = "el-upload-list__item";
  221.  
  222.                         // 再创建一个img节点
  223.                         var img = document.createElement("img");
  224.                         //设置 img 图片地址、宽、高
  225.                         img.src = "images/" + this.bookObj.picture;
  226.                         img.width = 148;
  227.                         img.height = 148;
  228.  
  229.                         ul.appendChild(li);
  230.                         li.appendChild(img);
  231.  
  232.                         // console.log(this.bookObj);
  233.                     })
  234.             },
  235.             // 模态框取消按钮
  236.             cancel() {
  237.                 $("#modal_box").css("display", "none");
  238.                 $(".text").val("");
  239.                 // 删除缩略图图片
  240.                 $(".el-upload-list__item").remove();
  241.             }
  242.         }
  243.     });
  244.  
  245.     // 模态框显示
  246.     $("#appBook").click(function () {
  247.         $("#modal_box").slideToggle();
  248.         $("#td").html("新增图书信息");
  249.     });
  250.  
  251. </script>
  252.  
  253. </html>

运行结果：

二、Node.js 访问 MySQL 数据库

2.1、导入mysql模块

  1. npm i mysql;

2.2、连接并查询

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. pool.getConnection((connErr,conn)=>{  //获取连接对象
  12.     pool.query("select id,name,sex from student",(err,results)=>{//执行查询
  13.         if(err) throw err;  //如果有错误，则抛出异常
  14.         console.log(JSON.parse(JSON.stringify(results)));  //转换并输出查询结果
  15.         conn.release();  //释放连接
  16.     });
  17. });

2.3、带参数查询

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. pool.getConnection((connErr,conn)=>{  //获取连接对象
  12.     pool.query("select id,name,sex from student where sex=?",['boy'],(err,results)=>{//执行查询
  13.         if(err) throw err;  //如果有错误，则抛出异常
  14.         console.log(JSON.parse(JSON.stringify(results)));  //转换并输出查询结果
  15.         conn.release();  //释放连接
  16.     });
  17. });

2.4、新增数据

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. let sql="insert into student(name,sex) values(?,?)";
  12. pool.getConnection((connErr,conn)=>{  //获取连接对象
  13.     pool.query(sql,['tom','boy'],(err,results)=>{//执行添加，指定参数
  14.         if(err) throw err;  //如果有错误，则抛出异常
  15.         console.log(results);  //输出结果
  16.         conn.release();  //释放连接
  17.     });
  18. });

2.5、便捷增加

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. let sql="insert into student set ?";
  12. let student={name:"rose",sex:"girl"};
  13. pool.getConnection((connErr,conn)=>{  //获取连接对象
  14.     pool.query(sql,student,(err,results)=>{//执行添加，指定参数对象
  15.         if(err) throw err;  //如果有错误，则抛出异常
  16.         console.log(results);  //输出结果
  17.         conn.release();  //释放连接
  18.         //process.exit(1);  //关闭应用
  19.     });
  20. });

2.6、更新数据

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. let sql="update student set name=?,sex=? where id=?";
  12. pool.getConnection((connErr,conn)=>{  //获取连接对象
  13.     pool.query(sql,['mark','boy',34],(err,results)=>{//执行更新，指定参数
  14.         if(err) throw err;  //如果有错误，则抛出异常
  15.         console.log(results);  //输出结果
  16.         conn.release();  //释放连接
  17.     });
  18. });

2.7、便捷更新数据

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. let sql="update student set ? where id=?";
  12. let student={name:"jone",sex:'boy'};
  13. pool.getConnection((connErr,conn)=>{  //获取连接对象
  14.     pool.query(sql,[student,33],(err,results)=>{//执行更新，指定参数
  15.         if(err) throw err;  //如果有错误，则抛出异常
  16.         console.log(results);  //输出结果
  17.         conn.release();  //释放连接
  18.     });
  19. });

2.8、删除数据

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"gomall"  //数据库,port可以省去
  9. });
  10.  
  11. let sql="delete from student where id=?";
  12. pool.getConnection((connErr,conn)=>{  //获取连接对象
  13.     pool.query(sql,[33],(err,results)=>{//执行查询
  14.         if(err) throw err;  //如果有错误，则抛出异常
  15.         if(results.affectedRows===1){  //如果影响行数为1
  16.             console.log("删除成功");
  17.         }
  18.         else{
  19.             console.log("删除失败");
  20.         }
  21.         conn.release();  //释放连接
  22.     });
  23. });

2.9、释放连接

  1. //查询
  2. pool.getConnection((err,conn)=>{
  3.     pool.query("select * from student",(err,results)=>{
  4.         results=JSON.parse(JSON.stringify(results));
  5.         results.forEach((stu,index)=>{
  6.             console.log(stu.id,stu.name,stu.sex);
  7.         });
  8.         conn.release();
  9.         process.exit(1);
  10.     });
  11. });

2.10、路由文件参考：

  1. // 1.导入mysql模块
  2. const mysql = require('mysql')
  3.  
  4. // 2.建立和MySQL数据库的联系
  5. const db = mysql.createPool({
  6.     host: '127.0.0.1', //数据库的ip地址
  7.     user: 'root', //登录数据库的账号
  8.     password: 'hoshi1234', //登录数据库的密码
  9.     datebase: 'my_dv_01' //指定要操作那个数据库
  10. })
  11.  
  12. // 3.测试mysql模块是否正常工作
  13. db.query('select 1',(err, results) => {
  14.     // mysql工作期间报错了
  15.     if(err) return console.log(err.message);
  16.  
  17.     // 能够正常执行SQL语句
  18.     console.log(results);
  19.     // 返回 [ RowDataPacket { '1': 1 } ]
  20. })
  21.  
  22. // 4.查询 users 表中所有数据
  23. const sqlStr = 'select * from my_dv_01.users'
  24. db.query(sqlStr ,(err, results) => {
  25.     // mysql工作期间报错了
  26.     if(err) return console.log(err.message);
  27.  
  28.     // 能够正常执行SQL语句
  29.     console.log(results);
  30.     // 返回 users表的字段
  31. })
  32.  
  33. // 5.插入数据到 users 表中
  34.  
  35. // 要插入到表中的数据
  36. const user = { usersname: 'benben', password:'886886' }
  37.  
  38. // 待执行的 SQL语句 ，英文问号 ? 代表占位符(SQL语法)
  39. const sqlStr2 = 'insert into users (usersname, password) VALUES (?,?)'
  40.  
  41. // 使用数组的形式，依次为 ? 占位符指定具体的位置
  42. db.query(sqlStr2, [user.usersname , user.password],(err, results) => {
  43.         // mysql工作期间报错了
  44.         if(err) return console.log(err.message);
  45.  
  46.         // 如果执行的是insert into这个插入语句，则results是一个对象
  47.         // 可以通过results.affectedRows判断是否成功
  48.         if(results.affectedRows === 1) {
  49.             console.log('插入数据成功');
  50.             // 打开MySQL的users表格也能看到新数据
  51.             // 当前数据只有4条，本条数据id为什么是5？
  52.             // 因为之前有过4的数据，但是被删除了，id具有唯一性，删除了也不能被其他数据使用
  53.         }
  54. })
  55.  
  56. // 插入数据的便捷方式
  57. const user = { usersname: 'niuniu', password:'000000' }
  58.  
  59. // 定义待执行的 SQL 语句
  60. const sqlStr = 'insert into my_dv_01.users set ?'
  61.  
  62. // 执行 SQL 语句
  63. db.query(sqlStr, user,(err, results) => {
  64.  
  65.         if(err) return console.log(err.message);
  66.         if(results.affectedRows === 1) {
  67.             console.log('插入数据成功');
  68.         }
  69. })
  70.  
  71. // 如何更新用户的信息（UPDATE 语句用于更新表中已存在的记录）
  72.  
  73. // 要插入到表中的数据
  74. const user = { id: 6, usersname: '犇犇', password:'000111' }
  75.  
  76. // 定义SQL语句
  77. const sqlStr = 'update my_dv_01.users set usersname=?, password=? where id=?'
  78.  
  79. // 执行SQL语句
  80. db.query(sqlStr,[user.usersname, user.password, user.id], (err, results) => {
  81.     if(err) return console.log(err.message);
  82.     if(results.affectedRows === 1) {
  83.         console.log('插入数据成功');
  84.     }
  85. })
  86.  
  87. // 更新用户信息的便捷方式（数据对象的每个属性和字段一一对应的情况下可使用）
  88. const user = { id: 6, usersname: '夸夸牛', password:'000111' }
  89.  
  90. // 定义SQL语句
  91. const sqlStr = 'update my_dv_01.users set ? where id=?'
  92.  
  93. // 执行SQL语句
  94. db.query(sqlStr,[user, user.id], (err, results) => {
  95.     if(err) return console.log(err.message);
  96.     if(results.affectedRows === 1) {
  97.         console.log('插入数据成功');
  98.     }
  99. })
  100.  
  101. // 删除数据
  102. // 定义SQL语句
  103. const sqlStr = 'delete from my_dv_01.users where id=?'
  104.  
  105. // 执行SQL语句
  106. // SQL语句中有多个占位符，则必须使用数组为每个占位符指定具体的值
  107. // 如果只有一个占位符，则可以省略数组
  108. db.query(sqlStr,5,(err,results) => {
  109.     if(err) return console.log(err.message);
  110.         if(results.affectedRows === 1) {
  111.             console.log('删除数据成功');
  112.         }
  113. })
  114.  
  115. // 标记删除
  116. // 使用delete语句会把数据真正删除掉，非常危险，一般情况下推荐使用标记删除，类似于修改status字段的状态，比如更新成1表示删除；
  117.  
  118. // 定义SQL语句
  119. const sqlStr = 'update my_dv_01.users set status=? where id=?'
  120.  
  121. // 执行SQL语句
  122. db.query(sqlStr,[1, 3],(err, results) => {
  123.     if(err) return console.log(err.message);
  124.             if(results.affectedRows === 1) {
  125.                 console.log('标记删除成功');
  126.             }
  127. })

2.11、封装代码

访问数据库的代码存在许多的重复，为了便于维护与扩展可以将数据库访问代码封装起来。

  • 创建一个 mysqlutil.js 文件，代码如下：
  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"bookInfo"  //数据库,port可以省去
  9. });
  10.  
  11. function query(sql,param){
  12.     return new Promise((resolve,reject)=>{
  13.         pool.getConnection((connErr,conn)=>{  //获取连接对象
  14.             pool.query(sql,param||[],(err,results)=>{//执行sql
  15.                 try{
  16.                     if(err) reject(err);
  17.                     resolve(JSON.parse(JSON.stringify(results)));
  18.                 }
  19.                 finally{
  20.                     conn.release();  //释放连接
  21.                 }
  22.             });
  23.         });
  24.     });
  25. }
  26.  
  27. module.exports={query};

创建一个js文件，测试代码如下：

  1. const mysqlutil=require("./mysqlutil");  //导入mysql工具模块
  2.  
  3. //查询所有
  4. //mysqlutil.query("select * from student").then(console.log).catch(console.log);
  5. //查询并带参数
  6. //mysqlutil.query("select * from student where id=?",[1]).then(console.log).catch(console.log);
  7.  
  8. //执行更新
  9. let sql="update student set ? where id=?";
  10. let student={name:"张二",sex:"girl"};
  11. //mysqlutil.query(sql,[student,1]).then(console.log).catch(console.log);
  12.  
  13. async function findAll(){
  14.     try{
  15.         let result= await mysqlutil.query("select * from student");
  16.         return result;
  17.         }
  18.     catch(err){
  19.         throw err;
  20.     }
  21. }
  22.  
  23. findAll().then(console.log);

2.12、连接MySQL数据库，实现curd、图片上传（使用element-ui框架）功能的完整代码如下：

封装代码 util 包：

  1. const mysql=require("mysql");  //依赖mysql模块
  2.  
  3. //创建连接池对象
  4. let pool=mysql.createPool({
  5.     host:"localhost",  //主机
  6.     user:"root",  //用户名
  7.     password:"123456",  //密码
  8.     database:"bookInfo"  //数据库,port可以省去
  9. });
  10.  
  11. function query(sql,param){
  12.     return new Promise((resolve,reject)=>{
  13.         pool.getConnection((connErr,conn)=>{  //获取连接对象
  14.             pool.query(sql,param||[],(err,results)=>{//执行sql
  15.                 try{
  16.                     if(err) reject(err);
  17.                     resolve(JSON.parse(JSON.stringify(results)));
  18.                 }
  19.                 finally{
  20.                     conn.release();  //释放连接
  21.                 }
  22.             });
  23.         });
  24.     });
  25. }
  26.  
  27. module.exports={query};

路由 Api 接口：

  1. const mysqlutil = require("./mysqlutil"); //导入mysql工具模块
  2. var express = require("express");
  3. var router = express.Router();
  4.  
  5. async function findAll(sql, param) {
  6.     try {
  7.         let result = await mysqlutil.query(sql, param);
  8.         return result;
  9.     } catch (err) {
  10.         throw err;
  11.     }
  12. }
  13.  
  14. // 查询
  15. router.get("/", (req, res) => {
  16.     let sql = "select * from book";
  17.     findAll(sql, "").then(result => {
  18.         res.json({
  19.             status: "ok",
  20.             data: result
  21.         });
  22.     });
  23. });
  24.  
  25. // 删除
  26. router.delete("/:id", (req, res) => {
  27.     let sql = "delete from book where id=?";
  28.     findAll(sql, [req.params.id]).then(result => {
  29.         console.log(result);
  30.         res.json({
  31.             status: "ok",
  32.             data: result
  33.         });
  34.     });
  35. });
  36.  
  37. // 添加
  38. router.post("/", (req, res) => {
  39.     let sql = "insert into book set ?";
  40.     let inputTest = req.body;
  41.     findAll(sql, inputTest).then(result => {
  42.         res.json({
  43.             status: "ok",
  44.             data: result
  45.         });
  46.     });
  47. });
  48.  
  49. // 显示信息
  50. router.get("/:id", (req, res) => {
  51.     let sql = "select * from book where id= ?";
  52.     findAll(sql, [req.params.id]).then(result => {
  53.         res.json({
  54.             status: "ok",
  55.             data: result
  56.         });
  57.     });
  58.  
  59. });
  60.  
  61. // 修改
  62. router.put("/", (req, res) => {
  63.     let sql = "update book set ? where id=?";
  64.     let inputTest = req.body;
  65.     findAll(sql, [inputTest, inputTest.id]).then(result => {
  66.         res.json({
  67.             status: "ok",
  68.             data: result
  69.         });
  70.     });
  71. });
  72.  
  73. module.exports = router;

ejs 页面：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>连接MySQL实现增删查改 —— 图书管理系统</title>
  9.     <!-- 图标 -->
  10.     <!-- ejs里的图片路径直接不用管public ！！！ -->
  11.     <link rel="shortcut icon" href="/images/taozi.svg" type="image/x-icon">
  12.     <!-- 样式 -->
  13.     <link rel="stylesheet" href="/stylesheets/book.css">
  14. </head>
  15.  
  16. <body>
  17.     <div id="app">
  18.         <h3>图书管理系统</h3>
  19.         <div id="addbtn">
  20.             <button id="appBook">新增图书&nbsp;+&nbsp;</button>
  21.         </div>
  22.         <table>
  23.             <tr>
  24.                 <th>编号</th>
  25.                 <th>书名</th>
  26.                 <th>封面</th>
  27.                 <th>作者</th>
  28.                 <th>价格</th>
  29.                 <th>操作</th>
  30.             </tr>
  31.             <tr v-for="(b, i) in book" :key="b.id">
  32.                 <td>{{ b.id }}</td>
  33.                 <td>{{ b.name }}</td>
  34.                 <td>
  35.                     <div id="picture" :style="{backgroundImage: 'url(/images/' + b.picture + ')'}"></div>
  36.                 </td>
  37.                 <td>{{ b.author }}</td>
  38.                 <td>{{ b.price }}</td>
  39.                 <td>
  40.                     <button id="update" @click="edit(b.id)">编辑</button>
  41.                     <button id="delete" @click="del(b.id)">删除</button>
  42.                 </td>
  43.             </tr>
  44.         </table>
  45.  
  46.         <!-- 模态框 -->
  47.         <div id="modal_box">
  48.             <!--修改or添加  -->
  49.             <div id="mdinfo">
  50.                 <table>
  51.                     <tr>
  52.                         <td colspan="2" id="td">新增图书信息</td>
  53.                     </tr>
  54.                     <tr>
  55.                         <td>书名：</td>
  56.                         <td>
  57.                             <input type="text" id="name" class="text" v-model="bookObj.name" />
  58.                         </td>
  59.                     </tr>
  60.                     <tr>
  61.                         <td>作者：</td>
  62.                         <td>
  63.                             <input type="text" id="author" class="text" v-model="bookObj.author" />
  64.                         </td>
  65.                     </tr>
  66.                     <tr>
  67.                         <td>价格：</td>
  68.                         <td>
  69.                             <input type="text" id="price" class="text" v-model="bookObj.price" />
  70.                         </td>
  71.                     </tr>
  72.                     <tr>
  73.                         <td>封面名称：</td>
  74.                         <td>
  75.                             <input type="text" id="pictures" class="text" v-model="bookObj.picture" />
  76.                         </td>
  77.                     </tr>
  78.                     <tr>
  79.                         <td colspan="2">
  80.                             <button id="btn1" @click="save" class="btn">提交</button>
  81.                             <button id="btn2" class="btn">取消</button>
  82.                         </td>
  83.                     </tr>
  84.                 </table>
  85.             </div>
  86.         </div>
  87.     </div>
  88. </body>
  89. <script src="javascripts/jquery-1.12.4.js"></script>
  90. <script src="javascripts/axios.js"></script>
  91. <script src="javascripts/vue.js"></script>
  92. <script>
  93.  
  94.     var path = "http://127.0.0.1:8082/bookApi/";
  95.     var app = new Vue({
  96.         el: "#app",
  97.         data: {
  98.             book: [],
  99.             bookObj: { id: 0, name: "", picture: "", author: "", price: "" },
  100.             // 获取编号最大的图书。即最新添加的编号
  101.             maxId: ""
  102.         },
  103.         created() {
  104.             this.seleBook();
  105.         },
  106.         methods: {
  107.             seleBook() {
  108.                 axios
  109.                     .get(path)
  110.                     .then((data) => {
  111.                         this.book = data.data.data;
  112.                         // console.log(data.data.data);
  113.                     })
  114.                     .catch((err) => {
  115.                         throw err;
  116.                     });
  117.             },
  118.             // 传该行对应的对象，和第几行的索引
  119.             del(id) {
  120.                 if (confirm("您确定要删除这数据吗？")) {
  121.                     axios
  122.                         .delete(path + id)
  123.                         .then((data) => {
  124.                             alert("删除成功！");
  125.                             this.seleBook();
  126.                         })
  127.                 }
  128.             },
  129.             save() {
  130.                 if (this.bookObj.id) {
  131.                     // 修改
  132.                     axios
  133.                         .put(path, this.bookObj)
  134.                         .then((data) => {
  135.                             if (data.data.status === "ok") {
  136.                                 alert("修改成功！");
  137.                                 this.book = data.data.data;
  138.                                 this.bookObj = { id: 0, name: "", picture: "", author: "", price: "" };
  139.                                 $("#modal_box").css("display", "none");
  140.                                 this.seleBook();
  141.                             }
  142.                         })
  143.  
  144.                 } else {
  145.                     console.log(this.bookObj);
  146.                     // 添加
  147.                     axios
  148.                         .post(path, this.bookObj)
  149.                         .then((data) => {
  150.                             if (data.data.status === "ok") {
  151.                                 alert("添加成功！");
  152.                                 this.book.id = 0; // 因为是添加，所以id要重置为0
  153.                                 this.bookObj = { id: 0, name: "", picture: "", author: "", price: "" };
  154.                                 $("#modal_box").css("display", "none");
  155.                                 this.seleBook();
  156.                             }
  157.                         })
  158.                 }
  159.             },
  160.             // 显示数据到模态框
  161.             edit(id) {
  162.                 $("#td").html("修改图书信息");
  163.                 $("#modal_box").slideToggle();
  164.                 axios
  165.                     .get(path + id)
  166.                     .then((data) => {
  167.                         this.bookObj = data.data.data[0];
  168.                     })
  169.                     .catch((err) => {
  170.                         throw err;
  171.                     })
  172.             },
  173.             // 搜索
  174.             search() {
  175.                 console.log($("#searchText").val());
  176.                 axios
  177.                     .get(path + ($("#searchText").val()))
  178.                     .then((data) => {
  179.                         this.book = [data.data.data];
  180.                         // console.log(this.book.id);
  181.                         console.log(this.book);
  182.                     })
  183.                     .catch((err) => {
  184.                         throw err;
  185.                     })
  186.             },
  187.             // 按id倒序
  188.             sortId() {
  189.                 axios
  190.                     .get(path + "book/sort")
  191.                     .then((data) => {
  192.                         this.book = data.data.data;
  193.                     })
  194.                     .catch((err) => {
  195.                         throw err;
  196.                     })
  197.             },
  198.             // 文件上传的样式
  199.             // 删除
  200.             handleRemove(file) {
  201.                 console.log(file);
  202.             },
  203.             hold() {
  204.                 $("#modal_box").css("display", "none");
  205.             }
  206.         },
  207.     });
  208.  
  209.     // 模态框显示
  210.     $("#appBook").click(function () {
  211.         $("#modal_box").slideToggle();
  212.         $("#td").html("新增图书信息");
  213.     });
  214.     $("#btn2").click(function () {
  215.         $("#modal_box").css("display", "none");
  216.         $(".text").val("");
  217.     });
  218.  
  219. </script>
  220.  
  221. </html>

Node.js 的学习（四）分别连接MongoDB与MySQL数据库，实现增删查改功能的更多相关文章

  1. MongoDB在Java下的增删查改

    我们总不能一直使用cmd对数据库操作,数据库总是要在程序中使用的.今天来说一下怎么通过Java调用MongoDB. 学习一下最基本也是最常用的增删查改语句,这是使用数据库的基础. 注意事项: 1.要打 ...

  2. MongoDB数据库(二):增删查改

    MongoDB数据库的增删查改 1.插入数据 语法: db.集合名称.insert(document) db.table_name.insert({name:'gj',gender:1}) db.ta ...

  3. [课本]JDBC课程6--使用JDBC的DAO模块化--完成数据库的增删查改_工具类JDBCTools四个(Preparedstatement)功能模块的敲定版

    (课本P273-任务九) /**DAO: Data Access Object * 为什么用: 实现功能的模块化,更有利于代码的维护和升级 * 是什么: 访问数据信息的类,包含对数据的CRUD(cre ...

  4. Node.js基础学习四之注册功能

    前言:在Node.js学习(二)和(三)中介绍了如何在Node.js 中获取登录的用户名和密码与数据库进行验证并返回数据给客户端 需求:实现注册功能 为了区分登录和注册是两个不同的请求,在端口后面加上 ...

  5. node.js环境安装，及连接mongodb测试

    1.node.js环境安装 npm config set python python2.7npm config set msvs_version 2013npm config set registry ...

  6. MongoDB数据库进阶 --- 增删查改...

    注意: monogdb数据在使用之后必须及时 mongodb.close()否则后台崩溃. 在之前的文章中,我已经介绍了什么事MongoDB以及怎么在windows下安装MongoDB等等基本知识. ...

  7. KoaHub平台基于Node.js开发的Koa的连接MongoDB插件代码详情

    koa-mongo MongoDB middleware for koa, support connection pool. koa-mongo koa-mongo is a mongodb midd ...

  8. MongoDB 学习笔记（二）：shell中执行增删查改

    一.查 1.查询集合中所有文档:db.集合名.find(). 2.查询集合中第一个文档:db.集合名.findOne(). 3.指定查询条件:第一个参数就是指定查询条件 查询全部文档:db.集合名.f ...

  9. js实现对数据库的增删查改

    1.查询 复制代码 代码如下: <HTML> <HEAD> <TITLE>数据查询</TITLE> <Script > var conn = ...

  10. C++连接sqlite数据库的增删查改操作

    这个代码是接着上次说的,要用VS2013操作数据库,首先要配置好环境,创建好数据库表等. 不明白的翻我前面2篇看看~~~ 关于前面的用到的goto 语句,这个我也是参考其他博主写的,现在我注释掉了,毕 ...

随机推荐

  1. 搭建docker镜像仓库(一)：使用registry搭建本地镜像仓库

    目录 一.系统环境 二.前言 三.使用registry搭建私有镜像仓库 3.1 环境介绍 3.2 k8smaster节点配置镜像仓库 3.3 k8sworker1节点配置从私有仓库上传和拉取镜像 3. ...

  2. Hive 组件安装配置

    下载和解压安装文件 基础环境和安装准备 Hive组件的部署规划和软件包路径如下: (1)当前环境中已安装 Hadoop全分布系统 (2)本地安装 MySQL数据库(账号 root,密码 Passwor ...

  3. Python实现XMind测试用例快速转Excel用例

    转载请注明出处️ 作者:测试蔡坨坨 原文链接:caituotuo.top/c2d10f21.html 你好,我是测试蔡坨坨. 今天分享一个Python编写的小工具,实现XMind测试用例转Excel用 ...

  4. Android平台RTMP/RTSP播放器开发系列--解码和绘制

    本文主要抛砖引玉,粗略介绍下Android平台RTMP/RTSP播放器中解码和绘制相关的部分(Github). 解码 提到解码,大家都知道软硬解,甚至一些公司觉得硬解码已经足够通用,慢慢抛弃软解了,如 ...

  5. DS

    树状数组 原始问题 \(a_x \overset+\gets y\) \(\sum\limits_{i=1}^{r} a_i\) 解决方法: 定义 \({\rm lb}(i) = i-i \wedge ...

  6. JS输出内容为[object Object]

    问题描述 项目中,欲在控制台输出变量res(自定义对象)查看数据,代码为: console.log('res:' + res); 但控制台显示结果为res: [object Object],并非想要查 ...

  7. 《网页设计基础——HTML常用标签》

    网页设计基础--HTML常用标签       一.网页框架: 格式: <html> <head> <title>网页标题</title> <sty ...

  8. 【面试题】JS改变this指向的三种方法

    一.this指向 点击打开视频讲解更加详细 this随处可见,一般谁调用,this就指向谁.this在不同环境下,不同作用下,表现的也不同. 以下几种情况,this都是指向window 1.全局作用下 ...

  9. 《Win10——常用快捷键》

    Win10--常用快捷键       Ctrl+C:复制 Ctrl+V:粘贴 Ctrl+A:全选 Ctrl+X:剪切 Ctrl+D:删除 Ctrl+Z:撤销 Ctrl+Y:反撤销 Ctrl+Shift ...

  10. 第六章：Django 综合篇 - 12：聚合内容 RSS/Atom

    Django提供了一个高层次的聚合内容框架,让我们创建RSS/Atom变得简单,你需要做的只是编写一个简单的Python类. 一.范例 要创建一个feed,只需要编写一个Feed类,然后设置一条指向F ...