mongoDB

CAP （三者只可取两者）

CAP原则又称CAP定理，指的是在一个分布式系统中， Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可得兼。
一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）
可用性（A）：保证每个请求不管成功或者 失败都有响应。
分区容忍性（P）：系统中任意信息的丢失 或失败不会影响系统的继续运作。

ACID

BASE

什么是MongoDB

1. c++编写，分布式文件存储的开源数据库系统
2. 将数据存储为一个文档，数据结构由key-value组成，类似json格式

特点

1. 面向文档存储
2. 建立任何属性的索引来实现更快的排序
3. 分布式扩展？？？
4. 查询指令使用json形式的标记
5. 支持Map/reduce，批量处理数据
6. 有GridFS,适用存放大量小文件
7. 支持各种编程语言

层次关系 database>collection=table(mysql)>rows=documents(mysql)

mysql	mongoDB
database	database
table	collection
rows	documents

ObjectId详解

ObjectId是一个12字节的 BSON 类型字符串。按照字节顺序，一次代表：
4字节：UNIX时间戳
3字节：表示运行MongoDB的机器
2字节：表示生成此_id的进程
3字节：由一个随机数开始的计数器生成的值

612f33c0 6bc326 9c94 47df8e
时间戳 机器码 PID 计数器

MongoDB初始化

1. 先进入MongoDB的bin目录
2. 启动服务：./mongod --dbpath 文件夹路径
3. 连接服务：./mongo

数据库操作

use DATABASE_NAME（创建数据库）
如果数据库不存在，则创建数据库，否则切换到指定数据库。
db（查看当前使用数据库）
show dbs（查看所有数据库）
db.dropDatabase() 删除当前数据库

集合（表）操作

db.createCollection(“name”)（创建集合，类似数据库中表）
show tables （查看集合，也可用show collections）
db.collection.drop() （删除集合）

插入文档insert

1. db.collection_name.insertOne(document)
db.collection_name.insertMany([documents])
2. examples
   db.pz.stu.insertOne({"name", "ming"})
db.pz.stu.insertMany([{"name", "ming"}, {"name", "wang"}])

更新文档update

1. 参数说明：

   query : update的查询条件，类似sql update查询内where后面的。

   update : update的对象和一些更新的操作符（如$,$inc…）等，也可以理解为sql update查询内set后面的

2. examples
   更改单条语句
   db.pz.stu.updateOne({"name", "wang"}, {$set: {"name": "haha"}})
   更改多条语句
   db.pz.stu.updateMany({"name", "wang"}, {$set: {"name": "haha"}})

删除文档delete

1. 参数说明：
   query :（可选）删除的文档的条件。
2. examples
   db.stu.deleteOne({"name": "ming"})
db.stu.deleteMany({"name": "ming"})

查询文档find

db.collection.find(query, projection)

1. 参数说明
   query ：可选，使用查询操作符指定查询条件
   projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：db.col.find().pretty()
2. examples
   投影
   db.inventory.find({$or: [ {qty: {$eq: 50} }, {qty: {$eq: 80} } ] }, {_id:0, item:1, qty:1}).pretty()
   正则查询
   db.people.find({user_id: {$regex:/bc/ }})
   正序排序
   db.people.find().sort({user_id: 1})
   逆序排序
   db.people.find().sort({user_id: -1})
   统计符合条件的记录
   db.people.find().count({user_id: {$exists: true}})
   查询n条数据并略过前m条数据
   db.people.find().limit(n).skip(m)
   在原来的基础上增加数值
   db.people.update({status: "A" }, {$inc: {age: 3 } })
   去重
   db.people.distinct("status")

查询练习

//创建数据库
use db1
//删除数据库db1
db.dropDatabase()

//创建集合
db.createCollection("col1")
//删除集合
db.col1.drop()



use db1
db.createCollection('col1')
//插入文档
db.col1.insert({"name": "zhangsan","age":18})
db.col1.insertOne({"name": "zhaoliu","age":15})
//插入多条
db.col1.insertMany( [ {"name": "wangwu","age":23}, {"name": "lisi","age":19}])

