Java spring boot BmongoDB 实现增删改查功能（模糊查询，条件查询/修改(更新、删除)，批量插入）(一)

叁歲伎倆 2023-09-27 15:06 15阅读 0赞

### 关于使用mongodb原生语句（包括增删改查，除了聚合，正则表达式一些进阶方法，基本的使用都覆盖到了） ###

**Java中****类****在mongodb中是****集合****(collection)且相当于mysql的****表（mysql和MongoDB语句都不用加分号）**

创建集合（但 MongoDB 中，不需要创建集合,插入一些文档时MongoDB 会自动创建。）

创建集合  db.createCollection(name, options)
    参数说明：name:要创建的集合名称;options:可选参数,指定有关内存大小及索引的选项
    db.createCollection("mongoBook1")
    创建固定集合 nosql，整个集合空间大小 6142800 KB, 文档最大个数为 10000 个
    db.createCollection("nosql", 
    { capped : true, autoIndexId : true, size :6142800, max : 10000 } )

插入（增）/修改（更新，删除）

insert: 若新增数据主键已经存在，会抛 org.springframework.dao.DuplicateKeyException

异常提示主键重复，不保存当前数据。

save: 若新增数据的主键已经存在，则会对当前已经存在的数据进行修改操作。

//新增数据的两种方式.save、insert
    
    db.book.save({"name":"springboot"})
    db.book.insert({"name":"mangoDB01"})
    
    //至此，已经在book集合中创建了springboot和mangoDB01两个文档，
    
    db.book.save([{"id":1,"name":"springboot1",type:"工具书"},
                 {"id":2,"name":"springboot2",type:"工具书"},
                 {"id":3,"name":"springboot3",type:"工具书"}])
    
    //虽然指定了id(添加了id字段),(就算不指定)但还是会在插入文档的同时，自动生成一个附加的_id字段 
    //_id和id并不相同，千万不要搞混
    
    //删除所有工具书的记录
    db.book.remove({type:"工具书"})
    //删除所有记录
    db.book.remove({})
    
    //删除
    db.book.remove({type:"工具书"})
    
    db.book.insertMany([{
        title:'批量插入1',
        author:'wang',
        publishedData: new Date(),
        tags:['mongo', '批量插入'],
        favCount: 19
    }, {
        title:'批量插入2',
        author:'zhou',
        publishedData: new Date(),
        tags:['mongo', '批量插入'],
        favCount: 20
    }])
    
    //当然也可以写一个for循环去将文档插入/添加到集合
    for(var i = 1;i<=20;i++)
    db.book.insert({"name":"Book User"+i,"type":"BBB"})
    
    db.book.insertMany([/* 1 */{
        "_id" : ObjectId("5ec8c716a0d7734e6c2f16fa"),
        "name" : "数据1",
        "datas" : [ 
            "AA", 
            "BB", 
            "CC"
        ],
    },
    /* 2 */{
        "_id" : ObjectId("5ec8c74ca0d7734e6c2f16fb"),
        "name" : "数据2",
        "datas" : [ 
            "AA", 
            "DD", 
            "EE"
        ],
    }])
    //删除name为数据1的datas数组里面的AA(删除指定位置的元素)
    //(并不是像remove一样把整个/* 1 */文档都删除)
    db.getCollection('book').updateMany({'name':'数据1'},
                                {'$pull': {'datas':'AA'}})
    
    //删除所有数据数组datas里面的AA(条件删除)
    db.getCollection('book').updateMany({'datas':'AA'},
                                {'$pull': {'datas':'AA'}})
    
    db.book.save(/* 3 */{
        "_id" : ObjectId("5ec8f2b4a0d77352bc90c929"),
        "name" : "数据3",
        "datas" : [ 
            {
                "time" : "99",
                "counts" : NumberLong(30)
            }, 
            {
                "time" : "100",
                "counts" : NumberLong(88)
            }
        ]
    })
    //删除文档数组元素(删除time="9999"的datas项,datas数组此时就只有一个文档了)
    db.getCollection('book').updateMany({},
                    {$pull:{datas:{time:"9999"}}})
    //或者
    db.getCollection('book').updateMany({'datas.time':"9999"},
                    {$pull:{datas:{time:"9999"}}})
    
    //删除多层嵌套数组某个文档(数组 datas 里面有数组 counts ，现在删除的是counts 的数据)
    db.book.save(/* 4 */{
        "_id" : ObjectId("5ecde35f3bf8aad5abfe111d"),
        "name" : "数据4",
        "datas" : [ 
            {
                "time" : "9999",
                "counts" : [ 
                    {
                        "man" : "张山",
                        "girl" : "小丽"
                    }, 
                    {
                        "man" : "李四",
                        "girl" : "小红"
                    }
                ]
            }, 
            {
                "time" : "10000",
                "counts" : [ 
                    {
                        "man" : "王五",
                        "girl" : "小花"
                    }
                ]
            }
        ]
    })
    //删除张山这个文档
    db.book.updateMany({'datas.time':"9999"},
            {$pull:{'datas.$.counts':{'man':"张山"}}})
    
    //删除数组里面某个集合键值(这里不用 pull 命令，改用upset用upset来删除指定键值)
    db.book.updateMany({'datas.time':"9999"},
            {$unset:{'datas.$.time':null}})
    //或
    db.book.updateMany({'datas.time':"9999"},
            {$unset:{'datas.$.time':""}})
    
    //修改数据"name":"springboot"为"name":"springboot02"
    //update:遇到满足条件的第一条数据进行修改,前面是查询条件(filter,过滤器)，后面是要修改的值
    db.book.update({"name":"springboot"},
             {$set{"name":"springboot02"}})
    //updateOne:修改满足条件的第一条数据。
    //语法：db.collection.updateOne(filter,update,options)
    //filter 用作在更新之前筛选符合条件的document
    //update 具体更新document中哪些字段,options 附加可选的额外操作
    
    db.book.updateOne({"name":"springboot02"}, 
            {$set{"name":"springboot03"}})
    //updateMany :修改(多条)所有满足条件的
    db.book.updateMany({"name":"springboot"},
            {$set:{"name":"springboot2"}})
    
    //更新单条数据 将id = 1的用户,用户名修改为liuliuliu,
    db.book.update({id: 1},{$set: {user: 'liuliuliu'}})

