数据库"/>
MogoDB数据库
MogoDB概述
MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统,MongoDB是为快速开发互联网Web应用而设计的数据库系统，MongoDB的设许目标是极简、灵活、作为Web应用栈的一部分，MongoDB的数据模型是面向文档的, 所谓文档是一种类似于JSON的结构，简单理解MongoDB这个数据库中存的是各种各样的JSON。( BSON )
优势以及使用场景
- 对数据库高并发读写。
- 对海量数据的高效率存储和访问。
- 对数据库的高可扩展性和高可用性。
弱势
- 数据库事务一致性需求
- 数据库的写实时性和读实时性需求
- 对复杂的SQL查询，特别是多表关联查询的需求
MogoDB基本概念及与传统sql对应关系
数据库( database )：数据库是一个仓库，在仓库中可以存放集合。
集合( collection )：集合类似于数组，在集合中可以存放文档。相当于sql中的table
文档( document )：文档数据库中的最小单位,我们存储和操作的内容都是文档。相当于sql中的行
| MogoDB术语 | sql术语 | 解释 |
| database | database | 数据库 |
| collection（集合） | table | 集合/数据库表 |
| document（文档） | row | 文档/数据记录行 |
| field | column | 域/数据字段 |
| index | index | 索引 |
| primary key | primary key | 主键 Mogo自动把_id设为主键 |
基本操作命令
查看所有的数据库：show dbs /show databases
切换（不存在就新建）数据库：use db_name
查看使用当前的数据库：db
删除当前的数据库：db.dropDatabase()
查看数据库中所有集合（表）：show collections
查看指定集合下所有文档（JSON数据）：db.集合名称.find()
数据类型
| 数据类型 | 描述 |
| Object ID | 集合主键id |
| String | 字符串，常用，必须有效字符UTF-8 |
| Boolean | 布尔值 存储true或者false |
| Integer | 整数，可以是32位或者64位，取决于服务器 |
| Double | 浮点型 |
| Arrays | 数组或列表， 多个值存储到⼀个键 |
| Object | ⽤于嵌⼊式的⽂档， 即⼀个值为⼀个⽂档 |
| Null | 用于存储Null值 |
| Timestamp | 时间戳 表示从1970-1-1到现在的总秒数 |
| Date | 存储当前⽇期或时间的UNIX时间格式 |
| Binary Data | 存储二进制数据 |
| Regular expression | 正则表达式类型。用于存储正则表达式。 |
| Code | 存储代码数据 |
ObjectID
每个⽂档都有⼀个属性， 为_id， 保证每个⽂档的唯⼀性，可以⾃⼰去设置_id插⼊⽂档，如果没有提供， 那么MongoDB为每个⽂档提供了⼀个独特的_id， 类型为objectID，objectID是⼀个12字节的⼗六进制数
生成规则
- 前4个字节为当前时间戳
- 接下来3个字节的机器ID
- 接下来的2个字节中MongoDB的服务进程id
- 最后3个字节是简单的增量值
集合
不手动创建集合：向不存在的集合中第⼀次加⼊数据时， 集合会被创建出来
- db.createCollection(name,options)
- db.createCollection("stu")
- db.createCollection("sub", { capped : true, size : 10 } )
- 参数capped： 默认值为false表示不设置上限,值为true表示设置上限
- 参数size： 当capped值为true时， 需要指定此参数， 表示上限⼤⼩,当⽂档达到上限时， 会将之前的数据覆盖， 单位为字节
查看集合：show collections
删除集合：db.集合名称.drop()
插入数据
语法如下
语法如下：
db.集合名称.insert(JSON对象)
db.集合名称.save(JSON对象)
插入1条数据：db.集合名称.insertOne(JSON对象)
插入多条数据：db.集合名称.insertMany([JSON 1，JSON 2，JSON 3，...JSON n])
指定_id参数：db.集合名称.insert({_id:"001", name:"gj", gender:1})
- 插入数据时不需要专门去创建集合(表)，因为插入数据时会自动创建集合
- 插⼊⽂档时， 如果不指定_id参数， MongoDB会为⽂档分配⼀个唯⼀的ObjectId
- 如果⽂档的_id已经存在则报错
// 保存数据，注意：如果⽂档的_id已经存在则修改， 如果⽂档的_id不存在则添加
db.User.save({name:'zhangsan',age:21,sex:true})// 插入1条数据
db.test001.insert({name: "张三", age: 18, sex: true});db.test001.insertOne({name: "王王", age: 18, sex: true});// 插入多条数据
db.test001.insertMany([{name: "张三", age: 18, sex: true},{name: "李四", age: 20, sex: true},{name: "王五", age: 21, sex: true},
]);
查询数据
查看当前所有集合数据 ：db.集合名称.find()
> db.test.find()
{ "_id" : ObjectId("62177e62cec136e6f853bbe9"), "name" : "张三", "age" : 18, "sex" : true }
{ "_id" : ObjectId("62177e62cec136e6f853bbea"), "name" : "李四", "age" : 20, "sex" : true }
{ "_id" : ObjectId("62177e62cec136e6f853bbeb"), "name" : "王五", "age" : 21, "sex" : true }
条件查询
条件查询 ：db.集合名称.find({条件⽂档})
查询只返回第⼀个：db.集合名称.findOne({条件⽂档})
将结果格式化：db.集合名称.find({条件⽂档}).pretty()
// 插入多条数据
db.test.insertMany([{name: "张飞", hometown: "蜀国", age: 30, sex: "男"},{name: "关羽", hometown: "蜀国", age: 40, sex: "男"},{name: "刘备", hometown: "蜀国", age: 50, sex: "男"},{name: "曹操", hometown: "魏国", age: 45, sex: "男"},{name: "司马懿", hometown: "魏国", age: 45, sex: "男"},{name: "孙权", hometown: "吴国", age: 50, sex: "男"}
]);// 查询年龄为50
> db.test.find({age:50})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "hometown" : "蜀国", "age" : 50, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3ea"), "name" : "孙权", "hometown" : "吴国", "age" : 50, "sex" : "男" }//查询一个年龄为50
> db.test.findOne({age:50})
{"_id" : ObjectId("6219a246d1ca96a61ceca3e7"),"name" : "刘备","hometown" : "蜀国","age" : 50,"sex" : "男"}//美化输出年龄为50
> db.test.find({age:50}).pretty()
{"_id" : ObjectId("6219a246d1ca96a61ceca3e7"),"name" : "刘备","hometown" : "蜀国","age" : 50,"sex" : "男"
}
{"_id" : ObjectId("6219a246d1ca96a61ceca3ea"),"name" : "孙权","hometown" : "吴国","age" : 50,"sex" : "男"
}比较运算符
等于： 默认是等于判断， 没有运算符
⼩于：$lt （less than）
⼩于等于：$lte （less than equal）
⼤于：$gt （greater than）
⼤于等于：$gte
不等于：$ne
格式：db.集合名称.find({age:{$gte:18}})
//年龄小于45
> db.test002.find({age:{$lt:45}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }//年龄小于等于45
> db.test002.find({age:{$lte:45}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }//年龄大于45
> db.test002.find({age:{$gt:45}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "hometown" : "蜀国", //年龄大于等于45
> db.test002.find({age:{$gte:45}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "hometown" : "蜀国", "age" : 50, "sex" : "男" }//年龄不等于45
> db.test002.find({age:{$ne:45}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }范围运算符
判断是否在某个范围内：使⽤$in， $nin
格式：db.集合名字.find({age:{$in:[18,28]}})
//年龄为30,40,50
> db.test002.find({age:{$in:[30,40,50]}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }//年龄不为30,40,50
> db.test002.find({age:{$nin:[30,40,50]}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e8"), "name" : "曹操", "hometown" : "魏国", "age" : 45, "sex" : "男" }
逻辑运算符与正则表达式
and：在json中写多个条件即可
格式：db.集合名称.find({条件1, 条件2})
or：使⽤$or， 值为数组， 数组中每个元素为json
格式：db.集合名词.find({$or:[{条件1}, {条件2}]})
使⽤//或$regex编写正则表达式
格式1：db.集合名称.find({name:/^张/})
格式2：db.集合名词.find({name:{$regex:'^张'}})
//年龄为40的蜀国人
> db.test.find({age: 40, hometown: "蜀国"})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e6"), "name" : "关羽", "hometown" : "蜀国", "age" : 40, "sex" : "男" }//年龄小于50或者为吴国人
> db.test.find({$or:[{age:{$lt:50}}, {hometown: "吴国"}]})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }//查询姓名以张开头
> db.test.find({name:/^张/})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }> db.test.find({name:{$regex:'^张'}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }
自定义查询
使⽤$where后⾯写⼀个函数， 返回满⾜条件的数据
格式
db.集合名称.find({$where:function() {return this.条件;}
})
//查询年龄大于40
> db.test002.find({$where:function() {return this.age>40;}})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "hometown" : "蜀国", "age" : 50, "sex" : "男" }
投影取字段
在查询到的返回结果中， 只选择必要的字段：db.集合名称.find({条件（可省略）},{字段名称:1,...})
-
参数为字段与值， 值为1表示显示， 不显示则不用写
-
特殊： 对于_id列默认是显示的， 如果不显示需要明确设置为0
//显示name和age字段
> db.test002.find({},{name:1, age:1})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "age" : 30 }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e6"), "name" : "关羽", "age" : 40 }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "age" : 50 }limit和skip
⽤于读取指定数量的⽂档：db.集合名称.find().limit(number)
⽤于跳过指定数量的⽂档：db.集合名称.find().skip(number)
同时使用
db.集合名称.find().limit(number).skip(number)
或
db.集合名称.find().skip(number).limit(number) //推荐使用效率会更高
//查询前两条数据
> db.test002.find().limit(2)
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e6"), "name" : "关羽", "hometown" : "蜀国", "age" : 40, "sex" : "男" }//查询除前两条以外的数据
> db.test002.find().skip(2)
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "hometown" : "蜀国", "age" : 50, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e8"), "name" : "曹操", "hometown" : "魏国", "age" : 45, "sex" : "男" }//查询前五条数据中后两条
> db.test002.find().limit(5).skip(3)
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e8"), "name" : "曹操", "hometown" : "魏国", "age" : 45, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e9"), "name" : "司马懿", "hometown" : "魏国", "age" : 45, "sex" : "男" }排序
db.集合名称.find().sort({字段:1,...})
-
参数1为升序排列
-
参数-1为降序排列
//根据年龄升序排序
> db.test002.find().sort({age:1})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e6"), "name" : "关羽", "hometown" : "蜀国", "age" : 40, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e8"), "name" : "曹操", "hometown" : "魏国", "age" : 45, "sex" : "男" }//根据年龄降序排序
> db.test002.find().sort({age:-1})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e7"), "name" : "刘备", "hometown" : "蜀国", "age" : 50, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3ea"), "name" : "孙权", "hometown" : "吴国", "age" : 50, "sex" : "男" }//先根据name降序，再根据age降序
> db.test002.find().sort({name:-1, age:-1})
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e8"), "name" : "曹操", "hometown" : "魏国", "age" : 45, "sex" : "男" }
{ "_id" : ObjectId("6219a246d1ca96a61ceca3e5"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }统计个数及去重
db.集合名称.find({条件}).count()db.集合名称.count({条件})
数据进⾏去重：db.集合名称.distinct('去重字段',{条件})
//统计蜀国人个数
> db.test002.find({hometown: "蜀国"}).count()
3> db.test002.count({hometown: "蜀国"})
3//对hometown去重
> db.test002.distinct('hometown')
[ "吴国", "蜀国", "魏国" ]
//对age去重
> db.test002.distinct('age')
[ 30, 40, 45, 50 ]//对age去重，并且为蜀国人
> db.test002.distinct('age',{hometown:"蜀国"})
[ 30, 40, 50 ]
聚合简介
聚合(aggregate)是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果。
语法
db.集合名称.aggregate({管道:{表达式}})常用管道
常用管道如下：$group： 将集合中的⽂档分组， 可⽤于统计结果$match： 过滤数据， 只输出符合条件的⽂档$project： 修改输⼊⽂档的结构， 如重命名、 增加、 删除字段、 创建计算结果$sort： 将输⼊⽂档排序后输出$limit： 限制聚合管道返回的⽂档数$skip： 跳过指定数量的⽂档， 并返回余下的⽂档$unwind： 将数组类型的字段进⾏拆分
常用表达式
语法格式：表达式:'$列名'常⽤表达式:$sum： 计算总和， $sum:1 表示以⼀倍计数$avg： 计算平均值$min： 获取最⼩值$max： 获取最⼤值$push： 在结果⽂档中插⼊值到⼀个数组中$first： 根据资源⽂档的排序获取第⼀个⽂档数据$last： 根据资源⽂档的排序获取最后⼀个⽂档数据
// 返回sex有哪些值
> db.test003.aggregate({$group:{_id:"$sex"}}
)
{ "_id" : "男" }
{ "_id" : "女" }//统计男生、女生分别的总人数
> db.test003.aggregate({$group:{_id:"$sex",count:{$sum:1}}}
)
{ "_id" : "男", "count" : 6 }
{ "_id" : "女", "count" : 4 }//统计男、女分别的平均年龄
> db.test003.aggregate({$group:{_id:"$sex",count:{$sum:1},avg_age:{$avg:"$age"}}}
)
{ "_id" : "男", "count" : 6, "avg_age" : 43.333333333333336 }
{ "_id" : "女", "count" : 4, "avg_age" : 18 }//按照hometown进行分组，获取不同组的平均年龄
> db.test003.aggregate({$group:{_id:"$hometown",avg_age:{$avg:"$age"}}}
)
{ "_id" : "蜀国", "avg_age" : 40 }
{ "_id" : "唐朝", "avg_age" : 18 }
{ "_id" : "越国", "avg_age" : 18 }
{ "_id" : "吴国", "avg_age" : 50 }//统计不同性别的人物名字
> db.test003.aggregate({$group:{_id:"$sex",name:{$push:"$name"}}}
)
{ "_id" : "男", "name" : [ "张飞", "关羽", "刘备", "曹操", "司马懿", "孙权" ] }
{ "_id" : "女", "name" : [ "貂蝉", "西施", "王昭君", "杨玉环" ] }// 使用$$ROOT可以将文档内容加入到结果集的数组中
> db.test003.aggregate({$group:{_id:"$sex",name:{$push:"$$ROOT"}}}
)
{ "_id" : "男", "name" : [ { "_id" : ObjectId("621cbd0aea5c14fd51410b33"), "name" : "张飞", "hometown" : "蜀国", "age" : 30, "sex" : "男" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b34"), "name" : "关羽", "hometown" : "蜀国", "age" : 40, "sex" : "男" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b35"), "name" : " 刘备", "hometown" : "蜀国", "age" : 50, "sex" : "男" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b36"), "name" : "曹操", "hometown" : "魏国", "age" : 45, "sex" : "男" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b37"), "name" : "司马懿", "hometown" : "魏国", "age" : 45, "sex" : "男" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b38"), "name" : "孙权", "hometown" : "吴国", "age" : 50, "sex" : "男" } ] }
{ "_id" : "女", "name" : [ { "_id" : ObjectId("621cbd0aea5c14fd51410b39"), "name" : "貂蝉", "hometown" : "未知", "age" : 18, "sex" : "女" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b3a"), "name" : "西施", "hometown" : "越国", "age" : 18, "sex" : "女" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b3b"), "name" : " 王昭君", "hometown" : "西汉", "age" : 18, "sex" : "女" }, { "_id" : ObjectId("621cbd0aea5c14fd51410b3c"), "name" : "杨玉环", "hometown" : "唐朝", "age" : 18, "sex" : "女" } ] }
修改数据
db.集合名称.update(<query> ,<update>,{multi: <boolean>})
更新一条（字段全部替换）：db.集合名称.update({name:'原始数据'},{name:'修改后数据'})
更新一条（仅更新一个字段）：db.集合名称.update({name:'原始数据'},{$set:{name:'修改后数据'}}) ，推荐使用
更新全部：db.集合名称.update({name:'原始数据'},{$set:{name:'修改后数据'}},{multi:true})
参数query：查询条件
参数update：更新操作符
参数multi：可选， 默认是false，表示只更新找到的第⼀条记录， 值为true表示把满⾜条件的⽂档全部更新
注意：{multi:true}需要和$set配合使用、
//把名字为小黑的更新为小白
> db.test001.update({name: '小黑'},{name:'小白'})))
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.test001.find()
{ "_id" : ObjectId("621780b5cec136e6f853bbef"), "name" : "张三", "age" : 18, "sex" : "男", "hobby" : "美女" }
{ "_id" : ObjectId("621780b5cec136e6f853bbf0"), "name" : "李四", "age" : 20, "sex" : "男", "hobby" : "跑车" }
{ "_id" : ObjectId("621780b5cec136e6f853bbf1"), "name" : "王五", "age" : 21, "sex" : "男", "hobby" : "黑丝" }
{ "_id" : 1, "name" : "小白" }
- 注意：这种写法会替换掉其他的字段（全部替换），age、sex、hobby都没有了
//把名字为王五的更新为小王
> db.test001.update({name:'王五'},{$set:{name:'小王'}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.test001.find() '}})
{ "_id" : ObjectId("621780b5cec136e6f853bbef"), "name" : "张三", "age" : 18, "sex" : "男", "hobby" : "美女" }
{ "_id" : ObjectId("621780b5cec136e6f853bbf0"), "name" : "李四", "age" : 20, "sex" : "男", "hobby" : "跑车" }
{ "_id" : ObjectId("621780b5cec136e6f853bbf1"), "name" : "小王", "age" : 21, "sex" : "男", "hobby" : "黑丝" }
{ "_id" : 1, "name" : "小白" }
- 可以看出加上
$set:后仅更新了name一个字段 推荐使用
删除数据
db.集合名称.remove(<query>,{justOne: <boolean>})
- 参数query:可选，删除的⽂档的条件
- 参数justOne:可选， 如果设为true或1， 则只删除⼀条， 默认false， 表示删除多条
//先删除一条数据
> db.test.remove({sex: '女'}, {justOne:true})
WriteResult({ "nRemoved" : 1 })
> db.test001.find()
{ "_id" : ObjectId("621780b5cec136e6f853bbf0"), "name" : "李四", "age" : 20, "sex" : "女", "hobby" : "跑车" }
{ "_id" : ObjectId("621780b5cec136e6f853bbf1"), "name" : "小王", "age" : 21, "sex" : "女", "hobby" : "黑丝" }
{ "_id" : 1, "name" : "小白" }
// 全部删除
> db.test.remove({sex: '女'})
WriteResult({ "nRemoved" : 2 })
> db.test001.find() )
{ "_id" : 1, "name" : "小白" }
索引
建立索引语法：db.集合名称.ensureIndex({字段名:1})；其中 1 表示升序， -1 表示降序
删除索引语法：db.集合名称.dropIndex({'索引名称'})
创建唯一索引：db.集合名称.ensureIndex({"name":1}, {"unique":true})
创建联合索引: db.test005.ensureIndex({name:1, age:1})
> db.test005.ensureIndex({"name":1}, {"unique":true})
{"ok" : 0,"errmsg" : "Index build failed: eab854cd-330b-414f-ae86-9cfb317efbf5: Collection test.test005 ( 45744ab1-2a71-4722-8f84-99812ccc9ffb ) :: caused by :: E11000 duplicate key error collection: test.test005 index: name_1 dup key: { name: \"test0\" }","code" : 11000,"codeName" : "DuplicateKey","keyPattern" : {"name" : 1},"keyValue" : {"name" : "test0"}
}> db.test005.dropIndex({'name':1})
{ "nIndexesWas" : 2, "ok" : 1 }
//再次查看全部索引
> db.test005.getIndexes()
[ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_" } ]
MogoDB备份和恢复
备份
备份的语法：mongodump -h dbhost -d dbname -o dbdirectory
- -h： 指定服务器地址；如果是当前本机数据库可以去掉-h
- -port ：指定端口号；如果是默认端口可以去掉
- -d： 需要备份的数据库名称；如果不指定则导出所有数据库
- -o： 备份的数据存放位置， 此⽬录中存放着备份出来的数据
- -c： 指定集合名称；如果不指定则全部导出
- -u： 用户名；如果没有用户，可以不用指定
- -p： 密码；如果没有密码，可以不用指定
注意：
- 命名需要在终端输出，而不是数据库命令行
- 每个参数前后是有空格
mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1bak恢复
恢复语法：mongorestore -h dbhost -d dbname --dir dbdirectory
-h： 服务器地址-d： 需要恢复的数据库实例--dir： 备份数据所在位置
mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1bak/test1springBoot整合MogoDB
导入依赖
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-mongodb</artifactId></dependency>
添加配置
mogo安装之后没有密码 ，首先设置密码
#用户名不要用root
db.createUser({user:"用户名",pwd:"密码",roles:[{role:"root",db:"admin"}]})spring.data.mongodb.uri=mongodb://admin:123456@localhost:27017/file测试
package com.test.entity;import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;@Data
@Document("User")
public class User {@Idprivate String id;private String name;private Integer age;private String email;private String createDate;}MongoTemplate 操作MogoDB
package com.test;import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.test.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Example;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;@SpringBootTest
class MongodbApplicationTests {//注入MongoTemplate@Autowiredprivate MongoTemplate mongoTemplate;//添加操作@Testvoid contextLoads() {User user = new User();user.setAge(20);user.setName("test");user.setEmail("4932200@qq");User user1 = mongoTemplate.insert(user);System.out.println(user1);}//查询所有@Testpublic void findUser() {List<User> userList = mongoTemplate.findAll(User.class);System.out.println(userList);}//id查询@Testpublic void getById() {User user = mongoTemplate.findById("62501d8d5e835d2841ebcfc7",User.class);System.out.println(user);}//条件查询@Testpublic void findUserList() {Query query = new Query(Criteria.where("name").is("test").and("age").is(20));List<User> list = mongoTemplate.find(query,User.class);System.out.println(list);}//模糊查询@Testpublic void findUsersLikeName() {String name = "est";String regex = String.format("%s%s%s", "^.*", name, ".*$");//采用正则表达式进行匹配Pattern pattern = Patternpile(regex, Pattern.CASE_INSENSITIVE);Query query = new Query(Criteria.where("name").regex(pattern));List<User> userList = mongoTemplate.find(query, User.class);System.out.println(userList);}//分页查询@Testpublic void findUsersPage() {String name = "est";int pageNo = 1; //当前页int pageSize = 10; //每页的大小Query query = new Query(); //条件构建部分String regex = String.format("%s%s%s", "^.*", name, ".*$");Pattern pattern = Patternpile(regex, Pattern.CASE_INSENSITIVE);query.addCriteria(Criteria.where("name").regex(pattern));int totalCount = (int) mongoTemplate.count(query, User.class); //查询记录数//其中的skip表示跳过的记录数，当前页为1则跳过0条，为2则跳过10条，（也就是跳过第一页的10条数据）List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class); //分页查询Map<String, Object> pageMap = new HashMap<>();pageMap.put("list", userList);pageMap.put("totalCount",totalCount);System.out.println(pageMap);}//修改@Testpublic void updateUser() {User user = mongoTemplate.findById("62501d8d5e835d2841ebcfc7", User.class); // 先查询数据user.setName("test_1");user.setAge(25);user.setEmail("493220990@qq"); //设置修改的值Query query = new Query(Criteria.where("_id").is(user.getId()));//查到数据Update update = new Update();update.set("name", user.getName()); //设置mongodb的字段值update.set("age", user.getAge());update.set("email", user.getEmail());UpdateResult result = mongoTemplate.upsert(query, update, User.class);long count = result.getModifiedCount(); //影响行数System.out.println(count);}//删除操作@Testpublic void delete() {Query query =new Query(Criteria.where("_id").is("62501d8d5e835d2841ebcfc7")); //查询到数据DeleteResult result = mongoTemplate.remove(query, User.class); //删除方法long count = result.getDeletedCount();System.out.println(count);}}MongoRepository操作MogoDB
Spring Data提供了对mongodb数据访问的支持，我们只需要继承MongoRepository类，按照SpringData 方法定义规范
1、不是随便声明的，而需要符合一定的规范
2、 查询方法以find | read | get开头
3、 涉及条件查询时，条件的属性用条件关键字连接
4、 要注意的是：条件属性首字母需要大写
5、 支持属性的级联查询，但若当前类有符合条件的属性则优先使用，而不使用级联属性,若需要使用级联属性，则属性之间使用_强制进行连接
package com..test1;import com.test.entity.User;
import com.test.service.UserRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.*;import java.util.List;@SpringBootTest
public class MongodbTest {//注入mongoTemplate@Autowiredprivate UserRepository userRepository;//添加@Testpublic void createUser() {User user = new User();user.setAge(20);user.setName("张三");user.setEmail("3332200@qq");User user1 = userRepository.save(user);}//查询所有@Testpublic void findUser() {List<User> userList = userRepository.findAll();System.out.println(userList);}//id查询@Testpublic void getById() {User user = userRepository.findById("625028281f21814892d182cd").get();System.out.println(user);}//条件查询@Testpublic void findUserList() {User user = new User();user.setName("张三");user.setAge(20);Example<User> userExample = Example.of(user); //构建条件List<User> userList = userRepository.findAll(userExample);System.out.println(userList);}//模糊查询@Testpublic void findUsersLikeName() {//创建匹配器，即如何使用查询条件ExampleMatcher matcher = ExampleMatcher.matching() //构建对象.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询.withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写User user = new User();user.setName("三");Example<User> userExample = Example.of(user, matcher);List<User> userList = userRepository.findAll(userExample);System.out.println(userList);}//分页查询@Testpublic void findUsersPage() {Sort sort = Sort.by(Sort.Direction.DESC, "age");
//0为第一页Pageable pageable = PageRequest.of(0, 10, sort);
//创建匹配器，即如何使用查询条件ExampleMatcher matcher = ExampleMatcher.matching() //构建对象.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询.withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写User user = new User();user.setName("三");Example<User> userExample = Example.of(user, matcher);
//创建实例Example<User> example = Example.of(user, matcher);Page<User> pages = userRepository.findAll(example, pageable);System.out.println(pages);}//修改@Testpublic void updateUser() {User user = userRepository.findById("625028281f21814892d182cd").get();user.setName("张三_1");user.setAge(25);user.setEmail("883220990@qq");User save = userRepository.save(user);System.out.println(save);}//删除@Testpublic void delete() {userRepository.deleteById("625028281f21814892d182cd");}}使用mogo存储文件
MongoDB单个文档的存储限制是16M，如果要存储大于16M的文件，就要用到MongoDB GridFS。
GridFS是Mongo的一个子模块,使用GridFS可以基于MongoDB来持久存储文件。并且支持分布式应用(文件分布存储和读取)。作为MongoDB中二进制数据存储在数据库中的解决方案，通常用来处理大文件。
GridFS不是MongoDB自身特性，只是一种将大型文件存储在MongoDB的文件规范，所有官方支持的驱动均实现了GridFS规范。GridFS制定大文件在数据库中如何处理，通过开发语言驱动来完成、通过API接口来存储检索大文件。
GridFS使用两个集合（collection）存储文件。一个集合是chunks, 用于存储文件内容的二进制数据；一个集合是files，用于存储文件的元数据。
GridFS会将两个集合放在一个普通的buket中，并且这两个集合使用buket的名字作为前缀。MongoDB的GridFs默认使用fs命名的buket存放两个文件集合。因此存储文件的两个集合分别会命名为集合fs.files ,集合fs.chunks。
当把一个文件存储到GridFS时，如果文件大于chunksize （每个chunk块大小为256KB），会先将文件按照chunk的大小分割成多个chunk块，最终将chunk块的信息存储在fs.chunks集合的多个文档中。然后将文件信息存储在fs.files集合的唯一一份文档中。其中fs.chunks集合中多个文档中的file_id字段对应fs.files集中文档”_id”字段。
GridFS规范：mogo存储文件（二进制）
更多推荐
MogoDB数据库
发布评论