//查找文档
db.col1.find().pretty()
//准确查找
db.col1.find({"age": 18}).pretty()
db.col1.find({"age": {"$gt": 18}}).pretty()
//查询多个字段
db.col1.find({"name": "zhangsan", "age": 18})
db.col1.find({"$and":[ {"name": "zhangsan"}, {"age": 18}]})
db.col1.find({"$or":[ {"age": 18}, {"name": "lisi"}]})
//in（类型相同时用）
db.col1.find({"age": {"$in": [19, 15, 23]}})
db.col1.find({"$and": [{ "name": {"$in": ["zhangsan", "lisi","wangwu"]}}, {"age": {"$in": [15, 23]}}]})
//获取integer类型的数据
//可选double ,string ,object ,array binary data ,undefined, object id, boolean ,date,  null
db.col1.find({"name" : {"$type" : "string"}})
//正则查询
db.col1.find({"name": {"$regex": "z.*"}})
//跳过前9条，查询3条 10-13
db.col1.find().limit(3).skip(9);
//去重
db.col1.distinct("age")


//删除文档
db.col1.insertOne({"name": "xiaoyao","age":12})
db.col1.remove({"name": {"$regex": ".*"}}, false)
db.col1.deleteOne({"name": "xiaoyao"})
db.col1.deleteMany({"name": "xiaoyao"})


//更新文档
db.col1.insertOne({"name": "yanqi","age":33})
//更新第一个符合条件的文档
db.col1.updateOne({"name": "yanqi"},{"$set":{ "age": 34, "name": "yanqi1"} })
//更新所有符合条件的文档
db.col1.updateMany({ "age": 34},{ "$set":{ "age": 22, "name": "yanqi"} })
//增加字段
db.col1.updateOne({ "age": 22}, { "$set": { "sex": "man", "nickname": "dugu"}})
//删除字段
db.col1.updateOne({ "age": 22}, { "$unset": { "sex":"", "nickname": ""}})
//增加文档中字段的值
db.col1.updateOne({ "age": 23}, {"$inc": { "age": 111}})
//减少文档中字段的值
db.col1.updateOne({ "age": 134}, {"$inc": {"age": -111}})
//重命名字段
db.col1.updateOne({"age": 22}, {"$rename": {"age": "year"}})
db.col1.updateOne({"year": 22}, {"$rename": {"year": "age"}})

//替换文档
db.col1.insertOne({"name": "gaba","age":55})
db.col1.replaceOne({"age": 55}, {"name": "gaba1", "age":66, "phone": 1233212})

查询练习

// 1.	创建两个集合，1）以你名字首字母开头的集合，2）你的学号作为集合的名字
use test
db.createCollection("pxw")
db.createCollection("123")

//2.	把这两个集合给删除了
db.getCollection("pxw").drop()
db.getCollection("123").drop()
//3.	创建一个集合名叫：pzrg，插入10条学生信息后，查询出来。
db.createCollection("pzrg")

class Score {
    constructor(start, end) {
        this._math = Student.genRandInt(start, end);
        this._chinese = Student.genRandInt(start, end);
        this._english = Student.genRandInt(start, end);
    }

    get math() {
        return this._math;
    }

    set math(value) {
        this._math = value;
    }

    get chinese() {
        return this._chinese;
    }

    set chinese(value) {
        this._chinese = value;
    }

    get english() {
        return this._english;
    }

    set english(value) {
        this._english = value;
    }
}

class Student {

    // constructor
    constructor() {
        this._name = this.genName("金克斯");
        this._address = this.genAddress("祖安");
        this._tel = this.genTel();
        this._createDate = new Date();
        this._score = new Score(50, 100);
        this._status = this.genStatus();
    }

    //左右闭区间
    static genRandInt(start, end) {
        return start + Math.round(Math.random() * (end - start));
    }

    genTel() {
        let res = "1"
        for (let i = 0; i < 10; i++) {
            res += genRandInt(0, 9);
        }
        return res;
    }

