點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

鏈接 | blog.csdn.net/hayre/article/details/80628431

1.MongoDB是什麼？用一句話總結

MongoDB是一款為web應用程序和互聯網基礎設施設計的數據庫管理系統。沒錯MongoDB就是數據庫，是NoSQL類型的數據庫。

2.為什麼要使用MongoDB？

（1）MongoDB提出的是文檔、集合的概念，使用BSON（類JSON）作為其數據模型結構，其結構是面向對象的而不是二維表，存儲一個用戶在MongoDB中是這樣子的。

｛
username:'123',
password:'123'
｝

使用這樣的數據模型，使得MongoDB能在生產環境中提供高讀寫的能力，吞吐量較於mysql等SQL數據庫大大增強。

（2）易伸縮，自動故障轉移。易伸縮指的是提供了分片能力，能對數據集進行分片，數據的存儲壓力分攤給多臺服務器。自動故障轉移是副本集的概念，MongoDB能檢測主節點是否存活，當失活時能自動提升從節點為主節點，達到故障轉移。

（3）數據模型因為是面向對象的，所以可以表示豐富的、有層級的數據結構，比如博客系統中能把“評論”直接懟到“文章“的文檔中，而不必像myqsl一樣創建三張表來描述這樣的關係。

3.主要特性

（1）文檔數據類型

SQL類型的數據庫是正規化的，可以通過主鍵或者外鍵的約束保證數據的完整性與唯一性，所以SQL類型的數據庫常用於對數據完整性較高的系統。MongoDB在這一方面是不如SQL類型的數據庫，且MongoDB沒有固定的Schema，正因為MongoDB少了一些這樣的約束條件，可以讓數據的存儲數據結構更靈活，存儲速度更加快。（2）即時查詢能力

MongoDB保留了關係型數據庫即時查詢的能力，保留了索引（底層是基於B tree）的能力。這一點汲取了關係型數據庫的優點，相比於同類型的NoSQL redis 並沒有上述的能力。（3）複製能力

MongoDB自身提供了副本集能將數據分佈在多臺機器上實現冗餘，目的是可以提供自動故障轉移、擴展讀能力。（4）速度與持久性

MongoDB的驅動實現一個寫入語義 fire and forget ，即通過驅動調用寫入時，可以立即得到返回得到成功的結果（即使是報錯），這樣讓寫入的速度更加快，當然會有一定的不安全性，完全依賴網絡。

MongoDB提供了Journaling日誌的概念，實際上像mysql的bin-log日誌，當需要插入的時候會先往日誌裡面寫入記錄，再完成實際的數據操作，這樣如果出現停電，進程突然中斷的情況，可以保障數據不會錯誤，可以通過修復功能讀取Journaling日誌進行修復。

（5）數據擴展

MongoDB使用分片技術對數據進行擴展，MongoDB能自動分片、自動轉移分片裡面的數據塊，讓每一個服務器裡面存儲的數據都是一樣大小。

4.C/S服務模型

MongoDB核心服務器主要是通過mongod程序啟動的，而且在啟動時不需對MongoDB使用的內存進行配置，因為其設計哲學是內存管理最好是交給操作系統，缺少內存配置是MongoDB的設計亮點，另外，還可通過mongos路由服務器使用分片功能。

MongoDB的主要客戶端是可以交互的js shell 通過mongo啟動，使用js shell能使用js直接與MongoDB進行交流，像使用sql語句查詢mysql數據一樣使用js語法查詢MongoDB的數據，另外還提供了各種語言的驅動包，方便各種語言的接入。

5.完善的命令行工具

mongodump和mongorestore,備份和恢復數據庫的標準工具。輸出BSON格式，遷移數據庫。

mongoexport和mongoimport，用來導入導出JSON、CSV和TSV數據，數據需要支持多格式時有用。mongoimport還能用與大數據集的初始導入，但是在導入前順便還要注意一下，為了能充分利用好mongoDB通常需要對數據模型做一些調整。

mongosniff,網絡嗅探工具，用來觀察發送到數據庫的操作。基本就是把網絡上傳輸的BSON轉換為易於人們閱讀的shell語句。

因此，可以總結得到，MongoDB結合鍵值存儲和關係數據庫的最好特性。因為簡單，所以數據極快，而且相對容易伸縮還提供複雜查詢機制的數據庫。MongoDB需要跑在64位的服務器上面，且最好單獨部署，因為是數據庫，所以也需要對其進行熱備、冷備處理。

二、進入MongoDB shell

因為本篇文章不是API手冊，所有這裡對shell的使用也是基礎的介紹什麼功能可以用什麼語句，主要是為了展示使用MongoDB shell的方便性，如果需要知道具體的MongoDB shell語法可以查閱官方文檔。

1.切換數據庫

use dba

創建數據庫並不是必須的操作，數據庫與集合只有在第一次插入文檔時才會被創建，與對數據的動態處理方式是一致的。簡化並加速開發過程，而且有利於動態分配命名空間。如果擔心數據庫或集合被意外創建，可以開啟嚴格模式。

2.插入語法

db.users.insert({username:"smith"})
db.users.save({username:"smith"})

• 區別:若新增的數據中存在主鍵 ，insert 會提示錯誤，而save 則更改原來的內容為新內容。如：
  已存在數據：{_id : 1, " name " : " n1 " }，再次進行插入操作時，insert({_id : 1, " name " : " n2 " }) 會報主鍵重複的錯誤提示，save({ _id : 1, " name " : " n2 " }) 會把 n1 修改為 n2 。
• 相同點：若新增的數據中沒有主鍵時，會增加一條記錄。已存在數據：{ _id : 1, " name " : " n1 " }，再次進行插入操作時，insert({ " name " : " n2 " }) 插入的數據因為沒有主鍵，所以會增加一條數據，save({ " name " : " n2 " }) 增加一條數據。

3.查找語法

db.users.find
db.users.count

4.更新語法

db.users.update({username:"smith"},{$set:{country:"Canada"}})
//把用戶名為smith的用戶的國家改成Canada

db.users.update({username:"smith"},{$unset:{country:1}})
//把用戶名為smith的用戶的國家字段給移除

db.users.update({username:"jones"},{$set:{favorites:{movies:["casablance","rocky"]}}})
//這裡主要體現多值修改，在favorties字段中添加多個值

db.users.update({"favorites.movies":"casablance"},{$addToSet:{favorites.movies:"the maltese"}},false,true)
//多項更新

5.刪除語法

db.foo.remove //刪除所有數據
db.foo.remove({favorties.cities:"cheyene"}) //根據條件進行刪除
db.drop //刪除整個集合

6.索引相關語法

db.numbers.ensureIndex({num:1})
//創建一個升序索引
db.numbers.getIndexes
//獲取全部索引

7.基本管理語法

show dbs
//查詢所有數據庫
show collections
//顯示所有表
db.stats
//顯示數據庫狀態信息
db.numbers.stats
//顯示集合表狀態信息
db,shutdownServer
//停止數據庫
db.help
//獲取數據庫操作命令
db.foo.help
//獲取表操作命令
tab 鍵 //能自動幫我們補全命令

以上的命令只是簡單實例，假設如果你之前沒有學習過任何數據庫語法，同時開始學sql查詢語法和MongoDB 查詢語法，你會發現哪一個更簡單呢？如果你使用的是java驅動去操作MongoDB，你會發現任何的查詢都像Hibernate提供出來的查詢方式一樣，只要構建好一個查詢條件對象，便能輕鬆查詢（接下來會給出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成沒問題，也正因為這樣簡潔，完善的查詢機制，深深的愛上了MongoDB。

三、使用java驅動

使用java驅動鏈接MongoDB是一件非常簡單的事情，簡單的引用，簡單的做增刪改查。在使用完java驅動後我才發現spring 對MongoDB 的封裝還不如官方自身提供出來的東西好用，下面簡單的展示一下使用。

1.使用maven引入jar包

 <dependency>
<groupId>org.mongodbgroupId>
<artifactId>mongodb-driver-syncartifactId>
<version>3.8.0-beta3version>
dependency>

2.創建一個訪問客戶端

MongoClient client = MongoClients.create(“mongodb://10.201.76.94:27017”);

3.獲取集合數量

public long count {
MongoClient client = this.getClient;
MongoCollection
return collections.count;
}

4.查詢集合

public List
MongoClient client = this.getClient;
MongoCollection
List
collections.find(params).sort(sort).skip(skip).limit(limit).forEach(new Block
@Override
public void apply(Document document) {
list.add(document);
}
});
return list;
}

這裡只舉例了簡單的鏈接與簡單的MongoDB操作，可見其操作的容易性。使用驅動時是基於TCP套接字與MongoDB進行通信的，如果查詢結果較多，恰好無法全部放進第一服務器中，將會向服務器發送一個getmore指令獲取下一批查詢結果。

插入數據到服務器時間，不會等待服務器的響應，驅動會假設寫入是成功的，實際是使用客戶端生成對象id，但是該行為可以通過配置配置，可以通過安全模式開啟，安全模式可以校驗服務器端插入的錯誤。

四、schema 設計原則

1.需要關注MongoDB的自身的特性

要清楚瞭解MongoDB的基本數據單元。在關係型數據庫中有帶列和行的數據表。而MongoDB數據的基本單元是BSON文檔，在鍵值中有指向不定類型值的鍵，MongoDB擁有即時查詢，但不支持聯結操作，簡單的鍵值存儲只能根據單個鍵來獲取值，不支持事務，但支持多種原子更新操作。

2.需要關注系統本身的讀寫特性

如讀寫比是怎樣的，需要何種查詢，數據是如何更新的，會不會存在什麼併發問題，數據結構化的程度是要求高還是低。系統本身的需求決定mysql還是MongoDB。

3.關注MongoDB schema 的設計模式

• 內嵌與引用：當子對象總是出現在父對象的上下文中時，使用內嵌文檔；否則將子對象單獨存一個集合。
• 一對多的關係：在“多”的集合關係中添加id指向依賴的id。
• 多對多：在其中一種對應關係中使用對象數組指向另外一個對象。
• 樹：具化路徑，在樹中的每個節點都包含一個path字段，該字段具體保存了每個節點祖先的id。
• 動態屬性：可以為不同的動態屬性添加索引，如果需要將屬性圈在一個範圍，那麼可以通過key-value的方式，然後在統一的key上面加索引。
• 關於事務：如果需要事務支持，那麼只能選擇另一種數據庫，或者提供補償性事務來解決事務的問題。

在關於schema 的設計中要注意一些原則，比如：

• 不能創建沒用的索引

• 不能在同一個字段中存不同的類型

• 不能把多類實體都放在一個集合裡 不能創建體積大、嵌套深的文檔

• 不能過多的創建集合，集合、索引、數據庫的命名空間都是有限的

• 不能創建無法分片的集合

4.關注MongoDB裡面一些具體細節

數據庫是集合的邏輯與物理分組，MongoDB沒有提供創建數據庫的語法，只有在插入集合時，數據庫才開始建立。創建數據庫後會在磁盤分配一組數據文件，所有集合、索引和數據庫的其他元數據都保存在這些文件中，查閱數據庫使用磁盤狀態可通過。

db.stats

（2）關注集合概念

集合是結構上或概念上相似得文檔的容器，集合的名稱可以包含數字、字母或 . 符號，但必須以字母或數字開頭，完全。

限定集合名不能超過128個字符，實際上 . 符號在集合中很有用，能提供某種虛擬命名空間，這是一種組織上的原則，和其他集合是一視同仁的。在集合中可以使用。

system.namespaces //查詢當前數據庫中定義的所有命名空間
system.indexes //存儲當前數據庫的所有索引定義

（3）關注文檔

其次是鍵值，在MongoDB裡面所有的字符串都是UTF-8類型。數字類型包括double、int、long。日期類型都是UTC格式，所以在MongoDB裡面看到的時間會比北京時間慢8小時。整個文檔大小會限制在16m以內，因為這樣可以防止創建難看的數據類型，且小文檔可以提升性能，批量插入文檔理想數字範圍是10~200，大小不能超過16MB。

五、索引與查詢優化

1.索引的經驗法則

（2）解析查詢時MongoDB通過最優計劃選擇一個索引進行查詢，當沒有最適合索引時，會先不同的使用各個索引進行查詢，最終選出一個最優索引做查詢

（3）如果有一個a-b的複合索引，那麼僅針對a的索引是冗餘的

（4）複合索引裡的鍵的順序是很重要的

2.索引類型

（2）複合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段會出現的值，或是大量文檔都不包含被索引的鍵。

3.索引的構建問題

如果數據集很大時，構建索引將會花費很長的時間，且會影響程序性能，可通過

db.currentOp //查看索引的構建時間

當使用 mongorestore 時會重新構建索引。當曾經執行過大規模的刪除時，可使用

db.values.reIndex 

對索引進行壓縮，重建。

4.識別慢查詢

（1）查閱慢查詢日誌

grep -E '([0-9])+ms' mongod.log //使用grep 命令 識別命令信息

db.setProfillingLevel(2) //使用解刨器，將記錄每次的讀寫到日誌

db.setProfillingLevel(1) //只記錄慢（100ms）操作

（2）分析慢查詢

db.values.find({}).sort({close:-1}).limit(1).explain

• scanOrder 字段表明沒有使用索引

• cursor當沒有索引時，用的是BasicCursor，當使用索引時使用的是BtreeCursor

• n 表示需要返回的結果集

• nscanned表示需要遍歷的文檔數 indexBounds 表示索引邊界

注意新版本的MongoDB 的explain方法是需要參數的，不然只顯示普通的信息。

六、MongoDB副本集

本節同樣主要簡單呈現MongoDB副本集搭建的簡易性，與副本集的強壯性，監控容易性

1.為什麼要使用副本集

提供主從複製能力，熱備能力，故障轉移能力

2.構建方式

rs.initiate
rs.add("localhost:40001")
rs.add("localhost:40002",{arbiterOnly:true})

3.監控

db.isMasrter
rs.status

4.副本集的工作原理

實際上MongoDB對副本集的操作跟mysql主從操作是差不多的，先看一下mysql的主從數據流動過程

主binlog -> 從relay.log -> 從bin.log -> 從數據庫

而MongoDB主要依賴的日誌文件是oplog

主oplog -> 從oplog

寫操作先被記錄下來，添加到主節點的oplog裡。與此同時，所有從結點複製oplog。首先，查看自己oplog裡最後一條的時間戳；其次，查詢主節點oplog裡所有大於此時間戳的條目;最後，把那些條目添加到自己的oplog裡並應用到自己的庫裡。從節點使用長輪詢立即應用來自主結點oplog的新條目。

當遇到以下情況，從節點會停止複製

• 如果從節點在主節點的oplog裡找不到它所同步的點，那麼會永久停止複製

• 一旦某個從節點沒能 在主節點的oplog裡找到它已經同步的點，就無法再保證這個從結點的完美副本

local數據庫保存了所有副本集元素據和oplog日誌

• replset.minvalid 包含指定副本集成員的初始化同步信息

• system.replset 保存在副本集配置文檔

• system.indexes 標準索引說明容器

• me slaves 主要用於寫關注

可以使用以下命令查看複製情況

db.oplog.rs.findOne

• ts 保存了該條目的BSON時間戳

• t 是從紀元開始的描述

• i是計數器

• op 表示操作碼

• ns 標明瞭有關的命名空間

5.心跳檢測

每個副本集成員每秒鐘ping一次其他所有成員，可以通過rs.status看到節點上次的心跳檢測時間戳和健康狀況。

6.故障轉移

這個點沒必要過多描述，但是有一個特殊場景，如果從節點和仲裁節點都被殺了，只剩下主節點，他會把自己降級成為從節點。

7.提交與回滾

如果主節點的數據還沒有寫到從庫，那麼數據不能算提交，當該主節點變成從節點時，便會觸發回滾，那些沒寫到從庫的數據將會被刪除，可以通過rollback子目錄中的BSON文件恢復回滾的內容。

8.驅動與複製

只能鏈接到主節點，如果鏈接到從節點的話，會被拒絕寫入操作，但是如果沒有使用安全模式，因為mongo的fire and forget 特性，會把拒絕寫入的異常給吃掉。

（2）使用副本集方式鏈接

能根據寫入的情況自動進行故障轉移，但是當副本集進行新的選舉時，還是會出現故障，如果不使用安全模式，依舊會出現寫不進去，但現實成功的情況。

（3）寫關注

可以使用寫關注來關注數據是否已經被寫入MongoDB的庫中，使用寫關注會消耗性能，需要在速度和持久性之間做出權衡。

七、分片

分片是數據庫切分的一個概念實現，這裡也是簡單總結為什麼要使用分片以及分片的原理，操作。

1.為什麼需要分片

當數據量過大，索引和工作數據集佔用的內存就會越來越多，所以需要通過分片負載來解決這個問題

2.分片的工作原理

• 分片：每個分片都是一個副本集

• mongos路由器：是一個路由器，將讀寫請求指引到合適的分片上

• 配置服務器config：持久化分片集群的元數據，包括：全局集群配置；每個數據庫、集合和特定範圍數據位置；一份變更記錄，保存了數據在分片之間進行遷移的歷史信息。配置服務器之間不是副本集形式存在，mongos向配置服務器提交信息時是兩階段提交，保證配置服務器之間的一致性。

（2）分片的核心操作

分片一個集合：分片是根據一個屬性的範圍進行劃分的，MongoDB使用所謂的分片鍵讓每個文檔在這些範圍裡找到自己的位置

塊：是位於一個分片中的一段連續的分片鍵範圍，可以理解為若干個塊組成分片，分片組成MongoDB的全部數據

