mongodb基本使用
1.介绍
基本概述
1.MongoDB 是一个跨平台的,面向文档的数据库,是当前 NoSQL 数据库产品中最热门的一种。它介于关系数据库和非关系数据库之间,是非关系数据库当中功能最丰富,最像关系数据库的产品。它支持的数据结构非常松散,是类似JSON 的 BSON 格式,因此可以存储比较复杂的数据类型。
2.MongoDB 最大的特点是他支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。它是一个面向集合的,模式自由的文档型数据库。
具体特点总结如下:
(1)面向集合存储,易于存储对象类型的数据
(2)模式自由
(3)支持动态查询
(4)支持完全索引,包含内部对象
(5)支持复制和故障恢复
(6)使用高效的二进制数据存储,包括大型对象(如视频等)
(7)自动处理碎片,以支持云计算层次的扩展性
(8)支持 Python,PHP,Ruby,Java,C,C#,Javascript,Perl 及 C++语言的驱动程序,社区中也提供了对 Erlang 及.NET 等平台的驱动程序
(9) 文件存储格式为 BSON(一种 JSON 的扩展)
MongoDB体系结构
MongoDB 的逻辑结构是一种层次结构。主要由:
文档(document)、集合(collection)、数据库(database)这三部分组成的。逻辑结构是面向用户
的,用户使用 MongoDB 开发应用程序使用的就是逻辑结构。
(1)MongoDB 的文档(document),相当于关系数据库中的一行记录。
(2)多个文档组成一个集合(collection),相当于关系数据库的表。
(3)多个集合(collection),逻辑上组织在一起,就是数据库(database)。
(4)一个 MongoDB 实例支持多个数据库(database)。
MongoDb | 关系型数据库Mysql |
---|---|
数据库(databases) | 数据库(databases) |
集合(collections) | 表(table) |
文档(document) | 行(row) |
使用use 数据库名称即可选择数据库,如果该数据库不存在会自动创建
db.集合名称.save(变量); 集合名称(表) 如果该表不存在会自动创建
2.安装
1.docker search mongo
2.docker pull mongo
3.docke run -p 27017:27017 -v $PWD/db:/data/db -d --name mymongo mongo
docker run --name my-mongo -p 27017:27017 -d mongo
4.docker ps
5.docker exec -it 8b761d771c3d sh
6.mongo
7.db.use test
8.db.test.insert({name:'test001'})
9.exit
10.exit
即可退出shell
//其它操作
docker stop mymongo
docker ps -a
docker start mymongo
ps aux|grep mongo 显示进程
3.mongodb基本操作指令
数据库
选择和创建数据库- 选择和创建数据库
use articledb 如果数据库不存在则自动创建
查看数据库-查看有权限查看的所有的数据库命令
show dbs
查看正在使用的数据库
db
删除数据库
MongoDB 删除数据库的语法格式如下:
db.dropDatabase()
集合
创建集合
db.createCollection(name)
集合的命名规范:
- 集合名不能是空字符串""。
- 集合名不能含有\0字符(空字符),这个字符表示集合名的结尾。
- 集合名不能以"system."开头,这是为系统集合保留的前缀。
- 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含,这是因为某些系统生成的集合中包含该字符。除 非你要访问这种系统创建的集合,否则千万不要在名字里出现$。
隐式创建
当向一个集合中插入一个文档的时候,如果集合不存在,则会自动创建集合,通常我们使用隐式创建文档即可
查看集合
show collections
或
show tables
删除集合
db.collection.drop()
或
db.集合.drop()
如果成功删除选定集合,则 drop() 方法返回 true,否则返回 false。
例如:要删除mycollection集合
db.mycollection.drop()
文档
插入文档
跟mysql一样既可以单条插入,也可以多条执行
单条插入
使用insert() 或 save() 方法向集合中插入文档,语法如下:
db.collection.insert(
<document or array of documents>,
{
writeConcern: <document>,
ordered: <boolean>
}
)
//要向comment的集合(表)中插入一条测试数据:
db.comment.insert({
"articleid": "100000",
"content": "今天天气真好,阳光明 媚",
"userid": "1001",
"nickname": "Rose",
"createdatetime": new Date(),
"likenum": NumberInt(10),
"state": null
})
批量插入
语法:
db.collection.insertMany(
[ <document 1> , <document 2>, ... ],
{ writeConcern: <document>, ordered: <boolean> }
)
db.comment.insertMany([{
"_id": "1",
"articleid": "100001",
"content": "我们不应该把清晨浪费在手机上,健康很重要,一杯温水幸福你我 他。",
"userid": "1002",
"nickname": "相忘于江湖",
"createdatetime": new Date("2019-08- 05T22:08:15.522Z"),
"likenum": NumberInt(1000),
"state": "1"
},
{
"_id": "2",
"articleid": "100001",
"content": "我夏天空腹喝凉开水,冬天喝温开水",
"userid": "1005",
"nickname": "伊人憔 悴",
"createdatetime": new Date("2019-08-05T23:58:51.485Z"),
"likenum": NumberInt(888),
"state": "1"
}]);
修改文档
更新文档的语法:
db.collection.update(query, update, options)
或
db.collection.update(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>,
writeConcern: <document>,
collation: <document>,
arrayFilters: [ <filterdocument1>, ... ],
hint: <document|string> // Available starting in MongoDB 4.2
}
)
示例:
//覆盖的修改 执行后,我们会发现,这条文档除了likenum字段其它字段都不见了
db.comment.update({_id:"1"},{likenum:NumberInt(1001)})
//局部修改
db.comment.update({_id:"2"},{$set:{likenum:NumberInt(889)}})
//批量修改
//默认只修改第一条数据
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒2"}})
//修改所有符合条件的数据
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒大帝"}},{multi:true})
//列值增长的修改 需求:对3号数据的点赞数,每次递增1
如果我们想实现对某列值在原有值的基础上进行增加或减少,可以使用 $inc 运算符来实现。
db.comment.update({_id:"3"},{$inc:{likenum:NumberInt(1)}})
删除文档
删除文档的语法结构:
db.集合名称.remove(条件)
//以下语句可以将数据全部删除,请慎用
db.comment.remove({})
//如果删除_id=1的记录,输入以下语句
db.comment.remove({_id:"1"})
查询文档
查询数据的语法格式如下:
db.collection.find(<query>, [projection])
示例
//查询所有
db.comment.find() 或 db.comment.find({})
//按一定条件来查询,比如我想查询userid为1003的记录
db.comment.find({userid:'1003'})
//返回符合条件的第一条数据
db.comment.findOne({userid:'1003'})
//投影查询(Projection Query) 查询结果返回部分字段
//查询结果只显示 _id、userid、nickname :
db.comment.find({userid:"1003"},{userid:1,nickname:1})
//查询结果只显示 、userid、nickname ,不显示 _id :
db.comment.find({userid:"1003"},{userid:1,nickname:1,_id:0})
//查询所有数据,但只显示 _id、userid、nickname :
db.comment.find({},{userid:1,nickname:1})
//统计查询
db.collection.count(query, options)
//统计comment集合的所有的记录数:
db.comment.count()
//统计userid为1003的记录条数
db.comment.count({userid:"1003"})
//分页查询
//基本语法如下所示:
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
// 返回指定条数的记录
db.comment.find().limit(3)
//skip方法同样接受一个数字参数作为跳过的记录条数。(前N个不要),默认值是0 页数
db.comment.find().skip(3)
//分页查询:需求:每页2个,第二页开始:跳过前两条数据,接着值显示3和4条数据
//第一页
db.comment.find().skip(0).limit(2)
//第二页
db.comment.find().skip(2).limit(2)
//第三页
db.comment.find().skip(4).limit(2)
//排序查询
db.COLLECTION_NAME.find().sort({KEY:1}) 或 db.集合名称.find().sort(排序方式)
//对userid降序排列,并对访问量进行升序排
db.comment.find().sort({userid:-1,likenum:1})
//正则查询
db.collection.find({field:/正则表达式/})
或
db.集合.find({字段:/正则表达式/})
//查询评论内容包含“开水”的所有文档
db.comment.find({content:/开水/})
//查询评论的内容中以“专家”开头
db.comment.find({content:/^专家/})
//比较查询
<, <=, >, >= 这个操作符也是很常用的,格式如下:
db.集合名称.find({ "field" : { $lt: value }}) // 小于: field < value
db.集合名称.find({ "field" : { $gte: value }}) // 大于等于: field >= value
db.集合名称.find({ "field" : { $lte: value }}) // 小于等于: field <= value
db.集合名称.find({ "field" : { $ne: value }}) // 不等于: field != value
//查询评论点赞数量大于700的记录
db.comment.find({likenum:{$gt:NumberInt(700)}})
//包含查询
//查询评论的集合中userid字段包含1003或1004的文档
db.comment.find({userid:{$in:["1003","1004"]}})
//查询评论集合中userid字段不包含1003和1004的文档
db.comment.find({userid:{$nin:["1003","1004"]}})
//条件连接查询
查询同时满足两个以上条件,需要使用$and操作符将条件进行关联。 格式为:
$and:[ { },{ },{ } ]
//查询评论集合中likenum大于等于700 并且小于2000的文档:
db.comment.find({$and:[{likenum:{$gte:NumberInt(700)}},{likenum:{$lt:NumberInt(2000)}}]}) //查询评论集合中userid为1003,或者点赞数小于1000的文档记录
db.comment.find({$or:[ {userid:"1003"} ,{likenum:{$lt:1000} }]})
# 模糊查询 通过正则表达式实现 /模糊查询字符串/
db.student.find({address:/洞/}); #address中含有洞的所有文档
db.student.find({address:/^西/}); #address中以西开头的所有文档
# NULL
db.student.find({address:null}); #查询address为null以及不存在该字段的所有文档
# 不等于
db.student.find({sex:{$ne:"男"}}); # not euqals
# 判断文档是否存在/不存在某个字段
db.student.find({address:{$exists:true}});
db.student.find({address:{$exists:false}});
提示:
skip(), limilt(), sort()三个放在一起执行的时候,执行的顺序是先 sort(), 然后是 skip(),最后是显示的 limit(),和命令编写顺序无关。
索引
1 索引的类型
1.1 单字段索引
MongoDB支持在文档的单个字段上创建用户定义的升序/降序索引,称为单字段索引(Single Field Index)。
对于单个字段索引和排序操作,索引键的排序顺序(即升序或降序)并不重要,因为MongoDB可以在任何方向上遍历索引。
1.2 复合索引
MongoDB还支持多个字段的用户定义索引,即复合索引(Compound Index)。
复合索引中列出的字段顺序具有重要意义。例如,如果复合索引由 { userid: 1, score: -1 } 组成,则索引首先按userid正序排序,然后
在每个userid的值内,再在按score倒序排序
1.3 其他索引
地理空间索引(Geospatial Index)、文本索引(Text Indexes)、哈希索引(Hashed Indexes)。
1.3.1 地理空间索引(Geospatial Index)
为了支持对地理空间坐标数据的有效查询,MongoDB提供了两种特殊的索引:返回结果时使用平面几何的二维索引和返回结果时使用球面 几何的二维球面索引。
1.3.2 文本索引(Text Indexes)
MongoDB提供了一种文本索引类型,支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的停止词(例如“the”、“a”、“or”),而将集合中的词作为词干,只存储根词。
1.3.3 哈希索引(Hashed Indexes)
为了支持基于散列的分片,MongoDB提供了散列索引类型,它对字段值的散列进行索引。这些索引在其范围内的值分布更加随机,但只支 持相等匹配,不支持基于范围的查询。
2 索引管理
2.1 查询索引
返回一个集合中的所有索引的数组
db.collection.getIndexes() 结果中显示的是默认 _id 索引。
注意:该索引是唯一索引,因此值不能重复,即 _id 值不能重复的。在分片集群中,通常使用 _id 作为片键
2.2 创建索引
在集合上创建索引。
db.collection.createIndex(keys, options)
示例
//单字段索引示例:对 userid 字段建立索引:
db.comment.createIndex({userid:1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
//复合索引:对 userid 和 nickname 同时建立复合(Compound)索引:
db.comment.createIndex({userid:1,nickname:-1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 2,
"numIndexesAfter" : 3,
"ok" : 1
}
2.3 索引的移除
可以移除指定的索引,或移除所有索引
//指定索引的移除
db.collection.dropIndex(index)
示例:
//删除 comment 集合中 userid 字段上的升序索引:
db.comment.dropIndex({userid:1})
//所有索引的移除
db.collection.dropIndexes()
2.4 索引的使用
db.collection.find(query,options).explain(options)
示例:
//查看根据userid查询数据的情况
db.comment.find({userid:"1003"}).explain()
//userid建立索引
> db.comment.createIndex({userid:1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
springboot集成monggodb
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
添加配置
spring:
data:
mongodb:
host: 192.168.1.113
port: 27017
database: admin
authentication-database: true
使用MongoTemplate
@RestController
public class MongoController {
@Autowired
MongoTemplate mongoTemplate;
/**
* 向mongoDB里插入数据
* @param model
* @return
*/
@GetMapping("/add")
public String add1(Model model){
// Failed to convert value of type 'java.lang.String' to required type 'org.bson.types.ObjectId
MongoEntity d =new MongoEntity();
d.setBy("徐国亮");
d.setDescription("zuolianxi");
d.setLikes(500);
d.setTags("hellowolrd");
d.setTitle("shanchushuju");
d.setUrl("www.baidu.com");
model.addAttribute("mongoEntity",d);
mongoTemplate.save(d);
return "success";
}
/**
* 查询mongoDB是否有MongoEntity的数据
* @param model
* @return
*/
@GetMapping("/list")
@Cacheable(cacheNames = "mongo")
public List add(Model model){
List<MongoEntity> departmentList = mongoTemplate.findAll(MongoEntity.class);
for (MongoEntity department :departmentList) {
System.out.println(department);
}
model.addAttribute("departmentList",departmentList);
return departmentList ;
}
@ResponseBody
@GetMapping("/getUser")
public List findAll(){
List<Emps> departmentList = mongoTemplate.findAll(Emps.class);
if(CollectionUtils.isEmpty(departmentList)){
List list=new ArrayList();
list.add("没有查询到数据");
return list;
}else {
return departmentList ;
}
}
//一. 常用查询1. 查询一条数据:(多用于保存时判断db中是否已有当前数据,这里 is 精确匹配,模糊匹配 使用 regex...)
@ResponseBody
@GetMapping("/findOne")
public List findOne() {
System.out.println("进入查询一条数据方法");
return mongoTemplate.find(new Query(Criteria.where("ename").is("吴用")),Emps.class);
}
//查询多条数据: 属于分级查询,limit不指定就查所有,skip表示跳过的行数,不指定就不跳过
//mongoTemplate.find(new Query().limit(rows).skip((page-1)*rows),Emps.class)
//pageindex显示的当前页,pageSize,显示的记录数
@ResponseBody
@GetMapping("/getPagedUser")
public PageImpl<Emps> getPagedUser(int page, int rows) {
System.out.println("查询多条数据: 属于分级查询");
Query query=new Query();
//每页五个
Pageable pageable=new PageRequest(page,rows);
query.with(pageable);
//按sal排序
query.with(new Sort(Sort.Direction.DESC,"sal"));
//查询总数
Long count=mongoTemplate.count(query,Emps.class,"emp");
List<Emps> emps=mongoTemplate.find(query,Emps.class);
return (PageImpl<Emps>)PageableExecutionUtils.getPage(emps,pageable,()->count);
}
//模糊查询
@ResponseBody
@GetMapping("/like")
public List like() {
Query query = new Query(new Criteria().where("job").regex(Pattern.compile("^.*.职.*$",Pattern.CASE_INSENSITIVE)));
return mongoTemplate.find(query,Emps.class);
}
//多条件查询
@ResponseBody
@GetMapping("/manyCase")
public List manyCase() {
Query query = new Query();
query.addCriteria(Criteria.where("depno").is(20));
query.addCriteria(Criteria.where("sal").gte(1200));
return mongoTemplate.find(query,Emps.class);
}
/*
* project:列出所有本次查询的字段,包括查询条件的字段和需要搜索的字段;
* match:搜索条件criteria
* unwind:某一个字段是集合,将该字段分解成数组
* group:分组的字段,以及聚合相关查询
* sum:求和(同sql查询)
* count:数量(同sql查询)
* as:别名(同sql查询)
* addToSet:将符合的字段值添加到一个集合或数组中
* sort:排序
* skip&limit:分页查询
*/
@ResponseBody
@GetMapping("/agreegation")
public List agreegation() {
//统计部门人数
Aggregation aggregation=Aggregation.newAggregation(Aggregation.group("depno").count().as("部门人数"));
AggregationResults results=mongoTemplate.aggregate(aggregation,"emp", BasicDBObject.class);
return results.getMappedResults();
}
//or
/*@ResponseBody
@GetMapping("/orOperator")
public List orOperator() {
Query query=new Query(Criteria.where("sal").gt(1500)
.orOperator(Criteria.where("empno")).is(7782));
return mongoTemplate.find(query,Emps.class);
}*/
}
//扩展 属性内两字段比较
Criteria criteria = new Criteria() {
@Override
public DBObject getCriteriaObject() {
DBObject obj = new BasicDBObject();
obj.put("$where", "this.completeMortarNum > this.mortarNum");
return obj;
}
};
criteria.and("missionStatus").is(1);
query.addCriteria(criteria);
List<Mission> missions = missionListDao.find(query);
@SpringBootTest(classes = JineErpApplication.class)
public class Test_3 {
@Autowired
private MongoTemplate mongoTemplate;
@Test
public void fangfa_5() {
Query query = new Query();
//查询嵌入对象的值
query.addCriteria(Criteria.where("ename.firstname").is("san"));
/*
$gt:大于
$lt:小于
$gte:大于或等于
$lte:小于或等于
*/
//这个就可以直接是时间范围查询
query.addCriteria(Criteria.where("age").gt(586).lt(590));
//不等于 $ne
query.addCriteria(Criteria.where("age").ne(28));
//in
//也可以query.addCriteria(Criteria.where("companyId").in(集合))
query.addCriteria(Criteria.where("roles").in("gen","vip"));
//not in
query.addCriteria(Criteria.where("roles").nin("gen","vip"));
/*
$all和$in类似,但是他需要匹配条件内所有的值 ,【gen, vip, putong】 这种也会返回
*/
query.addCriteria(Criteria.where("roles").all("gen","vip"));
/*
取模运算$mod
如 age % 2 == 0
*/
query.addCriteria(Criteria.where("age").mod(2,0));
/*
$size是匹配数组内的元素数量的,如有一个对象:{roles:["gen", "vip", "putong"]},他有3个元素
官网上说不能用来匹配一个范围内的元素,如果想找$size<5之类的,他们建议创建一个字段来保存元素的数量。
*/
query.addCriteria(Criteria.where("roles").size(3));
//$exists用来判断一个字段是否存在
query.addCriteria(Criteria.where("address").exists(true));
//$type 基于 bson type来匹配一个字段的类型
query.addCriteria(Criteria.where("_id").type(JsonSchemaObject.Type.BsonType.OBJECT_ID));
List<Userinfos> userList = mongoTemplate.find(query, Userinfos.class, "userinfos");
}