MongoDB


简介

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,或不写该字段。

执行后,如下,说明插入一个数据成功了

注意:

  1. 文档中的键/值对是有序的。
  2. 文档中的值不仅可以是在双引号里面的字符串,还可以是其他几种数据类型(甚至可以是整个嵌入的文档)。
  3. MongoDB区分类型和大小写。
  4. MongoDB的文档不能有重复的键。
  5. 文档的键是字符串。除了少数例外情况,键可以使用任意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( 
    , 
    , 
    { 
        upsert: , 
        multi: , 
        writeConcern: , 
        collation: , 
        arrayFilters: [ , ... ], 
        hint:  // 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;
}

新增结果

查询结果:

参考: https://blog.csdn.net/qq_37421862/article/details/81287247?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase


文章作者: 小莫の咕哒君
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 小莫の咕哒君 !
评论
  目录