（3）拆分與遷移

塊的拆分：初始化時只有一個塊，達到最大塊尺寸64MB或100000個文檔就會觸發塊的拆分。把原來的範圍一分為二，這樣就有了兩個塊，每個塊都有相同數量的文檔。

遷移：當分片中的數據大小不一時會產生遷移的動作，比如分片A的數據比較多，會將分片A裡面的一些塊轉移到分片B裡面去。分片集群通過在分片中移動塊來實現均衡，是由名為均衡器的軟件進程管理的，任務是確保數據在各個分片中保持均勻分佈，當集群中擁有塊最多的分片與擁有塊最少分片的塊差大於8時，均衡器就會發起一次均衡處理。

3.分片實戰

啟動兩個副本集、三個配置服務器、一個mongos進程

配置分片

sh.help //查看分片相關幫助
sh.addShard //添加分片
db,getSiblingDB("config").shards.find //查看分片列表
sh.status //分片詳情
sh.enableSharding("cloud-docs") //開啟一個數據庫上的分片
db.getSiblingDB("config").databases,find //查看數據庫列表
sh.shardCollection("cloud-docs.spreadsheets",{username:1,_id:1}) //使用一個分片鍵定義一個分片集合spreadsheets，根據用戶名進行切分
sh.getSiiblingDB("config").collections.findOne //查看集合列表
db.chunks.count //查看塊的個數
db.chunks.findOne //查看塊的信息
db.changelog.count(}what:"split"|) //查看塊切分日誌
db.changelog.find({what:"moveChunk.commit"}).count //查看日誌遷移記錄

4.分片的查詢與索引

• 針對性查詢：查詢包含分片鍵

• 全局查詢或分散/聚集查：查詢不包含分片鍵

• 查詢過程：通過分片鍵將查詢路由給指定分片，一旦到了某個分片上，由分片自行決定使用哪個索引來執行該查詢

（2）索引

每個分片都維護了自己的索引，當在分片集合上聲明索引時，每個分片都會為它那部分集合構建獨立的索引，每個分片上的分片集合都應該擁有相同的索引。

分片集合只允許在_id字段和分片鍵上添加唯一性索引，其他地方不行，因為這需要在分片間進行通信，實施起來很複雜。

當創建分片時，會根據分片鍵創建一個索引。

5.選擇分片鍵

（2）低效的分片鍵

• 分佈性差：如使用BSON對象ID，那麼會導致所有最新插入的文檔都會落到某個很小的連續範圍，無法分散插入

• 缺乏局部性：升序分片鍵有明確的方向，完全隨機的分片鍵則根本沒有方向。前者無法分散插入，後者插入分散，如使用MD5作為分片鍵

（3）理想的分片鍵

• 將插入數據均勻分佈到各個分片上

• 保證CRUD操作能夠利用局部性 有足夠的粒度進行塊拆分

• 滿足這些要求的分片鍵通常由兩個字段組成，第一個是粗粒度的，第二個粒度較細

6.生產環境中的分片

• 複製mongod：需要獨立的部署服務器

• 配置服務器：配置服務器不需要有自己的機器

根據不同的數據中心劃分

點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

鏈接 | blog.csdn.net/hayre/article/details/80628431

1.MongoDB是什麼？用一句話總結

MongoDB是一款為web應用程序和互聯網基礎設施設計的數據庫管理系統。沒錯MongoDB就是數據庫，是NoSQL類型的數據庫。

2.為什麼要使用MongoDB？

（1）MongoDB提出的是文檔、集合的概念，使用BSON（類JSON）作為其數據模型結構，其結構是面向對象的而不是二維表，存儲一個用戶在MongoDB中是這樣子的。

｛
username:'123',
password:'123'
｝

使用這樣的數據模型，使得MongoDB能在生產環境中提供高讀寫的能力，吞吐量較於mysql等SQL數據庫大大增強。

（2）易伸縮，自動故障轉移。易伸縮指的是提供了分片能力，能對數據集進行分片，數據的存儲壓力分攤給多臺服務器。自動故障轉移是副本集的概念，MongoDB能檢測主節點是否存活，當失活時能自動提升從節點為主節點，達到故障轉移。

（3）數據模型因為是面向對象的，所以可以表示豐富的、有層級的數據結構，比如博客系統中能把“評論”直接懟到“文章“的文檔中，而不必像myqsl一樣創建三張表來描述這樣的關係。

3.主要特性

（1）文檔數據類型

SQL類型的數據庫是正規化的，可以通過主鍵或者外鍵的約束保證數據的完整性與唯一性，所以SQL類型的數據庫常用於對數據完整性較高的系統。MongoDB在這一方面是不如SQL類型的數據庫，且MongoDB沒有固定的Schema，正因為MongoDB少了一些這樣的約束條件，可以讓數據的存儲數據結構更靈活，存儲速度更加快。（2）即時查詢能力

MongoDB保留了關係型數據庫即時查詢的能力，保留了索引（底層是基於B tree）的能力。這一點汲取了關係型數據庫的優點，相比於同類型的NoSQL redis 並沒有上述的能力。（3）複製能力

MongoDB自身提供了副本集能將數據分佈在多臺機器上實現冗餘，目的是可以提供自動故障轉移、擴展讀能力。（4）速度與持久性

MongoDB的驅動實現一個寫入語義 fire and forget ，即通過驅動調用寫入時，可以立即得到返回得到成功的結果（即使是報錯），這樣讓寫入的速度更加快，當然會有一定的不安全性，完全依賴網絡。

MongoDB提供了Journaling日誌的概念，實際上像mysql的bin-log日誌，當需要插入的時候會先往日誌裡面寫入記錄，再完成實際的數據操作，這樣如果出現停電，進程突然中斷的情況，可以保障數據不會錯誤，可以通過修復功能讀取Journaling日誌進行修復。

（5）數據擴展

MongoDB使用分片技術對數據進行擴展，MongoDB能自動分片、自動轉移分片裡面的數據塊，讓每一個服務器裡面存儲的數據都是一樣大小。

4.C/S服務模型

MongoDB核心服務器主要是通過mongod程序啟動的，而且在啟動時不需對MongoDB使用的內存進行配置，因為其設計哲學是內存管理最好是交給操作系統，缺少內存配置是MongoDB的設計亮點，另外，還可通過mongos路由服務器使用分片功能。

MongoDB的主要客戶端是可以交互的js shell 通過mongo啟動，使用js shell能使用js直接與MongoDB進行交流，像使用sql語句查詢mysql數據一樣使用js語法查詢MongoDB的數據，另外還提供了各種語言的驅動包，方便各種語言的接入。

5.完善的命令行工具

mongodump和mongorestore,備份和恢復數據庫的標準工具。輸出BSON格式，遷移數據庫。

mongoexport和mongoimport，用來導入導出JSON、CSV和TSV數據，數據需要支持多格式時有用。mongoimport還能用與大數據集的初始導入，但是在導入前順便還要注意一下，為了能充分利用好mongoDB通常需要對數據模型做一些調整。

mongosniff,網絡嗅探工具，用來觀察發送到數據庫的操作。基本就是把網絡上傳輸的BSON轉換為易於人們閱讀的shell語句。

因此，可以總結得到，MongoDB結合鍵值存儲和關係數據庫的最好特性。因為簡單，所以數據極快，而且相對容易伸縮還提供複雜查詢機制的數據庫。MongoDB需要跑在64位的服務器上面，且最好單獨部署，因為是數據庫，所以也需要對其進行熱備、冷備處理。

二、進入MongoDB shell

因為本篇文章不是API手冊，所有這裡對shell的使用也是基礎的介紹什麼功能可以用什麼語句，主要是為了展示使用MongoDB shell的方便性，如果需要知道具體的MongoDB shell語法可以查閱官方文檔。

1.切換數據庫

use dba

創建數據庫並不是必須的操作，數據庫與集合只有在第一次插入文檔時才會被創建，與對數據的動態處理方式是一致的。簡化並加速開發過程，而且有利於動態分配命名空間。如果擔心數據庫或集合被意外創建，可以開啟嚴格模式。

2.插入語法

db.users.insert({username:"smith"})
db.users.save({username:"smith"})

• 區別:若新增的數據中存在主鍵 ，insert 會提示錯誤，而save 則更改原來的內容為新內容。如：
  已存在數據：{_id : 1, " name " : " n1 " }，再次進行插入操作時，insert({_id : 1, " name " : " n2 " }) 會報主鍵重複的錯誤提示，save({ _id : 1, " name " : " n2 " }) 會把 n1 修改為 n2 。
• 相同點：若新增的數據中沒有主鍵時，會增加一條記錄。已存在數據：{ _id : 1, " name " : " n1 " }，再次進行插入操作時，insert({ " name " : " n2 " }) 插入的數據因為沒有主鍵，所以會增加一條數據，save({ " name " : " n2 " }) 增加一條數據。

3.查找語法

db.users.find
db.users.count

4.更新語法

db.users.update({username:"smith"},{$set:{country:"Canada"}})
//把用戶名為smith的用戶的國家改成Canada

db.users.update({username:"smith"},{$unset:{country:1}})
//把用戶名為smith的用戶的國家字段給移除

db.users.update({username:"jones"},{$set:{favorites:{movies:["casablance","rocky"]}}})
//這裡主要體現多值修改，在favorties字段中添加多個值

db.users.update({"favorites.movies":"casablance"},{$addToSet:{favorites.movies:"the maltese"}},false,true)
//多項更新

5.刪除語法

db.foo.remove //刪除所有數據
db.foo.remove({favorties.cities:"cheyene"}) //根據條件進行刪除
db.drop //刪除整個集合

6.索引相關語法

db.numbers.ensureIndex({num:1})
//創建一個升序索引
db.numbers.getIndexes
//獲取全部索引

7.基本管理語法

show dbs
//查詢所有數據庫
show collections
//顯示所有表
db.stats
//顯示數據庫狀態信息
db.numbers.stats
//顯示集合表狀態信息
db,shutdownServer
//停止數據庫
db.help
//獲取數據庫操作命令
db.foo.help
//獲取表操作命令
tab 鍵 //能自動幫我們補全命令

以上的命令只是簡單實例，假設如果你之前沒有學習過任何數據庫語法，同時開始學sql查詢語法和MongoDB 查詢語法，你會發現哪一個更簡單呢？如果你使用的是java驅動去操作MongoDB，你會發現任何的查詢都像Hibernate提供出來的查詢方式一樣，只要構建好一個查詢條件對象，便能輕鬆查詢（接下來會給出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成沒問題，也正因為這樣簡潔，完善的查詢機制，深深的愛上了MongoDB。

三、使用java驅動

使用java驅動鏈接MongoDB是一件非常簡單的事情，簡單的引用，簡單的做增刪改查。在使用完java驅動後我才發現spring 對MongoDB 的封裝還不如官方自身提供出來的東西好用，下面簡單的展示一下使用。

1.使用maven引入jar包

 <dependency>
<groupId>org.mongodbgroupId>
<artifactId>mongodb-driver-syncartifactId>
<version>3.8.0-beta3version>
dependency>

2.創建一個訪問客戶端

MongoClient client = MongoClients.create(“mongodb://10.201.76.94:27017”);

3.獲取集合數量

public long count {
MongoClient client = this.getClient;
MongoCollection
return collections.count;
}

4.查詢集合

public List
MongoClient client = this.getClient;
MongoCollection
List
collections.find(params).sort(sort).skip(skip).limit(limit).forEach(new Block
@Override
public void apply(Document document) {
list.add(document);
}
});
return list;
}

這裡只舉例了簡單的鏈接與簡單的MongoDB操作，可見其操作的容易性。使用驅動時是基於TCP套接字與MongoDB進行通信的，如果查詢結果較多，恰好無法全部放進第一服務器中，將會向服務器發送一個getmore指令獲取下一批查詢結果。

插入數據到服務器時間，不會等待服務器的響應，驅動會假設寫入是成功的，實際是使用客戶端生成對象id，但是該行為可以通過配置配置，可以通過安全模式開啟，安全模式可以校驗服務器端插入的錯誤。

四、schema 設計原則

1.需要關注MongoDB的自身的特性

要清楚瞭解MongoDB的基本數據單元。在關係型數據庫中有帶列和行的數據表。而MongoDB數據的基本單元是BSON文檔，在鍵值中有指向不定類型值的鍵，MongoDB擁有即時查詢，但不支持聯結操作，簡單的鍵值存儲只能根據單個鍵來獲取值，不支持事務，但支持多種原子更新操作。

2.需要關注系統本身的讀寫特性

如讀寫比是怎樣的，需要何種查詢，數據是如何更新的，會不會存在什麼併發問題，數據結構化的程度是要求高還是低。系統本身的需求決定mysql還是MongoDB。

3.關注MongoDB schema 的設計模式

• 內嵌與引用：當子對象總是出現在父對象的上下文中時，使用內嵌文檔；否則將子對象單獨存一個集合。
• 一對多的關係：在“多”的集合關係中添加id指向依賴的id。
• 多對多：在其中一種對應關係中使用對象數組指向另外一個對象。
• 樹：具化路徑，在樹中的每個節點都包含一個path字段，該字段具體保存了每個節點祖先的id。
• 動態屬性：可以為不同的動態屬性添加索引，如果需要將屬性圈在一個範圍，那麼可以通過key-value的方式，然後在統一的key上面加索引。
• 關於事務：如果需要事務支持，那麼只能選擇另一種數據庫，或者提供補償性事務來解決事務的問題。

在關於schema 的設計中要注意一些原則，比如：

• 不能創建沒用的索引

• 不能在同一個字段中存不同的類型

• 不能把多類實體都放在一個集合裡 不能創建體積大、嵌套深的文檔

• 不能過多的創建集合，集合、索引、數據庫的命名空間都是有限的

• 不能創建無法分片的集合

4.關注MongoDB裡面一些具體細節

數據庫是集合的邏輯與物理分組，MongoDB沒有提供創建數據庫的語法，只有在插入集合時，數據庫才開始建立。創建數據庫後會在磁盤分配一組數據文件，所有集合、索引和數據庫的其他元數據都保存在這些文件中，查閱數據庫使用磁盤狀態可通過。

db.stats

（2）關注集合概念

集合是結構上或概念上相似得文檔的容器，集合的名稱可以包含數字、字母或 . 符號，但必須以字母或數字開頭，完全。

限定集合名不能超過128個字符，實際上 . 符號在集合中很有用，能提供某種虛擬命名空間，這是一種組織上的原則，和其他集合是一視同仁的。在集合中可以使用。

system.namespaces //查詢當前數據庫中定義的所有命名空間
system.indexes //存儲當前數據庫的所有索引定義

（3）關注文檔

其次是鍵值，在MongoDB裡面所有的字符串都是UTF-8類型。數字類型包括double、int、long。日期類型都是UTC格式，所以在MongoDB裡面看到的時間會比北京時間慢8小時。整個文檔大小會限制在16m以內，因為這樣可以防止創建難看的數據類型，且小文檔可以提升性能，批量插入文檔理想數字範圍是10~200，大小不能超過16MB。

五、索引與查詢優化

1.索引的經驗法則

（2）解析查詢時MongoDB通過最優計劃選擇一個索引進行查詢，當沒有最適合索引時，會先不同的使用各個索引進行查詢，最終選出一個最優索引做查詢

（3）如果有一個a-b的複合索引，那麼僅針對a的索引是冗餘的

（4）複合索引裡的鍵的順序是很重要的

2.索引類型

（2）複合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段會出現的值，或是大量文檔都不包含被索引的鍵。

3.索引的構建問題

如果數據集很大時，構建索引將會花費很長的時間，且會影響程序性能，可通過

db.currentOp //查看索引的構建時間

當使用 mongorestore 時會重新構建索引。當曾經執行過大規模的刪除時，可使用

db.values.reIndex 

對索引進行壓縮，重建。

4.識別慢查詢

（1）查閱慢查詢日誌

grep -E '([0-9])+ms' mongod.log //使用grep 命令 識別命令信息

db.setProfillingLevel(2) //使用解刨器，將記錄每次的讀寫到日誌

db.setProfillingLevel(1) //只記錄慢（100ms）操作

（2）分析慢查詢

db.values.find({}).sort({close:-1}).limit(1).explain

• scanOrder 字段表明沒有使用索引

• cursor當沒有索引時，用的是BasicCursor，當使用索引時使用的是BtreeCursor

• n 表示需要返回的結果集

• nscanned表示需要遍歷的文檔數 indexBounds 表示索引邊界

注意新版本的MongoDB 的explain方法是需要參數的，不然只顯示普通的信息。

六、MongoDB副本集

本節同樣主要簡單呈現MongoDB副本集搭建的簡易性，與副本集的強壯性，監控容易性

1.為什麼要使用副本集

提供主從複製能力，熱備能力，故障轉移能力

2.構建方式

rs.initiate
rs.add("localhost:40001")
rs.add("localhost:40002",{arbiterOnly:true})

3.監控

db.isMasrter
rs.status

4.副本集的工作原理

實際上MongoDB對副本集的操作跟mysql主從操作是差不多的，先看一下mysql的主從數據流動過程

主binlog -> 從relay.log -> 從bin.log -> 從數據庫

而MongoDB主要依賴的日誌文件是oplog

主oplog -> 從oplog

寫操作先被記錄下來，添加到主節點的oplog裡。與此同時，所有從結點複製oplog。首先，查看自己oplog裡最後一條的時間戳；其次，查詢主節點oplog裡所有大於此時間戳的條目;最後，把那些條目添加到自己的oplog裡並應用到自己的庫裡。從節點使用長輪詢立即應用來自主結點oplog的新條目。

當遇到以下情況，從節點會停止複製

• 如果從節點在主節點的oplog裡找不到它所同步的點，那麼會永久停止複製

• 一旦某個從節點沒能 在主節點的oplog裡找到它已經同步的點，就無法再保證這個從結點的完美副本

local數據庫保存了所有副本集元素據和oplog日誌

• replset.minvalid 包含指定副本集成員的初始化同步信息

• system.replset 保存在副本集配置文檔

• system.indexes 標準索引說明容器

• me slaves 主要用於寫關注

可以使用以下命令查看複製情況

db.oplog.rs.findOne

• ts 保存了該條目的BSON時間戳

• t 是從紀元開始的描述

• i是計數器

• op 表示操作碼

• ns 標明瞭有關的命名空間

5.心跳檢測

每個副本集成員每秒鐘ping一次其他所有成員，可以通過rs.status看到節點上次的心跳檢測時間戳和健康狀況。

6.故障轉移

這個點沒必要過多描述，但是有一個特殊場景，如果從節點和仲裁節點都被殺了，只剩下主節點，他會把自己降級成為從節點。

7.提交與回滾

如果主節點的數據還沒有寫到從庫，那麼數據不能算提交，當該主節點變成從節點時，便會觸發回滾，那些沒寫到從庫的數據將會被刪除，可以通過rollback子目錄中的BSON文件恢復回滾的內容。

8.驅動與複製

只能鏈接到主節點，如果鏈接到從節點的話，會被拒絕寫入操作，但是如果沒有使用安全模式，因為mongo的fire and forget 特性，會把拒絕寫入的異常給吃掉。

（2）使用副本集方式鏈接

能根據寫入的情況自動進行故障轉移，但是當副本集進行新的選舉時，還是會出現故障，如果不使用安全模式，依舊會出現寫不進去，但現實成功的情況。

（3）寫關注

可以使用寫關注來關注數據是否已經被寫入MongoDB的庫中，使用寫關注會消耗性能，需要在速度和持久性之間做出權衡。

七、分片

分片是數據庫切分的一個概念實現，這裡也是簡單總結為什麼要使用分片以及分片的原理，操作。

1.為什麼需要分片

當數據量過大，索引和工作數據集佔用的內存就會越來越多，所以需要通過分片負載來解決這個問題

2.分片的工作原理

• 分片：每個分片都是一個副本集

• mongos路由器：是一個路由器，將讀寫請求指引到合適的分片上

• 配置服務器config：持久化分片集群的元數據，包括：全局集群配置；每個數據庫、集合和特定範圍數據位置；一份變更記錄，保存了數據在分片之間進行遷移的歷史信息。配置服務器之間不是副本集形式存在，mongos向配置服務器提交信息時是兩階段提交，保證配置服務器之間的一致性。

（2）分片的核心操作

分片一個集合：分片是根據一個屬性的範圍進行劃分的，MongoDB使用所謂的分片鍵讓每個文檔在這些範圍裡找到自己的位置

塊：是位於一個分片中的一段連續的分片鍵範圍，可以理解為若干個塊組成分片，分片組成MongoDB的全部數據

（3）拆分與遷移

塊的拆分：初始化時只有一個塊，達到最大塊尺寸64MB或100000個文檔就會觸發塊的拆分。把原來的範圍一分為二，這樣就有了兩個塊，每個塊都有相同數量的文檔。

遷移：當分片中的數據大小不一時會產生遷移的動作，比如分片A的數據比較多，會將分片A裡面的一些塊轉移到分片B裡面去。分片集群通過在分片中移動塊來實現均衡，是由名為均衡器的軟件進程管理的，任務是確保數據在各個分片中保持均勻分佈，當集群中擁有塊最多的分片與擁有塊最少分片的塊差大於8時，均衡器就會發起一次均衡處理。

3.分片實戰

啟動兩個副本集、三個配置服務器、一個mongos進程

配置分片

sh.help //查看分片相關幫助
sh.addShard //添加分片
db,getSiblingDB("config").shards.find //查看分片列表
sh.status //分片詳情
sh.enableSharding("cloud-docs") //開啟一個數據庫上的分片
db.getSiblingDB("config").databases,find //查看數據庫列表
sh.shardCollection("cloud-docs.spreadsheets",{username:1,_id:1}) //使用一個分片鍵定義一個分片集合spreadsheets，根據用戶名進行切分
sh.getSiiblingDB("config").collections.findOne //查看集合列表
db.chunks.count //查看塊的個數
db.chunks.findOne //查看塊的信息
db.changelog.count(}what:"split"|) //查看塊切分日誌
db.changelog.find({what:"moveChunk.commit"}).count //查看日誌遷移記錄

4.分片的查詢與索引

• 針對性查詢：查詢包含分片鍵

• 全局查詢或分散/聚集查：查詢不包含分片鍵

• 查詢過程：通過分片鍵將查詢路由給指定分片，一旦到了某個分片上，由分片自行決定使用哪個索引來執行該查詢

（2）索引

每個分片都維護了自己的索引，當在分片集合上聲明索引時，每個分片都會為它那部分集合構建獨立的索引，每個分片上的分片集合都應該擁有相同的索引。

分片集合只允許在_id字段和分片鍵上添加唯一性索引，其他地方不行，因為這需要在分片間進行通信，實施起來很複雜。

當創建分片時，會根據分片鍵創建一個索引。

5.選擇分片鍵

（2）低效的分片鍵

• 分佈性差：如使用BSON對象ID，那麼會導致所有最新插入的文檔都會落到某個很小的連續範圍，無法分散插入

• 缺乏局部性：升序分片鍵有明確的方向，完全隨機的分片鍵則根本沒有方向。前者無法分散插入，後者插入分散，如使用MD5作為分片鍵

（3）理想的分片鍵

• 將插入數據均勻分佈到各個分片上

• 保證CRUD操作能夠利用局部性 有足夠的粒度進行塊拆分

• 滿足這些要求的分片鍵通常由兩個字段組成，第一個是粗粒度的，第二個粒度較細

6.生產環境中的分片

• 複製mongod：需要獨立的部署服務器

• 配置服務器：配置服務器不需要有自己的機器

根據不同的數據中心劃分

（2）最低要求

• 副本集每個成員，無論是完整的副本集節點還是仲裁節點，都需要放在不同的機器上 每個用於複製的副本集成員都需要有自己的機器

• 副本集仲裁節點很輕量級，和其他進程共用一臺機器即可

• 配置服務器也可以選擇與其他進程共用一臺機器

點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

鏈接 | blog.csdn.net/hayre/article/details/80628431

1.MongoDB是什麼？用一句話總結

MongoDB是一款為web應用程序和互聯網基礎設施設計的數據庫管理系統。沒錯MongoDB就是數據庫，是NoSQL類型的數據庫。

2.為什麼要使用MongoDB？

（1）MongoDB提出的是文檔、集合的概念，使用BSON（類JSON）作為其數據模型結構，其結構是面向對象的而不是二維表，存儲一個用戶在MongoDB中是這樣子的。

｛
username:'123',
password:'123'
｝

使用這樣的數據模型，使得MongoDB能在生產環境中提供高讀寫的能力，吞吐量較於mysql等SQL數據庫大大增強。

（2）易伸縮，自動故障轉移。易伸縮指的是提供了分片能力，能對數據集進行分片，數據的存儲壓力分攤給多臺服務器。自動故障轉移是副本集的概念，MongoDB能檢測主節點是否存活，當失活時能自動提升從節點為主節點，達到故障轉移。

（3）數據模型因為是面向對象的，所以可以表示豐富的、有層級的數據結構，比如博客系統中能把“評論”直接懟到“文章“的文檔中，而不必像myqsl一樣創建三張表來描述這樣的關係。

3.主要特性

（1）文檔數據類型

SQL類型的數據庫是正規化的，可以通過主鍵或者外鍵的約束保證數據的完整性與唯一性，所以SQL類型的數據庫常用於對數據完整性較高的系統。MongoDB在這一方面是不如SQL類型的數據庫，且MongoDB沒有固定的Schema，正因為MongoDB少了一些這樣的約束條件，可以讓數據的存儲數據結構更靈活，存儲速度更加快。（2）即時查詢能力

MongoDB保留了關係型數據庫即時查詢的能力，保留了索引（底層是基於B tree）的能力。這一點汲取了關係型數據庫的優點，相比於同類型的NoSQL redis 並沒有上述的能力。（3）複製能力

MongoDB自身提供了副本集能將數據分佈在多臺機器上實現冗餘，目的是可以提供自動故障轉移、擴展讀能力。（4）速度與持久性

MongoDB的驅動實現一個寫入語義 fire and forget ，即通過驅動調用寫入時，可以立即得到返回得到成功的結果（即使是報錯），這樣讓寫入的速度更加快，當然會有一定的不安全性，完全依賴網絡。

MongoDB提供了Journaling日誌的概念，實際上像mysql的bin-log日誌，當需要插入的時候會先往日誌裡面寫入記錄，再完成實際的數據操作，這樣如果出現停電，進程突然中斷的情況，可以保障數據不會錯誤，可以通過修復功能讀取Journaling日誌進行修復。

（5）數據擴展

MongoDB使用分片技術對數據進行擴展，MongoDB能自動分片、自動轉移分片裡面的數據塊，讓每一個服務器裡面存儲的數據都是一樣大小。

4.C/S服務模型

MongoDB核心服務器主要是通過mongod程序啟動的，而且在啟動時不需對MongoDB使用的內存進行配置，因為其設計哲學是內存管理最好是交給操作系統，缺少內存配置是MongoDB的設計亮點，另外，還可通過mongos路由服務器使用分片功能。

MongoDB的主要客戶端是可以交互的js shell 通過mongo啟動，使用js shell能使用js直接與MongoDB進行交流，像使用sql語句查詢mysql數據一樣使用js語法查詢MongoDB的數據，另外還提供了各種語言的驅動包，方便各種語言的接入。

5.完善的命令行工具

mongodump和mongorestore,備份和恢復數據庫的標準工具。輸出BSON格式，遷移數據庫。

mongoexport和mongoimport，用來導入導出JSON、CSV和TSV數據，數據需要支持多格式時有用。mongoimport還能用與大數據集的初始導入，但是在導入前順便還要注意一下，為了能充分利用好mongoDB通常需要對數據模型做一些調整。

mongosniff,網絡嗅探工具，用來觀察發送到數據庫的操作。基本就是把網絡上傳輸的BSON轉換為易於人們閱讀的shell語句。

因此，可以總結得到，MongoDB結合鍵值存儲和關係數據庫的最好特性。因為簡單，所以數據極快，而且相對容易伸縮還提供複雜查詢機制的數據庫。MongoDB需要跑在64位的服務器上面，且最好單獨部署，因為是數據庫，所以也需要對其進行熱備、冷備處理。

二、進入MongoDB shell

因為本篇文章不是API手冊，所有這裡對shell的使用也是基礎的介紹什麼功能可以用什麼語句，主要是為了展示使用MongoDB shell的方便性，如果需要知道具體的MongoDB shell語法可以查閱官方文檔。

1.切換數據庫

use dba

創建數據庫並不是必須的操作，數據庫與集合只有在第一次插入文檔時才會被創建，與對數據的動態處理方式是一致的。簡化並加速開發過程，而且有利於動態分配命名空間。如果擔心數據庫或集合被意外創建，可以開啟嚴格模式。

2.插入語法

db.users.insert({username:"smith"})
db.users.save({username:"smith"})

• 區別:若新增的數據中存在主鍵 ，insert 會提示錯誤，而save 則更改原來的內容為新內容。如：
  已存在數據：{_id : 1, " name " : " n1 " }，再次進行插入操作時，insert({_id : 1, " name " : " n2 " }) 會報主鍵重複的錯誤提示，save({ _id : 1, " name " : " n2 " }) 會把 n1 修改為 n2 。
• 相同點：若新增的數據中沒有主鍵時，會增加一條記錄。已存在數據：{ _id : 1, " name " : " n1 " }，再次進行插入操作時，insert({ " name " : " n2 " }) 插入的數據因為沒有主鍵，所以會增加一條數據，save({ " name " : " n2 " }) 增加一條數據。

3.查找語法

db.users.find
db.users.count

4.更新語法

db.users.update({username:"smith"},{$set:{country:"Canada"}})
//把用戶名為smith的用戶的國家改成Canada

db.users.update({username:"smith"},{$unset:{country:1}})
//把用戶名為smith的用戶的國家字段給移除

db.users.update({username:"jones"},{$set:{favorites:{movies:["casablance","rocky"]}}})
//這裡主要體現多值修改，在favorties字段中添加多個值

db.users.update({"favorites.movies":"casablance"},{$addToSet:{favorites.movies:"the maltese"}},false,true)
//多項更新

5.刪除語法

db.foo.remove //刪除所有數據
db.foo.remove({favorties.cities:"cheyene"}) //根據條件進行刪除
db.drop //刪除整個集合

6.索引相關語法

db.numbers.ensureIndex({num:1})
//創建一個升序索引
db.numbers.getIndexes
//獲取全部索引

7.基本管理語法

show dbs
//查詢所有數據庫
show collections
//顯示所有表
db.stats
//顯示數據庫狀態信息
db.numbers.stats
//顯示集合表狀態信息
db,shutdownServer
//停止數據庫
db.help
//獲取數據庫操作命令
db.foo.help
//獲取表操作命令
tab 鍵 //能自動幫我們補全命令

以上的命令只是簡單實例，假設如果你之前沒有學習過任何數據庫語法，同時開始學sql查詢語法和MongoDB 查詢語法，你會發現哪一個更簡單呢？如果你使用的是java驅動去操作MongoDB，你會發現任何的查詢都像Hibernate提供出來的查詢方式一樣，只要構建好一個查詢條件對象，便能輕鬆查詢（接下來會給出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成沒問題，也正因為這樣簡潔，完善的查詢機制，深深的愛上了MongoDB。

三、使用java驅動

使用java驅動鏈接MongoDB是一件非常簡單的事情，簡單的引用，簡單的做增刪改查。在使用完java驅動後我才發現spring 對MongoDB 的封裝還不如官方自身提供出來的東西好用，下面簡單的展示一下使用。

1.使用maven引入jar包

 <dependency>
<groupId>org.mongodbgroupId>
<artifactId>mongodb-driver-syncartifactId>
<version>3.8.0-beta3version>
dependency>

2.創建一個訪問客戶端

MongoClient client = MongoClients.create(“mongodb://10.201.76.94:27017”);

3.獲取集合數量

public long count {
MongoClient client = this.getClient;
MongoCollection
return collections.count;
}

4.查詢集合

public List
MongoClient client = this.getClient;
MongoCollection
List
collections.find(params).sort(sort).skip(skip).limit(limit).forEach(new Block
@Override
public void apply(Document document) {
list.add(document);
}
});
return list;
}

這裡只舉例了簡單的鏈接與簡單的MongoDB操作，可見其操作的容易性。使用驅動時是基於TCP套接字與MongoDB進行通信的，如果查詢結果較多，恰好無法全部放進第一服務器中，將會向服務器發送一個getmore指令獲取下一批查詢結果。

插入數據到服務器時間，不會等待服務器的響應，驅動會假設寫入是成功的，實際是使用客戶端生成對象id，但是該行為可以通過配置配置，可以通過安全模式開啟，安全模式可以校驗服務器端插入的錯誤。

四、schema 設計原則

1.需要關注MongoDB的自身的特性

要清楚瞭解MongoDB的基本數據單元。在關係型數據庫中有帶列和行的數據表。而MongoDB數據的基本單元是BSON文檔，在鍵值中有指向不定類型值的鍵，MongoDB擁有即時查詢，但不支持聯結操作，簡單的鍵值存儲只能根據單個鍵來獲取值，不支持事務，但支持多種原子更新操作。

2.需要關注系統本身的讀寫特性

如讀寫比是怎樣的，需要何種查詢，數據是如何更新的，會不會存在什麼併發問題，數據結構化的程度是要求高還是低。系統本身的需求決定mysql還是MongoDB。

3.關注MongoDB schema 的設計模式

• 內嵌與引用：當子對象總是出現在父對象的上下文中時，使用內嵌文檔；否則將子對象單獨存一個集合。
• 一對多的關係：在“多”的集合關係中添加id指向依賴的id。
• 多對多：在其中一種對應關係中使用對象數組指向另外一個對象。
• 樹：具化路徑，在樹中的每個節點都包含一個path字段，該字段具體保存了每個節點祖先的id。
• 動態屬性：可以為不同的動態屬性添加索引，如果需要將屬性圈在一個範圍，那麼可以通過key-value的方式，然後在統一的key上面加索引。
• 關於事務：如果需要事務支持，那麼只能選擇另一種數據庫，或者提供補償性事務來解決事務的問題。

在關於schema 的設計中要注意一些原則，比如：

• 不能創建沒用的索引

• 不能在同一個字段中存不同的類型

• 不能把多類實體都放在一個集合裡 不能創建體積大、嵌套深的文檔

• 不能過多的創建集合，集合、索引、數據庫的命名空間都是有限的

• 不能創建無法分片的集合

4.關注MongoDB裡面一些具體細節

數據庫是集合的邏輯與物理分組，MongoDB沒有提供創建數據庫的語法，只有在插入集合時，數據庫才開始建立。創建數據庫後會在磁盤分配一組數據文件，所有集合、索引和數據庫的其他元數據都保存在這些文件中，查閱數據庫使用磁盤狀態可通過。

db.stats

（2）關注集合概念

