简介
MongoDB是一个开源、高性能、无模式的文档型数据库,当初的设计就是用于简化开发和方便扩展,是NoSQL数据库产品中的一种。是最像关系型数据库(MySQL)的非关系型数据库。
它支持的数据结构非常松散,是一种类似于 JSON 的 格式叫BSON,所以它既可以存储比较复杂的数据类型,又相当的灵活。
MongoDB中的记录是一个文档,它是一个由字段和值对(fifield:value)组成的数据结构。MongoDB文档类似于JSON对象,即一个文档认 为就是一个对象。字段的数据类型是字符型,它的值除了使用基本的一些类型外,还可以包括其他文档、普通数组和文档数组
体系结构
MySQL和MongoDB对比
术语
相关术语对比
数据模型
MongoDB的最小存储单位就是文档(document)对象。文档(document)对象对应于关系型数据库的行。数据在MongoDB中以 BSON(Binary-JSON)文档的格式存储在磁盘上。
BSON(Binary Serialized Document Format)是一种类json的一种二进制形式的存储格式,简称Binary JSON。BSON和JSON一样,支持 内嵌的文档对象和数组对象,但是BSON有JSON没有的一些数据类型,如Date和BinData类型。
BSON采用了类似于 C 语言结构体的名称、对表示方法,支持内嵌的文档对象和数组对象,具有轻量性、可遍历性、高效性的三个特点,可 以有效描述非结构化数据和结构化数据。这种格式的优点是灵活性高,但它的缺点是空间利用率不是很理想。
Bson中,除了基本的JSON类型:string,integer,boolean,double,null,array和object,mongo还使用了特殊的数据类型。这些类型包括 date,object id,binary data,regular expression 和code。每一个驱动都以特定语言的方式实现了这些类型,查看你的驱动的文档来获取详 细信息。
BSON数据类型参考列表:
安装并创建用户
下载镜像
docker pull mongo
创建容器,并挂载数据卷
docker run -p 27017:27017 --name mongodb -v $PWD/db:/data/db -d mongo:latest --auth
进入容器
docker exec -it mongodb /bin/bash
运行mongo命令
看是否能正常启动
mongo
创建用户和密码
使用admin用户
use admin
创建管理员账户并设置密码
db.createUser({ user: 'root', pwd: 'root', roles: [ { role: "userAdminAnyDatabase", db: "admin" } ] });
以 admin 用户身份进入mongo
docker exec -it mongodb mongo admin
进行身份验证
就是上一步创建的管理员账号密码
db.auth("root","root")
创建 用户、密码和数据库:
db.createUser({ user: 'jcl', pwd: 'jcl123456', roles: [ { role: "readWrite", db: "learn" } ] });
以 admin 用户身份进入mongo :
docker exec -it mongodb mongo admin
对 zy 进行身份认证:
db.auth("zy","zy123456");
切换数据库
use app
数据库基本操作
离不开的增删改查,MongoDB 中默认的数据库为 test,如果你没有选择数据库,集合将存放在 test 数据库中,有一些数据库名是保留的,可以直接访问这些有特殊作用的数据库
查看数据库
show dbs
选择和创建数据库
如果数据库不存在则自动创建,并切换
use learn
查看当前数据库
db
删除数据库
MongoDB 删除数据库的语法格式如下:
db.dropDatabase()
提示:主要用来删除已经持久化的数据库
集合基本操作
查看集合
show collections
或者
show tables
显示创建集合
db.createCollection(stu)
集合的命名规范:
- 集合名不能是空字符串""。
- 集合名不能含有\0字符(空字符),这个字符表示集合名的结尾。
- 集合名不能以"system."开头,这是为系统集合保留的前缀。
- 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含,这是因为某些系统生成的集合中包含该字符。除 非你要访问这种系统创建的集合,否则千万不要在名字里出现$。
隐式创建集合并插入数据
当向一个集合中插入一个文档的时候,如果集合不存在,则会自动创建集合,通常我们使用隐式创建文档即可
db.stus.insert({name: "xiaoming",age: 18,gender: "male"});
# 多个插入
db.stus.insert([
{name: "zhubajie",age: 27,gender: "male"},
{name: "shaheshang",age: 27,gender: "male"}
])
删除集合
db.collection.drop()
或
db.集合.drop()
如果成功删除选定集合,则 drop() 方法返回 true,否则返回 false。
例如:要删除stus集合
db.stus.drop()
文档基本操作
插入文档
# 多个插入
db.comment.insert({
"articleid": "100000",
"content": "今天天气真好,阳光明 媚",
"userid": "1001",
"nickname": "Rose",
"createdatetime": new Date(),
"likenum": NumberInt(10),
"state": null
})
提示:
- comment集合如果不存在,则会隐式创建
- mongo中的数字,默认double类型,如要存整型,必须使用函数NumberInt,否则取出来就有问题了。
- 插入当前日期使用 new Date()
- 插入的数据没有指定 _id ,会自动生成主键值
- 如果某字段没值,可以赋值为null,或不写该字段。
执行后,如下,说明插入一个数据成功了
注意:
- 文档中的键/值对是有序的。
- 文档中的值不仅可以是在双引号里面的字符串,还可以是其他几种数据类型(甚至可以是整个嵌入的文档)。
- MongoDB区分类型和大小写。
- MongoDB的文档不能有重复的键。
- 文档的键是字符串。除了少数例外情况,键可以使用任意UTF-8字符。
文档键命名规范:
- 键不能含有\0 (空字符)。这个字符用来表示键的结尾。
- .和$有特别的意义,只有在特定环境下才能使用。
- 以下划线"_"开头的键是保留的(不是严格要求的)
批量插入
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"
},
{
"_id": "3",
"articleid": "100001",
"content": "我一直喝凉开水,冬天夏天都喝。",
"userid": "1004",
"nickname": "杰克船 长",
"createdatetime": new Date("2019-08-06T01:05:06.321Z"),
"likenum": NumberInt(666),
"state": "1"
},
{
"_id": "4",
"articleid": "100001",
"content": "专家说不能空腹吃饭,影响健康。",
"userid": "1003",
"nickname": "凯 撒",
"createdatetime": new Date("2019-08-06T08:18:35.288Z"),
"likenum": NumberInt(2000),
"state": "1"
},
{
"_id": "5",
"articleid": "100001",
"content": "研究表明,刚烧开的水千万不能喝,因为烫 嘴。",
"userid": "1003",
"nickname": "凯撒",
"createdatetime": new Date("2019-08- 06T11:01:02.521Z"),
"likenum": NumberInt(3000),
"state": "1"
}]);
提示:
插入时指定了 _id ,则主键就是该值。
异常捕获
如果某条数据插入失败,将会终止插入,但已经插入成功的数据不会回滚掉。
因为批量插入由于数据较多容易出现失败,因此,可以使用try catch进行异常捕捉处理,测试的时候可以不处理。
try {
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": "5",
"articleid": "100001",
"content": "研究表明,刚烧开的水千万不能喝,因为烫 嘴。",
"userid": "1003",
"nickname": "凯撒",
"createdatetime": new Date("2019-08- 06T11:01:02.521Z"),
"likenum": NumberInt(3000),
"state": "1"
}]);
} catch (e) {
print (e);
}
查询集合中的文档
查询所有
如果我们要查询集合的所有文档,我们输入以下命令
db.comment.find()
或
db.comment.find({})
这里你会发现每条文档会有一个叫_id的字段,这个相当于我们原来关系数据库中表的主键,当你在插入文档记录时没有指定该字段, MongoDB会自动创建,其类型是ObjectID类型。 如果我们在插入文档记录时指定该字段也可以,其类型可以是ObjectID类型,也可以是MongoDB支持的任意类型.
如果我想按一定条件来查询,比如我想查询userid为1003的记录,怎么办?很简单!只 要在fifind()中添加参数即可,参数也是json格式,如 下:
db.comment.find({userid:'1003'})
如果你只需要返回符合条件的第一条数据,我们可以使用fifindOne命令来实现,语法和fifind一样。
如:查询用户编号是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)
参数:
Parameter | Type | Description |
---|---|---|
query | document | 查询选择条件。 |
options | document | 可选。用于修改计数的额外选项。 |
【示例】
统计comment集合的所有的记录数:
db.comment.count()
统计userid为1003的记录条数
db.comment.count({userid:"1003"})
分页查询
可以使用limit()方法来读取指定数量的数据,使用skip()方法来跳过指定数量的数据
基本语法如下所示:
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
如果你想返回指定条数的记录,可以在fifind方法后调用limit来返回结果(TopN),默认值20,例如
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)
排序查询
sort() 方法对数据进行排序,sort() 方法可以通过参数指定排序的字段,并使用 1 和 -1 来指定排序的方式,其中 1 为升序排列,而 -1 是用 于降序排列
db.COLLECTION_NAME.find().sort({KEY:1})
或
db.集合名称.find().sort(排序方式)
例如:
对userid降序排列,并对访问量进行升序排列
db.comment.find().sort({userid:-1,likenum:1})
提示:
skip(), limilt(), sort()三个放在一起执行的时候,执行的顺序是先 sort(), 然后是 skip(),最后是显示的 limit(),和命令编写顺序无关。
正则查询
MongoDB的模糊查询是通过正则表达式的方式实现的。格式为:
db.collection.find({field:/正则表达式/})
或
db.集合.find({字段:/正则表达式/})
提示:正则表达式是js的语法,直接量的写法。
例如,我要查询评论内容包含“开水”的所有文档,代码如下:
db.comment.find({content:/开水/})
如果要查询评论的内容中以“专家”开头的,代码如下:
db.comment.find({content:/^专家/})
比较查询
<, <=, >, >= 这个操作符也是很常用的,格式如下:
db.集合名称.find({ "field" : { $gt: value }}) // 大于: field > value
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)}})
包含查询
包含使用$in操作符。 示例:查询评论的集合中userid字段包含1003或1004的文档
db.comment.find({userid:{$in:["1003","1004"]}})
不包含使用$nin操作符。 示例:查询评论集合中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)}}]})
如果两个以上条件之间是或者的关系,我们使用 操作符进行关联,与前面 and的使用方式相同 格式为:
$or:[ { },{ },{ } ]
示例:查询评论集合中userid为1003,或者点赞数小于1000的文档记录
db.comment.find({$or:[ {userid:"1003"} ,{likenum:{$lt:1000} }]})
修改文档数据
更新文档的语法:
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
}
)
【示例】
覆盖的修改
如果我们想修改_id为1的记录,点赞量为1001,输入以下语句:
db.comment.update({_id:"1"},{likenum:NumberInt(1001)})
执行后,我们会发现,这条文档除了likenum字段其它字段都不见了
局部修改
为了解决这个问题,我们需要使用修改器$set来实现,命令如下:
我们想修改_id为2的记录,浏览量为889,输入以下语句:
db.comment.update({_id:"2"},{$set:{likenum:NumberInt(889)}})
这样就OK啦。
批量修改
更新所有用户为 1003 的用户的昵称为 凯撒大帝 。
//默认只修改第一条数据
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒2"}})
//修改所有符合条件的数据
db.comment.update({userid:"1003"},{$set:{nickname:"凯撒大帝"}},{multi:true})
提示:如果不加后面的参数,则只更新符合条件的第一条记录
列值增长的修改
如果我们想实现对某列值在原有值的基础上进行增加或减少,可以使用 $inc 运算符来实现。
需求:对3号数据的点赞数,每次递增1
db.comment.update({_id:"3"},{$inc:{likenum:NumberInt(1)}})
删除文档
删除文档的语法结构:
db.集合名称.remove(条件)
以下语句可以将数据全部删除,请慎用
db.comment.remove({})
如果删除_id=1的记录,输入以下语句
db.comment.remove({_id:"1"})
文档替换
将指定的文档的字段值替换
db.users.replaceOne({username: "zhubajie"},{username: "tangsheng"})
文档删除指定字段
删除指定用户的address字段
db.users.update({username: "tangsheng"},{$unset: {address: 1}})
其他相关命令
[ 启动客户端 => ./bin/mongo --host 192.168.200.100 ]
1: 查看所有已经创建的数据库 => show dbs
2: 切换或者创建数据库 => use 数据库名称
3: 删除当前数据库 => db.dropDatabase()
4: 获取当前数据库的名称 => db.getName()
5: 获取当前数据库的连接地址 => db.getMongo()
7: 获取当前数据库的所有集合(表) => show cellections
8: 向集合(表)添加数据, 不存在的集合会自动创建 => db.集合名称.save(json)
9: 修改数据 => db.集合名称.update(json1, json2)
9.1: json1 为查询条件 如 {“id”: 25}
9.2: json2 为修改成 如 {“name”: “测试”}
9.3: 意思为 将 id 是 25 的所有数据的 name 字段修改为 "测试"
10: 删除数据 => db.集合名称.remove(json)
10.1: json 和 9 的 json1 相似, 为需要删除的条件
11: 查询数据 => db.结合名称.find(json)
11.1: json 和 9 的 json1 相似, 为需要查询的条件
12: 创建数据库超级管理员 => db.createUser({ user: “root”, pwd: “920619”, roles: [ { role: “root”, db: “admin” } ]})
12.1: user: 账号, pwd: 密码, db: 数据库 // 超级管理员只能在 admin 下创建
12.2: roles: 权限 有以下选择 =>
12.3: 数据库用户角色:read、readWrite;
12.4: 数据库管理角色:dbAdmin、dbOwner、userAdmin;
12.5: 集群管理角色:clusterAdmin、clusterManager、clusterMonitor、hostManager;
12.6: 备份恢复角色:backup、restore;
12.7: 当前数据库角色:readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
12.8: 超级用户角色:root, 这里还有几个角色间接或直接提供了系统超级用户的访问(dbOwner 、userAdmin、userAdminAnyDatabase)
12.9: 内部角色:__system
13: 重新启动mongodb登入客户端还和以前一样, 但是登入后你回答无法操作数据库
13.1: 登入用户 => use admin => db.auth(‘root’, ‘920619’) => 输出 1 表示登入成功
13.2: 超级管理员在 admin 下登入, 具体数据库的管理员在具体的数据库下登入
14: 删除用户可以直接操作 admin 下的 system.users 集合
ps:更多命令请查看官网代码
SpringBoot整合MongoDB
依赖
<!-- mongodb -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
配置
spring:
data:
mongodb:
host: 127.0.0.1
port: 27017
username: manager
password: manager
authentication-database: admin #认证的库
database: exam #操作的库
logging:
level:
top.codekiller.test.mongodb: DEBUG #配置MongoTemplate日志
工具类
我这里是用的其他博主的测试工具类,看最下方链接处。
我对工具类进行了一些改变,原工具类的查询是传入对象,并且返回的类型也有点一言难尽,所以我用了一个泛型,直接传入类对象,方便了很多。原来的我也保留了。
package top.codekiller.test.mongodb.util;
import org.springframework.beans.factory.annotation.Autowired;
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 org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.List;
/**
* @author codekiller
* @date 2020/5/30 15:53
* Mongodb工具类
*/
@Component
public class MongodbUtils {
public static MongodbUtils mongodbUtils;
@PostConstruct
public void init() {
mongodbUtils = this;
mongodbUtils.mongoTemplate = this.mongoTemplate;
}
@Autowired
private MongoTemplate mongoTemplate;
/**
* 保存数据对象,集合为数据对象中@Document 注解所配置的collection
*
* @param obj
* 数据对象
*/
public static void save(Object obj) {
mongodbUtils.mongoTemplate.save(obj);
}
/**
* 指定集合保存数据对象
*
* @param obj
* 数据对象
* @param collectionName
* 集合名
*/
public static void save(Object obj, String collectionName) {
mongodbUtils.mongoTemplate.save(obj, collectionName);
}
/**
* 根据数据对象中的id删除数据,集合为数据对象中@Document 注解所配置的collection
*
* @param obj
* 数据对象
*/
public static void remove(Object obj) {
mongodbUtils.mongoTemplate.remove(obj);
}
/**
* 指定集合 根据数据对象中的id删除数据
*
* @param obj
* 数据对象
* @param collectionName
* 集合名
*/
public static void remove(Object obj, String collectionName) {
mongodbUtils.mongoTemplate.remove(obj, collectionName);
}
/**
* 根据key,value到指定集合删除数据
*
* @param key
* 键
* @param value
* 值
* @param collectionName
* 集合名
*/
public static void removeById(String key, Object value, String collectionName) {
Criteria criteria = Criteria.where(key).is(value);
criteria.and(key).is(value);
Query query = Query.query(criteria);
mongodbUtils.mongoTemplate.remove(query, collectionName);
}
/**
* 指定集合 修改数据,且仅修改找到的第一条数据
*
* @param accordingKey
* 修改条件 key
* @param accordingValue
* 修改条件 value
* @param updateKeys
* 修改内容 key数组
* @param updateValues
* 修改内容 value数组
* @param collectionName
* 集合名
*/
public static void updateFirst(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues,
String collectionName) {
Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
Query query = Query.query(criteria);
Update update = new Update();
for (int i = 0; i < updateKeys.length; i++) {
update.set(updateKeys[i], updateValues[i]);
}
mongodbUtils.mongoTemplate.updateFirst(query, update, collectionName);
}
/**
* 指定集合 修改数据,且修改所找到的所有数据
*
* @param accordingKey
* 修改条件 key
* @param accordingValue
* 修改条件 value
* @param updateKeys
* 修改内容 key数组
* @param updateValues
* 修改内容 value数组
* @param collectionName
* 集合名
*/
public static void updateMulti(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues,
String collectionName) {
Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
Query query = Query.query(criteria);
Update update = new Update();
for (int i = 0; i < updateKeys.length; i++) {
update.set(updateKeys[i], updateValues[i]);
}
mongodbUtils.mongoTemplate.updateMulti(query, update, collectionName);
}
/**
* 根据条件查询出所有结果集 集合为数据对象中@Document 注解所配置的collection
*
* @param obj
* 数据对象
* @param findKeys
* 查询条件 key
* @param findValues
* 查询条件 value
* @return
*/
public static List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues) {
Criteria criteria = null;
for (int i = 0; i < findKeys.length; i++) {
if (i == 0) {
criteria = Criteria.where(findKeys[i]).is(findValues[i]);
} else {
criteria.and(findKeys[i]).is(findValues[i]);
}
}
Query query = Query.query(criteria);
List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass());
return resultList;
}
/**
* 指定集合 根据条件查询出所有结果集
*
* @param obj
* 数据对象
* @param findKeys
* 查询条件 key
* @param findValues
* 查询条件 value
* @param collectionName
* 集合名
* @return
*/
public static List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String collectionName) {
Criteria criteria = null;
for (int i = 0; i < findKeys.length; i++) {
if (i == 0) {
criteria = Criteria.where(findKeys[i]).is(findValues[i]);
} else {
criteria.and(findKeys[i]).is(findValues[i]);
}
}
Query query = Query.query(criteria);
List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
return resultList;
}
/**
* 指定集合 根据条件查询出所有结果集 并排倒序
*
* @param obj
* 数据对象
* @param findKeys
* 查询条件 key
* @param findValues
* 查询条件 value
* @param collectionName
* 集合名
* @param sort
* 排序字段
* @return
*/
public static List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String collectionName ,String sort) {
Criteria criteria = null;
for (int i = 0; i < findKeys.length; i++) {
if (i == 0) {
criteria = Criteria.where(findKeys[i]).is(findValues[i]);
} else {
criteria.and(findKeys[i]).is(findValues[i]);
}
}
Query query = Query.query(criteria);
query.with(new Sort(Direction.DESC, sort));
List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
return resultList;
}
/**
* 根据条件查询出符合的第一条数据 集合为数据对象中 @Document 注解所配置的collection
*
* @param obj
* 数据对象
* @param findKeys
* 查询条件 key
* @param findValues
* 查询条件 value
* @return
*/
public static Object findOne(Object obj, String[] findKeys, Object[] findValues) {
Criteria criteria = null;
for (int i = 0; i < findKeys.length; i++) {
if (i == 0) {
criteria = Criteria.where(findKeys[i]).is(findValues[i]);
} else {
criteria.and(findKeys[i]).is(findValues[i]);
}
}
Query query = Query.query(criteria);
Object resultObj = mongodbUtils.mongoTemplate.findOne(query, obj.getClass());
return resultObj;
}
/**
* 指定集合 根据条件查询出符合的第一条数据
*
* @param obj
* 数据对象
* @param findKeys
* 查询条件 key
* @param findValues
* 查询条件 value
* @param collectionName
* 集合名
* @return
*/
public static Object findOne(Object obj, String[] findKeys, Object[] findValues, String collectionName) {
Criteria criteria = null;
for (int i = 0; i < findKeys.length; i++) {
if (i == 0) {
criteria = Criteria.where(findKeys[i]).is(findValues[i]);
} else {
criteria.and(findKeys[i]).is(findValues[i]);
}
}
Query query = Query.query(criteria);
Object resultObj = mongodbUtils.mongoTemplate.findOne(query, obj.getClass(), collectionName);
return resultObj;
}
/**
* 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
*
* @param obj
* 数据对象
* @return
*/
public static List<? extends Object> findAll(Object obj) {
List<? extends Object> resultList = mongodbUtils.mongoTemplate.findAll(obj.getClass());
return resultList;
}
/**
* 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
* @param clazz
* @param <T>
* @return
*/
public static <T> List<T> findAll(Class<T> clazz){
List<T> resultList = mongodbUtils.mongoTemplate.findAll(clazz);
return resultList;
}
/**
* 指定集合 查询出所有结果集
*
* @param obj
* 数据对象
* @param collectionName
* 集合名
* @return
*/
public static List<? extends Object> findAll(Object obj, String collectionName) {
List<? extends Object> resultList = mongodbUtils.mongoTemplate.findAll(obj.getClass(), collectionName);
return resultList;
}
/**
* 指定集合 查询出所有结果集
* @param clazz
* @param collectionName
* @param <T>
* @return
*/
public static <T> List<T> findAll(Class<T> clazz, String collectionName) {
List<T> resultList = mongodbUtils.mongoTemplate.findAll(clazz, collectionName);
return resultList;
}
}
测试
因为操作都差不多,我这里就测试两个好了,其他的今后使用的时候看注释好了。(其他相关操作的测试请看下方的链接处)
/**
* @author codekiller
* @date 2020/5/30 15:58
*/
@SpringBootTest(classes = MongodbtestSpringApplication.class)
@RunWith(SpringRunner.class)
public class TestMongodb {
@Test
public void testSave(){
Topic topic=new Topic();
topic.setName("从器件角度看,计算机经历了五代变化。但从系统结构看,至今绝大多数计算机仍属于( )计算机。");
topic.setType(1);
topic.setSubject(1266661195234037761L);
Map<Integer,String> select=new HashMap<>(16);
select.put(0,"并行");
select.put(1,"冯诺依曼");
select.put(2,"智能");
select.put(3,"串行");
topic.setSelect(select);
topic.setAnswer(1);
topic.setCreated(new Date());
topic.setDeleted(false);
topic.setNote("计算机组成原理");
MongodbUtils.save(topic);
}
@Test
public void testFind(){
List<Topic> all = MongodbUtils.findAll(Topic.class);
all.forEach((value)-> System.out.println(value));
}
实体类
/**
* @author codekiller
* @date 2020/5/30 16:02
*/
@Document(collection = "tb_topic")
@Data
public class Topic {
/**
* id
*/
@Id
private String id;
/**
* 名称
*/
private String name;
/**
* 选择题的选项
*/
private Map<Integer,String> select;
/**
* 答案
*/
private Integer answer;
/**
* 题目类型(0:选择题,1:判断题)
*/
private Integer type;
/**
* 题目的学科类型id
*/
private Long subject;
/**
* 备注信息
*/
private String note;
/**
* 相关的图片地址
*/
private String image;
/**
* 创建时间
*/
private Date created;
/**
* 逻辑删除
*/
private Boolean deleted;
}
新增结果:
查询结果: