MongoDB 學習筆記

概述

MongoDB 是一個介於關係型數據庫和非關係型數據庫之間的產品,是非關係型數據庫中功能最豐富,最像關係型數據庫的。

MongoDB 支持的數據結構非常鬆散,類似 json 的 bson 格式,因此可以存儲比較複雜的數據類型。MongoDB 最大的特點是支持的查詢語言非常強大,語法類似於面向對象的查詢語言,幾乎可以實現類似關係型數據庫單表查詢的絕大部分功能,還支持對數據建立索引

MongoDB 的特點:

  • 面向集合存儲,易存儲對象類型的數據
  • 支持查詢,以及動態查詢
  • 支持多種語言
  • 文件存儲格式為 BSON
  • 支持主從複製、故障恢復和分片

MongoDB 的應用場景:

  • 遊戲應用:使用 MongoDB 作為遊戲服務器的數據庫存儲用戶信息,用戶的遊戲裝備、積分等直接以內嵌文檔的形式存儲,方便查詢和更新
  • 物流應用:使用 MongoDB 存儲訂單信息,訂單狀態在運送過程中會不斷更新,以內嵌數組的形式存儲,一次查詢就能將訂單所有的變更讀取出來
  • 社交應用:使用 MongoDB 存儲用戶信息以及用戶發表的朋友圈信息,通過地理位置索引實現附近的人、地點等功能,存儲聊天記錄
  • 大數據應用:使用 MongoDB 作為大數據的雲存儲系統,隨時進行數據提取分析,掌握行業動態

MongoDB 安裝

1. 傳統方式安裝

在官網下載對應版本的安裝包並解壓://www.mongodb.com/try/download/communiy

這裡選擇 ubuntu 環境下的 5.0.8 版本

進入 bin 目錄,啟動 MongoDB 服務

./mongod --port=27017 --dbpath ../data --logpath ../logs/mongo.log &
  • port:指定服務監聽端口,默認 27017
  • dbpath:指定 mongo 的數據存放目錄
  • logpath:指定 mongo 的日誌存放目錄
  • &:表示程序在後台運行

使用客戶端連接 MongoDB 服務

# ./mongo [mongodb://[主機名:端口號]]
./mongo mongodb://127.0.0.1:27017

2. Docker 方式安裝

拉取 MongoDB 鏡像

docker pull mongo:5.0.8

運行 MongoDB 鏡像

docker run -d --name mongo --p 27017:27017 mongo:5.0.5

進入 MongoDB 容器

docker exec -it [容器id] bash

MongoDB 核心概念

1. 庫

MongoDB 中的庫類似傳統關係型數據庫中庫的概念,用來通過不同的庫隔離不同的數據

MongoDB 中可以建立多個數據庫,每一個庫都有自己的集合和權限,不同的數據庫也放置在不同的文件中

2. 集合

集合就是 MongoDB 文檔組,類似於關係型數據庫中表的概念

集合存儲在庫中,一個庫可以有多個集合,每個集合沒有固定的結構,這意味着可以對集合插入不同格式和類型的數據,但通常我們插入集合數據都會有一定的關聯性

3. 文檔

文檔集合中的記錄,是一組鍵值對(BSON)

MongoDB 的文檔不需要設置相同的字段,並且相同的字段不需要相同的數據類型,這與關係型數據庫有很大的區別,也是 MongoDB 的特點

一個簡單的文檔例子:

{"site":"www.google.com", "name":"xiaowang"}

MongoDB 基本操作

1. 庫操作

# 查看所有庫,默認不顯示沒有集合的庫
show databases | show dbs
# 選中一個庫,如果庫不存在,則自動創建
use [庫名]
# 幫助指令
db.help()
# 查看當前庫
db
# 刪除當前庫
db.dropDatabase()

