大數據技術之_22_MongoDB學習_MongoDB 的簡介、下載、安裝、啓動、配置和關閉 + MongoDB 的基本操做 + Mongoose + 使用 java 對 MongoDB 增刪改查
第一章 數據庫的概述1.1 什麼是數據庫1.2 數據庫分類第二章 MongoDB 的簡介、下載、安裝、啓動、配置和關閉2.1 MongoDB 簡介2.2 下載 MongoDB2.3 安裝 MongoDB2.4 啓動 MongoDB2.5 配置 MongoDB 的 windows 服務2.6 關閉 MongoDB第三章 MongoDB 的基本操做3.1 MongoDB 的基本概念3.2 基本指令3.3 數據庫的 CRUD（增刪改查）的操做3.4 安裝圖形化工具3.5 文檔的增刪改查3.6 練習題3.7 文檔中的關係3.8 sort 和投影第四章 Mongoose4.1 Mongoose 的簡介4.2 Mongoose 的好處4.3 新的對象4.4 經過 Mongoose 鏈接 MongoDB4.5 Schema--模式對象(約束對象)4.6 Model--模型對象4.7 Model 對象的方法4.8 Document--文檔對象4.9 Document 對象的方法4.10 Mongoose 的模塊化第五章 使用 java 對 MongoDB 增刪改查5.1 在 java 中解析 json5.2 java 版 Mongo HelloWorld5.3 使用 java 對 MongoDB 增刪改查javascript
第一章 數據庫的概述
1.1 什麼是數據庫
• 數據庫是按照數據結構來組織、存儲和管理數據的倉庫。
• 咱們的程序都是在內存中運行的，一旦程序運行結束或者計算機斷電，程序運行中的數據都會丟失。
• 因此咱們就須要將一些程序運行的數據持久化到硬盤之中，以確保數據的安全性。而數據庫就是數據持久化的最佳選擇。
• 說白了，數據庫就是存儲數據的倉庫。css
1.2 數據庫分類
數據庫主要分紅兩種：
關係型數據庫
• MySQL、Oracle、DB二、SQL Server ……
關係數據庫中全都是表
非關係型數據庫
• MongoDB、Redis ……
• 鍵值對數據庫
• 文檔數據庫 MongoDBjava
第二章 MongoDB 的簡介、下載、安裝、啓動、配置和關閉
2.1 MongoDB 簡介
• MongoDB 是爲快速開發互聯網 Web 應用而設計的數據庫系統。
• MongoDB 的設計目標是極簡、靈活、做爲 Web 應用棧的一部分。
• MongoDB 的數據模型是面向文檔的，所謂文檔是一種相似於 JSON 的結構，簡單理解：MongoDB 這個數據庫中存的是各類各樣的 JSON。（BSON）nginx
2.2 下載 MongoDB
• 下載地址：https://www.mongodb.org/dl/win32/
• MongoDB 的版本偶數版本爲穩定版，奇數版本爲開發版。
• MongoDB 對於 32 位系統支持不佳，因此 3.2 版本之後沒有再對 32 位系統的支持。
• 本博主下載的版本是：mongodb-win32-x86_64-2008plus-ssl-3.2.4-signedsql
2.3 安裝 MongoDB
一、雙擊安裝文件 mongodb-win32-x86_64-2008plus-ssl-3.2.4-signedmongodb
二、點擊接受協議
三、選擇自定義安裝
四、選擇安裝目錄
五、點擊安裝
六、安裝過程當中
七、安裝完成
八、MongoDB 的安裝目錄結構
2.4 啓動 MongoDB
一、將 MongoDB 的 bin 目錄添加到 path 下（這裏咱們使用 bruce 的用戶變量）shell
二、在 C 盤根目錄下建立 data 文件夾，在 data 下建立 db 文件夾，該文件用於存放 MongoDB 的文件，在 data 下建立 db 文件夾
啓動 mongodb 服務器，打開 cmd 命令行窗口，輸入：mongod
• 32操做系統位注意：第一次啓動 mongodb 服務器時，須要輸入以下內容：
mongod --storageEngine=mmapv1
第一次啓動後，再次啓動 mongodb 服務器時，只需輸入 mongodb 便可。數據庫
• 若是咱們不想使用 mongodb 提供的默認數據庫路徑和端口，該如何作呢？
答：在控制檯啓動 mongodb 時，能夠指定路徑和端口
mongod --dbpath 數據庫路徑 --port 端口號
示例：mongod --dbpath C:\Users\bruce\Desktop\mongo\data\db --port 123npm
三、再從新打開一個 cmd 窗口，輸入 mongo 鏈接 mongodb 數據庫，出現下圖json
注意：打開的命令行窗口不能關閉。
2.5 配置 MongoDB 的 windows 服務
將 MongoDB 設置爲系統服務，能夠自動在後臺啓動，不須要每次都手動啓動。
一、在 c 盤根目錄建立 data，在 data 下建立 db 和 log 文件夾
二、建立配置文件，在目錄 D:\work\MongoDB\Server\3.2 下添加一個配置文件 mongod.cfg，並添加以下內容
systemLog:
destination: file
path: c:\data\log\mongod.log
storage:
dbPath: c:\data\db
三、以管理員的身份打開命令行窗口，執行以下的命令：
sc.exe create MongoDB binPath= "\"D:\work\MongoDB\Server\3.2\bin\mongod.exe\" --service --config=\"D:\work\MongoDB\Server\3.2\mongod.cfg\"" DisplayName= "MongoDB" start= "auto"
sc.exe create MongoDB binPath= "\"mongod的bin目錄\mongod.exe\" --service --config=\"mongo的安裝目錄\mongod.cfg\"" DisplayName= "MongoDB" start= "auto"
四、打開命令行，啓動 mongodb 服務
五、若是啓動失敗，證實上邊的操做有誤，在控制檯輸入 sc delete MongoDB 刪除以前配置的服務，而後從第一步再來一次。
2.6 關閉 MongoDB
一、打開新的命令行窗口，輸入命令，登陸到服務器
mongo
二、切換管理員用戶
use admin;
三、關閉數據庫
db.shutdownServer();
第三章 MongoDB 的基本操做
3.1 MongoDB 的基本概念
數據庫（database）：數據庫是一個倉庫，在倉庫中能夠存放集合。
集合（collection）：集合相似於數組，在集合中能夠存放文檔。
文檔（document）：文檔是數據庫中最小單位，咱們存儲和操做的內容都是文檔。
在 MongoDB 中，數據庫和集合都不須要手動建立，當咱們建立文檔時，若是文檔所在的集合或數據庫不存在會自動建立數據庫和集合。
文檔（document）：相似於 JS 中的對象，在 MongoDB 中每一條數據都是一個文檔。
集合（collection）：集合就是一組文檔，也就是集合是用來存放文檔的。
集合中存儲的文檔能夠是各類各樣的，沒有格式要求，多個文檔組成集合，多個集合組成數據庫。
3.2 基本指令
經常使用指令舉例：
show dbs
show databases
- 顯示當前的全部數據庫
use 數據庫名
- 進入到指定的數據庫中
db
- db表示的是當前所處的數據庫
show collections
- 顯示數據庫中全部的集合
Mongo Shell 小解
3.3 數據庫的 CRUD（增刪改查）的操做
- 向數據庫中插入文檔
db.<collection>.insert(doc(s));
- 向指定的集合插入一個或多個文檔，若是集合不存在則建立
- 具體示例：db.users.insert({username:"sunwukong",age:18,gender:"male"})
db.<collection>.find();
- 查詢當前集合中的全部文檔
- 具體示例：db.users.find()
db.<collection>.count();
- 統計集合中文檔的數量
- 具體示例：db.users.count()
db.collection.remove();
- 刪除文檔
db.collection.drop();
- 刪除集合
3.4 安裝圖形化工具
一、雙擊 mongodbmanagerfree_inst.exe
二、選擇接受
三、選擇安裝目錄
四、所有選上
五、選擇 next
六、建立桌面快捷方式
七、點擊安裝
八、安裝完成
九、選擇接受
十、輸入鏈接 MongoDB 數據庫的 IP 地址和 端口
十一、點擊 「+」 號，鏈接成功
3.5 文檔的增刪改查
插入文檔
db.collection.insert();
insert() 能夠用於向集合中添加一個或多個文檔，能夠傳遞一個對象，或一個數組。
能夠將對象或數組中的對象添加進集合中，添加時若是集合或數據庫不存在，會自動建立。
插入的文檔對象會默認添加_id 屬性，這個屬性對應一個惟一的id，是該文檔的惟一標識。 _id 屬性能夠本身指定
db.users.insert({username: "sunwukong", age: 18, gender: "male"}); // 默認id
db.users.insert({_id: "001", username: "sunwukong", age: 18, gender: "male"}); // 本身指定id
db.users.insert([
{username: "sunwukong", age: 18, gender: "male"},
{username: "zhubajie", age: 20, gender: "male"},
{username: "shaheshang", age:25, gender: "female"}
]);
db.users.insertOne(); // 插入一個文檔對象，從 3.2 版本開始有該方法
db.users.insertMany(); // 插入多個文檔對象，從 3.2 版本開始有該方法
查詢文檔
db.collection.find()
find() 用來查詢集合中的全部符合條件的文檔。
find() 中能夠接收一個條件參數。
db.users.find(); // 查詢集合中的全部文檔
db.users.find({}); // 查詢集合中的全部文檔
db.users.find({_id: "001"});
db.users.find({username: "sunwukong"});
db.users.find({username: "sunwukong", age: 25});
db.users.find({age:25}); // 返回的是一個文檔對象的數組
db.users.find({age:25})[1];
db.users.find({age:25})[5];
db.users.findOne({age:25}); // 查詢符合條件的第一個文檔對象
db.users.findOne({age:25}).name; // 查詢一個符合條件的文檔對象的屬性值
db.users.findOne({age:25}).count(); // 查詢一個符合條件的文檔對象的屬性值（該方法經常使用）
db.users.findOne({age:25}).length(); // 查詢一個符合條件的文檔對象的屬性值（該方法不經常使用）
刪除文檔
db.collection.remove()
remove()能夠用來移除指定文檔對象，該方法接收一個查詢文檔做爲參數，只有符合條件的文檔纔會被刪除。
刪除數據是永久的，不能撤銷。
db.users.remove({_id: "001"}); // 刪除一個或多個符合條件的文檔對象
db.users.remove({age: 25, true}); // 只刪除一個符合條件的文檔對象
db.users.remove({}); // 刪除全部的文檔對象（即清空集合，性能略差），集合還在
db.users.deleteOne();
db.users.deleteMany();
刪除集合
db.collection.drop()
db.users.drop(); // 刪除集合（性能好），集合不存在
刪除數據庫
db.dropDatabase()
數據庫中的數據通常不會刪除，因此刪除方法通常不用。
通常會在數據中增長一個字段，來表示數據是否被刪除。（即經過數據冗餘）
修改文檔
db.collection.update()
能夠在 update() 中傳遞兩個參數，第一個是查詢文檔，第二個是新的文檔，這樣符和條件的文檔將會被新文檔所【替換】，即舊的對象沒有了。
update() 的第三個參數，用來指定是否使用 upsert，默認爲 false。
update() 的第四個參數，用來指定是否同時修改多個文檔，默認爲 false。
若是須要修改指定的值，而不是替換，須要使用【修改操做符】來完成修改。
$set 修改文檔中的指定屬性
$unset 刪除文檔中指定的屬性
$inc 自增文檔中指定的屬性的值
$push
$addToSet
db.users.update({username: "sunwukong"}, {age: 10}); // 新的文檔對象替換舊的文檔對象（只替換符合條件的第一個文檔對象）
db.users.replaceOne({username: "sunwukong"}, {age: 100}); // 新的文檔對象替換舊的文檔對象（只替換符合條件的第一個文檔對象）
db.users.update({username: "sunwukong"}, {$set: {age: 10}}); // 替換舊的文檔對象中某個屬性的值（只替換符合條件的第一個文檔對象）
db.users.update({username: "sunwukong"}, {$set: {age: 10}}, {multi: true}); // 替換舊的文檔對象中某個屬性的值（替換符合條件的一個或多個文檔對象）
db.users.update({username: "sunwukong"}, {$unset: {age: 10}}); // 刪除舊的文檔對象中某個屬性
db.users.updateOne({username: "sunwukong"}, {$set: {age: 10}}); // 替換舊的文檔對象中某個屬性的值（只替換符合條件的第一個文檔對象）
db.users.updateMany({username: "sunwukong"}, {$set: {age: 10}}); // 替換舊的文檔對象中屬性的值（替換符合條件的一個或多個文檔對象）
3.6 練習題
// 1.進入 my_test 數據庫
use my_test;
// 2.向數據庫的 user 集合中插入一個文檔
db.users.insert({
username: "sunwukong"
});
// 3.查詢 user 集合中的文檔
db.users.find();
// 4.向數據庫的 user 集合中插入一個文檔
db.users.insert({
username: "zhubajie"
});
// 5.查詢數據庫 user 集合中的文檔
db.users.find();
// 6.統計數據庫user集合中的文檔數量
db.users.find().count();
// 7.查詢數據庫 user 集合中 username 爲 sunwukong 的文檔
db.users.find({username: "sunwukong"});
// 8.向數據庫 user 集合中的 username 爲 sunwukong 的文檔，添加一個 address 屬性，屬性值爲 huaguoshan
db.users.update({username: "sunwukong"}, {$set: {address: "huaguoshan"}});
// 9.使用{username: "tangseng"} 替換 username 爲 zhubajie的 文檔
db.users.replaceOne({username: "zhubajie"}, {username: "tangseng"});
// 10.刪除 username 爲 sunwukong 的文檔的 address 屬性
db.users.update({username: "sunwukong"}, {$unset: {address: 1}});
// 11.向 username 爲 sunwukong 的文檔中，添加一個 hobby: {cities: ["beijing", "shanghai", "shenzhen"], movies: ["sanguo", "hero"]}
// MongoDB 的文檔的屬性值也能夠是一個文檔，當一個文檔的屬性值是一個文檔時，咱們稱這個文檔叫作內嵌文檔。
db.users.update({username: "sunwukong"}, {$set: {hobby: {cities: ["beijing", "shanghai", "shenzhen"], movies: ["sanguo", "hero"]}}});
db.users.find();
// 12.向 username 爲 tangseng 的文檔中，添加一個 hobby: {movies: ["A Chinese Odyssey", "King of comedy"]}
db.users.update({username: "tangseng"}, {$set: {hobby: {movies: ["A Chinese Odyssey", "King of comedy"]}}})
// 13.查詢喜歡電影 hero 的文檔
// MongoDB 支持直接經過內嵌文檔的屬性進行查詢，若是要查詢內嵌文檔則能夠經過.的形式來匹配
// 若是要經過內嵌文檔來對文檔進行查詢，此時屬性名必須使用引號（單雙引號都可）
db.users.find({"hobby.movies": "hero"});
db.users.find({'hobby.movies': "hero"});
// 14.向 tangseng 中添加一個新的電影 Interstellar
// $push 用於向數組中添加一個新的元素（便可以重複添加）
// $addToSet 向數組中添加一個新元素，若是數組中已經存在了該元素，則不會添加（即不能夠重複添加）
db.users.update({username: "tangseng"}, {$push: {"hobby.movies": "Interstellar"}});
db.users.update({username: "tangseng"}, {$addToSet: {"hobby.movies": "Interstellar"}});
db.users.find();
// 15.刪除喜歡 beijing 的用戶
db.users.remove({"hobby.cities": "beijing"});
// 16.刪除 user 集合
db.users.remove({}); // 刪除全部的文檔對象（即清空集合，性能略差），集合還在
db.users.drop();
show dbs;
// 17.向 numbers 中插入 20000 條數據 7.2s
// 方式一：太慢
for(var i=1 ; i<=20000 ; i++){
db.numbers.insert({num:i});
}
db.numbers.find()
db.numbers.remove({});
// 方式二：先 push 進數組，再 insert 進集合，0.4s
var arr = [];
for(var i = 1; i <= 20000; i++){
arr.push({num: i});
}
db.numbers.insert(arr);
// 18.查詢 numbers 中 num 爲 500 的文檔
db.numbers.find({num: 500})
db.numbers.find({num: {$eq: 500}});
// 19.查詢numbers中num大於5000的文檔
db.numbers.find({num: {$gt: 500}});
// 20.查詢numbers中num小於30的文檔
db.numbers.find({num: {$lt: 30}});
// 21.查詢 numbers 中 num 大於 40 小於 50 的文檔
db.numbers.find({num: {$gt: 40, $lt: 50}});
// 22.查詢 numbers 中 num 大於 19996 的文檔
db.numbers.find({num: {$gt: 19996}});
// 23.查看 numbers 集合中的前 10 條數據
db.numbers.find({num: {$lte: 10}});
// limit() 設置顯示數據的上限
db.numbers.find().limit(10);
// 在開發時，咱們絕對不會執行不帶條件的查詢
db.numbers.find();
//24.查看 numbers 集合中的第 11 條到 20 條數據
/*
分頁 每頁顯示10條
1-10 0
11-20 10
21-30 20
。。。
skip((頁碼-1) * 每頁顯示的條數).limit(每頁顯示的條數);
skip() 用於跳過指定數量的數據。
MongoDB 會自動調整 skip 和 limit 的位置。
*/
db.numbers.find().skip(10).limit(10);
// 25.查看 numbers 集合中的第 21 條到 30 條數據
db.numbers.find().skip(20).limit(10);
db.numbers.find().limit(10).skip(10);
// 26.將 dept 和 emp 集合導入到數據庫中
db.dept.find();
db.emp.find();
db.dept.drop();
db.emp.drop();
// 27.查詢工資小於 2000 的員工
db.emp.find({sal: {$lt: 2000}});
// 28.查詢工資在 1000-2000 之間的員工
db.emp.find({sal: {$gt: 1000, $lt: 2000}});
// 29.查詢工資小於 1000 或大於 2500 的員工
db.emp.find({$or: [{sal: {$lt: 1000}}, {sal: {$gt: 2500}}]});
// 30.查詢財務部的全部員工
//(deptno)
var deptno = db.dept.findOne({dname: "財務部"}).deptno;
db.emp.find({deptno: deptno});
// 31.查詢銷售部的全部員工
var deptno = db.dept.findOne({dname: "銷售部"}).deptno;
db.emp.find({deptno: deptno});
// 32.查詢全部 mgr 爲 7698 的全部員工
db.emp.find({mgr: 7698});
// 33.爲全部薪資低於 1000 的員工增長工資 400 元
db.emp.updateMany({sal: {$lte: 1000}}, {$inc: {sal: 400}});
db.emp.find();
3.7 文檔中的關係
文檔之間的關係：
一對一：在 MongoDB 中能夠經過內嵌文檔的形式來體現出一對一的關係。
db.wifeAndHusband.insert([
{
name: "黃蓉",
husband: {
name: "郭靖"
}
}, {
name: "潘金蓮",
husband: {
name:"武大郎"
}
}
]);
一對多：也能夠經過內嵌文檔來映射一對多的關係。在多的表中存放一的id。
db.users.insert([
{
username: "swk"
}, {
username:"zbj"
}
]);
db.order.insert({
list: ["牛肉","漫畫"],
user_id: ObjectId("59c47e35241d8d36a1d50de0")
});
多對多：
db.teachers.insert([
{name:"洪七公"},
{name:"黃藥師"},
{name:"龜仙人"}
]);
db.stus.insert([
{
name:"郭靖",
tech_ids: [
ObjectId("59c4806d241d8d36a1d50de4"),
ObjectId("59c4806d241d8d36a1d50de5")
]
}, {
name:"孫悟空",
tech_ids: [
ObjectId("59c4806d241d8d36a1d50de4"),
ObjectId("59c4806d241d8d36a1d50de5"),
ObjectId("59c4806d241d8d36a1d50de6")
]
}
])
3.8 sort 和投影
//查詢文檔時，默認狀況是按照_id的值進行排列（升序）
//sort() 能夠用來指定文檔的排序的規則，sort() 須要傳遞一個對象來指定排序規則，1 表示升序顯示該字段的數據；-1 表示降序顯示該字段的數據，0 表示不顯示該字段的數據。
//limit、skip、sort 能夠以任意的順序進行調用
db.emp.find({}).sort({sal: 1, empno: -1}); // 按照工資升序排序，工資相同時按照員工編號降序排序
//在查詢時，能夠在第二個參數的位置來設置查詢結果的--即投影
db.emp.find({}, {ename: 1, _id: 0, sal: 1});
第四章 Mongoose
4.1 Mongoose 的簡介
以前咱們都是經過 shell 來完成對數據庫的各類操做的，在開發中大部分時候咱們都須要經過程序來完成對數據庫的操做。
而 Mongoose 就是一個讓咱們能夠經過 Node 來操做 MongoDB 的模塊。
Mongoose 是一個對象文檔模型（ODM）庫，它對 Node 原生的 MongoDB 模塊進行了進一步的優化封裝，並提供了更多的功能。
在大多數狀況下，它被用來把結構化的模式應用到一個 MongoDB 集合，並提供了驗證和類型轉換等好處。
4.2 Mongoose 的好處
• 能夠爲文檔建立一個模式結構（Schema）
• 能夠對模型中的對象/文檔進行驗證
• 數據能夠經過類型轉換轉換爲對象模型
• 可使用中間件來應用業務邏輯掛鉤
• 比 Node 原生的 MongoDB 驅動更容易
4.3 新的對象
mongoose 中爲咱們提供了幾個新的對象：
Schema(模式對象)
• Schema 對象定義約束了數據庫中的文檔結構。
Model
• Model 對象做爲集合中的全部文檔的表示，至關於 MongoDB 數據庫中的集合 Collection。
Document
• Document 表示集合中的具體文檔，至關於集合中的一個具體的文檔。
4.4 經過 Mongoose 鏈接 MongoDB
一、使用 Mongoose 必須先安裝 mongoose 包
npm i mongoose --save 或者
npm install mongoose
二、加載 Mongoose
const mongoose = require("mongoose");
三、鏈接 MongoDB 數據庫
mongoose.connect("mongodb://地址", {useMongoClient: true});
地址例子：mongodb://127.0.0.1:27017/mg_test
若是端口號是默認端口號，則能夠省略不寫。
注意：不一樣的 MongoDB 版本， connect() 函數中的參數不同。
四、監聽數據庫的鏈接狀態（通常不須要調用）
在 Mongoose 對象中有一個屬性叫作 connection，該對象表示的就是數據庫鏈接，經過監視該對象的狀態。能夠監聽數據庫的鏈接與斷開。
mongoose.connection.once("open", function() {}); // 數據庫鏈接成功的事件
mongoose.connection.once("close", function() {}); // 數據庫鏈接斷開的事件
五、斷開鏈接（通常不須要調用）
mongoose.disconnect();
對於 MongoDB 數據庫。通常狀況下。只須要鏈接一次，鏈接一次成功後，除非項目中止服務器關閉，不然鏈接通常不會斷開。由於 MongoDB 數據庫沒有事務控制。
Connection
一旦鏈接了 MongoDB 數據庫，底層的 Connection 對象就能夠經過 mongoose 模塊的connection屬性來訪問。
connection 對象是對數據庫鏈接的抽象，它提供了對象鏈接、底層的 DB 對象和表示結合的 Model 對象的訪問。
而且能夠對 connection 對象上的一些事件進行監聽，來獲悉數據庫鏈接的開始與端開。好比，能夠經過 open 和 close 事件來監控鏈接的打開和關閉。
4.5 Schema--模式對象(約束對象)
使用 Mongoose 你必須常常定義模式。
模式爲集合中的文檔定義字段和字段類型。
若是你的數據是被結構化成支持模式的，這是很是有用的。
簡單來講，模式就是對文檔的約束，有了模式，文檔中的字段必須符合模式的規定。不然將不能正常操做。
4.6 Model--模型對象
一旦定義好了 Schema 對象，就須要經過該 Schema 對象來建立 Model 對象。
一旦建立好了 Model 對象，就會自動和數據庫中對應的集合創建鏈接，以確保在應用更改時，集合已經建立並具備適當的索引，且設置了必須性和惟一性。
Model 對象就至關於數據庫中的集合，經過 Model 能夠完成對集合的 CRUD 操做。
示例js代碼以下：
var mongoose = require('mongoose');
mongoose.connect("mongodb://127.0.0.1/mongoose_test", {useMongoClient: true});
mongoose.connection.once("open", function() {
console.log("數據庫鏈接成功~~~");
});
var Schema = mongoose.Schema; // 注意：Schema 該變量名使用大寫，表示構造函數。
// 建立 Schema（模式）對象
var stuSchema = new Schema({ // 注意：stuSchema 該變量名使用小寫，習慣寫法。
name: String,
age: Number,
gender: {
type: String,
default: "female"
},
address: String
});
// 經過 Schema 來建立 Model，Model 表明的是數據庫中的集合，經過 Model 才能對數據庫進行操做
// mongoose.model(modelName, schema): // modelName 就是要映射的集合名稱，mongoose 會自動將集合名稱變成複數。
var StuModel = mongoose.model("student", stuSchema); // 注意：StuModel 該變量名使用大寫，表示構造函數。
// StuModel.create(doc, function(err){}); // 向數據庫中插入一個文檔
StuModel.create({
name: "白骨精",
age: 16,
address: "白骨洞"
}, function (err) {
if (!err) {
console.log("插入成功~~~");
}
});
4.7 Model 對象的方法
• remove(conditions, callback)
• deleteOne(conditions, callback)
• deleteMany(conditions, callback)
• find(conditions, projection, options, callback)
• findById(id, projection, options, callback)
• findOne(conditions, projection, options, callback)
• count(conditions, callback)
• create(doc, callback)
• update(conditions, doc, options, callback)
等等
示例js代碼以下：
var mongoose = require('mongoose');
mongoose.connect("mongodb://127.0.0.1/mongoose_test", {useMongoClient: true});
mongoose.connection.once("open", function() {
console.log("數據庫鏈接成功~~~");
});
var Schema = mongoose.Schema; // 注意：Schema 該變量名使用大寫，表示構造函數。
// 建立 Schema（模式）對象
var stuSchema = new Schema({ // 注意：stuSchema 該變量名使用小寫，習慣寫法。
name: String,
age: Number,
gender: {
type: String,
default: "female"
},
address: String
});
-----------------------------------------------------
// 經過 Schema 來建立 Model，Model 表明的是數據庫中的集合，經過 Model 才能對數據庫進行操做
// mongoose.model(modelName, schema): // modelName 就是要映射的集合名稱，mongoose 會自動將集合名稱變成複數。
var StuModel = mongoose.model("student", stuSchema); // 注意：StuModel 該變量名使用大寫，表示構造函數。
// StuModel.create(doc, function(err){}); // 向數據庫中插入一個文檔
StuModel.create({
name: "白骨精",
age: 16,
address: "白骨洞"
}, function (err) {
if (!err) {
console.log("插入成功~~~");
}
});
-----------------------------------------------------
var StuModel = mongoose.model("student" , stuSchema);
StuModel.create([
{
name: "沙和尚",
age: 38,
gender: "male",
address: "流沙河"
}
], function (err) {
if (!err) {
console.log(arguments); // arguments 該參數是返回的插入的文檔，通常用的比較少。
}
});
-----------------------------------------------------
/*
- 有了 Model，咱們就能夠來對數據庫進行增刪改查的操做了！
Model.create(doc(s), [callback])
- 用來建立一個或多個文檔並添加到數據庫中
- 參數：
doc(s) 能夠是一個文檔對象，也能夠是一個文檔對象的數組。
callback 當操做完成之後調用的回調函數。
查詢的方法：
Model.find(conditions, [projection], [options], [callback])
- 查詢全部符合條件的文檔，總會返回一個數組
Model.findById(id, [projection], [options], [callback])
- 根據文檔的id屬性查詢文檔
Model.findOne([conditions], [projection], [options], [callback])
- 查詢符合條件的第一個文檔，總會返回一個具體的文檔對象
參數解釋：
conditions 查詢的條件
projection 投影，須要獲取到的字段
- 兩種方式：
方式一：{name: 1, _id: 0} // 只顯示name，不顯示id
方式二："name -_id" // 只顯示name，不顯示id
options 查詢選項(經常使用 skip、limit)
示例：{skip: 3, limit: 1}
callback 回調函數，查詢結果會經過回調函數返回
這裏回調函數必須傳，若是不傳回調函數，壓根就不會去查詢
*/
-----------------------------------------------------
StuModel.find({name: "唐僧"}, function(err, docs) {
if (!err) {
console.log(docs);
}
});
StuModel.find({}, {name: 1, _id: 0}, function(err, docs) {
if (!err) {
console.log(docs);
}
});
StuModel.find({}, "name age -_id", {skip: 3, limit: 1}, function(err, docs) {
if (!err) {
console.log(docs);
}
});
StuModel.findOne({}, function(err, doc) {
if (!err) {
console.log(doc);
}
});
StuModel.findById("59c4c3cf4e5483191467d392", function(err, doc) {
if (!err) {
// console.log(doc);
// 經過 find() 查詢的結果，返回的對象就是 Document 對象或 Document 對象數組。
// Document 對象是 Model 的實例
console.log(doc instanceof StuModel); // 驗證 Document 對象是不是 Model 的實例，使用 【文檔對象 instanceof 模型對象】
}
});
-----------------------------------------------------
/* 修改
Model.update(conditions, doc, [options], [callback])
Model.updateMany(conditions, doc, [options], [callback])
Model.updateOne(conditions, doc, [options], [callback])
Model.replaceOne(conditions, doc, [options], [callback])
- 用來修改一個或多個文檔
- 參數：
conditions 查詢條件
doc 修改後的對象
options 配置參數
callback 回調函數
*/
// 修改唐僧的年齡爲 20
StuModel.updateOne({name: "唐僧"}, {$set: {age: 20}}, function(err) {
if (!err){
console.log("修改爲功~~~");
}
});
-----------------------------------------------------
/* 刪除：
Model.remove(conditions, [callback])
Model.deleteOne(conditions, [callback])
Model.deleteMany(conditions, [callback])
*/
StuModel.remove({name: "白骨精"}, function(err) {
if (!err) {
console.log("刪除成功~~~");
}
});
-----------------------------------------------------
/*
Model.count(conditions, [callback])
- 統計文檔的數量
*/
StuModel.count({}, function(err, count) {
if (!err) {
console.log(count);
}
});
4.8 Document--文檔對象
經過 Model 對數據庫進行查詢時，會返回 Document 對象或 Document 對象數組。
Document 繼承自 Model，表明一個集合中的文檔。
Document 對象也能夠和數據庫進行交互操做。
4.9 Document 對象的方法
• equals(doc)
• id
• get(path, [type])
• set(path, value, [type])
• update(update, [options], [callback])
• save([callback])
• remove([callback])
• isNew
• isInit(path)
• toJSON()
• toObject()
示例js代碼以下：
var mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test", {useMongoClient: true});
mongoose.connection.once("open", function() {
console.log("數據庫鏈接成功~~~");
});
var Schema = mongoose.Schema;
var stuSchema = new Schema({
name: String,
age: Number,
gender: {
type: String,
default: "female"
},
address: String
});
var StuModel = mongoose.model("student", stuSchema);
-----------------------------------------------------
/*
Document 和 集合中的文檔一一對應， Document 是 Model 的實例。
經過 Model 查詢到結果都是 Document 對象或 Document 對象數組。
*/
// 本身建立一個 Document
var stu = new StuModel({
name: "奔波霸",
age: 48,
gender: "male",
address: "碧波潭"
});
// Document 的方法：Model#save([options], [fn])
stu.save(function (err) {
if (!err) {
console.log("保存成功~~~");
}
});
StuModel.findOne({}, function(err, doc) {
if (!err) {
// console.log(doc);
/*
修改對象：update(update, [options], [callback])
刪除對象：remove([callback])
*/
// 修改方式一：
doc.update({$set: {age: 28}}, function(err) {
if (!err) {
console.log("修改爲功~~~");
}
});
// 修改方式二：
// doc.age = 18;
// doc.save();
doc.remove(function (err) {
if (!err) {
console.log("大師兄再見~~~");
}
});
/*
get(name)
- 獲取文檔中的指定屬性值
set(name, value)
- 設置文檔的指定的屬性值
id
- 獲取文檔的 _id 屬性值
toJSON()
- 轉換爲一個 JSON 對象
toObject() 該 Document 對象的方法很經常使用！！！
- 將 Document 對象轉換爲一個普通的 js 對象。轉換爲普通的 js 對象之後，全部的 Document 對象的方法或屬性都不能使用了。
*/
// console.log(doc.get("age"));
// console.log(doc.age);
// doc.set("name", "豬小小");
// doc.name = "hahaha";
// console.log(doc._id);
// var j = doc.toJSON();
// console.log(j);
// var o = doc.toObject();
// console.log(o);
// 轉爲 js 對象後，再刪除 js 對象的屬性（用於保護隱私數據）
js = doc.toObject();
delete js.address;
// console.log(js.id); // 錯誤
console.log(js._id); // id 是 Document 對象的屬性，而 _id 是 js 對象的屬性
}
});
4.10 Mongoose 的模塊化
一、定義一個模塊，用於鏈接 MongoDB 數據庫
conn_mongo.js
var mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test", {useMongoClient: true});
mongoose.connection.once("open", function() {
console.log("數據庫鏈接成功~~~");
});
在新的 js 文件中如何使用上述模塊呢？以下：
require("./utils/conn_mongo");
二、定義一個模塊，用於定義具體的模型對象
第一種方式：
student.js
var mongoose = require("mongoose");
var Schema = mongoose.Schema;
var stuSchema = new Schema({
name: String,
age: Number,
gender: {
type: String,
default: "female"
},
address: String
});
var StuModel = mongoose.model("student", stuSchema);
// 將具體的模型對象暴露出去
exports.model = StuModel;
在新的 js 文件中如何使用上述模塊呢？間接引用，以下：
var Student = require("./utils/student").model;
第二種方式：
student.js
var mongoose = require("mongoose");
var Schema = mongoose.Schema;
var stuSchema = new Schema({
name: String,
age: Number,
gender: {
type: String,
default: "female"
},
address: String
});
var StuModel = mongoose.model("student", stuSchema);
// 將具體的模型對象直接賦值給 exports
module.exports = StuModel;
在新的 js 文件中如何使用上述模塊呢？直接引用，以下：
var Student = require("./utils/student");
第五章 使用 java 對 MongoDB 增刪改查
5.1 在 java 中解析 json
package com.atguigu.mongo;
import com.google.gson.Gson;
import org.junit.Test;
public class MyTest {
@Test
public void testJSON() {
// 建立一個 JSON 字符串
String json = "{\"name\":\"孫悟空\",\"age\":18,\"gender\":\"男\"}";
// 在 Java 默認狀況下是不支持 JSON 的解析的
// 須要引入第三方的 jar 包來對其進行支持
// 一、json-lib
// 二、jackson
// 三、gson
// 建立一個 Gson 解析器的實例
Gson gson = new Gson();
// 經過 gson 來對 json 進行解析
// 將 json 轉換爲 Map 對象
// Map map = gson.fromJson(json, Map.class);
// System.out.println(map); // {name=孫悟空, age=18.0, gender=男}
// 將 json 轉換爲 Student 對象
Student stu = gson.fromJson(json, Student.class);
System.out.println(stu); // Student{name='孫悟空', age=18, gender='男'}
}
@Test
public void testObj() {
// 建立一個 stu 對象
Student stu = new Student("豬八戒", 28, "男");
// 建立 Gson 解析器
Gson gson = new Gson();
// 將 Student 對象轉換爲 Gson 對象
String json = gson.toJson(stu);
System.out.println(json); // {"name":"豬八戒","age":28,"gender":"男"}
}
}
5.2 java 版 Mongo HelloWorld
package com.atguigu.mongo;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import org.junit.Test;
public class MongoTest {
@Test
public void test01() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient(); // 鏈接到指定的 MongoDB 數據庫，若是不設置 host 和 port，則自動鏈接 localhost:27017
// MongoClient mongoClient = new MongoClient("localhost", 27017);
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> usersCollection = my_testDB.getCollection("users");
// 向 users 集合中插入文檔
// 先建立一個文檔
Document document = new Document("name", "豬八戒");
// 向文檔中添加其餘屬性
document.append("age", 18);
document.append("gender", "男");
document.append("address", "雲棧洞");
// 插入集合
usersCollection.insertOne(document);
}
}
5.3 使用 java 對 MongoDB 增刪改查
package com.atguigu.mongo;
import com.google.gson.Gson;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import org.bson.Document;
import org.junit.Test;
public class MongoTest {
@Test
public void test01() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient(); // 鏈接到指定的 MongoDB 數據庫，若是不設置 host 和 port，則自動鏈接 localhost:27017
// MongoClient mongoClient = new MongoClient("localhost", 27017);
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> usersCollection = my_testDB.getCollection("users");
// 向 users 集合中插入文檔
// 先建立一個文檔
Document document = new Document("name", "豬八戒");
// 向文檔中添加其餘屬性
document.append("age", 18);
document.append("gender", "男");
document.append("address", "雲棧洞");
// 插入集合
usersCollection.insertOne(document);
}
/**
* 將 自定義的對象插入 MongoDB 數據庫中的集合中：自定義對象 --> JSON --> Document 對象
*/
@Test
public void testInsert() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient();
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> studentsCollection = my_testDB.getCollection("students");
// 建立一個 Student 對象
Student stu = new Student("沙和尚", 38, "男");
// 將 Student 對象轉換爲 JSON
Gson gson = new Gson();
String stuJson = gson.toJson(stu);
// 將 JSON 轉換爲 Document 對象
Document document = Document.parse(stuJson);
// 將 Document 對象插入集合中
studentsCollection.insertOne(document);
}
@Test
public void testFindOne() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient();
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> studentsCollection = my_testDB.getCollection("students");
// 查詢數據庫中的文檔（查詢第一個文檔）
// Document document = studentsCollection.find().first();
// System.out.println(document); // Document{{_id=5cd4cf4f97cace16f4581eb4, name=豬八戒, age=28, gender=男}}
// 查詢數據庫中的文檔（查詢第一個文檔）
Document document = studentsCollection.find().first();
Gson gson = new Gson();
// 將 Document 對象轉換爲 JSON，而後再將 JSON 轉換爲 Java 對象
Student student = gson.fromJson(document.toJson(), Student.class);
System.out.println(student); // Student{name='豬八戒', age=28, gender='男'}
}
@Test
public void testFindMany() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient();
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> studentsCollection = my_testDB.getCollection("students");
// 查詢數據庫中的文檔（查詢多個文檔）
// FindIterable<Document> documents = studentsCollection.find().skip(2).limit(1);
// FindIterable<Document> documents = studentsCollection.find();
// 在 Java 中查詢操做符是經過 Filters 方法來實現的
FindIterable<Document> documents = studentsCollection.find(Filters.eq("name", "沙和尚"));
for (Document document : documents) {
System.out.println(document.toJson());
}
}
@Test
public void testRemove() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient();
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> studentsCollection = my_testDB.getCollection("students");
// 刪除一個文檔對象
studentsCollection.deleteOne(Filters.eq("name", "沙和尚"));
}
@Test
public void testUpdate() {
// 鏈接 MongoDB 數據庫管理端
MongoClient mongoClient = new MongoClient();
// 鏈接到指定數據庫
MongoDatabase my_testDB = mongoClient.getDatabase("my_test");
// 獲取到指定的集合對象
MongoCollection<Document> studentsCollection = my_testDB.getCollection("students");
// 修改一個文檔對象中的屬性
// db.collection.update({name: "name"}, {$set: {age: 28}});
studentsCollection.updateOne(Filters.eq("name", "沙和尚"), new Document("$set", new Document("age", 28))); }}
- 1. 使用express+mongoose對mongodb實現增刪改查操做
- 2. MongoDB基本操做(增刪改查)
- 3. Scala對MongoDB的增刪改查操做 Scala對MongoDB的增刪改查操做 MongoDB學習筆記(查詢)
- 4. 使用mongoose操做MongoDB數據庫實現增刪改查
- 5. 基於mongoose 的增刪改查操做
- 6. mongodb基本操做=>增刪改查
- 7. MongoDB學習記錄(四) - MongoDB的"增查改刪"操做之"改"
- 8. MongoDB學習記錄(三) - MongoDB的"增查改刪"操做之"查"
- 9. MongoDB學習記錄(二) - MongoDB的"增查改刪"操做之"增"
- 10. MongoDB的增刪改查操做命令
- 更多相關文章...
- • Docker 安裝 MongoDB - Docker教程
- • Wireshark下載安裝和使用教程 - TCP/IP教程
- • Composer 安裝與使用
- • 適用於PHP初學者的學習線路和建議
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 使用express+mongoose對mongodb實現增刪改查操做
- 2. MongoDB基本操做(增刪改查)
- 3. Scala對MongoDB的增刪改查操做 Scala對MongoDB的增刪改查操做 MongoDB學習筆記(查詢)
- 4. 使用mongoose操做MongoDB數據庫實現增刪改查
- 5. 基於mongoose 的增刪改查操做
- 6. mongodb基本操做=>增刪改查
- 7. MongoDB學習記錄(四) - MongoDB的"增查改刪"操做之"改"
- 8. MongoDB學習記錄(三) - MongoDB的"增查改刪"操做之"查"
- 9. MongoDB學習記錄(二) - MongoDB的"增查改刪"操做之"增"
- 10. MongoDB的增刪改查操做命令