集合是結構上或概念上相似得文檔的容器，集合的名稱可以包含數字、字母或 . 符號，但必須以字母或數字開頭，完全。

限定集合名不能超過128個字符，實際上 . 符號在集合中很有用，能提供某種虛擬命名空間，這是一種組織上的原則，和其他集合是一視同仁的。在集合中可以使用。

system.namespaces //查詢當前數據庫中定義的所有命名空間
system.indexes //存儲當前數據庫的所有索引定義

（3）關注文檔

其次是鍵值，在MongoDB裡面所有的字符串都是UTF-8類型。數字類型包括double、int、long。日期類型都是UTC格式，所以在MongoDB裡面看到的時間會比北京時間慢8小時。整個文檔大小會限制在16m以內，因為這樣可以防止創建難看的數據類型，且小文檔可以提升性能，批量插入文檔理想數字範圍是10~200，大小不能超過16MB。

五、索引與查詢優化

1.索引的經驗法則

（2）解析查詢時MongoDB通過最優計劃選擇一個索引進行查詢，當沒有最適合索引時，會先不同的使用各個索引進行查詢，最終選出一個最優索引做查詢

（3）如果有一個a-b的複合索引，那麼僅針對a的索引是冗餘的

（4）複合索引裡的鍵的順序是很重要的

2.索引類型

（2）複合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段會出現的值，或是大量文檔都不包含被索引的鍵。

3.索引的構建問題

如果數據集很大時，構建索引將會花費很長的時間，且會影響程序性能，可通過

db.currentOp //查看索引的構建時間

當使用 mongorestore 時會重新構建索引。當曾經執行過大規模的刪除時，可使用

db.values.reIndex 

對索引進行壓縮，重建。

4.識別慢查詢

（1）查閱慢查詢日誌

grep -E '([0-9])+ms' mongod.log //使用grep 命令 識別命令信息

db.setProfillingLevel(2) //使用解刨器，將記錄每次的讀寫到日誌

db.setProfillingLevel(1) //只記錄慢（100ms）操作

（2）分析慢查詢

db.values.find({}).sort({close:-1}).limit(1).explain

• scanOrder 字段表明沒有使用索引

• cursor當沒有索引時，用的是BasicCursor，當使用索引時使用的是BtreeCursor

• n 表示需要返回的結果集

• nscanned表示需要遍歷的文檔數 indexBounds 表示索引邊界

注意新版本的MongoDB 的explain方法是需要參數的，不然只顯示普通的信息。

六、MongoDB副本集

本節同樣主要簡單呈現MongoDB副本集搭建的簡易性，與副本集的強壯性，監控容易性

1.為什麼要使用副本集

提供主從複製能力，熱備能力，故障轉移能力

2.構建方式

rs.initiate
rs.add("localhost:40001")
rs.add("localhost:40002",{arbiterOnly:true})

3.監控

db.isMasrter
rs.status

4.副本集的工作原理

實際上MongoDB對副本集的操作跟mysql主從操作是差不多的，先看一下mysql的主從數據流動過程

主binlog -> 從relay.log -> 從bin.log -> 從數據庫

而MongoDB主要依賴的日誌文件是oplog

主oplog -> 從oplog

寫操作先被記錄下來，添加到主節點的oplog裡。與此同時，所有從結點複製oplog。首先，查看自己oplog裡最後一條的時間戳；其次，查詢主節點oplog裡所有大於此時間戳的條目;最後，把那些條目添加到自己的oplog裡並應用到自己的庫裡。從節點使用長輪詢立即應用來自主結點oplog的新條目。

當遇到以下情況，從節點會停止複製

• 如果從節點在主節點的oplog裡找不到它所同步的點，那麼會永久停止複製

• 一旦某個從節點沒能 在主節點的oplog裡找到它已經同步的點，就無法再保證這個從結點的完美副本

local數據庫保存了所有副本集元素據和oplog日誌

• replset.minvalid 包含指定副本集成員的初始化同步信息

• system.replset 保存在副本集配置文檔

• system.indexes 標準索引說明容器

• me slaves 主要用於寫關注

可以使用以下命令查看複製情況

db.oplog.rs.findOne

• ts 保存了該條目的BSON時間戳

• t 是從紀元開始的描述

• i是計數器

• op 表示操作碼

• ns 標明瞭有關的命名空間

5.心跳檢測

每個副本集成員每秒鐘ping一次其他所有成員，可以通過rs.status看到節點上次的心跳檢測時間戳和健康狀況。

6.故障轉移

這個點沒必要過多描述，但是有一個特殊場景，如果從節點和仲裁節點都被殺了，只剩下主節點，他會把自己降級成為從節點。

7.提交與回滾

如果主節點的數據還沒有寫到從庫，那麼數據不能算提交，當該主節點變成從節點時，便會觸發回滾，那些沒寫到從庫的數據將會被刪除，可以通過rollback子目錄中的BSON文件恢復回滾的內容。

8.驅動與複製

只能鏈接到主節點，如果鏈接到從節點的話，會被拒絕寫入操作，但是如果沒有使用安全模式，因為mongo的fire and forget 特性，會把拒絕寫入的異常給吃掉。

（2）使用副本集方式鏈接

能根據寫入的情況自動進行故障轉移，但是當副本集進行新的選舉時，還是會出現故障，如果不使用安全模式，依舊會出現寫不進去，但現實成功的情況。

（3）寫關注

可以使用寫關注來關注數據是否已經被寫入MongoDB的庫中，使用寫關注會消耗性能，需要在速度和持久性之間做出權衡。

七、分片

分片是數據庫切分的一個概念實現，這裡也是簡單總結為什麼要使用分片以及分片的原理，操作。

1.為什麼需要分片

當數據量過大，索引和工作數據集佔用的內存就會越來越多，所以需要通過分片負載來解決這個問題

2.分片的工作原理

• 分片：每個分片都是一個副本集

• mongos路由器：是一個路由器，將讀寫請求指引到合適的分片上

• 配置服務器config：持久化分片集群的元數據，包括：全局集群配置；每個數據庫、集合和特定範圍數據位置；一份變更記錄，保存了數據在分片之間進行遷移的歷史信息。配置服務器之間不是副本集形式存在，mongos向配置服務器提交信息時是兩階段提交，保證配置服務器之間的一致性。

（2）分片的核心操作

分片一個集合：分片是根據一個屬性的範圍進行劃分的，MongoDB使用所謂的分片鍵讓每個文檔在這些範圍裡找到自己的位置

塊：是位於一個分片中的一段連續的分片鍵範圍，可以理解為若干個塊組成分片，分片組成MongoDB的全部數據

（3）拆分與遷移

塊的拆分：初始化時只有一個塊，達到最大塊尺寸64MB或100000個文檔就會觸發塊的拆分。把原來的範圍一分為二，這樣就有了兩個塊，每個塊都有相同數量的文檔。

遷移：當分片中的數據大小不一時會產生遷移的動作，比如分片A的數據比較多，會將分片A裡面的一些塊轉移到分片B裡面去。分片集群通過在分片中移動塊來實現均衡，是由名為均衡器的軟件進程管理的，任務是確保數據在各個分片中保持均勻分佈，當集群中擁有塊最多的分片與擁有塊最少分片的塊差大於8時，均衡器就會發起一次均衡處理。

3.分片實戰

啟動兩個副本集、三個配置服務器、一個mongos進程

配置分片

sh.help //查看分片相關幫助
sh.addShard //添加分片
db,getSiblingDB("config").shards.find //查看分片列表
sh.status //分片詳情
sh.enableSharding("cloud-docs") //開啟一個數據庫上的分片
db.getSiblingDB("config").databases,find //查看數據庫列表
sh.shardCollection("cloud-docs.spreadsheets",{username:1,_id:1}) //使用一個分片鍵定義一個分片集合spreadsheets，根據用戶名進行切分
sh.getSiiblingDB("config").collections.findOne //查看集合列表
db.chunks.count //查看塊的個數
db.chunks.findOne //查看塊的信息
db.changelog.count(}what:"split"|) //查看塊切分日誌
db.changelog.find({what:"moveChunk.commit"}).count //查看日誌遷移記錄

4.分片的查詢與索引

• 針對性查詢：查詢包含分片鍵

• 全局查詢或分散/聚集查：查詢不包含分片鍵

• 查詢過程：通過分片鍵將查詢路由給指定分片，一旦到了某個分片上，由分片自行決定使用哪個索引來執行該查詢

（2）索引

每個分片都維護了自己的索引，當在分片集合上聲明索引時，每個分片都會為它那部分集合構建獨立的索引，每個分片上的分片集合都應該擁有相同的索引。

分片集合只允許在_id字段和分片鍵上添加唯一性索引，其他地方不行，因為這需要在分片間進行通信，實施起來很複雜。

當創建分片時，會根據分片鍵創建一個索引。

5.選擇分片鍵

（2）低效的分片鍵

• 分佈性差：如使用BSON對象ID，那麼會導致所有最新插入的文檔都會落到某個很小的連續範圍，無法分散插入

• 缺乏局部性：升序分片鍵有明確的方向，完全隨機的分片鍵則根本沒有方向。前者無法分散插入，後者插入分散，如使用MD5作為分片鍵

（3）理想的分片鍵

• 將插入數據均勻分佈到各個分片上

• 保證CRUD操作能夠利用局部性 有足夠的粒度進行塊拆分

• 滿足這些要求的分片鍵通常由兩個字段組成，第一個是粗粒度的，第二個粒度較細

6.生產環境中的分片

• 複製mongod：需要獨立的部署服務器

• 配置服務器：配置服務器不需要有自己的機器

根據不同的數據中心劃分

（2）最低要求

• 副本集每個成員，無論是完整的副本集節點還是仲裁節點，都需要放在不同的機器上 每個用於複製的副本集成員都需要有自己的機器

• 副本集仲裁節點很輕量級，和其他進程共用一臺機器即可

• 配置服務器也可以選擇與其他進程共用一臺機器

（3）配置的注意事項

需要估計集群大小，可使用以下命令對現有集合進行分片處理

sh.splitAt("cloud-docs.spreadsheets",{"username":"chen","_id":ObjectId("")})
//手動拆分塊
sh.moveChunk("cloud-docs.spreadsheets",{username:"chen"},"shardB")
//手動將某分塊移至分片B
db.runCommand({removeshard:"shard-1/arete:30100,arete:30101"})
//刪除分片
db.runCommand({moveprimary:"test",to:"shard-0-test-rs"});
//移動主分片

（4）備份分片集群

備份分片時需要停止均衡器

db.settings.update({_id:"ba;ancer"},{$set:{stopped:true},true});
sh.setBalancerState(false)；
//停止均衡器，此時均衡器將進行最後一輪均衡

db.locks.find({_id:"balancer"});
sh.isBalancerRunning;
//查看均衡器狀態，任何狀態大於0 的狀態值都說明均衡器仍在進行中

八、部署與管理

1.部署

使用64位機器、32位機器會制約mongodb的內存，使其最大值為1.5GB

（2）cpumongodb 只有當索引和工作集都可放入內存時，才會遇到CPU瓶頸，CPU在mongodb使用中的作用是用來檢索數據，如果看到CPU使用飽和的情況，可以通過查詢慢查詢日誌，排查是不是查詢的問題導致的，如果是可以通過添加索引來解決問題

mongodb寫入數據時會使用到CPU，但是mongodb寫入時間一次只用到一個核，如果有頻繁的寫入行為，可以通過分片來解決這個問題（3）內存

大內存是mongodb的保障，如果工作集大小超過內存，將會導致性能下降，因為這將會增加數據加載入內存的動作

（4）硬盤

mongodb默認每60s會與磁盤強制同步一次，稱為後臺刷新，會產生I/O操作。在重啟時mongodb會將磁盤裡面的數據加載至內存，高速磁盤將會減少同步的時間

（5）文件系統

使用ext4 和 xfs 文件系統

禁用最後訪問時間

vim /etc/fstab

（6）文件描述符

linux 默認文件描述符是1024，需要大額度的提升這個額度

（7）時鐘

mongodb各個節點服務器之間使用ntp服務器

2.安全

啟動時使用 - -bind_ip 命令

（2）身份驗證

啟動時使用 - -auth 命令

db.addUser("","",true)
//創建用戶，最後一個參數指定是否只讀

（3）副本集身份認證

使用keyFile，注意keyFile文件的權限必須是600，不然會啟動不起來

3.數據的導入與導出

mongoimport
mongoexport

4.服務器配置

搭建副本集至少需要兩個節點，其中仲裁結點不需要有自己的服務器

（2）Journaling日誌寫數據時會先寫入日誌，而此時的數據也不是直接寫入硬盤，而是寫入內存

但是Journaling日誌會消耗內存，所以可以在主庫上面關閉，在從庫上面啟動

可以單獨為Journaling日誌使用一塊固態硬盤

在插入時，可以通過驅動確保Journaling插入後再反饋，但是會非常影響性能。

5.日誌

-vvvvv 選項（v越多，輸出越詳細）

db.runCommand({logrotare:1}) 開啟滾動日誌

6.數據庫監控命令

點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

鏈接 | blog.csdn.net/hayre/article/details/80628431

1.MongoDB是什麼？用一句話總結

MongoDB是一款為web應用程序和互聯網基礎設施設計的數據庫管理系統。沒錯MongoDB就是數據庫，是NoSQL類型的數據庫。

2.為什麼要使用MongoDB？

（1）MongoDB提出的是文檔、集合的概念，使用BSON（類JSON）作為其數據模型結構，其結構是面向對象的而不是二維表，存儲一個用戶在MongoDB中是這樣子的。

｛
username:'123',
password:'123'
｝

使用這樣的數據模型，使得MongoDB能在生產環境中提供高讀寫的能力，吞吐量較於mysql等SQL數據庫大大增強。

（2）易伸縮，自動故障轉移。易伸縮指的是提供了分片能力，能對數據集進行分片，數據的存儲壓力分攤給多臺服務器。自動故障轉移是副本集的概念，MongoDB能檢測主節點是否存活，當失活時能自動提升從節點為主節點，達到故障轉移。

（3）數據模型因為是面向對象的，所以可以表示豐富的、有層級的數據結構，比如博客系統中能把“評論”直接懟到“文章“的文檔中，而不必像myqsl一樣創建三張表來描述這樣的關係。

3.主要特性

（1）文檔數據類型

SQL類型的數據庫是正規化的，可以通過主鍵或者外鍵的約束保證數據的完整性與唯一性，所以SQL類型的數據庫常用於對數據完整性較高的系統。MongoDB在這一方面是不如SQL類型的數據庫，且MongoDB沒有固定的Schema，正因為MongoDB少了一些這樣的約束條件，可以讓數據的存儲數據結構更靈活，存儲速度更加快。（2）即時查詢能力

MongoDB保留了關係型數據庫即時查詢的能力，保留了索引（底層是基於B tree）的能力。這一點汲取了關係型數據庫的優點，相比於同類型的NoSQL redis 並沒有上述的能力。（3）複製能力

MongoDB自身提供了副本集能將數據分佈在多臺機器上實現冗餘，目的是可以提供自動故障轉移、擴展讀能力。（4）速度與持久性

MongoDB的驅動實現一個寫入語義 fire and forget ，即通過驅動調用寫入時，可以立即得到返回得到成功的結果（即使是報錯），這樣讓寫入的速度更加快，當然會有一定的不安全性，完全依賴網絡。

MongoDB提供了Journaling日誌的概念，實際上像mysql的bin-log日誌，當需要插入的時候會先往日誌裡面寫入記錄，再完成實際的數據操作，這樣如果出現停電，進程突然中斷的情況，可以保障數據不會錯誤，可以通過修復功能讀取Journaling日誌進行修復。

（5）數據擴展

MongoDB使用分片技術對數據進行擴展，MongoDB能自動分片、自動轉移分片裡面的數據塊，讓每一個服務器裡面存儲的數據都是一樣大小。

4.C/S服務模型

MongoDB核心服務器主要是通過mongod程序啟動的，而且在啟動時不需對MongoDB使用的內存進行配置，因為其設計哲學是內存管理最好是交給操作系統，缺少內存配置是MongoDB的設計亮點，另外，還可通過mongos路由服務器使用分片功能。

MongoDB的主要客戶端是可以交互的js shell 通過mongo啟動，使用js shell能使用js直接與MongoDB進行交流，像使用sql語句查詢mysql數據一樣使用js語法查詢MongoDB的數據，另外還提供了各種語言的驅動包，方便各種語言的接入。

5.完善的命令行工具

mongodump和mongorestore,備份和恢復數據庫的標準工具。輸出BSON格式，遷移數據庫。

mongoexport和mongoimport，用來導入導出JSON、CSV和TSV數據，數據需要支持多格式時有用。mongoimport還能用與大數據集的初始導入，但是在導入前順便還要注意一下，為了能充分利用好mongoDB通常需要對數據模型做一些調整。

mongosniff,網絡嗅探工具，用來觀察發送到數據庫的操作。基本就是把網絡上傳輸的BSON轉換為易於人們閱讀的shell語句。

因此，可以總結得到，MongoDB結合鍵值存儲和關係數據庫的最好特性。因為簡單，所以數據極快，而且相對容易伸縮還提供複雜查詢機制的數據庫。MongoDB需要跑在64位的服務器上面，且最好單獨部署，因為是數據庫，所以也需要對其進行熱備、冷備處理。

二、進入MongoDB shell

因為本篇文章不是API手冊，所有這裡對shell的使用也是基礎的介紹什麼功能可以用什麼語句，主要是為了展示使用MongoDB shell的方便性，如果需要知道具體的MongoDB shell語法可以查閱官方文檔。