MongoDB 有三個保留庫:

  • admin:從權限的角度來看,這是 root 數據庫。如果一個用戶被添加到這個數據庫,這個用戶將自動繼承對所有數據庫的權限。一些特定的服務器端命令也只能從這個數據庫運行,比如列出所有的數據庫或者關閉服務器
  • local:該庫的數據永遠不會被複制(例如創建副本),可以用來存儲僅限於本地單台服務器的任意集合
  • config:當 Mongo 用於分片設置時,config 數據庫在內部使用,用於保存分片的相關信息

2. 集合操作

# 查看當前庫的集合
show collections | show tables
# 顯示創建集合
# db.createCollection("[集合名]", [Options])
db.createCollection("products", {capped:true,size:5000})
# 向集合插入數據/隱式創建集合,向不存在的集合插入數據也可以創建集合
# db.[集合名稱].insert({"[屬性名]":"[屬性值]",...})
db.emp.insert({name:"xiaowang"})
# 刪除集合
# db.[集合名稱].drop()

Options 可以是如下參數:

  • capped:(可選)如果為true,則創建固定集合。固定集合是指有着固定大小的集合,當達到最大值時,它會自動覆蓋最早的文檔。當該值為 true 時,必須指定 size 參數
  • size:(可選)為固定集合指定一個最大值,即位元組數。如果 capped 為 true,也需要指定該字段
  • max:(可選)指定固定集合中包含文檔的最大數量

3. 文檔操作

# 插入單條文檔
db.[集合名稱].insert({"[屬性名]":"[屬性值]",...})
# 插入多條文檔
db.[集合名稱].insertMany(
	[<document1>,<document2>,...],
	{
		writeConcern: 1 # 寫入策略,默認為1,表示要求確認寫操作,為0不要求
		ordered: true	# 指定是否按順序寫入,默認為true,按順序寫入
	}
)
db.[集合名稱].insert(
	[<document1>,<document2>,...]
)
# 腳本方式插入多條文檔,MongoDB默認會為每一條文檔設置一個_id的key
for(var i = 0; i < 10; i++) {
	db.[集合名稱].insert({"_id":i, ....})
}
# 查詢文檔
# query 可選,指定查詢條件
# projection 可選,指定返回的鍵值,不寫默認返回全部鍵值
# pretty 對返回結果格式化
db.[集合名稱].find(query,project).pretty()
# 使用運算符查詢
# > : ($gt)
# < : ($lt)
# >= : ($gte)
# <= : ($lte)
# = : ($eq)
# != : ($ne)
# 查詢年齡大於29的用戶記錄
db.users.find({age:{$gt:29}})
# AND 查詢
db.[集合名稱].find($and:[{key1:value1,key2:value2,...},...]).pretty()
# OR 查詢
db.[集合名稱].find($or:[{key1:value1,key2:value2,...},...]).pretty()
# and or 聯合
db.[集合名稱].find($and:[...],$or:[...]).pretty()
# not or 查詢,既不是也不是
db.[集合名稱].find($nor:[...]).pretty()
# 模糊查詢
db.[集合名稱].find({查詢字段:正則表達式})
# 數組中查詢,找出likes數組字段中有看電視值的記錄
db.users.find({likes:"看電視"})
# 數組中查詢,找出likes數組字段長度為3的記錄
db.users.find({likes:{$size:3}})
# 對查詢排序,1升序,2降序
db.[集合名稱].find({查詢條件}).sort({排序字段:升序/降序,...})
# 對查詢分頁
db.[集合名稱].find({查詢條件}).skip(起始條數).limit(每頁顯示的記錄數)
# 查詢總條數
db.[集合名稱].count()
# 去重
db.[集合名稱].distinct("字段")
# 文檔刪除
db.[集合名稱].remove(
	<query>,	# 可選,刪除文檔的條件
	{
		justOne: <boolean>	# 可選,設為true則只刪除一個文檔,否則刪除所有匹配的文檔
		writeConcern: <document>	# 可選,拋出異常的級別
	}
)
# 刪除_id為1的文檔
db.users.remove({"_id":1})
# 更新文檔
db.[集合名稱].update(
	<query>,	# 查詢條件
	<update>,	# 更新操作符,類似sql update的set
	{
		upsert: <boolean>,	# 可選,如果不存在記錄,則插入,默認為true
		multi: <boolean>,	# 可選,默認false表示只更新第一條記錄,true表示更新符合條件的全部記錄
		writeConcern: <document>	# 可選,拋出異常的級別
	}
)
# 這種更新相當於先刪除再插入
db.[集合名稱].update({"name":"zhangsan" },{name:"11",bir:new date()})
# 保存原有數據的更新
db.[集合名稱].update({"name":"xiaohei"},{$set:{name:"mingming"}})

MongoDB 索引

1. 簡介

索引能極大的提高查詢效率。索引是特殊的數據結構,它存儲在一個易於遍歷讀取的數據集合中,是對數據庫表中一列或多列的值進行排序的一種數據結構

MongoDB 索引原理如圖所示:

MongoDB 的索引和其他關係型數據庫中的索引類似,MongoDB 在集合層面上定義了索引,並支持對 MongoDB 集合中的任何字段或文檔的子字段進行索引

2. 索引操作

# 創建索引,1為指定按升序創建索引,-1為降序
db.[集合名稱].createIndex(keys,options)
db.topics.createIndex({"title":1})
# 創建複合索引,只有使用索引前部的查詢才能使用該索引
db.[集合名稱].createIndex({"[要創建索引的字段]":1,....})
# 查看索引
db.[集合名稱].getIndexes()
# 查看集合索引大小
db.[集合名稱].totalIndexSize()
# 刪除集合所有索引
db.[集合名稱].dropIndexs()
# 刪除集合指定索引
db.[集合名稱].dropIndex("索引字段")

createIndex 可接受以下可選參數:

Parameter Type Description
background Boolean 建索引過程會阻塞其它數據庫操作,background 可指定以後台方式創建索引,即增加 background 可選參數。 “background” 默認值為 false
unique Boolean 建立的索引是否唯一。指定為 true 創建唯一索引。默認值為 false
name string 索引的名稱。如果未指定,MongoDB 的通過連接索引的字段名和排序順序生成一個索引名稱
dropDups Boolean 3.0+ 版本已廢棄。在建立唯一索引時是否刪除重複記錄,指定 true 創建唯一索引。默認值為 false
sparse Boolean 對文檔中不存在的字段數據不啟用索引;這個參數需要特別注意,如果設置為 true 的話,在索引字段中不會查詢出不包含對應字段的文檔.。默認值為 false
expireAfterSeconds integer 指定一個以秒為單位的數值,完成 TTL 設定,設定集合的生存時間
v index version 索引的版本號。默認的索引版本取決於 mongod 創建索引時運行的版本
weights document 索引權重值,數值在 1 到 99,999 之間,表示該索引相對於其他索引字段的得分權重。
default_language string 對於文本索引,該參數決定了停用詞及詞幹和詞器的規則的列表。 默認為英語
language_override string 對於文本索引,該參數指定了包含在文檔中的字段名,語言覆蓋默認的 language,默認值為 language

SpringBoot 整合 MongoDB

引入依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

編寫配置

# mongodb(協議)://主機:端口/庫名
spring.data.mongodb.uri=mongodb://127.0.0.1:27017/test
# 如果開啟用戶名密碼校驗
spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.port=27017
spring.data.mongodb.database=test
spring.data.mongodb.username=root
spring.data.mongodb.password=123

創建和刪除集合

@Test
public void testCollection() {
    // 創建集合
    mongoTemplate.createCollection("products");
    // 刪除集合
    mongoTemplate.dropCollection("products");
}

操作文檔

@Document("users")	// 代表是users集合的文檔
public class User {
    
    @Id	// 映射文檔的_id
    private Integer id;
    @Field	// 映射文檔的鍵值對
    private String name;
    @Field
    private Integer salary;
    @Field
    private Date birthday;
    
