MongoDB
数据库
1. 使用数据库
use <dbname>
如果数据库不存在，则创建数据库，否则切换到指定数据库- 1
- 2
2. 查看数据库
show dbs
3. 添加数据
db.<dbname>.insert({"name":"Wang"})
4. 删除数据库
`db.dropDatabase()`
删除当前数据库，默认为test
**实例**
```
show dbs
use test
db.test.insert({"name":"Wang"})
db.dropDatabase()
```
删除集合
`db.collection.drop()`
**实例**
```
db.name.drop()
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
5. 插入文档
```
db.COLLECTION_NAME.insert(document)
```
**实例**
```
db.col.insert({
name:wang,
age:20,
likes:["python","NoSql"]
})
```
查询插入文档
```
db.dol.find()
```
通过变量插入数据
```
doc=({
name:wang,
age:20,
likes:["python","NoSql"]
})
db.col.insert(doc)
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
6. 更新文档
```
db.collection.update(
<query>,
<update>,{
upsert:<boolean>,
multi:<boolean>,
writeConcern:<document>
}
)
```
参数说明：
query:update的查询条件，类似sql中的where后面的内容。
update:update的更新对象，类似sql中的set后面的内容。
upsert:如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入，可选。
multi:mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新，可选。
writeConcern:抛出异常的级别，可选。
**实例**
```
db.col.insert({
name:wang,
age:20,
likes:["python","NoSql"]
})
db.col.update(
{"name":"wang"},{$set:{"name":"WANG"}}
)
//查看结果
db.col.find().pretty()
```
如果需要多条相应记录更新，应使用multi:true。
```
db.col.update(
{"name":"wang"},{$set:{"name":"WANG"}},{multi:true}
)
```
save()方法
```
db.collection.save(
<document>,{
writeConcern:<document>
}
)
```
参数说明：
document:文档数据。
weiteConcern:抛出异常的级别，可选。
**实例**
```
db.col.save({
"name":"wang",
"age":40
})
db.col.find().pretty()
```
更新第一条
```
db.col.update({"name":"wang"},{$set:{"name":"WANG"}})
db.col.update({"name":"wang"},{$set:{"name":"WANG"}},false,false)
```
全部更新
```
db.col.update({"name":"wang"},{$set:{"name":"WANG"}},false,ture)
```
只添加一条
```
db.col.update({"name":"wang"},{$set:{"name":"WANG"}},true,flase)
```
全部添加加进去
```
db.col.update({"name":"wang"},{$set:{"name":"WANG"}},true,true)
```
全部更新
```
db.col.update({"name":"wang"},{$set:{"name":"WANG"}},false,true)
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
7. 删除文档
```
db.collection.remove(
<query>,
<justOne>
)
db.collection.remove(
<query>,
{
justOne:<boolean>,
writeConcern:<document>
}
)
```
参数说明：
query:删除文件条件，可选。
justOne:如果设为true或者1，那么只删除一个文档，可选
writeConcern:抛出异常的级别，可选。
**实例**
```
db.col.insert({
name:wang,
age:20,
likes:["python","NoSql"]
})
db.col.remove({"name":"wang"})
```
删除第一条找到的记录
```
db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)
```
删除所有数据
```
db.col.remove()
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
8. 查询文档
```
db.collection.find(query, projection)
```
参数说明：
query:使用查询，可选。
projection:使用投影操作符指定返回的键。查询是返回文档中所有的键，只需要省略参数(默认省略)，可选
如果需要让返回结果更易读，可使用pretty()
```
db.col.find().pretty()
```
**实例**
等于
```
db.col.find({<key>:<value>})
db.col.find({"name":"wang"}).pretty()
```
小于
```
db.col.find({<key>:{$lt:<value>}})
db.col.find({"age":{$lt:20}}).pretty()
```
小于等于
```
db.col.find({<key>:{$lte:<value>}})
db.col.find({"age":{$lte:20}}).pretty()
```
大于
```
db.col.find({<key>:{$gt:<value>}})
db.col.find("age":{$gt:20}).pretty()
```
大于等于
```
db.col.find({<key>:{$gte:<value>}})
db.col.find({"age":{$gte:20}}).pretty
```
不等于
```
db.col.find({<key>:{$ne:<value>}})
db.col.find({"age":{$ne:20}}).pretty
```
AND条件
```
db.col.find({<key>:<value>,<key2>:<value2>}).pretty()
db.col.find("age":"20","name":"wang")
```
OR条件
```
db.col.find({$or:[
{<key>:<value>},{<key2>:<value2>}]
}
).pretty()
db.dol.find({$or:[{"name":"wang"},{"age":"20"}]}).pretty()
```
AND 和 OR 联合使用
```
db.col.find({"age": {$gt:20}, $or: [{"name": "wang"},{"like": "MongoDB"}]}).pretty()
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
9. 条件操作符
(>)大于 $gt
(>=)大于等于 $gte
(<)小于 $lt
(<=)小于等于 $lte
```
db.col.insert({
name:"wang",
age:20
})
db.col.insert({
name:"li",
age:18
})
db.col.insert({
name:"zhao",
age:24
})
//大于
db.col.find({"age":{$gt:20}})
//大于等于
db.col.find({"age":{$gte:20}})
//小于
db.col.find({"age":{$lt:20}})
//小于等于
db.col.find({"age":{$lte:20}})
//使用大于小于查询 $lt 和 $gt
db.col.find({age:{$lt:30,$gt:20}})
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
10. $type操作符
| 类型 | 数字 |
|---|---|
| Double | 1 |
| String | 2 |
| Object | 3 |
| Array | 4 |
| Binary data | 5 |
| Boolean | 8 |
| Object id | 7 |
| Date | 9 |
| Null | 10 |
db.col.find({"name":{$type:2}})
11. Limit()与Skip() db.COLLECTION_NAME.find().limit(NUMBER)
实例 db.col.find({},{"name":wang}).limit(1)
limit()方法中的参数不设置，则返回全部数据。
limit()方法用来返回一定数量的结果。 db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
实例 db.col.find({},{"name":"wang"}).limit(1).skip(1)
skip()方法默认参数0。
使用skip()方法来跳过指定数量的数据，skip()同样接收一个数字参数作为跳过的记录条数。
实例 //读取从100条记录后的100条数据
db.COLLECTION_NAME.find().skip(100).limit(100)
12. 排序
```
db.COLLECTION_NAME.find().sort({<key>:1})
```
sort()方法可以通过参数指定排序的字段，并使用1和-1来指定排序方式，1升序、-1降序
```
db.col.find({},{"name":1}).sort("age":-1)
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
13. 索引
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。
```
db.COLLECTION_NAME.ensureIndex({<key>:1})
```
key：创建的索引字段。
1：为指定按升序创建索引，-1则是降序创建索引
**实例**
```
db.col.ensureIndex({"name":1})
//使用多个字段创建索引
db.col.ensureIndex({"name":1,"age":1})
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
14. 聚合
类似sql中的COUNT(*) db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
实例 db.col.aggredate([{$group:{_id:"$age",num_tutorial:{$sum:1}}}])
//类似与
select age,count(*) from col group by age //求和
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$sum:"$age"}}}])
//平均值
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$avg:"$age"}}}])
//获取集合中所有文档对应值的最大值
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$max:"$age"}}}])
//获取集合中所有文档对应值的最小值
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$min:"$age"}}}])
//在结果文档中插入一个值到数组中
db.col.aggregate([{$group:{_id:"$age",url:{$push:"$url"}}}])
//根据文档的排序获取一个文档数据
db.col.aggregate([{$group:{_id:"$age",first_url:{$first:"$url"}}}])
//根据文档的排序获取最后一个文档数据
db.col.aggregate([{$group:{_id:"$age",last_url:{$last:"$url"}}}])
管道概念
管道在Unix和Linux中一般用于前一个命令的输出结果作为下一个命令的参数。
MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。
match：用于过滤数据，只输出符合条件的文档。match：用于过滤数据，只输出符合条件的文档。match使用MongoDB的标准查询操作。
limit：用来限制MongoDB聚合管道返回的文档数。limit：用来限制MongoDB聚合管道返回的文档数。skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。group：将集合中的文档分组，可用于统计结果。
$sort：将输入文档排序后输出。
```
db.article.aggregate(
{$project:(
title:1,
author:1,)
})
db.articles.aggregate([
{$match :{score : {$gt :70,$lte:90}}},
{$group :{_id:null,count:{$sum:1}}}
])
db.article.aggregate({
$skip:5
})
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
18. 复制
mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。
mongodb各个节点常见的搭配方式为：一主一从、一主多从。
主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。
特征
多个节点的集群
任何节点都可以做主节点
所有写入操作都在主节点上
自动故障一处
自动恢复 mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"
rs.add(HOST_NAME:PORT)
19. 备份与恢复
```
mongodump -h dbhost -d dbname -o dbdirectory
```
参数说明：
-h：MongDB所在服务器地址，例如127.0.0.1 或者127.0.0.1：27017。
-d：需要备份的数据库实例，例如test。
-o：备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
实例
进入Mongodb安装目录用命令行输入 mongodump
//备份所有mongoDB数据
mongodump --host HOST_NAME --port PORT_NUMBER
//被封制定数据库的集合
mongodump --collection COLLECTION --db DB_NAME
恢复 mongorestore -h <hostname><:port> -d dbname <path>
参数说明：
–host <:port>, -h <:port>：MongoDB所在服务器地址，默认为： localhost:27017。
–db, -d：需要回复的数据库实例。
–drop：回复的时候，先删除当前数据，然后恢复备份的数据，恢复后，备份后添加修改的数据会销毁，谨慎使用。
：mongorestore的最后一个参数，设置备份数据所在位置，不能懂事制定和–dir选项,–dir 也可以设置备份目录。
–dir：指定备份的目录，不能同时指定和–dir选项。
实例
进入Mongodb安装目录用命令行输入 mongorestore
20. 监控
MongoDB中提供了mongostat 和 mongotop 两个命令来监控MongoDB的运行情况。
mongostat 命令
进入Mongodb安装目录用命令行输入mongostat mongostat
mongotop 命令
进入Mongodb安装目录用命令行输入mongotop
输出结果参数说明：
ns:数据库命名空间，结合数据库名称和集合。
db:数据库名称。
total:mongod话费的时间工作，在这个操作过程中。
read:提供了大量的时间，这mongod花费在执行读操作，在此命名空间。
write:提供这个命名空间进行写操作，这mongod花了大量的时间。
21. MongoDB JDBC
驱动下载http://mongodb.github.io/mongo-java-driver/
“`
//链接数据库
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");
System.out.println("Connect to database successfully");
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//账号密码登陆
import java.util.ArrayList;
import java.util.List;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC {
public static void main(String[] args){
try {
//连接到MongoDB服务,如果是远程连接可以替换“localhost”为服务器所在IP地址
//ServerAddress()两个参数分别为 服务器地址 和 端口
ServerAddress serverAddress = new ServerAddress("localhost",27017);
List<ServerAddress> addrs = new ArrayList<ServerAddress>();
addrs.add(serverAddress);
//MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());
List<MongoCredential> credentials = new ArrayList<MongoCredential>();
credentials.add(credential);
//通过连接认证获取MongoDB连接
MongoClient mongoClient = new MongoClient(addrs,credentials);
//连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");
System.out.println("Connect to database successfully");
} catch (Exception e) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//创建集合
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
mongoDatabase.createCollection("test");
System.out.println("集合创建成功");
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//获取集合
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
MongoCollection<Document> collection = mongoDatabase.getCollection("test");
System.out.println("集合 test 选择成功");
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//插入文档
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
MongoCollection<Document> collection = mongoDatabase.getCollection("test");
System.out.println("集合 test 选择成功");
//插入文档
/**
+ 1. 创建文档 org.bson.Document 参数为key-value的格式
+ 2. 创建文档集合List<Document>
+ 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document)
+ */
Document document = new Document("title", "MongoDB").
append("description", "database").
append("likes", 100).
append("by", "Fly");
List<Document> documents = new ArrayList<Document>();
documents.add(document);
collection.insertMany(documents);
System.out.println("文档插入成功");
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//检索文档
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
MongoCollection<Document> collection = mongoDatabase.getCollection("test");
System.out.println("集合 test 选择成功");
//检索所有文档
/**
+ 1. 获取迭代器FindIterable<Document>
+ 2. 获取游标MongoCursor<Document>
+ 3. 通过游标遍历检索出的文档集合
+ */
FindIterable<Document> findIterable = collection.find();
MongoCursor<Document> mongoCursor = findIterable.iterator();
while(mongoCursor.hasNext()){
System.out.println(mongoCursor.next());
}
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//更新文档
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
MongoCollection<Document> collection = mongoDatabase.getCollection("test");
System.out.println("集合 test 选择成功");
//更新文档 将文档中likes=100的文档修改为likes=200
collection.updateMany(Filters.eq("likes", 100), new Document("$set",new Document("likes",200)));
//检索查看结果
FindIterable<Document> findIterable = collection.find();
MongoCursor<Document> mongoCursor = findIterable.iterator();
while(mongoCursor.hasNext()){
System.out.println(mongoCursor.next());
}
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
//删除第一个文档
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
MongoCollection<Document> collection = mongoDatabase.getCollection("test");
System.out.println("集合 test 选择成功");
//删除符合条件的第一个文档
collection.deleteOne(Filters.eq("likes", 200));
//删除所有符合条件的文档
collection.deleteMany (Filters.eq("likes", 200));
//检索查看结果
FindIterable<Document> findIterable = collection.find();
MongoCursor<Document> mongoCursor = findIterable.iterator();
while(mongoCursor.hasNext()){
System.out.println(mongoCursor.next());
}
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
```
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本