    genStatus() {
        let res = "D";
        let maxScore = 300;
        let sum = this.score.math + this.score.chinese + this.score.english;
        if (sum >= maxScore * 0.9) res = "A";
        else if (sum >= maxScore * 0.75) res = "B";
        else if (sum >= maxScore * 0.6) res = "C";
        return res;
    }

    genName(prefix) {
        return prefix + String.fromCharCode(genRandInt(65, 90));
    }

    genAddress(prefix) {
        return prefix + String.fromCharCode(genRandInt(65, 90));
    }


    get name() {
        return this._name;
    }

    set name(value) {
        this._name = value;
    }

    get address() {
        return this._address;
    }

    set address(value) {
        this._address = value;
    }

    get tel() {
        return this._tel;
    }

    set tel(value) {
        this._tel = value;
    }

    get createDate() {
        return this._createDate;
    }

    set createDate(value) {
        this._createDate = value;
    }

    get score() {
        return this._score;
    }

    set score(value) {
        this._score = value;
    }

    get status() {
        return this._status;
    }

    set status(value) {
        this._status = value;
    }
}

for (let i = 0; i < 10; i++) {
    let stu = new Student();
    db.pzrg.insertOne({
        "name": stu.name,
        "address": stu.address,
        "tel": stu.tel,
        "createDate": stu.createDate,
        "score": {
            "math": stu.score.math,
            "chinese": stu.score.chinese,
            "english": stu.score.english
        },
        "status": stu.status
    });
}
db.pzrg.find().pretty()

//4.	删除所有status为D的学生信息，然后格式化查询出来。
db.pzrg.deleteMany({"status": "D"})
db.pzrg.find().pretty()

//5.	随意修改一条信息的{name,address,tel,status}，只查询这一条信息，修改前和修改后都查询出来。
db.pzrg.find({"name": "金克斯Y"}).pretty()
db.pzrg.updateOne({"name": "金克斯Y"}, {"$set": {"name": "金克斯Y1", "address": "祖安酒馆", "tel": 12365978956, "status": "A"}})
db.pzrg.find({"name": "金克斯Y1"}).pretty()

//6.	查询status是“A“或”B“的学生信息。
db.pzrg.find({"$or": [{"status": "A"}, {"status": "B"}]})

//7.	查询math成绩大于90的学生信息，只显示姓名和电话。
db.pzrg.find({"score.math": {"$gt": 90}}, {"_id": false, "name": true, "tel": true})

//8.	查询math成绩或者english成绩都大于80的学生信息
db.pzrg.find({"$and": [{"score.math": {"$gt": 80}}, {"score.english": {"$gt": 80}}]})

//9.	查询学生status为A，且各科成绩大于80的学生信息。
db.pzrg.find({"$and": [{"status": "A"}, {"score.math": {"$gt": 80}}, {"score.english": {"$gt": 80}}, {"score.chinese": {"$gt": 80}}]})

//10.	查找名字以“王“开头的学生信息。
db.pzrg.find({"name": {"$regex": "^王.*$"}})
db.pzrg.find({"name": {"$regex": /^王/}})

//善后
db.pzrg.deleteMany({"name": {"$regex": ".*"}})
db.getCollection("pzrg").drop()
db.dropDatabase()

索引

use test
db.createCollection("idt")
for (let i = 0; i < 10; i++) {
    db.idt.insertOne({
        "name": "哈克" + i,
        "age": 30 + i,
        "address": "唐宁街1" + i + "号",
        "createDate": new Date(),
        "score": {
            "math": Math.round(Math.random() * 100),
            "chinese": Math.round(Math.random() * 100)
        },
        "status": String.fromCharCode(65 + i)
    });
}
db.idt.find().pretty()

//查看所有索引
db.idt.getIndexes()
//删除索引
db.idt.dropIndex({age:1})
//删除所有索引
db.idt.dropIndexes()

//创建文本索引
db.stores.insertMany(
    [{ _id: 1, name: "Java Hut", description: "Coffee and cakes" },
    { _id: 2, name: "Burger Buns", description: "Gourmet hamburgers" },
    { _id: 3, name: "Coffee Shop", description: "Just coffee" },
    { _id: 4, name: "Clothes Clothes Clothes", description: "Discount clothing" },
    { _id: 5, name: "Java Shopping", description: "Indonesian goods" }]
)
db.stores.createIndex({name:"text",description:"text"})
//相关性	值越高，匹配度越高
db.stores.find(
    //查询条件
    {$text:{$search:"java coffee shop"}},
    //投影
    {score:{$meta:"textScore"}}
).sort({score:{$meta:"textScore"}})
//减号可以去除查询条件
db.stores.find({
    $text:{$search:"-java coffee shop"}
})
// 查找含有“java”，“coffee”，“shop”的数据
db.stores.find({
    $text:{$search:"java coffee shop"}
})

//建立单键索引
//"1正序，-1逆序"
db.idt.createIndex({"age": 1})
db.idt.find({"age": 36}).explain()

//建立复合索引(Compound Indexes)指一个索引包含多个字段，用法和单键索引基本一致,mongoDB中一个复合索引最多可以包含32个字段
db.idt.createIndex({"name": 1, "age": 1})
db.idt.find({"name": "哈克", "age": 37}).explain()

//建立多键索引(mutiKey Indexes)是建在数组上的索引，在mongoDB的document中，有些字段的值为数组，多键索引就是为了提高查询这些数组的效率
//准备数据
db.classes.insertMany([
    {
        "classname":"class1",
        "students":[{name:'jack',age:30},
            {name:'tom',age:32},
            {name:'lilei',age:35}]
    },
    {
        "classname":"class2",
        "students":[{name:'lucy',age:30},
            {name:'jim',age:33},
            {name:'jarry',age:36}]
    }]
)
//
db.classes.createIndex({'students.age':1})
db.classes.find({"students.age": 36}).explain()

//建立哈希索引
db.idt.createIndex({"name": "hashed"})
db.idt.find({"name": "哈克"}).explain()

//建立唯一索引
db.idt.createIndex({name:1},{unique:true})

//建立局部索引
//idt集合中age>25的部分添加age字段索引
db.idt.createIndex(
    {age:1},
    { partialFilterExpression: {age:{$gt: 35 }}}
)
//查询age<25的document时，因为age<35的部分没有索引，会全表扫描查找
db.idt.find({age:33}).explain()
//查询age>25的document时，因为age>35的部分创建了索引，会使用索引进行查找
db.idt.find({age:36}).explain()

//建立稀疏索引
//稀疏索引(sparse indexes)在有索引字段的document上添加索引，如在address字段上添加稀疏索引时，只有document有address字段时才会添加索引。
// 而普通索引则是为所有的document添加索引，使用普通索引时如果document没有索引字段的话，设置索引字段的值为null。
db.idt.createIndex({"age":1}, {sparse:true})

// TTL索引(TTL indexes)是一种特殊的单键索引，用于设置document的过期时间，mongoDB会在document过期后将其删除
// TTL索引只能设置在date类型字段(或者包含date类型的数组)上，过期时间为字段值+exprireAfterSeconds；
// document过期时不一定就会被立即删除，因为mongoDB执行删除任务的时间间隔是60s；
// capped Collection(固定的集合)不能设置TTL索引，因为mongoDB不能主动删除capped Collection中的document。
db.idt.createIndex({"createDate":1}, { expireAfterSeconds: 120 })

//善后
db.idt.deleteMany({"name": {"$regex": ".*"}})
db.getCollection("idt").drop()
db.classes.deleteMany({"classname": {"$regex": ".*"}})
db.getCollection("classes").drop()
db.dropDatabase()