    ....
}
@Test
public void testDocument() {
    User user = new User(1, "hhh", 3000, new Date())
    // _id存在時更新數據
    mongoTemplate.save(user)
    // _id存在時發生主鍵衝突
    mongoTemplate.insert(user)
    // 批量插入
    List<User> users = Arrays.asList(
        new User(2, "aaa", 3000, new Date()),
        new User(3, "bbb", 3000, new Date())
    );
    mongoTemplate.insert(users, User.class)
        
    // 基於id查詢
    mongoTemplate.findById("1", User.class);
    // 查詢所有
    mongoTemplate.findAll(User.class);
    mongoTemplate.find(new Query(), User.class);
    // 等值查詢
     mongoTemplate.find(new Query(Criteria.where("name").is("aaa")), User.class);
    // > gt < lt >= gte <= lte
    mongoTemplate.find(new Query(Criteria.where("age").lt(25)), User.class);
    mongoTemplate.find(new Query(Criteria.where("age").gt(25)), User.class);
    mongoTemplate.find(new Query(Criteria.where("age").gte(25)), User.class);
    mongoTemplate.find(new Query(Criteria.where("age").lte(25)), User.class);
    // and 查詢
    mongoTemplate.find(new Query(Criteria.where("name").is("aaa").and("salary").is(3000)), User.class);
    // or 查詢
    mongoTemplate.find(
        new Query(
            Criteria.orOperator(
            	Criteria.where("name").is("aaa"),
                Criteria.where("name").is("bbb")
            )),
        User.class);
    // and or 查詢
    mongoTemplate.find(
        new Query(
            Criteria.where("salary").is("3000")
        		.orOperator(
                	Criteria.where("name").is("aaa")
                )),
        User.class);
    // 排序查詢
    mongoTemplate.find(
        new Query().with(Sort.by(Sort.Order.desc("salary"))),
        User.class);
    // 分頁查詢
    mongoTemplate.find(
        new Query().with(Sort.by(Sort.Order.desc("salary")))
        	.skip(0)
        	.limit(2),
        User.class);
    // 總條數
    mongoTemplate.count(new Query(), User.class);
    // 去重
    mongoTemplate.findDistinct(new Query(), User.class);
    // 使用json字符串查詢
    Query query = new BasicQuery("{name:'aaa'}");
    mongoTemplate.find(query, User.class);
    
    // 更新條件
    Query query = Query().query(Criteria.where("age").is(23));
    // 更新內容
    Update update = new Update();
    update.set("name", "ccc");
    // 單條更新
    mongoTemplate.updateFirst(query, update, User);
    // 多條更新
    mongoTemplate.updateMulti(query, update, User);
    // 更新插入
    mongoTemplate.upsert(query, update, User);
    
    // 刪除所有
    mongoTemplate.remove(new Query, User.class);
    // 條件刪除
    mongoTemplate.remove(
        Query.query(Criteria.where("name").is("aaa"))
        , User.class);
}

MongoDB 副本集

1. 簡介

MongoDB 副本集是有自動故障恢復功能的主從集群,由一個 Primary 節點和一個或多個 Secondary 節點組成。副本集群沒有固定的主節點。當出現故障時,整個集群會選舉出一個主節點,保證系統的高可用性

2. 搭建副本集

創建數據目錄

sudo mkdir repl1 repl2 repl3

啟動三個節點

# --replSet 副本集選項 myreplace 副本集名稱/集群中其他節點的主機和端口號 
sudo ./mongod --port 27017 --dbpath ../repl1 --bind_ip 0.0.0.0 --replSet myreplace/[localhost:27018,localhost:27019]
sudo ./mongod --port 27018 --dbpath ../repl2 --bind_ip 0.0.0.0 --replSet myreplace/[localhost:27017,localhost:27019]
sudo ./mongod --port 27019 --dbpath ../repl3 --bind_ip 0.0.0.0 --replSet myreplace/[localhost:27017,localhost:27018]

配置副本集,通過 client 登錄到任意一個節點,必須在 mongo 中默認的 admin 庫中做集群的配置