1.切換數據庫

use dba

創建數據庫並不是必須的操作，數據庫與集合只有在第一次插入文檔時才會被創建，與對數據的動態處理方式是一致的。簡化並加速開發過程，而且有利於動態分配命名空間。如果擔心數據庫或集合被意外創建，可以開啟嚴格模式。

2.插入語法

db.users.insert({username:"smith"})
db.users.save({username:"smith"})

• 區別:若新增的數據中存在主鍵 ，insert 會提示錯誤，而save 則更改原來的內容為新內容。如：
  已存在數據：{_id : 1, " name " : " n1 " }，再次進行插入操作時，insert({_id : 1, " name " : " n2 " }) 會報主鍵重複的錯誤提示，save({ _id : 1, " name " : " n2 " }) 會把 n1 修改為 n2 。
• 相同點：若新增的數據中沒有主鍵時，會增加一條記錄。已存在數據：{ _id : 1, " name " : " n1 " }，再次進行插入操作時，insert({ " name " : " n2 " }) 插入的數據因為沒有主鍵，所以會增加一條數據，save({ " name " : " n2 " }) 增加一條數據。

3.查找語法

db.users.find
db.users.count

4.更新語法

db.users.update({username:"smith"},{$set:{country:"Canada"}})
//把用戶名為smith的用戶的國家改成Canada

db.users.update({username:"smith"},{$unset:{country:1}})
//把用戶名為smith的用戶的國家字段給移除

db.users.update({username:"jones"},{$set:{favorites:{movies:["casablance","rocky"]}}})
//這裡主要體現多值修改，在favorties字段中添加多個值

db.users.update({"favorites.movies":"casablance"},{$addToSet:{favorites.movies:"the maltese"}},false,true)
//多項更新

5.刪除語法

db.foo.remove //刪除所有數據
db.foo.remove({favorties.cities:"cheyene"}) //根據條件進行刪除
db.drop //刪除整個集合

6.索引相關語法

db.numbers.ensureIndex({num:1})
//創建一個升序索引
db.numbers.getIndexes
//獲取全部索引

7.基本管理語法

show dbs
//查詢所有數據庫
show collections
//顯示所有表
db.stats
//顯示數據庫狀態信息
db.numbers.stats
//顯示集合表狀態信息
db,shutdownServer
//停止數據庫
db.help
//獲取數據庫操作命令
db.foo.help
//獲取表操作命令
tab 鍵 //能自動幫我們補全命令

以上的命令只是簡單實例，假設如果你之前沒有學習過任何數據庫語法，同時開始學sql查詢語法和MongoDB 查詢語法，你會發現哪一個更簡單呢？如果你使用的是java驅動去操作MongoDB，你會發現任何的查詢都像Hibernate提供出來的查詢方式一樣，只要構建好一個查詢條件對象，便能輕鬆查詢（接下來會給出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成沒問題，也正因為這樣簡潔，完善的查詢機制，深深的愛上了MongoDB。

三、使用java驅動

使用java驅動鏈接MongoDB是一件非常簡單的事情，簡單的引用，簡單的做增刪改查。在使用完java驅動後我才發現spring 對MongoDB 的封裝還不如官方自身提供出來的東西好用，下面簡單的展示一下使用。

1.使用maven引入jar包

 <dependency>
<groupId>org.mongodbgroupId>
<artifactId>mongodb-driver-syncartifactId>
<version>3.8.0-beta3version>
dependency>

2.創建一個訪問客戶端

MongoClient client = MongoClients.create(“mongodb://10.201.76.94:27017”);

3.獲取集合數量

public long count {
MongoClient client = this.getClient;
MongoCollection
return collections.count;
}

4.查詢集合

public List
MongoClient client = this.getClient;
MongoCollection
List
collections.find(params).sort(sort).skip(skip).limit(limit).forEach(new Block
@Override
public void apply(Document document) {
list.add(document);
}
});
return list;
}

這裡只舉例了簡單的鏈接與簡單的MongoDB操作，可見其操作的容易性。使用驅動時是基於TCP套接字與MongoDB進行通信的，如果查詢結果較多，恰好無法全部放進第一服務器中，將會向服務器發送一個getmore指令獲取下一批查詢結果。

插入數據到服務器時間，不會等待服務器的響應，驅動會假設寫入是成功的，實際是使用客戶端生成對象id，但是該行為可以通過配置配置，可以通過安全模式開啟，安全模式可以校驗服務器端插入的錯誤。

四、schema 設計原則

1.需要關注MongoDB的自身的特性

要清楚瞭解MongoDB的基本數據單元。在關係型數據庫中有帶列和行的數據表。而MongoDB數據的基本單元是BSON文檔，在鍵值中有指向不定類型值的鍵，MongoDB擁有即時查詢，但不支持聯結操作，簡單的鍵值存儲只能根據單個鍵來獲取值，不支持事務，但支持多種原子更新操作。

2.需要關注系統本身的讀寫特性

如讀寫比是怎樣的，需要何種查詢，數據是如何更新的，會不會存在什麼併發問題，數據結構化的程度是要求高還是低。系統本身的需求決定mysql還是MongoDB。

3.關注MongoDB schema 的設計模式

• 內嵌與引用：當子對象總是出現在父對象的上下文中時，使用內嵌文檔；否則將子對象單獨存一個集合。
• 一對多的關係：在“多”的集合關係中添加id指向依賴的id。
• 多對多：在其中一種對應關係中使用對象數組指向另外一個對象。
• 樹：具化路徑，在樹中的每個節點都包含一個path字段，該字段具體保存了每個節點祖先的id。
• 動態屬性：可以為不同的動態屬性添加索引，如果需要將屬性圈在一個範圍，那麼可以通過key-value的方式，然後在統一的key上面加索引。
• 關於事務：如果需要事務支持，那麼只能選擇另一種數據庫，或者提供補償性事務來解決事務的問題。

在關於schema 的設計中要注意一些原則，比如：

• 不能創建沒用的索引

• 不能在同一個字段中存不同的類型

• 不能把多類實體都放在一個集合裡 不能創建體積大、嵌套深的文檔

• 不能過多的創建集合，集合、索引、數據庫的命名空間都是有限的

• 不能創建無法分片的集合

4.關注MongoDB裡面一些具體細節

數據庫是集合的邏輯與物理分組，MongoDB沒有提供創建數據庫的語法，只有在插入集合時，數據庫才開始建立。創建數據庫後會在磁盤分配一組數據文件，所有集合、索引和數據庫的其他元數據都保存在這些文件中，查閱數據庫使用磁盤狀態可通過。

db.stats

（2）關注集合概念

集合是結構上或概念上相似得文檔的容器，集合的名稱可以包含數字、字母或 . 符號，但必須以字母或數字開頭，完全。

限定集合名不能超過128個字符，實際上 . 符號在集合中很有用，能提供某種虛擬命名空間，這是一種組織上的原則，和其他集合是一視同仁的。在集合中可以使用。

system.namespaces //查詢當前數據庫中定義的所有命名空間
system.indexes //存儲當前數據庫的所有索引定義

（3）關注文檔

其次是鍵值，在MongoDB裡面所有的字符串都是UTF-8類型。數字類型包括double、int、long。日期類型都是UTC格式，所以在MongoDB裡面看到的時間會比北京時間慢8小時。整個文檔大小會限制在16m以內，因為這樣可以防止創建難看的數據類型，且小文檔可以提升性能，批量插入文檔理想數字範圍是10~200，大小不能超過16MB。

五、索引與查詢優化

1.索引的經驗法則

（2）解析查詢時MongoDB通過最優計劃選擇一個索引進行查詢，當沒有最適合索引時，會先不同的使用各個索引進行查詢，最終選出一個最優索引做查詢

（3）如果有一個a-b的複合索引，那麼僅針對a的索引是冗餘的

（4）複合索引裡的鍵的順序是很重要的

2.索引類型

（2）複合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段會出現的值，或是大量文檔都不包含被索引的鍵。

3.索引的構建問題

如果數據集很大時，構建索引將會花費很長的時間，且會影響程序性能，可通過

db.currentOp //查看索引的構建時間

當使用 mongorestore 時會重新構建索引。當曾經執行過大規模的刪除時，可使用

db.values.reIndex 

對索引進行壓縮，重建。

4.識別慢查詢

（1）查閱慢查詢日誌

grep -E '([0-9])+ms' mongod.log //使用grep 命令 識別命令信息

db.setProfillingLevel(2) //使用解刨器，將記錄每次的讀寫到日誌

db.setProfillingLevel(1) //只記錄慢（100ms）操作

（2）分析慢查詢

db.values.find({}).sort({close:-1}).limit(1).explain

• scanOrder 字段表明沒有使用索引

• cursor當沒有索引時，用的是BasicCursor，當使用索引時使用的是BtreeCursor

• n 表示需要返回的結果集

• nscanned表示需要遍歷的文檔數 indexBounds 表示索引邊界

注意新版本的MongoDB 的explain方法是需要參數的，不然只顯示普通的信息。

六、MongoDB副本集

本節同樣主要簡單呈現MongoDB副本集搭建的簡易性，與副本集的強壯性，監控容易性

1.為什麼要使用副本集

提供主從複製能力，熱備能力，故障轉移能力

2.構建方式

rs.initiate
rs.add("localhost:40001")
rs.add("localhost:40002",{arbiterOnly:true})

3.監控

db.isMasrter
rs.status

4.副本集的工作原理

實際上MongoDB對副本集的操作跟mysql主從操作是差不多的，先看一下mysql的主從數據流動過程

主binlog -> 從relay.log -> 從bin.log -> 從數據庫

而MongoDB主要依賴的日誌文件是oplog

主oplog -> 從oplog

寫操作先被記錄下來，添加到主節點的oplog裡。與此同時，所有從結點複製oplog。首先，查看自己oplog裡最後一條的時間戳；其次，查詢主節點oplog裡所有大於此時間戳的條目;最後，把那些條目添加到自己的oplog裡並應用到自己的庫裡。從節點使用長輪詢立即應用來自主結點oplog的新條目。

當遇到以下情況，從節點會停止複製

• 如果從節點在主節點的oplog裡找不到它所同步的點，那麼會永久停止複製

• 一旦某個從節點沒能 在主節點的oplog裡找到它已經同步的點，就無法再保證這個從結點的完美副本

local數據庫保存了所有副本集元素據和oplog日誌

• replset.minvalid 包含指定副本集成員的初始化同步信息

• system.replset 保存在副本集配置文檔

• system.indexes 標準索引說明容器

• me slaves 主要用於寫關注

可以使用以下命令查看複製情況

db.oplog.rs.findOne

• ts 保存了該條目的BSON時間戳

• t 是從紀元開始的描述

• i是計數器

• op 表示操作碼

• ns 標明瞭有關的命名空間

5.心跳檢測

每個副本集成員每秒鐘ping一次其他所有成員，可以通過rs.status看到節點上次的心跳檢測時間戳和健康狀況。

6.故障轉移

這個點沒必要過多描述，但是有一個特殊場景，如果從節點和仲裁節點都被殺了，只剩下主節點，他會把自己降級成為從節點。

7.提交與回滾

如果主節點的數據還沒有寫到從庫，那麼數據不能算提交，當該主節點變成從節點時，便會觸發回滾，那些沒寫到從庫的數據將會被刪除，可以通過rollback子目錄中的BSON文件恢復回滾的內容。

8.驅動與複製

只能鏈接到主節點，如果鏈接到從節點的話，會被拒絕寫入操作，但是如果沒有使用安全模式，因為mongo的fire and forget 特性，會把拒絕寫入的異常給吃掉。

（2）使用副本集方式鏈接

能根據寫入的情況自動進行故障轉移，但是當副本集進行新的選舉時，還是會出現故障，如果不使用安全模式，依舊會出現寫不進去，但現實成功的情況。

（3）寫關注

可以使用寫關注來關注數據是否已經被寫入MongoDB的庫中，使用寫關注會消耗性能，需要在速度和持久性之間做出權衡。

七、分片

分片是數據庫切分的一個概念實現，這裡也是簡單總結為什麼要使用分片以及分片的原理，操作。

1.為什麼需要分片

當數據量過大，索引和工作數據集佔用的內存就會越來越多，所以需要通過分片負載來解決這個問題

2.分片的工作原理

• 分片：每個分片都是一個副本集

• mongos路由器：是一個路由器，將讀寫請求指引到合適的分片上

• 配置服務器config：持久化分片集群的元數據，包括：全局集群配置；每個數據庫、集合和特定範圍數據位置；一份變更記錄，保存了數據在分片之間進行遷移的歷史信息。配置服務器之間不是副本集形式存在，mongos向配置服務器提交信息時是兩階段提交，保證配置服務器之間的一致性。

（2）分片的核心操作

分片一個集合：分片是根據一個屬性的範圍進行劃分的，MongoDB使用所謂的分片鍵讓每個文檔在這些範圍裡找到自己的位置

塊：是位於一個分片中的一段連續的分片鍵範圍，可以理解為若干個塊組成分片，分片組成MongoDB的全部數據

（3）拆分與遷移

塊的拆分：初始化時只有一個塊，達到最大塊尺寸64MB或100000個文檔就會觸發塊的拆分。把原來的範圍一分為二，這樣就有了兩個塊，每個塊都有相同數量的文檔。

遷移：當分片中的數據大小不一時會產生遷移的動作，比如分片A的數據比較多，會將分片A裡面的一些塊轉移到分片B裡面去。分片集群通過在分片中移動塊來實現均衡，是由名為均衡器的軟件進程管理的，任務是確保數據在各個分片中保持均勻分佈，當集群中擁有塊最多的分片與擁有塊最少分片的塊差大於8時，均衡器就會發起一次均衡處理。

3.分片實戰

啟動兩個副本集、三個配置服務器、一個mongos進程

配置分片

sh.help //查看分片相關幫助
sh.addShard //添加分片
db,getSiblingDB("config").shards.find //查看分片列表
sh.status //分片詳情
sh.enableSharding("cloud-docs") //開啟一個數據庫上的分片
db.getSiblingDB("config").databases,find //查看數據庫列表
sh.shardCollection("cloud-docs.spreadsheets",{username:1,_id:1}) //使用一個分片鍵定義一個分片集合spreadsheets，根據用戶名進行切分
sh.getSiiblingDB("config").collections.findOne //查看集合列表
db.chunks.count //查看塊的個數
db.chunks.findOne //查看塊的信息
db.changelog.count(}what:"split"|) //查看塊切分日誌
db.changelog.find({what:"moveChunk.commit"}).count //查看日誌遷移記錄

4.分片的查詢與索引

• 針對性查詢：查詢包含分片鍵

• 全局查詢或分散/聚集查：查詢不包含分片鍵

• 查詢過程：通過分片鍵將查詢路由給指定分片，一旦到了某個分片上，由分片自行決定使用哪個索引來執行該查詢

（2）索引

每個分片都維護了自己的索引，當在分片集合上聲明索引時，每個分片都會為它那部分集合構建獨立的索引，每個分片上的分片集合都應該擁有相同的索引。

分片集合只允許在_id字段和分片鍵上添加唯一性索引，其他地方不行，因為這需要在分片間進行通信，實施起來很複雜。

當創建分片時，會根據分片鍵創建一個索引。

5.選擇分片鍵

（2）低效的分片鍵

• 分佈性差：如使用BSON對象ID，那麼會導致所有最新插入的文檔都會落到某個很小的連續範圍，無法分散插入

• 缺乏局部性：升序分片鍵有明確的方向，完全隨機的分片鍵則根本沒有方向。前者無法分散插入，後者插入分散，如使用MD5作為分片鍵

（3）理想的分片鍵

• 將插入數據均勻分佈到各個分片上

• 保證CRUD操作能夠利用局部性 有足夠的粒度進行塊拆分

• 滿足這些要求的分片鍵通常由兩個字段組成，第一個是粗粒度的，第二個粒度較細

6.生產環境中的分片

• 複製mongod：需要獨立的部署服務器

• 配置服務器：配置服務器不需要有自己的機器

根據不同的數據中心劃分

（2）最低要求

• 副本集每個成員，無論是完整的副本集節點還是仲裁節點，都需要放在不同的機器上 每個用於複製的副本集成員都需要有自己的機器

• 副本集仲裁節點很輕量級，和其他進程共用一臺機器即可

• 配置服務器也可以選擇與其他進程共用一臺機器

（3）配置的注意事項

需要估計集群大小，可使用以下命令對現有集合進行分片處理

sh.splitAt("cloud-docs.spreadsheets",{"username":"chen","_id":ObjectId("")})
//手動拆分塊
sh.moveChunk("cloud-docs.spreadsheets",{username:"chen"},"shardB")
//手動將某分塊移至分片B
db.runCommand({removeshard:"shard-1/arete:30100,arete:30101"})
//刪除分片
db.runCommand({moveprimary:"test",to:"shard-0-test-rs"});
//移動主分片

（4）備份分片集群

備份分片時需要停止均衡器

db.settings.update({_id:"ba;ancer"},{$set:{stopped:true},true});
sh.setBalancerState(false)；
//停止均衡器，此時均衡器將進行最後一輪均衡

db.locks.find({_id:"balancer"});
sh.isBalancerRunning;
//查看均衡器狀態，任何狀態大於0 的狀態值都說明均衡器仍在進行中

八、部署與管理

1.部署

使用64位機器、32位機器會制約mongodb的內存，使其最大值為1.5GB

（2）cpumongodb 只有當索引和工作集都可放入內存時，才會遇到CPU瓶頸，CPU在mongodb使用中的作用是用來檢索數據，如果看到CPU使用飽和的情況，可以通過查詢慢查詢日誌，排查是不是查詢的問題導致的，如果是可以通過添加索引來解決問題