/**
 stage的类型。类型列举如下：

 COLLSCAN：全表扫描

 IXSCAN：索引扫描

 FETCH：根据索引去检索指定document

 SHARD_MERGE：将各个分片返回数据进行merge

 SORT：表明在内存中进行了排序

 LIMIT：使用limit限制返回数

 SKIP：使用skip进行跳过

 IDHACK：针对_id进行查询

 SHARDING_FILTER：通过mongos对分片数据进行查询

 COUNT：利用db.coll.explain().count()之类进行count运算

 COUNTSCAN：count不使用Index进行count时的stage返回

 COUNT_SCAN：count使用了Index进行count时的stage返回

 SUBPLA：未使用到索引的$or查询的stage返回

 TEXT：使用全文索引进行查询时候的stage返回

 PROJECTION：限定返回字段时候stage的返回

 对于普通查询，希望看到stage的组合(查询的时候尽可能用上索引)：

 Fetch+IDHACK

 Fetch+ixscan

 Limit+（Fetch+ixscan）

 PROJECTION+ixscan

 SHARDING_FITER+ixscan

 COUNT_SCAN

 不希望看到包含如下的stage：
 COLLSCAN(全表扫描),SORT(使用sort但是无index),不合理的SKIP,SUBPLA(未用到index的$or),COUNTSCAN(不使用index进行count)
 */

聚合

//命令
//project, match, group,count,
//sum,avg,push,pop, min, max,sort,first,last,unwind,limit,skip

db.orders.aggregate(
    //$match就是查询条件
    {"$match": {"status": "A"}},
    //_id就是要以什么分组，必须写
    // 加上$代表引用
    {"$group": {"_id": "$cust_id", "total": {"$sum": "$price"}}},
    //不显示_id
    {"$project": {"_id": false}}
)

function genGender(){
    let i = Math.round(Math.random())
    let res = "男"
    if (i === 0) res = "女";
    return res;
}

for(let i=0; i<100; i++){
    db.stu.insertOne({
        name: "懒树"+i+"号",
        gender: genGender(),
        age: 20+i%9,
        date: new Date()
    })
}

// 统计学生数量
db.stu.aggregate(
    {"$count": "name"},
    {"$set": {"学生总数": "$name"}},
    {"$project": {"name": false}}
)
db.stu.aggregate(
    {"$group": {"_id": null, "学生总数": {"$sum": 1}}},
    {"$project": {"_id": false}}
)

// 统计学生年龄总和
db.stu.aggregate(
    {"$group": {"_id": null, "年龄总和": {"$sum": "$age"}}},
    {"$project": {"_id": false}}
)

// 男女各多少人
db.stu.aggregate(
    {"$group": {"_id": "$gender", "总数": {"$sum": 1}}},
    {"$project": {"_id": 0, "性别": "$_id", "总数": true}}
)

// 平均年龄
db.stu.aggregate(
    {"$group": {"_id": null, "平均年龄": {"$avg": "$age"}}},
    {"$project": {"_id": 0}}
)

// 男女平均年龄
db.stu.aggregate(
    {"$group": {"_id": "$gender", "平均年龄": {"$avg": "$age"}}},
    {"$project": {"_id": 0, "性别": "$_id", "平均年龄": true}}
)

// 计算大于22岁人数
db.stu.aggregate(
    {"$match": {"age": {"$gt": 22}}},
    {"$count": "age"},
    {"$project": {"_id": false, "大于22岁的人数": "$age"}}
)
// 得到男女姓名的名单的数组
db.stu.aggregate(
    {"$group": {"_id": "$gender", "姓名": {"$push": "$name"}}},
    {"$project": {"_id": false, "性别": "$_id", "姓名": true}}
)

// 格式化日期
db.stu.aggregate(
    {"$project": {"年": {"$year": "$date"},
            "月": {"$month": "$date"},
            "日": {"$dayOfMonth": "$date"},
            "星期":{"$dayOfWeek": "$date"},
            "一年中的第几天": {"$dayOfYear": "$date"}}},
    {"$project": {"_id": false}}
)

// 返回人口超过1000万的州
db.zipcodes.aggregate(
    {"$match": {"pop": {"$gte": 1000}}}
)
// 按州分组，求每个州的内人口数量
db.zipcodes.aggregate(
    {"$group": {"_id": "$state", "人口数量": {"$sum": "$pop"}}},
    {"$project": {"_id": false, "州": "$_id","人口数量": true}}
)

// 按州返回城市平均人口(计算每个州的城市平均人口)
// 按州，城市分组
// 把每个州中所有城市人口总数加起来
// 按州分组
db.zipcodes.aggregate(
    {"$group": {"_id": ["$state", "$city"],
            "总人口": {"$sum": "$pop"}}},
    {"$group": {"_id": "$state", "avg": {"$avgCity": "$总人口"}}}
)
//按州返回人口最多和最少的城市
db.zipcodes.aggregate(
    {$group:{
            _id:{state:"$state", city:"$city"},
            totalCity:{$sum:"$pop"}
        }},
    {$sort:{totalCity:1}},
    {$group:{
            _id:"$_id.state",
            laggestCity:{$last:"$_id.city"},
            laggestPop:{$last:"$totalCity"},
            minimalCity:{$first:"$_id.city"},
            minimalPop:{$first:"$totalCity"}
        }}
)

//以大写字母顺序返回用户名。聚合包括users集合中所有文档的用户名。您可以这样做来规范用户名以进行处理
db.users.aggregate(
    {"$project": {"_id": false, "name": {"$toUpper": "$_id"}}},
    {"$sort": {"name": 1}}
)

//返回按加入月份排序的用户名
db.users.aggregate(
    {"$project": {"_id": false,
            "name": {"$toUpper": "$_id"},
            "month_joined": {"$month":"$joined"}}},
    {"$sort": {"month_joined": 1}}
)

//返回每月用户加入总数
db.users.aggregate(
    {"$project": {"_id": false, "month_joined": {"$month":"$joined"}}},
    {"$group": {"_id": "$month_joined", "加入的人数": {"$sum": 1}}},
    {"$project": {"_id": false, "月份": "$_id", "加入的人数": true}}
)

//返回五个最常见的“喜欢”
db.users.aggregate(
    //把数组拆开
    {"$unwind": "$likes"},
    //统计每个项目喜欢的人数
    {"$group": {"_id": "$likes", "喜欢的人数": {"$sum": 1}}},
    //逆序
    {"$sort":{"喜欢的人数": -1}},
    //前5条
    {"$limit": 5},
    {"$project": {"_id":false, "项目": "$_id", "喜欢的人数": true}}
)

java操作mongodb

导包

mongo-java-driver-3.9.1.jar

操作

基本操作

import com.mongodb.Block;
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;
import com.mongodb.client.model.Updates;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.Document;

import java.util.ArrayList;
import java.util.Arrays;

public class MongoConn {
    public static void main(String[] args) {
        // 创建客户端对象
        MongoClient mongoClient = new MongoClient();
        // 访问数据库
        MongoDatabase database = mongoClient.getDatabase("mydb");
        // 访问集合
        MongoCollection<Document> collection = database.getCollection("test");
        // 调用方法
        MongoConn.insertMany(collection);
        // 关闭连接
        mongoClient.close();
    }

    // 删除多个文档
    public static void deleteMany(MongoCollection<Document> collection){
        DeleteResult result = collection.deleteMany(Filters.lt("i", 3));
        System.out.println(result);
    }

    // 删除单个文档
    public static void deleteOne(MongoCollection<Document> collection){
        DeleteResult result = collection.deleteOne(Filters.eq("i", 110));
        System.out.println(result);
    }

    // 修改多个文档
    public static void updateMany(MongoCollection<Document> collection){
        UpdateResult result = collection.updateMany(Filters.gt("i", 100),
                Updates.mul("i", 1/2));
        System.out.println(result);
    }

    // 修改单个文档
    public static void updateOne(MongoCollection<Document> collection){
        UpdateResult result = collection.updateOne(Filters.eq("i", 10),
                new Document("$set", new Document("name", "updateOne")));
        System.out.println(result);
    }


    // 过滤查询
    public static void findFilter(MongoCollection<Document> collection){
        Document first = collection.find(Filters.eq("i", 71)).first();
        System.out.println(first.toJson());
    }

    // 遍历数据
    public static void findIter(MongoCollection<Document> collection){
        FindIterable<Document> documents = collection.find();
        for (Document document : documents) {
            System.out.println(document.toJson());
        }
    }

    // 查询集合中的第一个数据
    public static void findFirst(MongoCollection<Document> collection){
        Document first = collection.find().first();
        System.out.print(first.toJson());
    }

    // 插入多个文档
    public static void insertMany(MongoCollection<Document> collection){
        ArrayList<Document> docs = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            docs.add(new Document("i", i));
        }
        collection.insertMany(docs);
    }

    // 插入单个文档
    public static void insertOne(MongoCollection<Document> collection){
        // 插入文档
        Document doc = new Document("name", "MongoDB")
                .append("type", "database")
                .append("count", 1)
                .append("versions", Arrays.asList("v3.2", "v3.0", "v2.6"))
                .append("info", new Document("x", 203).append("y", 102));
        // 插入单个文档
        collection.insertOne(doc);
    }
}

聚合操作

import com.mongodb.MongoClient;
import com.mongodb.client.AggregateIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Accumulators;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import org.bson.Document;

import java.util.Arrays;

public class MongoConn3 {
    public static void main(String[] args) {
        // 初始化连接
        MongoClient client = new MongoClient();
        //连接数据库
        MongoDatabase database = client.getDatabase("db");
        // 连接集合
        MongoCollection<Document> collection = database.getCollection("orders");
        // todo 操作代码
        aggregate2(collection);

        // 关闭连接
        client.close();
    }

    // 1.状态是A
    // 2.按照cust_id分组，统计price的值
    public static void aggregate1(MongoCollection<Document> collection) {
        AggregateIterable<Document> aggregate = collection.aggregate(
                Arrays.asList(
                        Aggregates.match(Filters.eq("status", "A")),
                        Aggregates.group("$cust_id", Accumulators.sum("total", "$price"))
                )
        );
        for (Document document : aggregate) {
            System.out.println(document);
        }
    }

    // 1.状态为A
    // 2.按照订单里面的分类，统计商品的购买数量
    // 3.查询出购买数量大于30的数值
    public static void aggregate2(MongoCollection<Document> collection) {
        AggregateIterable<Document> aggregate = collection.aggregate(
                Arrays.asList(
                        Aggregates.match(Filters.eq("status", "A")),
                        Aggregates.unwind("$items"),
                        Aggregates.group("$items.sku", Accumulators.sum("total", "$items.qty")),
                        Aggregates.match(Filters.gt("total", 30))
                )
        );
        for (Document document : aggregate) {
            System.out.println(document.toJson());
        }
    }

    public static void find(MongoCollection<Document> collection) {
        for (Document document : collection.find()) {
            System.out.println(document);
        }
    }
}

操作pojo

import com.mongodb.MongoClient;
import com.mongodb.MongoClientSettings;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;

import java.util.Date;

import static org.bson.codecs.configuration.CodecRegistries.fromProviders;
import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;

public class MongoConn2 {
    public static void main(String[] args) {
        // 实体类 pojo bean entity
        // Mogo设置pojo处理数据
        // 设置编码注册表
        CodecRegistry pojoCodecRegistry = fromRegistries(MongoClientSettings.getDefaultCodecRegistry(),
                fromProviders(PojoCodecProvider.builder().automatic(true).build()));

        // 初始化连接
        MongoClient client = new MongoClient();
        //连接数据库
        // todo 在这添加上.withCodecRegistry(pojoCodecRegistry)
        MongoDatabase database = client.getDatabase("db").withCodecRegistry(pojoCodecRegistry);
        // 连接集合
        MongoCollection<Orders> collection = database.getCollection("orders", Orders.class);
        // todo 操作代码
        Orders orders = new Orders();
        orders.setCustId("yxd");
        orders.setOrdDate(new Date());
        orders.setStatus("A");
        orders.setPrice(19.00);
        collection.insertOne(orders);
        // 关闭连接
        client.close();
    }
}

import java.util.Date;

public class Orders {
    private String custId;
    private Date ordDate;
    private String status;
    private Double price;

    public String getCustId() {
        return custId;
    }

    public void setCustId(String custId) {
        this.custId = custId;
    }

    public Date getOrdDate() {
        return ordDate;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public void setOrdDate(Date ordDate) {
        this.ordDate = ordDate;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}