查找（查找所有、条件查询、模糊查询）、统计、排序

//查询所有数据的两种方法
    db.book.find().pretty()//仅使用 find() 方法查询出的结果看起来比较凌乱，
    //MongoDB 中还提供了一个pretty()方法来格式化查询到结果，让查询到数据以更易读方式展示出来.pretty()加于不加在navicat中看不出影响，只是在没有可视化工具的情况下，加上可以让代码变的更美观
    
    //MongoDB 中的投影(即查询指定的字段，而不是直接查询文档的全部字段)。
    //语法格式如下：
    db.collection_name.find(query,{key1:1, key2:1, ...})
    //比如说某个文档中有5个字段，只需要其中3个字段，那么就可以使用投影来指定需要查询的3个字段。
    db.book.find({id: 1})
    db.getCollection("book").find()
    //查询用户ID大于1的用户信息
    //条件操作符: gt(大于),gte(大于等于),lt(小于),lte(小于等于)
    db.book.find({id: {$gt: 1}})
    //查询用户ID大于1的用户信息,且按照id降序
    db.book.find({}, {"id":1,_id:0}).sort({"id":-1})
    //只返回第一个文档
    db.book.findOne()
    //条件查询
    db.book.find({type:"工具书"})
    
    //统计
    db.book.count()
    //排序db.book.sort()
    //db.collection_name.find().sort({key:1})
    // key 用来定义要根据那个字段进行排序，后面的值 1 则表示以升序进行排序，
    若要以降序进行排序则需要将其设置为 -1。
    //如果在使用 sort() 方法时未指定排序的选项，那么 sort() 方法将默认按 _id 的升序显示文档
    db.book.find({}, {"name":1,_id:0}).sort({})
    //将集合中的数据按照 name 字段降序排列
    db.book.find({}, {"name":1,_id:0}).sort({"name":-1})
    //注意:string类型的值不能查处结果,使用命令提示符进行添加时默认为string,可使用MongoDB compass进项修改
    
    //把name为bbb1的所有记录都查找到了
    db.book.find({}, {"name":"bbb1",_id:0}).sort({})
    
    //分页查询,分页查询主要有两个参数
    //skip: 用于指定跳过记录数
    //limit: 用于限定返回结果数
    //例如:查询id>1的用户,且按照每页2条数据进行分页,取第二页
    db.book.find({id: {$gt: 1}}).skip(2).limit(2)
    db.book.find({age:{$type:16}})//查询age这个名字下面类型是int32(16)的文档
    
    显示条数的控制:limit
    db.BookList.find().limit(4)//显示4条查询出的文档
    
    跳过几条的方法:skip()
    db.book.find().skip(4)//跳过前四条查询出的文档
    
    db.book.find({},{"name":1,_id:0}).limit(2)//第一个{}里面放条件,
    若为空则显示所有的文档,第二个()里面指定哪些列显示,哪些不显示(1表示显示,0表示不显示)
    //同时使用sort,skip,limit.不论先后顺序,执行的顺序都是sort→skip→limit;
    //skip和limit都是只适合小数据量的分页,百万级的数据建议使用where_limit
    db.book.find({id:{$gt:1}}).sort({"name":1}).limit(10)
    
    //"$" 字符 代表 下标位置索引, 满足条件的数据下标位置就会传递给这个 //字符。
    使用的场景就是当操作的对象是数组里面某个符合的项，然后对这些项进行内部操作。
    //正常情况下需要写明$unset:{'datas.0.time':""}
    db.dateList.updateMany({'datas.time':"9999"},{$unset:{'datas.$.time':""}})
    
    MongoDB 中的聚合操作用来处理数据并返回计算结果，聚合操作可以将多个文档中的值组合在一起，
    并可对数据执行各种操作，以返回单个结果，有点类似于 SQL 语句中的 count(*)、group by 等。
    aggregate() 方法
    您可以使用 MongoDB 中的 aggregate() 方法来执行聚合操作，其语法格式如下：
    db.collection_name.aggregate(aggregate_operation)
    
    //模糊查询
    //查询name中包含“数据”的文档信息
    db.book.find({name:/数据/})
    //查询name中以“数”开头的文档
    db.book.find({name:/^数/})
    //查询name中以“3”结尾的文档
    db.book.find({name:/3$/})