mongodb寫入數據時會使用到CPU，但是mongodb寫入時間一次只用到一個核，如果有頻繁的寫入行為，可以通過分片來解決這個問題（3）內存

大內存是mongodb的保障，如果工作集大小超過內存，將會導致性能下降，因為這將會增加數據加載入內存的動作

（4）硬盤

mongodb默認每60s會與磁盤強制同步一次，稱為後臺刷新，會產生I/O操作。在重啟時mongodb會將磁盤裡面的數據加載至內存，高速磁盤將會減少同步的時間

（5）文件系統

使用ext4 和 xfs 文件系統

禁用最後訪問時間

vim /etc/fstab

（6）文件描述符

linux 默認文件描述符是1024，需要大額度的提升這個額度

（7）時鐘

mongodb各個節點服務器之間使用ntp服務器

2.安全

啟動時使用 - -bind_ip 命令

（2）身份驗證

啟動時使用 - -auth 命令

db.addUser("","",true)
//創建用戶，最後一個參數指定是否只讀

（3）副本集身份認證

使用keyFile，注意keyFile文件的權限必須是600，不然會啟動不起來

3.數據的導入與導出

mongoimport
mongoexport

4.服務器配置

搭建副本集至少需要兩個節點，其中仲裁結點不需要有自己的服務器

（2）Journaling日誌寫數據時會先寫入日誌，而此時的數據也不是直接寫入硬盤，而是寫入內存

但是Journaling日誌會消耗內存，所以可以在主庫上面關閉，在從庫上面啟動

可以單獨為Journaling日誌使用一塊固態硬盤

在插入時，可以通過驅動確保Journaling插入後再反饋，但是會非常影響性能。

5.日誌

-vvvvv 選項（v越多，輸出越詳細）

db.runCommand({logrotare:1}) 開啟滾動日誌

6.數據庫監控命令

• globalLock 表示服務器花在寫鎖上面的總時間

• mem顯示瞭如何使用內存

• bits 表明這臺機器的位長

• resident 表示佔用物理內存數量

• virtual 表示使用的虛擬內存

（2）top

點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

鏈接 | blog.csdn.net/hayre/article/details/80628431

1.MongoDB是什麼？用一句話總結

MongoDB是一款為web應用程序和互聯網基礎設施設計的數據庫管理系統。沒錯MongoDB就是數據庫，是NoSQL類型的數據庫。

2.為什麼要使用MongoDB？

（1）MongoDB提出的是文檔、集合的概念，使用BSON（類JSON）作為其數據模型結構，其結構是面向對象的而不是二維表，存儲一個用戶在MongoDB中是這樣子的。

｛
username:'123',
password:'123'
｝

使用這樣的數據模型，使得MongoDB能在生產環境中提供高讀寫的能力，吞吐量較於mysql等SQL數據庫大大增強。

（2）易伸縮，自動故障轉移。易伸縮指的是提供了分片能力，能對數據集進行分片，數據的存儲壓力分攤給多臺服務器。自動故障轉移是副本集的概念，MongoDB能檢測主節點是否存活，當失活時能自動提升從節點為主節點，達到故障轉移。

（3）數據模型因為是面向對象的，所以可以表示豐富的、有層級的數據結構，比如博客系統中能把“評論”直接懟到“文章“的文檔中，而不必像myqsl一樣創建三張表來描述這樣的關係。

3.主要特性

（1）文檔數據類型

SQL類型的數據庫是正規化的，可以通過主鍵或者外鍵的約束保證數據的完整性與唯一性，所以SQL類型的數據庫常用於對數據完整性較高的系統。MongoDB在這一方面是不如SQL類型的數據庫，且MongoDB沒有固定的Schema，正因為MongoDB少了一些這樣的約束條件，可以讓數據的存儲數據結構更靈活，存儲速度更加快。（2）即時查詢能力

MongoDB保留了關係型數據庫即時查詢的能力，保留了索引（底層是基於B tree）的能力。這一點汲取了關係型數據庫的優點，相比於同類型的NoSQL redis 並沒有上述的能力。（3）複製能力

MongoDB自身提供了副本集能將數據分佈在多臺機器上實現冗餘，目的是可以提供自動故障轉移、擴展讀能力。（4）速度與持久性

MongoDB的驅動實現一個寫入語義 fire and forget ，即通過驅動調用寫入時，可以立即得到返回得到成功的結果（即使是報錯），這樣讓寫入的速度更加快，當然會有一定的不安全性，完全依賴網絡。

MongoDB提供了Journaling日誌的概念，實際上像mysql的bin-log日誌，當需要插入的時候會先往日誌裡面寫入記錄，再完成實際的數據操作，這樣如果出現停電，進程突然中斷的情況，可以保障數據不會錯誤，可以通過修復功能讀取Journaling日誌進行修復。

（5）數據擴展

MongoDB使用分片技術對數據進行擴展，MongoDB能自動分片、自動轉移分片裡面的數據塊，讓每一個服務器裡面存儲的數據都是一樣大小。

4.C/S服務模型

MongoDB核心服務器主要是通過mongod程序啟動的，而且在啟動時不需對MongoDB使用的內存進行配置，因為其設計哲學是內存管理最好是交給操作系統，缺少內存配置是MongoDB的設計亮點，另外，還可通過mongos路由服務器使用分片功能。

MongoDB的主要客戶端是可以交互的js shell 通過mongo啟動，使用js shell能使用js直接與MongoDB進行交流，像使用sql語句查詢mysql數據一樣使用js語法查詢MongoDB的數據，另外還提供了各種語言的驅動包，方便各種語言的接入。

5.完善的命令行工具

mongodump和mongorestore,備份和恢復數據庫的標準工具。輸出BSON格式，遷移數據庫。

mongoexport和mongoimport，用來導入導出JSON、CSV和TSV數據，數據需要支持多格式時有用。mongoimport還能用與大數據集的初始導入，但是在導入前順便還要注意一下，為了能充分利用好mongoDB通常需要對數據模型做一些調整。

mongosniff,網絡嗅探工具，用來觀察發送到數據庫的操作。基本就是把網絡上傳輸的BSON轉換為易於人們閱讀的shell語句。

因此，可以總結得到，MongoDB結合鍵值存儲和關係數據庫的最好特性。因為簡單，所以數據極快，而且相對容易伸縮還提供複雜查詢機制的數據庫。MongoDB需要跑在64位的服務器上面，且最好單獨部署，因為是數據庫，所以也需要對其進行熱備、冷備處理。

二、進入MongoDB shell

因為本篇文章不是API手冊，所有這裡對shell的使用也是基礎的介紹什麼功能可以用什麼語句，主要是為了展示使用MongoDB shell的方便性，如果需要知道具體的MongoDB shell語法可以查閱官方文檔。

1.切換數據庫

use dba

創建數據庫並不是必須的操作，數據庫與集合只有在第一次插入文檔時才會被創建，與對數據的動態處理方式是一致的。簡化並加速開發過程，而且有利於動態分配命名空間。如果擔心數據庫或集合被意外創建，可以開啟嚴格模式。

2.插入語法

db.users.insert({username:"smith"})
db.users.save({username:"smith"})

• 區別:若新增的數據中存在主鍵 ，insert 會提示錯誤，而save 則更改原來的內容為新內容。如：
  已存在數據：{_id : 1, " name " : " n1 " }，再次進行插入操作時，insert({_id : 1, " name " : " n2 " }) 會報主鍵重複的錯誤提示，save({ _id : 1, " name " : " n2 " }) 會把 n1 修改為 n2 。
• 相同點：若新增的數據中沒有主鍵時，會增加一條記錄。已存在數據：{ _id : 1, " name " : " n1 " }，再次進行插入操作時，insert({ " name " : " n2 " }) 插入的數據因為沒有主鍵，所以會增加一條數據，save({ " name " : " n2 " }) 增加一條數據。

3.查找語法

db.users.find
db.users.count

4.更新語法

db.users.update({username:"smith"},{$set:{country:"Canada"}})
//把用戶名為smith的用戶的國家改成Canada

db.users.update({username:"smith"},{$unset:{country:1}})
//把用戶名為smith的用戶的國家字段給移除

db.users.update({username:"jones"},{$set:{favorites:{movies:["casablance","rocky"]}}})
//這裡主要體現多值修改，在favorties字段中添加多個值

db.users.update({"favorites.movies":"casablance"},{$addToSet:{favorites.movies:"the maltese"}},false,true)
//多項更新

5.刪除語法

db.foo.remove //刪除所有數據
db.foo.remove({favorties.cities:"cheyene"}) //根據條件進行刪除
db.drop //刪除整個集合

6.索引相關語法

db.numbers.ensureIndex({num:1})
//創建一個升序索引
db.numbers.getIndexes
//獲取全部索引

7.基本管理語法

show dbs
//查詢所有數據庫
show collections
//顯示所有表
db.stats
//顯示數據庫狀態信息
db.numbers.stats
//顯示集合表狀態信息
db,shutdownServer
//停止數據庫
db.help
//獲取數據庫操作命令
db.foo.help
//獲取表操作命令
tab 鍵 //能自動幫我們補全命令

以上的命令只是簡單實例，假設如果你之前沒有學習過任何數據庫語法，同時開始學sql查詢語法和MongoDB 查詢語法，你會發現哪一個更簡單呢？如果你使用的是java驅動去操作MongoDB，你會發現任何的查詢都像Hibernate提供出來的查詢方式一樣，只要構建好一個查詢條件對象，便能輕鬆查詢（接下來會給出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成沒問題，也正因為這樣簡潔，完善的查詢機制，深深的愛上了MongoDB。

三、使用java驅動

使用java驅動鏈接MongoDB是一件非常簡單的事情，簡單的引用，簡單的做增刪改查。在使用完java驅動後我才發現spring 對MongoDB 的封裝還不如官方自身提供出來的東西好用，下面簡單的展示一下使用。

1.使用maven引入jar包

 <dependency>
<groupId>org.mongodbgroupId>
<artifactId>mongodb-driver-syncartifactId>
<version>3.8.0-beta3version>
dependency>

2.創建一個訪問客戶端

MongoClient client = MongoClients.create(“mongodb://10.201.76.94:27017”);

3.獲取集合數量

public long count {
MongoClient client = this.getClient;
MongoCollection
return collections.count;
}

4.查詢集合

public List
MongoClient client = this.getClient;
MongoCollection
List
collections.find(params).sort(sort).skip(skip).limit(limit).forEach(new Block
@Override
public void apply(Document document) {
list.add(document);
}
});
return list;
}

這裡只舉例了簡單的鏈接與簡單的MongoDB操作，可見其操作的容易性。使用驅動時是基於TCP套接字與MongoDB進行通信的，如果查詢結果較多，恰好無法全部放進第一服務器中，將會向服務器發送一個getmore指令獲取下一批查詢結果。

插入數據到服務器時間，不會等待服務器的響應，驅動會假設寫入是成功的，實際是使用客戶端生成對象id，但是該行為可以通過配置配置，可以通過安全模式開啟，安全模式可以校驗服務器端插入的錯誤。

四、schema 設計原則

1.需要關注MongoDB的自身的特性

要清楚瞭解MongoDB的基本數據單元。在關係型數據庫中有帶列和行的數據表。而MongoDB數據的基本單元是BSON文檔，在鍵值中有指向不定類型值的鍵，MongoDB擁有即時查詢，但不支持聯結操作，簡單的鍵值存儲只能根據單個鍵來獲取值，不支持事務，但支持多種原子更新操作。

2.需要關注系統本身的讀寫特性

如讀寫比是怎樣的，需要何種查詢，數據是如何更新的，會不會存在什麼併發問題，數據結構化的程度是要求高還是低。系統本身的需求決定mysql還是MongoDB。

3.關注MongoDB schema 的設計模式

• 內嵌與引用：當子對象總是出現在父對象的上下文中時，使用內嵌文檔；否則將子對象單獨存一個集合。
• 一對多的關係：在“多”的集合關係中添加id指向依賴的id。
• 多對多：在其中一種對應關係中使用對象數組指向另外一個對象。
• 樹：具化路徑，在樹中的每個節點都包含一個path字段，該字段具體保存了每個節點祖先的id。
• 動態屬性：可以為不同的動態屬性添加索引，如果需要將屬性圈在一個範圍，那麼可以通過key-value的方式，然後在統一的key上面加索引。
• 關於事務：如果需要事務支持，那麼只能選擇另一種數據庫，或者提供補償性事務來解決事務的問題。

在關於schema 的設計中要注意一些原則，比如：

• 不能創建沒用的索引

• 不能在同一個字段中存不同的類型

• 不能把多類實體都放在一個集合裡 不能創建體積大、嵌套深的文檔

• 不能過多的創建集合，集合、索引、數據庫的命名空間都是有限的

• 不能創建無法分片的集合

4.關注MongoDB裡面一些具體細節

數據庫是集合的邏輯與物理分組，MongoDB沒有提供創建數據庫的語法，只有在插入集合時，數據庫才開始建立。創建數據庫後會在磁盤分配一組數據文件，所有集合、索引和數據庫的其他元數據都保存在這些文件中，查閱數據庫使用磁盤狀態可通過。

db.stats

（2）關注集合概念

集合是結構上或概念上相似得文檔的容器，集合的名稱可以包含數字、字母或 . 符號，但必須以字母或數字開頭，完全。

限定集合名不能超過128個字符，實際上 . 符號在集合中很有用，能提供某種虛擬命名空間，這是一種組織上的原則，和其他集合是一視同仁的。在集合中可以使用。

system.namespaces //查詢當前數據庫中定義的所有命名空間
system.indexes //存儲當前數據庫的所有索引定義

（3）關注文檔

其次是鍵值，在MongoDB裡面所有的字符串都是UTF-8類型。數字類型包括double、int、long。日期類型都是UTC格式，所以在MongoDB裡面看到的時間會比北京時間慢8小時。整個文檔大小會限制在16m以內，因為這樣可以防止創建難看的數據類型，且小文檔可以提升性能，批量插入文檔理想數字範圍是10~200，大小不能超過16MB。

五、索引與查詢優化

1.索引的經驗法則

（2）解析查詢時MongoDB通過最優計劃選擇一個索引進行查詢，當沒有最適合索引時，會先不同的使用各個索引進行查詢，最終選出一個最優索引做查詢

（3）如果有一個a-b的複合索引，那麼僅針對a的索引是冗餘的

（4）複合索引裡的鍵的順序是很重要的

2.索引類型

（2）複合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段會出現的值，或是大量文檔都不包含被索引的鍵。

3.索引的構建問題

如果數據集很大時，構建索引將會花費很長的時間，且會影響程序性能，可通過

db.currentOp //查看索引的構建時間

當使用 mongorestore 時會重新構建索引。當曾經執行過大規模的刪除時，可使用

db.values.reIndex 

對索引進行壓縮，重建。

4.識別慢查詢

（1）查閱慢查詢日誌

grep -E '([0-9])+ms' mongod.log //使用grep 命令 識別命令信息

db.setProfillingLevel(2) //使用解刨器，將記錄每次的讀寫到日誌

db.setProfillingLevel(1) //只記錄慢（100ms）操作

（2）分析慢查詢

db.values.find({}).sort({close:-1}).limit(1).explain

• scanOrder 字段表明沒有使用索引

• cursor當沒有索引時，用的是BasicCursor，當使用索引時使用的是BtreeCursor

• n 表示需要返回的結果集

• nscanned表示需要遍歷的文檔數 indexBounds 表示索引邊界

注意新版本的MongoDB 的explain方法是需要參數的，不然只顯示普通的信息。

六、MongoDB副本集

本節同樣主要簡單呈現MongoDB副本集搭建的簡易性，與副本集的強壯性，監控容易性

1.為什麼要使用副本集

提供主從複製能力，熱備能力，故障轉移能力

2.構建方式

rs.initiate
rs.add("localhost:40001")
rs.add("localhost:40002",{arbiterOnly:true})

3.監控

db.isMasrter
rs.status

4.副本集的工作原理

實際上MongoDB對副本集的操作跟mysql主從操作是差不多的，先看一下mysql的主從數據流動過程

主binlog -> 從relay.log -> 從bin.log -> 從數據庫

而MongoDB主要依賴的日誌文件是oplog

主oplog -> 從oplog

寫操作先被記錄下來，添加到主節點的oplog裡。與此同時，所有從結點複製oplog。首先，查看自己oplog裡最後一條的時間戳；其次，查詢主節點oplog裡所有大於此時間戳的條目;最後，把那些條目添加到自己的oplog裡並應用到自己的庫裡。從節點使用長輪詢立即應用來自主結點oplog的新條目。

當遇到以下情況，從節點會停止複製

• 如果從節點在主節點的oplog裡找不到它所同步的點，那麼會永久停止複製

• 一旦某個從節點沒能 在主節點的oplog裡找到它已經同步的點，就無法再保證這個從結點的完美副本

local數據庫保存了所有副本集元素據和oplog日誌

• replset.minvalid 包含指定副本集成員的初始化同步信息

• system.replset 保存在副本集配置文檔

• system.indexes 標準索引說明容器

• me slaves 主要用於寫關注

可以使用以下命令查看複製情況

db.oplog.rs.findOne

• ts 保存了該條目的BSON時間戳

• t 是從紀元開始的描述

• i是計數器

• op 表示操作碼

• ns 標明瞭有關的命名空間

5.心跳檢測

每個副本集成員每秒鐘ping一次其他所有成員，可以通過rs.status看到節點上次的心跳檢測時間戳和健康狀況。

6.故障轉移

這個點沒必要過多描述，但是有一個特殊場景，如果從節點和仲裁節點都被殺了，只剩下主節點，他會把自己降級成為從節點。

7.提交與回滾

如果主節點的數據還沒有寫到從庫，那麼數據不能算提交，當該主節點變成從節點時，便會觸發回滾，那些沒寫到從庫的數據將會被刪除，可以通過rollback子目錄中的BSON文件恢復回滾的內容。

8.驅動與複製

只能鏈接到主節點，如果鏈接到從節點的話，會被拒絕寫入操作，但是如果沒有使用安全模式，因為mongo的fire and forget 特性，會把拒絕寫入的異常給吃掉。

（2）使用副本集方式鏈接

能根據寫入的情況自動進行故障轉移，但是當副本集進行新的選舉時，還是會出現故障，如果不使用安全模式，依舊會出現寫不進去，但現實成功的情況。

（3）寫關注

可以使用寫關注來關注數據是否已經被寫入MongoDB的庫中，使用寫關注會消耗性能，需要在速度和持久性之間做出權衡。

七、分片

分片是數據庫切分的一個概念實現，這裡也是簡單總結為什麼要使用分片以及分片的原理，操作。

1.為什麼需要分片

當數據量過大，索引和工作數據集佔用的內存就會越來越多，所以需要通過分片負載來解決這個問題

2.分片的工作原理

• 分片：每個分片都是一個副本集

• mongos路由器：是一個路由器，將讀寫請求指引到合適的分片上

• 配置服務器config：持久化分片集群的元數據，包括：全局集群配置；每個數據庫、集合和特定範圍數據位置；一份變更記錄，保存了數據在分片之間進行遷移的歷史信息。配置服務器之間不是副本集形式存在，mongos向配置服務器提交信息時是兩階段提交，保證配置服務器之間的一致性。

（2）分片的核心操作

分片一個集合：分片是根據一個屬性的範圍進行劃分的，MongoDB使用所謂的分片鍵讓每個文檔在這些範圍裡找到自己的位置

塊：是位於一個分片中的一段連續的分片鍵範圍，可以理解為若干個塊組成分片，分片組成MongoDB的全部數據

（3）拆分與遷移

塊的拆分：初始化時只有一個塊，達到最大塊尺寸64MB或100000個文檔就會觸發塊的拆分。把原來的範圍一分為二，這樣就有了兩個塊，每個塊都有相同數量的文檔。

遷移：當分片中的數據大小不一時會產生遷移的動作，比如分片A的數據比較多，會將分片A裡面的一些塊轉移到分片B裡面去。分片集群通過在分片中移動塊來實現均衡，是由名為均衡器的軟件進程管理的，任務是確保數據在各個分片中保持均勻分佈，當集群中擁有塊最多的分片與擁有塊最少分片的塊差大於8時，均衡器就會發起一次均衡處理。

3.分片實戰

啟動兩個副本集、三個配置服務器、一個mongos進程

配置分片

sh.help //查看分片相關幫助
sh.addShard //添加分片
db,getSiblingDB("config").shards.find //查看分片列表
sh.status //分片詳情
sh.enableSharding("cloud-docs") //開啟一個數據庫上的分片
db.getSiblingDB("config").databases,find //查看數據庫列表
sh.shardCollection("cloud-docs.spreadsheets",{username:1,_id:1}) //使用一個分片鍵定義一個分片集合spreadsheets，根據用戶名進行切分
sh.getSiiblingDB("config").collections.findOne //查看集合列表
db.chunks.count //查看塊的個數
db.chunks.findOne //查看塊的信息
db.changelog.count(}what:"split"|) //查看塊切分日誌
db.changelog.find({what:"moveChunk.commit"}).count //查看日誌遷移記錄

4.分片的查詢與索引

• 針對性查詢：查詢包含分片鍵

• 全局查詢或分散/聚集查：查詢不包含分片鍵

• 查詢過程：通過分片鍵將查詢路由給指定分片，一旦到了某個分片上，由分片自行決定使用哪個索引來執行該查詢

（2）索引

每個分片都維護了自己的索引，當在分片集合上聲明索引時，每個分片都會為它那部分集合構建獨立的索引，每個分片上的分片集合都應該擁有相同的索引。

分片集合只允許在_id字段和分片鍵上添加唯一性索引，其他地方不行，因為這需要在分片間進行通信，實施起來很複雜。

當創建分片時，會根據分片鍵創建一個索引。

5.選擇分片鍵

（2）低效的分片鍵

• 分佈性差：如使用BSON對象ID，那麼會導致所有最新插入的文檔都會落到某個很小的連續範圍，無法分散插入

• 缺乏局部性：升序分片鍵有明確的方向，完全隨機的分片鍵則根本沒有方向。前者無法分散插入，後者插入分散，如使用MD5作為分片鍵

（3）理想的分片鍵

• 將插入數據均勻分佈到各個分片上

• 保證CRUD操作能夠利用局部性 有足夠的粒度進行塊拆分

• 滿足這些要求的分片鍵通常由兩個字段組成，第一個是粗粒度的，第二個粒度較細

6.生產環境中的分片

• 複製mongod：需要獨立的部署服務器

• 配置服務器：配置服務器不需要有自己的機器

根據不同的數據中心劃分

（2）最低要求

• 副本集每個成員，無論是完整的副本集節點還是仲裁節點，都需要放在不同的機器上 每個用於複製的副本集成員都需要有自己的機器

• 副本集仲裁節點很輕量級，和其他進程共用一臺機器即可

• 配置服務器也可以選擇與其他進程共用一臺機器

（3）配置的注意事項

需要估計集群大小，可使用以下命令對現有集合進行分片處理

sh.splitAt("cloud-docs.spreadsheets",{"username":"chen","_id":ObjectId("")})
//手動拆分塊
sh.moveChunk("cloud-docs.spreadsheets",{username:"chen"},"shardB")
//手動將某分塊移至分片B
db.runCommand({removeshard:"shard-1/arete:30100,arete:30101"})
//刪除分片
db.runCommand({moveprimary:"test",to:"shard-0-test-rs"});
//移動主分片

（4）備份分片集群

備份分片時需要停止均衡器

db.settings.update({_id:"ba;ancer"},{$set:{stopped:true},true});
sh.setBalancerState(false)；
//停止均衡器，此時均衡器將進行最後一輪均衡

db.locks.find({_id:"balancer"});
sh.isBalancerRunning;
//查看均衡器狀態，任何狀態大於0 的狀態值都說明均衡器仍在進行中

八、部署與管理

1.部署

使用64位機器、32位機器會制約mongodb的內存，使其最大值為1.5GB

（2）cpumongodb 只有當索引和工作集都可放入內存時，才會遇到CPU瓶頸，CPU在mongodb使用中的作用是用來檢索數據，如果看到CPU使用飽和的情況，可以通過查詢慢查詢日誌，排查是不是查詢的問題導致的，如果是可以通過添加索引來解決問題

mongodb寫入數據時會使用到CPU，但是mongodb寫入時間一次只用到一個核，如果有頻繁的寫入行為，可以通過分片來解決這個問題（3）內存

大內存是mongodb的保障，如果工作集大小超過內存，將會導致性能下降，因為這將會增加數據加載入內存的動作

（4）硬盤

mongodb默認每60s會與磁盤強制同步一次，稱為後臺刷新，會產生I/O操作。在重啟時mongodb會將磁盤裡面的數據加載至內存，高速磁盤將會減少同步的時間

（5）文件系統

使用ext4 和 xfs 文件系統

禁用最後訪問時間

vim /etc/fstab

（6）文件描述符

linux 默認文件描述符是1024，需要大額度的提升這個額度

（7）時鐘

mongodb各個節點服務器之間使用ntp服務器

2.安全

啟動時使用 - -bind_ip 命令

（2）身份驗證

啟動時使用 - -auth 命令

db.addUser("","",true)
//創建用戶，最後一個參數指定是否只讀

（3）副本集身份認證

使用keyFile，注意keyFile文件的權限必須是600，不然會啟動不起來

3.數據的導入與導出

mongoimport
mongoexport

4.服務器配置

搭建副本集至少需要兩個節點，其中仲裁結點不需要有自己的服務器

（2）Journaling日誌寫數據時會先寫入日誌，而此時的數據也不是直接寫入硬盤，而是寫入內存

但是Journaling日誌會消耗內存，所以可以在主庫上面關閉，在從庫上面啟動

可以單獨為Journaling日誌使用一塊固態硬盤

在插入時，可以通過驅動確保Journaling插入後再反饋，但是會非常影響性能。

5.日誌

-vvvvv 選項（v越多，輸出越詳細）

db.runCommand({logrotare:1}) 開啟滾動日誌

6.數據庫監控命令

• globalLock 表示服務器花在寫鎖上面的總時間

• mem顯示瞭如何使用內存

• bits 表明這臺機器的位長

• resident 表示佔用物理內存數量

• virtual 表示使用的虛擬內存

（2）top

（3）db.currentOp

點擊上方藍色字體，選擇“置頂公眾號”

優質文章，第一時間送達

鏈接 | blog.csdn.net/hayre/article/details/80628431

1.MongoDB是什麼？用一句話總結

MongoDB是一款為web應用程序和互聯網基礎設施設計的數據庫管理系統。沒錯MongoDB就是數據庫，是NoSQL類型的數據庫。

2.為什麼要使用MongoDB？

（1）MongoDB提出的是文檔、集合的概念，使用BSON（類JSON）作為其數據模型結構，其結構是面向對象的而不是二維表，存儲一個用戶在MongoDB中是這樣子的。

｛
username:'123',
password:'123'
｝

使用這樣的數據模型，使得MongoDB能在生產環境中提供高讀寫的能力，吞吐量較於mysql等SQL數據庫大大增強。

（2）易伸縮，自動故障轉移。易伸縮指的是提供了分片能力，能對數據集進行分片，數據的存儲壓力分攤給多臺服務器。自動故障轉移是副本集的概念，MongoDB能檢測主節點是否存活，當失活時能自動提升從節點為主節點，達到故障轉移。

（3）數據模型因為是面向對象的，所以可以表示豐富的、有層級的數據結構，比如博客系統中能把“評論”直接懟到“文章“的文檔中，而不必像myqsl一樣創建三張表來描述這樣的關係。

3.主要特性

（1）文檔數據類型

SQL類型的數據庫是正規化的，可以通過主鍵或者外鍵的約束保證數據的完整性與唯一性，所以SQL類型的數據庫常用於對數據完整性較高的系統。MongoDB在這一方面是不如SQL類型的數據庫，且MongoDB沒有固定的Schema，正因為MongoDB少了一些這樣的約束條件，可以讓數據的存儲數據結構更靈活，存儲速度更加快。（2）即時查詢能力

MongoDB保留了關係型數據庫即時查詢的能力，保留了索引（底層是基於B tree）的能力。這一點汲取了關係型數據庫的優點，相比於同類型的NoSQL redis 並沒有上述的能力。（3）複製能力

MongoDB自身提供了副本集能將數據分佈在多臺機器上實現冗餘，目的是可以提供自動故障轉移、擴展讀能力。（4）速度與持久性

MongoDB的驅動實現一個寫入語義 fire and forget ，即通過驅動調用寫入時，可以立即得到返回得到成功的結果（即使是報錯），這樣讓寫入的速度更加快，當然會有一定的不安全性，完全依賴網絡。

MongoDB提供了Journaling日誌的概念，實際上像mysql的bin-log日誌，當需要插入的時候會先往日誌裡面寫入記錄，再完成實際的數據操作，這樣如果出現停電，進程突然中斷的情況，可以保障數據不會錯誤，可以通過修復功能讀取Journaling日誌進行修復。

（5）數據擴展

MongoDB使用分片技術對數據進行擴展，MongoDB能自動分片、自動轉移分片裡面的數據塊，讓每一個服務器裡面存儲的數據都是一樣大小。

4.C/S服務模型

MongoDB核心服務器主要是通過mongod程序啟動的，而且在啟動時不需對MongoDB使用的內存進行配置，因為其設計哲學是內存管理最好是交給操作系統，缺少內存配置是MongoDB的設計亮點，另外，還可通過mongos路由服務器使用分片功能。

MongoDB的主要客戶端是可以交互的js shell 通過mongo啟動，使用js shell能使用js直接與MongoDB進行交流，像使用sql語句查詢mysql數據一樣使用js語法查詢MongoDB的數據，另外還提供了各種語言的驅動包，方便各種語言的接入。

5.完善的命令行工具

mongodump和mongorestore,備份和恢復數據庫的標準工具。輸出BSON格式，遷移數據庫。

mongoexport和mongoimport，用來導入導出JSON、CSV和TSV數據，數據需要支持多格式時有用。mongoimport還能用與大數據集的初始導入，但是在導入前順便還要注意一下，為了能充分利用好mongoDB通常需要對數據模型做一些調整。

mongosniff,網絡嗅探工具，用來觀察發送到數據庫的操作。基本就是把網絡上傳輸的BSON轉換為易於人們閱讀的shell語句。

因此，可以總結得到，MongoDB結合鍵值存儲和關係數據庫的最好特性。因為簡單，所以數據極快，而且相對容易伸縮還提供複雜查詢機制的數據庫。MongoDB需要跑在64位的服務器上面，且最好單獨部署，因為是數據庫，所以也需要對其進行熱備、冷備處理。

二、進入MongoDB shell

因為本篇文章不是API手冊，所有這裡對shell的使用也是基礎的介紹什麼功能可以用什麼語句，主要是為了展示使用MongoDB shell的方便性，如果需要知道具體的MongoDB shell語法可以查閱官方文檔。

1.切換數據庫

use dba

創建數據庫並不是必須的操作，數據庫與集合只有在第一次插入文檔時才會被創建，與對數據的動態處理方式是一致的。簡化並加速開發過程，而且有利於動態分配命名空間。如果擔心數據庫或集合被意外創建，可以開啟嚴格模式。

2.插入語法

db.users.insert({username:"smith"})
db.users.save({username:"smith"})

• 區別:若新增的數據中存在主鍵 ，insert 會提示錯誤，而save 則更改原來的內容為新內容。如：
  已存在數據：{_id : 1, " name " : " n1 " }，再次進行插入操作時，insert({_id : 1, " name " : " n2 " }) 會報主鍵重複的錯誤提示，save({ _id : 1, " name " : " n2 " }) 會把 n1 修改為 n2 。
• 相同點：若新增的數據中沒有主鍵時，會增加一條記錄。已存在數據：{ _id : 1, " name " : " n1 " }，再次進行插入操作時，insert({ " name " : " n2 " }) 插入的數據因為沒有主鍵，所以會增加一條數據，save({ " name " : " n2 " }) 增加一條數據。

3.查找語法

db.users.find
db.users.count

4.更新語法

db.users.update({username:"smith"},{$set:{country:"Canada"}})
//把用戶名為smith的用戶的國家改成Canada

db.users.update({username:"smith"},{$unset:{country:1}})
//把用戶名為smith的用戶的國家字段給移除

db.users.update({username:"jones"},{$set:{favorites:{movies:["casablance","rocky"]}}})
//這裡主要體現多值修改，在favorties字段中添加多個值

db.users.update({"favorites.movies":"casablance"},{$addToSet:{favorites.movies:"the maltese"}},false,true)
//多項更新

5.刪除語法

db.foo.remove //刪除所有數據
db.foo.remove({favorties.cities:"cheyene"}) //根據條件進行刪除
db.drop //刪除整個集合

6.索引相關語法

db.numbers.ensureIndex({num:1})
//創建一個升序索引
db.numbers.getIndexes
//獲取全部索引

7.基本管理語法

show dbs
//查詢所有數據庫
show collections
//顯示所有表
db.stats
//顯示數據庫狀態信息
db.numbers.stats
//顯示集合表狀態信息
db,shutdownServer
//停止數據庫
db.help
//獲取數據庫操作命令
db.foo.help
//獲取表操作命令
tab 鍵 //能自動幫我們補全命令

以上的命令只是簡單實例，假設如果你之前沒有學習過任何數據庫語法，同時開始學sql查詢語法和MongoDB 查詢語法，你會發現哪一個更簡單呢？如果你使用的是java驅動去操作MongoDB，你會發現任何的查詢都像Hibernate提供出來的查詢方式一樣，只要構建好一個查詢條件對象，便能輕鬆查詢（接下來會給出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成沒問題，也正因為這樣簡潔，完善的查詢機制，深深的愛上了MongoDB。

三、使用java驅動

使用java驅動鏈接MongoDB是一件非常簡單的事情，簡單的引用，簡單的做增刪改查。在使用完java驅動後我才發現spring 對MongoDB 的封裝還不如官方自身提供出來的東西好用，下面簡單的展示一下使用。

1.使用maven引入jar包

 <dependency>
<groupId>org.mongodbgroupId>
<artifactId>mongodb-driver-syncartifactId>
<version>3.8.0-beta3version>
dependency>

2.創建一個訪問客戶端

MongoClient client = MongoClients.create(“mongodb://10.201.76.94:27017”);

3.獲取集合數量

public long count {
MongoClient client = this.getClient;
MongoCollection
return collections.count;
}

4.查詢集合

public List
MongoClient client = this.getClient;
MongoCollection
List
collections.find(params).sort(sort).skip(skip).limit(limit).forEach(new Block
@Override
public void apply(Document document) {
list.add(document);
}
});
return list;
}

這裡只舉例了簡單的鏈接與簡單的MongoDB操作，可見其操作的容易性。使用驅動時是基於TCP套接字與MongoDB進行通信的，如果查詢結果較多，恰好無法全部放進第一服務器中，將會向服務器發送一個getmore指令獲取下一批查詢結果。

插入數據到服務器時間，不會等待服務器的響應，驅動會假設寫入是成功的，實際是使用客戶端生成對象id，但是該行為可以通過配置配置，可以通過安全模式開啟，安全模式可以校驗服務器端插入的錯誤。

四、schema 設計原則

1.需要關注MongoDB的自身的特性

要清楚瞭解MongoDB的基本數據單元。在關係型數據庫中有帶列和行的數據表。而MongoDB數據的基本單元是BSON文檔，在鍵值中有指向不定類型值的鍵，MongoDB擁有即時查詢，但不支持聯結操作，簡單的鍵值存儲只能根據單個鍵來獲取值，不支持事務，但支持多種原子更新操作。

2.需要關注系統本身的讀寫特性

如讀寫比是怎樣的，需要何種查詢，數據是如何更新的，會不會存在什麼併發問題，數據結構化的程度是要求高還是低。系統本身的需求決定mysql還是MongoDB。

3.關注MongoDB schema 的設計模式

• 內嵌與引用：當子對象總是出現在父對象的上下文中時，使用內嵌文檔；否則將子對象單獨存一個集合。
• 一對多的關係：在“多”的集合關係中添加id指向依賴的id。
• 多對多：在其中一種對應關係中使用對象數組指向另外一個對象。
• 樹：具化路徑，在樹中的每個節點都包含一個path字段，該字段具體保存了每個節點祖先的id。
• 動態屬性：可以為不同的動態屬性添加索引，如果需要將屬性圈在一個範圍，那麼可以通過key-value的方式，然後在統一的key上面加索引。
• 關於事務：如果需要事務支持，那麼只能選擇另一種數據庫，或者提供補償性事務來解決事務的問題。

在關於schema 的設計中要注意一些原則，比如：

• 不能創建沒用的索引

• 不能在同一個字段中存不同的類型

• 不能把多類實體都放在一個集合裡 不能創建體積大、嵌套深的文檔

• 不能過多的創建集合，集合、索引、數據庫的命名空間都是有限的

• 不能創建無法分片的集合

4.關注MongoDB裡面一些具體細節

數據庫是集合的邏輯與物理分組，MongoDB沒有提供創建數據庫的語法，只有在插入集合時，數據庫才開始建立。創建數據庫後會在磁盤分配一組數據文件，所有集合、索引和數據庫的其他元數據都保存在這些文件中，查閱數據庫使用磁盤狀態可通過。

db.stats

（2）關注集合概念

集合是結構上或概念上相似得文檔的容器，集合的名稱可以包含數字、字母或 . 符號，但必須以字母或數字開頭，完全。

限定集合名不能超過128個字符，實際上 . 符號在集合中很有用，能提供某種虛擬命名空間，這是一種組織上的原則，和其他集合是一視同仁的。在集合中可以使用。

system.namespaces //查詢當前數據庫中定義的所有命名空間
system.indexes //存儲當前數據庫的所有索引定義

（3）關注文檔

其次是鍵值，在MongoDB裡面所有的字符串都是UTF-8類型。數字類型包括double、int、long。日期類型都是UTC格式，所以在MongoDB裡面看到的時間會比北京時間慢8小時。整個文檔大小會限制在16m以內，因為這樣可以防止創建難看的數據類型，且小文檔可以提升性能，批量插入文檔理想數字範圍是10~200，大小不能超過16MB。

五、索引與查詢優化

1.索引的經驗法則

（2）解析查詢時MongoDB通過最優計劃選擇一個索引進行查詢，當沒有最適合索引時，會先不同的使用各個索引進行查詢，最終選出一個最優索引做查詢

（3）如果有一個a-b的複合索引，那麼僅針對a的索引是冗餘的

（4）複合索引裡的鍵的順序是很重要的

2.索引類型

（2）複合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段會出現的值，或是大量文檔都不包含被索引的鍵。

3.索引的構建問題

如果數據集很大時，構建索引將會花費很長的時間，且會影響程序性能，可通過

db.currentOp //查看索引的構建時間

當使用 mongorestore 時會重新構建索引。當曾經執行過大規模的刪除時，可使用

db.values.reIndex 

對索引進行壓縮，重建。

4.識別慢查詢

（1）查閱慢查詢日誌

grep -E '([0-9])+ms' mongod.log //使用grep 命令 識別命令信息

db.setProfillingLevel(2) //使用解刨器，將記錄每次的讀寫到日誌

db.setProfillingLevel(1) //只記錄慢（100ms）操作

（2）分析慢查詢

db.values.find({}).sort({close:-1}).limit(1).explain

• scanOrder 字段表明沒有使用索引

• cursor當沒有索引時，用的是BasicCursor，當使用索引時使用的是BtreeCursor

• n 表示需要返回的結果集

• nscanned表示需要遍歷的文檔數 indexBounds 表示索引邊界

注意新版本的MongoDB 的explain方法是需要參數的，不然只顯示普通的信息。

六、MongoDB副本集

本節同樣主要簡單呈現MongoDB副本集搭建的簡易性，與副本集的強壯性，監控容易性

1.為什麼要使用副本集

提供主從複製能力，熱備能力，故障轉移能力

2.構建方式

rs.initiate
rs.add("localhost:40001")
rs.add("localhost:40002",{arbiterOnly:true})

3.監控

db.isMasrter
rs.status

4.副本集的工作原理

實際上MongoDB對副本集的操作跟mysql主從操作是差不多的，先看一下mysql的主從數據流動過程

主binlog -> 從relay.log -> 從bin.log -> 從數據庫

而MongoDB主要依賴的日誌文件是oplog

主oplog -> 從oplog

寫操作先被記錄下來，添加到主節點的oplog裡。與此同時，所有從結點複製oplog。首先，查看自己oplog裡最後一條的時間戳；其次，查詢主節點oplog裡所有大於此時間戳的條目;最後，把那些條目添加到自己的oplog裡並應用到自己的庫裡。從節點使用長輪詢立即應用來自主結點oplog的新條目。

當遇到以下情況，從節點會停止複製

• 如果從節點在主節點的oplog裡找不到它所同步的點，那麼會永久停止複製

• 一旦某個從節點沒能 在主節點的oplog裡找到它已經同步的點，就無法再保證這個從結點的完美副本

local數據庫保存了所有副本集元素據和oplog日誌

• replset.minvalid 包含指定副本集成員的初始化同步信息

• system.replset 保存在副本集配置文檔

• system.indexes 標準索引說明容器

• me slaves 主要用於寫關注

可以使用以下命令查看複製情況

db.oplog.rs.findOne

• ts 保存了該條目的BSON時間戳

• t 是從紀元開始的描述

• i是計數器

• op 表示操作碼

• ns 標明瞭有關的命名空間

5.心跳檢測

每個副本集成員每秒鐘ping一次其他所有成員，可以通過rs.status看到節點上次的心跳檢測時間戳和健康狀況。

6.故障轉移

這個點沒必要過多描述，但是有一個特殊場景，如果從節點和仲裁節點都被殺了，只剩下主節點，他會把自己降級成為從節點。

7.提交與回滾

如果主節點的數據還沒有寫到從庫，那麼數據不能算提交，當該主節點變成從節點時，便會觸發回滾，那些沒寫到從庫的數據將會被刪除，可以通過rollback子目錄中的BSON文件恢復回滾的內容。

8.驅動與複製

只能鏈接到主節點，如果鏈接到從節點的話，會被拒絕寫入操作，但是如果沒有使用安全模式，因為mongo的fire and forget 特性，會把拒絕寫入的異常給吃掉。

（2）使用副本集方式鏈接

能根據寫入的情況自動進行故障轉移，但是當副本集進行新的選舉時，還是會出現故障，如果不使用安全模式，依舊會出現寫不進去，但現實成功的情況。

（3）寫關注

可以使用寫關注來關注數據是否已經被寫入MongoDB的庫中，使用寫關注會消耗性能，需要在速度和持久性之間做出權衡。

七、分片

分片是數據庫切分的一個概念實現，這裡也是簡單總結為什麼要使用分片以及分片的原理，操作。

1.為什麼需要分片

當數據量過大，索引和工作數據集佔用的內存就會越來越多，所以需要通過分片負載來解決這個問題

2.分片的工作原理

• 分片：每個分片都是一個副本集

• mongos路由器：是一個路由器，將讀寫請求指引到合適的分片上

• 配置服務器config：持久化分片集群的元數據，包括：全局集群配置；每個數據庫、集合和特定範圍數據位置；一份變更記錄，保存了數據在分片之間進行遷移的歷史信息。配置服務器之間不是副本集形式存在，mongos向配置服務器提交信息時是兩階段提交，保證配置服務器之間的一致性。

（2）分片的核心操作

分片一個集合：分片是根據一個屬性的範圍進行劃分的，MongoDB使用所謂的分片鍵讓每個文檔在這些範圍裡找到自己的位置

塊：是位於一個分片中的一段連續的分片鍵範圍，可以理解為若干個塊組成分片，分片組成MongoDB的全部數據

（3）拆分與遷移

塊的拆分：初始化時只有一個塊，達到最大塊尺寸64MB或100000個文檔就會觸發塊的拆分。把原來的範圍一分為二，這樣就有了兩個塊，每個塊都有相同數量的文檔。

遷移：當分片中的數據大小不一時會產生遷移的動作，比如分片A的數據比較多，會將分片A裡面的一些塊轉移到分片B裡面去。分片集群通過在分片中移動塊來實現均衡，是由名為均衡器的軟件進程管理的，任務是確保數據在各個分片中保持均勻分佈，當集群中擁有塊最多的分片與擁有塊最少分片的塊差大於8時，均衡器就會發起一次均衡處理。

3.分片實戰

啟動兩個副本集、三個配置服務器、一個mongos進程

配置分片

sh.help //查看分片相關幫助
sh.addShard //添加分片
db,getSiblingDB("config").shards.find //查看分片列表
sh.status //分片詳情
sh.enableSharding("cloud-docs") //開啟一個數據庫上的分片
db.getSiblingDB("config").databases,find //查看數據庫列表
sh.shardCollection("cloud-docs.spreadsheets",{username:1,_id:1}) //使用一個分片鍵定義一個分片集合spreadsheets，根據用戶名進行切分
sh.getSiiblingDB("config").collections.findOne //查看集合列表
db.chunks.count //查看塊的個數
db.chunks.findOne //查看塊的信息
db.changelog.count(}what:"split"|) //查看塊切分日誌
db.changelog.find({what:"moveChunk.commit"}).count //查看日誌遷移記錄

4.分片的查詢與索引

• 針對性查詢：查詢包含分片鍵

• 全局查詢或分散/聚集查：查詢不包含分片鍵

• 查詢過程：通過分片鍵將查詢路由給指定分片，一旦到了某個分片上，由分片自行決定使用哪個索引來執行該查詢

（2）索引

每個分片都維護了自己的索引，當在分片集合上聲明索引時，每個分片都會為它那部分集合構建獨立的索引，每個分片上的分片集合都應該擁有相同的索引。

分片集合只允許在_id字段和分片鍵上添加唯一性索引，其他地方不行，因為這需要在分片間進行通信，實施起來很複雜。

當創建分片時，會根據分片鍵創建一個索引。

5.選擇分片鍵

（2）低效的分片鍵

• 分佈性差：如使用BSON對象ID，那麼會導致所有最新插入的文檔都會落到某個很小的連續範圍，無法分散插入

• 缺乏局部性：升序分片鍵有明確的方向，完全隨機的分片鍵則根本沒有方向。前者無法分散插入，後者插入分散，如使用MD5作為分片鍵

（3）理想的分片鍵

• 將插入數據均勻分佈到各個分片上

• 保證CRUD操作能夠利用局部性 有足夠的粒度進行塊拆分

• 滿足這些要求的分片鍵通常由兩個字段組成，第一個是粗粒度的，第二個粒度較細

6.生產環境中的分片

• 複製mongod：需要獨立的部署服務器

• 配置服務器：配置服務器不需要有自己的機器

根據不同的數據中心劃分

（2）最低要求

• 副本集每個成員，無論是完整的副本集節點還是仲裁節點，都需要放在不同的機器上 每個用於複製的副本集成員都需要有自己的機器

• 副本集仲裁節點很輕量級，和其他進程共用一臺機器即可

• 配置服務器也可以選擇與其他進程共用一臺機器

（3）配置的注意事項

需要估計集群大小，可使用以下命令對現有集合進行分片處理

sh.splitAt("cloud-docs.spreadsheets",{"username":"chen","_id":ObjectId("")})
//手動拆分塊
sh.moveChunk("cloud-docs.spreadsheets",{username:"chen"},"shardB")
//手動將某分塊移至分片B
db.runCommand({removeshard:"shard-1/arete:30100,arete:30101"})
//刪除分片
db.runCommand({moveprimary:"test",to:"shard-0-test-rs"});
//移動主分片

（4）備份分片集群

備份分片時需要停止均衡器

db.settings.update({_id:"ba;ancer"},{$set:{stopped:true},true});
sh.setBalancerState(false)；
//停止均衡器，此時均衡器將進行最後一輪均衡

db.locks.find({_id:"balancer"});
sh.isBalancerRunning;
//查看均衡器狀態，任何狀態大於0 的狀態值都說明均衡器仍在進行中

八、部署與管理

1.部署

使用64位機器、32位機器會制約mongodb的內存，使其最大值為1.5GB

（2）cpumongodb 只有當索引和工作集都可放入內存時，才會遇到CPU瓶頸，CPU在mongodb使用中的作用是用來檢索數據，如果看到CPU使用飽和的情況，可以通過查詢慢查詢日誌，排查是不是查詢的問題導致的，如果是可以通過添加索引來解決問題

mongodb寫入數據時會使用到CPU，但是mongodb寫入時間一次只用到一個核，如果有頻繁的寫入行為，可以通過分片來解決這個問題（3）內存

大內存是mongodb的保障，如果工作集大小超過內存，將會導致性能下降，因為這將會增加數據加載入內存的動作

（4）硬盤

mongodb默認每60s會與磁盤強制同步一次，稱為後臺刷新，會產生I/O操作。在重啟時mongodb會將磁盤裡面的數據加載至內存，高速磁盤將會減少同步的時間

（5）文件系統

使用ext4 和 xfs 文件系統

禁用最後訪問時間

vim /etc/fstab

（6）文件描述符

linux 默認文件描述符是1024，需要大額度的提升這個額度

（7）時鐘

mongodb各個節點服務器之間使用ntp服務器

2.安全

啟動時使用 - -bind_ip 命令

（2）身份驗證

啟動時使用 - -auth 命令

db.addUser("","",true)
//創建用戶，最後一個參數指定是否只讀

（3）副本集身份認證

使用keyFile，注意keyFile文件的權限必須是600，不然會啟動不起來

3.數據的導入與導出

mongoimport
mongoexport

4.服務器配置

搭建副本集至少需要兩個節點，其中仲裁結點不需要有自己的服務器

（2）Journaling日誌寫數據時會先寫入日誌，而此時的數據也不是直接寫入硬盤，而是寫入內存

但是Journaling日誌會消耗內存，所以可以在主庫上面關閉，在從庫上面啟動

可以單獨為Journaling日誌使用一塊固態硬盤

在插入時，可以通過驅動確保Journaling插入後再反饋，但是會非常影響性能。

5.日誌

-vvvvv 選項（v越多，輸出越詳細）

db.runCommand({logrotare:1}) 開啟滾動日誌

6.數據庫監控命令

• globalLock 表示服務器花在寫鎖上面的總時間

• mem顯示瞭如何使用內存

• bits 表明這臺機器的位長

• resident 表示佔用物理內存數量

• virtual 表示使用的虛擬內存

（2）top

（3）db.currentOp

7.mongostat

動態展示mongodb活動數據

8.web控制檯

佔用當前mongodb監聽端口往上1000號的端口

9.備份與恢復

把數據庫內容導出成BSON文件，而mongorestore能讀取並還原這些文件

（2）mongorestore

把導出的BSON文件還原到數據庫

（3）備份原始數據文件可以這麼做，但是，操作之前需要進行鎖庫處理db.runCommand({fsync:1,lock:true})db.$cmd.sys.unlock.findOne請求解鎖操作，但是數據庫不會立刻解鎖，需要使用db.currentOp驗證。

10.壓緊與修復

db.runCommand({repairDatabase:1})修復單個數據庫

修復就是根據Jourling文件讀取和重寫所有數據文件並重建各個索引（2）壓緊

db.spreadsheets.reIndex //重建索引
db.runCommand({compact:"spreadsheets"})

壓緊，會重寫數據文件，並重建集合的全部索引，需要停機或者在從庫上面運行,如果需要在主庫上面運行，需要添加force參數 保證加寫鎖。

11.性能調優

iostat

（2）為提升性能檢查索引和查詢

總的來說，掃描儘可能少的文檔。

保證沒有冗餘的索引，冗餘的索引會佔用磁盤空間、消耗更多的內存，在每次寫入時還需做更多工作

（3）添加內存

db.stats //查看數據庫數據佔用大小狀態

dataSize 數據大小 和 indexSize 索引大小，如果兩者的和大於內存，那麼將會影響性能。

storageSize超過dataSize 數據大小 兩倍以上，就會因磁盤碎片而影響性能，需要壓縮。

如果喜歡本篇文章，歡迎轉發、點贊。關注訂閱號「Web項目聚集地」，回覆「技術博文」即可獲取更多圖文教程、技術博文、學習資源。