use admin
# 定義配置信息
> var config = {
	"_id":"myreplace",
    members:[
        {_id:0,host:"aaa:27017"},
        {_id:1,host:"aaa:27018"},
        {_id:2,host:"aaa:27019"}]
}
# 初始化副本集
rs.initiate(config)
# 開啟從節點查詢權限
rs.slaveOk()
# 查看副本集狀態
rs.status()

MongoDB 分片集群

1. 簡介

分片是指將數據拆分,將其分散存在不同的機器上,不需要功能強大的大型計算機就可以存儲更多的數據,處理更大的負載

MongoDB 支持自動分片,可以擺脫手動分片的管理困擾。MongoDB 分片的基本思想就是將集合切分成小塊,這些塊分散到若干片裏面,每個片只負責總數據的一部分,應用程序不必知道分片細節

  • Shard:用於實際存儲的數據塊,實際生產中一個 Shard Server 角色可以組成一個副本集,防止主機單點故障
  • Config Server:配置服務器存儲集群的元數據和相關設置,配置服務器必須部署為副本集
  • Query Remote:分片之前要運行一個路由進程,該進程名為 mongos,這個路由器知道所有數據的存放位置,應用可以連接它來正常發送請求。路由器知道數據和片的對應關係,能夠轉發請求正確的片上,如果請求有了回應,路由器將收集起來回送給應用
  • Shard Key:設置分片時需要在集合中選一個鍵,用該鍵的值作為拆分數據的依據,這個片鍵稱為 shard key

2. 搭建分片集群

# 1.集群規劃
Shard Server 1:27017
Shard Repl 1:27018

Shard Server 2:27019
Shard Repl 2:27020

Shard Server 3:27021
Shard Repl 3:27022

Config Server :27023
Conifg Server :27024
Conifg Server :27025

Route Process :27026

# 2.進入安裝的 bin 目錄創建數據目錄
mkdir -p ../cluster/shard/s1
mkdir -p ../cluster/shard/s1-repl
...
mkdir -p ../cluster/shard/config3

# 3.啟動4個shard服務並分別初始化
sudo ./mongod --port 27017 --dbpath ../cluster/shard/s1 --bind_ip 0.0.0.0 --shardsvr --replSet r0/127.0.0.1:27018
sudo ./mongod --port 27018 --dbpath ../cluster/shard/s1 --bind_ip 0.0.0.0 --shardsvr --replSet r0/127.0.0.1:27017
...

# 4.啟動3個config服務並初始化
sudo ./mongod --port 27023 --dbpath ../cluster/shard/config1 --bind_ip 0.0.0.0 --configsvr --replSet r0/[127.0.0.1:27024,127.0.0.1:27025]
...
> var config = {
	"_id":"config",
	configsvr:true,
	members:[
		{_id:0,host:"127.0.0.1:27023"},
		{_id:1,host:"127.0.0.1:27024"},
		{_id:2,host:"127.0.0.1:27025"}
	]
}
> rs.initiate(config)

# 5.啟動路由服務
 ./mongos --port 27026 --configdb config/127.0.0.1:27023,127.0.0.1:27024,127.0.0.1:27025 --bind_ip 0.0.0.0
 
# 6.登錄mongos服務
# 6.1 登錄 mongo --port 27026
# 6.2 使用 admin 庫
use admin
# 6.3 添加分片信息
db.runCommand({addshard:"127.0.0.1:27017","allowLocal":true})
db.runCommand({addshard:"127.0.0.1:27019","allowLocal":true})
db.runCommand({addshard:"127.0.0.1:27021","allowLocal":true})
# 6.4 指定分片的數據庫
db.runCommand({enablesharding:"[庫名]"})
# 6.5 設置庫的片鍵信息
db.runCommand({shardcollection:"[庫名].[集合名]",key:{[字段名]:1}})
db.runCommand({shardcollection:"[庫名].[集合名]",key:{[字段名]:"hashed"}})  # 通過對片鍵哈希將數據散開

Tags: