美文网首页
MongoDB入门

MongoDB入门

作者: MiniSoulBigBang | 来源:发表于2020-12-04 16:07 被阅读0次

    1 MongoDB中的基本概念及原理

    1.1 MongoDB介绍

    ​ 官网地址:https://www.mongodb.com/
    ​ MongoDB 是由C++语言编写的,是一个基于分布式文件存储的开源数据库系统。 在高负载的情况下,添加更多的节点,可以保证服务器性能。 MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。

    ​ MongoDB是一个介于非系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。 MongoDB 将数据存储为一个文档,数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档,数组及文档数组。它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。

    1.2 MongoDB概念解析

    ​ 不管我们学习什么数据库都应该学习其中的基础概念,在mongodb中基本的概念是文档、集合、数据库,下面我们挨个介绍。
    ​ 下表将帮助您更容易理解Mongo中的一些概念:

    SQL术语/概念 MongoDB术语/概念 解释/说明
    database database 数据库
    table collection 数据库表/集合
    row document 数据记录行/文档
    column field 数据字段/域
    index index 索引
    table joins -- 表连接,MongoDB不支持
    primary key primary key 主键,MongoDB自动将_id字段设置为主键

    通过下图实例,我们也可以更直观的了解Mongo中的一些概念:

    001.png

    1.2.1 数据库

    ​ 一个mongodb中可以建立多个数据库。MongoDB的默认数据库为"test",该数据库存储在data目录中(安装时,可以默认可以指定,但是必须该目录是存在的)。MongoDB的单个实例可以容纳多个独立的数据库,每一个都有自己的集合和权限,不同的数据库放置在不同的文件中。
    ​ 执行 "show dbs" 命令可以显示所有数据库的列表。

    > show dbs 
    local 0.078GB 
    test 0.078GB 
    >
    

    ​ 执行 "db" 命令可以显示当前数据库对象或集合。

    > db 
    test 
    >
    

    ​ 执行 "use"命令,可以连接到一个指定的数据库。

    > use local 
    switched to db local 
    > db 
    local 
    >
    

    数据库命名规范
    数据库也通过名字来标识。数据库名可以是满足以下条件的任意UTF-8字符串。
    不能是空字符串
    不得含有' '(空格)、.、$、/、\和\0 (空字符)
    应全部小写
    最多64字节
    有一些数据库名是保留的,可以直接访问这些有特殊作用的数据库。
    admin: 从权限的角度来看,这是"root"数据库。要是将一个用户添加到这个数据库,这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行,比如列出所有的数据库或者关闭服务器。
    local: 这个数据永远不会被复制,可以用来存储限于本地单台服务器的任意集合
    config: 当Mongo用于分片设置时,config数据库在内部使用,用于保存分片的相关信息。

    1.2.2 集合

    ​ 集合就是 MongoDB 文档组,类似于 RDBMS中的表格。
    ​ 集合存在于数据库中,集合没有固定的结构,这意味着你在对集合可以插入不同格式和类型的数据,但通常情况下我们插入集合的数据都会有一定的关联性。比如,我们可以将以下不同数据结构的文档插入到集合中:

    {"site":"www.baidu.com"} 
    {"site":"www.google.com","name":"Google"} 
    

    ​ 当第一个文档插入时,集合就会被创建。
    ​ 一个collection(集合)中的所有field(域)是collection(集合)中所有document(文档)中包含 的field(域)的并集。

    集合命名规范
    集合名不能是空字符串""。
    集合名不能含有\0字符(空字符),这个字符表示集合名的结尾。
    集合名不能以"system."开头,这是为系统集合保留的前缀。
    用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含,这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合,否则千万不要在名字里出现。
    如下实例:

    db.col.findOne()
    

    capped collections
    Capped collections 就是固定大小的collection。它有很高的性能以及队列过期的特性(过期按照插入的顺序)。有点和 "RRD" 概念类似。Capped collections 是高性能自动的维护对象的插入顺序。它非常适合类似记录日志的功能。和标准的collection 不同,你必须要显式的创建一个capped collection,指定一个 collection 的大小,单位是字节。collection 的数据存储空间值提前分配的。
    Capped collections 可以按照文档的插入顺序保存到集合中,而且这些文档在磁盘上存放位置也是按照插入顺序来保存的,所以当我们更新Capped collections 中文档的时候,更新后的文档不可以超过之前文档的大小,这样话就可以确保所有文档在磁盘上的位置一直保持不变。
    由于 Capped collection 是按照文档的插入顺序而不是使用索引确定插入位置,这样的话可以提高增添数据的效率。MongoDB 的操作日志文件 oplog.rs 就是利用 Capped Collection 来实现的。
    要注意的是指定的存储大小包含了数据库的头信息

    db.createCollection("mycoll", {capped:true, size:100000})
    

    ​ 在 capped collection 中,你能添加新的对象。
    ​ 能进行更新,然而,对象不会增加存储空间。如果增加,更新就会失败 。
    ​ 使用 Capped Collection 不能删除一个文档,可以使用 drop() 方法删除 collection 所有的行。
    ​ 删除之后,你必须显式的重新创建这个 collection。
    ​ 在32bit机器中,capped collection 最大存储为 1e9( 1X10的9次方)个字节。

    1.2.3 文档

    ​ 文档是一组键值(key-value)对(即 BSON)。MongoDB 的文档不需要设置相同的字段,并且相同的字段不需要相同的数据类型,这与关系型数据库有很大的区别,也是 MongoDB 非常突出的特点。
    ​ 一个简单的文档例子如下:

    {"site":"www.kaikeba.com", "name":"开课吧"}
    

    下表列出了 RDBMS 与 MongoDB 对应的术语:

    RDBMS MongoDB
    数据库 数据库
    表格 集合
    文档
    字段
    表联合 嵌入文档
    主键 主键 (MongoDB 提供了 key 为 _id )

    需要注意的是
    文档中的键/值对是有序的。
    文档中的值不仅可以是在双引号里面的字符串,还可以是其他几种数据类型(甚至可以是整个嵌入的文档)。
    MongoDB区分类型和大小写。
    MongoDB的文档不能有重复的键。
    文档的键是字符串。除了少数例外情况,键可以使用任意UTF-8字符。
    文档键命名规范
    键不能含有\0 (空字符)。这个字符用来表示键的结尾。
    .和$有特别的意义,只有在特定环境下才能使用。
    以下划线"_"开头的键是保留的(不是严格要求的)。

    1.2.4 元数据

    ​ 数据库的信息是存储在集合中。它们使用了系统的命名空间:

    dbname.system.*
    

    ​ 在MongoDB数据库中名字空间 .system.* 是包含多种系统信息的特殊集合(Collection),如下:

    集合命名空间 描述
    dbname.system.namespaces 列出所有名字空间
    dbname.system.indexes 列出所有索引
    dbname.system.profifile 包含数据库概要(profifile)信息
    dbname.system.users 列出所有可访问数据库的用户
    dbname.system.sources 包含复制对端(slave)的服务器信息和状态

    ​ 对于修改系统集合中的对象有如下限制。
    ​ 在{{system.indexes}}插入数据,可以创建索引。但除此之外该表信息是不可变的(特殊的drop index命令将自动更新相关信息)。
    ​ {{system.users}}是可修改的。
    ​ {{system.profile}}是可删除的。

    1.3 MongoDB 数据类型

    ​ 下表为MongoDB中常用的几种数据类型:

    数据类型 说明 解释 举例
    String 字符串 UTF-8 编码的字符串才是合法的。 {“v”:“kkb”}
    Integer 整型数值 根据你所采用的服务器,可分为32 位或 64 位。 {“v”:1}
    Boolean 布尔值 用于存储布尔值(真/假)。 {“v”:true}
    Double 双精度浮点值 用于存储浮点值 {“v”:3.14}
    ObjectID 对象ID 用于创建文档的ID {“__id”:ObjectId(“123123”)}
    Array 数组 用于将数组或列表或多个值存储为一个键 {“arr”:[“a”,“b”]}
    Timestamp 时间戳 从开始纪元开始的毫秒数
    Object 内嵌文档 文档可以作为文档中某个key的value {“o”:{“foo”:“bar”}}
    Null 空值 表示空值或者未定义的对象 {“v”:null}
    Date 日期 日期时间,用Unix日期格式来存储当前日期或时间。 {“date”:new Date()}
    Regular 正则表达式 文档中可以包含正则表达式,遵循JS语法 {“v”:/kkb/i}
    Code 代码 可以包含JS代码 {“x”:function(){}}
    File 文件 1、二进制转码(Base64)后存储(<16M) 2、GridFS(>16M) GridFS 用两个集合来存储一个文件:fs.files与fs.chunks

    ​ 下面说明下几种重要的数据类型。

    1.3.1 ObjectId

    ​ ObjectId 类似唯一主键,可以很快的去生成和排序,包含 12 bytes,含义是:
    ​ 前 4 个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间,比北京时间晚了 8 个小时
    ​ 接下来的 3 个字节是机器标识码
    ​ 紧接的两个字节由进程 id 组成 PID
    ​ 最后三个字节是随机数

    002.png

    ​ MongoDB 中存储的文档必须有一个 _id 键。这个键的值可以是任何类型的,默认是个 ObjectId 对象。由于 ObjectId 中保存了创建的时间戳,所以你不需要为你的文档保存时间戳字段,你可以通过getTimestamp 函数来获取文档的创建时间:

    > var newObject = ObjectId() 
    > newObject.getTimestamp() 
    ISODate("2017-11-25T07:21:10Z")
    

    ObjectId 转为字符串

    > newObject.str 
    5a1919e63df83ce79df8b38f
    

    1.3.2 字符串

    ​ BSON 字符串都是 UTF-8 编码。

    1.3.3 时间戳

    ​ BSON有一个特殊的时间戳类型用于MongoDB内部使用,与普通的日期类型不相关。时间戳值是一个 64 位的值。其中:前32位是一个 time_t 值(与Unix新纪元相差的秒数),后32位是在某秒中操作的一个递增的序数。
    ​ 在单个 mongod 实例中,时间戳值通常是唯一的。
    ​ 在复制集中, oplog 有一个 ts 字段。这个字段中的值使用BSON时间戳表示了操作时间。
    ​ BSON 时间戳类型主要用于 MongoDB 内部使用。在大多数情况下的应用开发中,你可以使用BSON 日期类型。

    1.3.4 日期

    ​ 表示当前距离 Unix新纪元(1970年1月1日)的毫秒数。日期类型是有符号的, 负数表示 1970 年之前的日期。

    > var mydate1 = new Date() //格林尼治时间 
    > mydate1 ISODate("2018-03-04T14:58:51.233Z") 
    > typeof mydate1 
    object 
    > var mydate2 = ISODate() //格林尼治时间 
    > mydate2 ISODate("2018-03-04T15:00:45.479Z") 
    > typeof mydate2 
    object
    

    ​ 这样创建的时间是日期类型,可以使用 JS 中的 Date 类型的方法。
    ​ 返回一个时间类型的字符串:

    > var mydate1str = mydate1.toString() 
    > mydate1str 
    Sun Mar 04 2018 14:58:51 GMT+0000 (UTC) 
    > typeof mydate1str 
    string
    

    或者

    > Date() 
    Sun Mar 04 2018 1
    

    2 MongoDB安装和常用命令

    2.1 安装

    ​ 下载地址:https://www.mongodb.com/download-center#community

    ​ 下载安装包并解压 :

    wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.6.11.tgz 
    tar -zxvf mongodb-linux-x86_64-rhel70-3.6.11.tgz
    mv mongodb-linux-x86_64-rhel70-3.6.11 mongodb 
    #一定注意要创建数据存储目录,默认路径/data/db 
    mkdir -p /data/db
    

    ​ 配置环境变量:

    vim /etc/profile
    export PATH=$JAVA_HOME/bin:/root/mongodb/bin:$PATH
    source /etc/profile
    

    2.2 启动

    ​ 通过配置文件方式启动

    mongod --config 配置文件路径
    mongod -f 配置文件路径
    

    ​ 说明:-f是--config的缩写。配置文件,需要手动创建,参考以下配置即可。

    ​ 创建mongodb.cfg配置文件

    #数据库文件位置
    dbpath=/root/mongodb/singleton/data 
    #日志文件位置
    logpath=/root/mongodb/singleton/logs/mongodb.log 
    #以追加方式写入日志
    logappend=true
    #是否以守护进程方式运行
    fork=true
    #绑定客户端访问的ip 0.0.0.0 不绑定ip 
    bind_ip=192.168.10.135
    #默认端口号27017
    port=27017
    

    ​ 创建数据存储目录和日志文件目录:

    mkdir /root/mongodb/singleton/data -p 
    mkdir /root/mongodb/singleton/logs -p
    

    ​ 通过配置文件方式启动:

    mongod -f /root/mongodb/sinleton/mongodb.cfg
    

    2.3 连接客户端

    mongo 192.168.10.135:27017
    

    常用客户端
    自带命令行客户端
    Navicat for mongodb
    MongoVUE
    Studio 3T
    Robo 3T
    RockMongo

    2.4 常用命令

    2.4.1 创建数据库

    ​ MongoDB 创建数据库的语法格式如下:

    use DATABASE_NAME
    

    ​ 如果数据库不存在,则创建数据库,否则切换到指定数据库。以下实例我们创建了数据库 zhoutian:

    > use zhoutian 
    switched to db zhoutian
    > db 
    zhoutian 
    >
    

    ​ 如果你想查看所有数据库,可以使用 show dbs 命令:

    > show dbs 
    admin 0.000GB 
    local 0.000GB 
    >
    

    ​ 可以看到,我们刚创建的数据库zhoutian并不在数据库的列表中,要显示它,我们需要向zhoutian数据库插入一些数据。

    > db.mycollection.insert({"name":"周天"}) 
    WriteResult({ "nInserted" : 1 }) 
    > show dbs 
    local 0.078GB 
    zhoutian 0.078GB 
    test 0.078GB 
    >
    

    2.4.2 删除数据库

    ​ MongoDB 删除数据库的语法格式如下:

    db.dropDatabase()
    

    ​ 删除当前数据库,默认为 test,你可以使用 db 命令查看当前数据库名。以下实例我们删除了数据库 zhoutian。
    ​ 首先,查看所有数据库:

    > show dbs 
    local 0.078GB 
    zhoutian 0.078GB 
    test 0.078GB
    

    ​ 接下来我们切换到数据库 zhoutian:

    > use zhoutian
    switched to db zhoutian
    >
    

    ​ 执行删除命令:

    > db.dropDatabase() 
    { "dropped" : "zhoutian", "ok" : 1 } 
    

    ​ 最后,我们再通过show dbs命令数据库是否删除成功:

    show dbs 
    local 0.078GB 
    test 0.078GB 
    >
    

    2.4.3 创建集合

    ​ MongoDB中使用 createCollection()方法来创建集合。
    ​ 语法格式:

    db.createCollection(name, options)
    

    ​ 参数说明:
    ​ name: 要创建的集合名称
    ​ options: 可选参数, 指定有关内存大小及索引的选项。options 可以是如下参数:

    字段 类型 描述
    capped 布尔 (可选)如果为 true,则创建固定集合。
    固定集合是指有着固定大小的集合,当达到最大值时,它会自动覆盖最早的文档。
    当该值为 true 时,必须指定 size 参数。
    autoIndexId 布尔 (可选)如为 true,自动在 _id 字段创建索引。默认为 false。
    size 数值 (可选)为固定集合指定一个最大值(以字节计)。
    如果 capped 为true,也需要指定该字段。
    max 数值 (可选)指定固定集合中包含文档的最大数量。

    ​ 在插入文档时,MongoDB 首先检查固定集合的 size 字段,然后检查 max 字段。
    ​ 在 test 数据库中创建 mycollection集合:

    > use test 
    switched to db test 
    > db.createCollection("mycollection") 
    { "ok" : 1 } 
    >
    

    ​ 如果要查看已有集合,可以使用 show collections或show tables 命令:

    > show collections 
    mycollection 
    system.indexes
    

    ​ 下面是带有几个关键参数的 createCollection() 的用法:
    ​ 创建固定集合 mycol,整个集合空间大小 6142800 KB, 文档最大个数为 10000 个。

    > db.createCollection("mycol", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
    { "ok" : 1 }
    >
    

    ​ 在 MongoDB 中,你不需要创建集合。当你插入一些文档时,MongoDB 会自动创建集合。

    > db.mycol2.insert({"name" : "嗨"})
    > show collections
    mycol2
    ...
    

    2.4.4 删除集合

    ​ 集合删除语法格式如下:

    db.collection_name.drop()
    

    ​ 以下实例删除了zhoutian数据库中的集合 site:

    > use zhoutian 
    switched to db zhoutian 
    > show tables 
    site 
    > db.site.drop() 
    true 
    > show tables 
    >
    

    2.4.5 插入文档

    ​ MongoDB 使用 insert() 或 save() 方法向集合中插入文档,语法如下:

    db.COLLECTION_NAME.insert(document)
    或
    db.COLLECTION_NAME.save(document)
    

    ​ save():如果 _id 主键存在则更新数据,如果不存在就插入数据。该方法新版本中已废弃,可以使用 db.collection.insertOne() 或 db.collection.replaceOne() 来代替。
    ​ insert(): 若插入的数据主键已经存在,则会抛 org.springframework.dao.DuplicateKeyException 异常,提示主键重复,不保存当前数据。
    ​ 3.2 版本之后新增了 db.collection.insertOne() 和 db.collection.insertMany()。
    ​ 以下文档可以存储在 MongoDB 的zhoutian数据库 的 mycollection 集合中:

    >db.mycollection.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库', 
    by: '周天', 
    url: 'http://www.zhoutian.com', 
    tags: ['mongodb', 'database', 'NoSQL'], 
    likes: 100 
    })
    
    >var document = {title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库', 
    by: '周天', 
    url: 'http://www.zhoutian.com', 
    tags: ['mongodb', 'database', 'NoSQL'], 
    likes: 100 
    }
    >db.mycollection.insert(document)
    

    2.4.6 更新文档

    ​ MongoDB 使用 update() 和 save() 方法来更新集合中的文档。
    ​ update() 方法用于更新已存在的文档。语法格式如下:

    db.COLLECTION_NAME.update(
       <query>,
       <update>,
       {
         upsert: <boolean>,
         multi: <boolean>,
         writeConcern: <document>
       }
    )
    

    参数说明:
    query : update的查询条件,类似sql update查询内where后面的。
    update : update的对象和一些更新的操作符(如,inc...)等,也可以理解为sql update查询内set后面的
    upsert : 可选,这个参数的意思是,如果不存在update的记录,是否插入objNew,true为插入,默认是false,不插入。
    multi : 可选,mongodb 默认是false,只更新找到的第一条记录,如果这个参数为true,就把按条件查出来多条记录全部更新。
    writeConcern :可选,抛出异常的级别。

    ​ 我们在集合 mycollection中插入如下数据:

    >db.mycollection.insert({
        title: 'MongoDB 教程', 
        description: 'MongoDB 是一个 Nosql 数据库',
        by: '周天',
        url: 'http://www.zhoutian.com',
        tags: ['mongodb', 'database', 'NoSQL'],
        likes: 100
    })
    

    ​ 接着我们通过 update() 方法来更新标题(title):

    >db.mycollection.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })   # 输出信息
    > db.col.find().pretty()
    {
            "_id" : ObjectId("56064f89ade2f21f36b03136"),
            "title" : "MongoDB",
            "description" : "MongoDB 是一个 Nosql 数据库",
            "by" : "周天",
            "url" : "http://www.zhoutian.com",
            "tags" : [
                    "mongodb",
                    "database",
                    "NoSQL"
            ],
            "likes" : 100
    }
    >
    

    ​ 可以看到标题(title)由原来的 "MongoDB 教程" 更新为了 "MongoDB"。
    ​ 以上语句只会修改第一条发现的文档,如果你要修改多条相同的文档,则需要设置 multi 参数为 true。

    >db.mycollection.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}},{multi:true})
    

    ​ save() 方法通过传入的文档来替换已有文档,_id 主键存在就更新,不存在就插入。语法格式如下:

    db.COLLECTION_NAME.save(
       <document>,
       {
         writeConcern: <document>
       }
    )
    

    参数说明:
    document : 文档数据。
    writeConcern :可选,抛出异常的级别。

    ​ 以下实例中我们替换了 _id 为 56064f89ade2f21f36b03136 的文档数据:

    >db.mycollection.save({
        "_id" : ObjectId("56064f89ade2f21f36b03136"),
        "title" : "MongoDB",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "zhoutian",
        "url" : "http://www.zhoutian.com",
        "tags" : [
                "mongodb",
                "NoSQL"
        ],
        "likes" : 110
    })
    

    ​ 替换成功后,我们可以通过 find() 命令来查看替换后的数据

    >db.mycollection.find().pretty()
    {
            "_id" : ObjectId("56064f89ade2f21f36b03136"),
            "title" : "MongoDB",
            "description" : "MongoDB 是一个 Nosql 数据库",
            "by" : "zhoutian",
            "url" : "http://www.zhoutian.com",
            "tags" : [
                    "mongodb",
                    "NoSQL"
            ],
            "likes" : 110
    }
    > 
    

    2.4.7 删除文档

    ​ MongoDB 使用remove()方法是用来移除集合中的数据。在执行remove()方法前先执行find()方法来判断执行的条件是否正确,这是一个比较好的习惯。
    ​ remove() 方法的基本语法格式如下所示:

    db.COLLECTION_NAME.remove( <query>, <justOne> )
    

    ​ 如果你的 MongoDB 是 2.6 版本以后的,语法格式如下:

    db.COLLECTION_NAME.remove( <query>, { justOne: <boolean>, writeConcern: <document> } )
    

    参数说明:
    query :(可选)删除的文档的条件。
    justOne : (可选)如果设为 true 或 1,则只删除一个文档,如果不设置该参数,或使用默认值false,则删除所有匹配条件的文档。
    writeConcern :(可选)抛出异常的级别。

    ​ 以下文档我们执行两次插入操作:

    >db.mycollection.insert({
        title: 'MongoDB 教程',
        description: 'MongoDB 是一个 Nosql 数据库', 
        by: '周天', 
        url: 'http://www.zhoutian.com', 
        tags: ['mongodb', 'database', 'NoSQL'], 
        likes: 100 
    })
    

    ​ 使用 find() 函数查询数据:

    > db.mycollection.find() 
    { "_id" : ObjectId("56066169ade2f21f36b03137"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 } 
    
    { "_id" : ObjectId("5606616dade2f21f36b03138"), "title" : "MongoDB 教程","description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }
    

    ​ 接下来我们移除 title 为 'MongoDB 教程' 的文档:

    >db.mycollection.remove({'title':'MongoDB 教程'}) 
    WriteResult({ "nRemoved" : 2 }) # 删除了两条数据 
    >db.mycollection.find() 
    …… # 没有数据
    

    ​ 如果你只想删除第一条找到的记录可以设置 justOne 为 1,如下所示:

    >db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)
    

    ​ 如果你想删除所有数据,可以使用以下方式:

    >db.COLLECTION_NAME.remove({}) 
    >db.COLLECTION_NAME.find() 
    >
    

    2.4.8 查询文档

    ​ MongoDB 查询文档使用 find() 方法。find() 方法以非结构化的方式来显示所有文档。MongoDB 查询数据的语法格式如下:

    db.COLLECTION_NAME.find(query, projection)
    

    ​ query :可选,使用查询操作符指定查询条件
    ​ projection :可选,使用投影操作符指定返回的键。查询时返回文档中所有键值,只需省略该参数即可(默认省略)。
    ​ 如果你需要以易读的方式来读取数据,可以使用 pretty() 方法,语法格式如下:

    >db.COLLECTION_NAME.find().pretty()
    

    ​ 以下实例我们查询了集合 mycollection 中的数据:

    > db.mycollection.find().pretty() 
    { 
        "_id" : ObjectId("56063f17ade2f21f36b03133"), 
        "title" : "MongoDB 教程", 
        "description" : "MongoDB 是一个 Nosql 数据库", 
        "by" : "周天", 
        "url" : "http://www.zhoutian.com", 
        "tags" : ["mongodb", "database", "NoSQL" ],
        "likes" : 100 
    }
    

    ​ 通过下表可以更好的理解 MongoDB 的条件语句查询:

    操作 格式 范例 RDBMS中的类似语句
    等于 {:} db.col.find({"by":"教程"}).pretty() where by = '教程'
    小于 {:{$lt:}} db.col.find({"likes":{$lt:50}}).pretty() where likes < 50
    小于或等于 {:{$lte:}} db.col.find({"likes":{$lte:50}}).pretty() where likes <= 50
    大于 {:{$gt:}} db.col.find({"likes":{$gt:50}}).pretty() where likes > 50
    大于或等于 {:{$gte:}} db.col.find({"likes":{$gte:50}}).pretty() where likes >= 50
    不等于 {:{$ne:}} db.col.find({"likes":{$ne:50}}).pretty() where likes != 50

    ​ MongoDB 的 find() 方法可以传入多个键(key),每个键(key)以逗号隔开,即常规 SQL 的 AND 条件。
    语法格式如下:

    >db.COLLECTION_NAME.find({key1:value1, key2:value2}).pretty()
    
    > db.mycollection.find({"by":"周天", "title":"MongoDB 教程"}).pretty()
    

    MongoDB OR 条件语句使用了关键字 $or,语法格式如下:

    >db.COLLECTION_NAME.find(
       {
          $or: [
             {key1: value1}, {key2:value2}
          ]
       }
    ).pretty()
    
    >db.mycollection.find({$or:[{"by":"周天"},{"title": "MongoDB 教程"}]}).pretty()
    

    以下实例演示了 AND 和 OR 联合使用,类似常规 SQL 语句为: 'where likes>50 AND (by = '周天' OR title = 'MongoDB 教程')'

    >db.mycollection.find({"likes": {$gt:50}, $or: [{"by": "周天"},{"title": "MongoDB 教程"}]}).pretty()
    

    如果你需要在MongoDB中读取指定数量的数据记录,可以使用MongoDB的Limit方法,limit()方法接受一个数字参数,该参数指定从MongoDB中读取的记录条数。limit()方法基本语法如下所示:

    >db.COLLECTION_NAME.find().limit(NUMBER)
    

    ​ 集合 mycollection 中的数据如下:

    { "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "php" ], "likes" : 200 } 
    { "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "java" ], "likes" : 150 }
    { "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb" ], "likes" : 100 }
    

    ​ 以下实例为显示查询文档中的两条记录:

    > db.mycollection .find({},{"title":1,_id:0}).limit(2) 
    { "title" : "PHP 教程" } 
    { "title" : "Java 教程" } 
    >
    

    ​ 注:如果你们没有指定limit()方法中的参数则显示集合中的所有数据。
    ​ 我们除了可以使用limit()方法来读取指定数量的数据外,还可以使用skip()方法来跳过指定数量的数据,skip方法同样接受一个数字参数作为跳过的记录条数。skip() 方法脚本语法格式如下:

    >db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
    

    ​ 以下实例只会显示第二条文档数据

    >db.mycollection.find({},{"title":1,_id:0}).limit(1).skip(1) 
    { "title" : "Java 教程" } 
    >
    

    ​ 注:skip()方法默认参数为 0 。

    ​ 在 MongoDB 中使用 sort() 方法对数据(文档)进行排序,sort() 方法可以通过参数指定排序的字段,并使用1 和 -1 来指定排序的方式,其中 1 为升序排列,而 -1 是用于降序排列。sort()方法基本语法如下所示:

    >db.COLLECTION_NAME.find().sort({KEY:1})
    

    ​ mycollection集合中的数据如下:

    { "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "php" ], "likes" : 200 } 
    { "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "java" ], "likes" : 150 } 
    { "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb" ], "likes" : 100 }
    

    ​ 以下实例演示了 mycollection 集合中的数据按字段 likes 的降序排列:

    >db.mycollection.find({},{"title":1,_id:0}).sort({"likes":-1}) 
    { "title" : "PHP 教程" } 
    { "title" : "Java 教程" } 
    { "title" : "MongoDB 教程" } 
    >
    

    $type操作符是基于BSON类型来检索集合中匹配的数据类型,并返回结果。
    如果想获取 "col" 集合中 title 为 String 的数据,你可以使用以下命令:

    db.col.find({"title" : {$type : 2}})
    或
    db.col.find({"title" : {$type : 'string'}})
    

    2.4.9 聚合查询

    ​ MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等),并返回计算后的数据结果。有点类似sql语句中的 count(*)。 MongoDB中聚合的方法使用aggregate()。
    ​ 基本语法为:

    >db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
    

    ​ 为了便于理解,先将常见的mongo的聚合表达式和mysql的查询做下类比:

    表达式 SQL操作 描述
    $group group by 分组
    $sum count()、sum() 计算总和。
    $avg avg() 计算平均值
    $min min() 获取集合中所有文档对应值得最小值。
    $max max() 获取集合中所有文档对应值得最大值。
    $match where、having 查询条件
    $sort order by 排序
    $limit limit 取条数
    $project select 选择
    $lookup(v3.2 新增) join 连接

    ​ 下面以一个案例来演示,集合中的数据如下

    > db.mycollection.find() 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ"}
    

    $group
    按照城市分组对年龄进行求和

    > db.mycollection.aggregate([{$group : {_id : "$city", snum : {$sum : "$age"}}}]) 
    { "_id" : "TJ", "snum" : 34 } 
    { "_id" : "BJ", "snum" : 21 }
    

    $sum
    按照城市分组对年龄进行求和

    > db.mycollection.aggregate([{$group : {_id : "$city", snum : {$sum : "$age"}}}]) 
    { "_id" : "TJ", "snum" : 34 } 
    { "_id" : "BJ", "snum" : 21 }
    

    ​ 按照城市分组求总个数

    > db.mycollection.aggregate([{$group : {_id : "$city", sc : {$sum : 1}}}]) 
    { "_id" : "TJ", "sc" : 4 } 
    { "_id" : "BJ", "sc" : 6 }
    

    $avg
    按照城市分组对年龄进行求平均

    > db.mycollection.aggregate([{$group : {_id : "$city", avg : {$avg : "$age"}}}]) 
    { "_id" : "TJ", "avg" : 8.5 } 
    { "_id" : "BJ", "avg" : 3.5 }
    

    $min
    按照城市分组获得每组最小年龄

    > db.mycollection.aggregate([{$group : {_id : "$city", min : {$min : "$age"}}}]) 
    { "_id" : "TJ", "min" : 7 } 
    { "_id" : "BJ", "min" : 1 }
    

    $max
    按照城市分组获得每组最大年龄

    > db.mycollection.aggregate([{$group : {_id : "$city", max : {$max : "$age"}}}]) 
    { "_id" : "TJ", "max" : 10 } 
    { "_id" : "BJ", "max" : 6 }
    

    $match
    取年龄大于3并且小于10的记录再按照城市分组求个数和

    > db.mycollection.aggregate( [{ $match : { age : { $gt : 3, $lte : 10 } } },{ $group: { _id: "$city",count: { $sum: 1 } } }] ); 
    { "_id" : "TJ", "count" : 4 } 
    { "_id" : "BJ", "count" : 3 }
    

    $sort
    按照年龄的倒序显示

    > db.mycollection.aggregate( [{ $sort:{ age :-1}}] ) 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ"}
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" }
    

    $limit
    取得前5条数据

    > db.mycollection.aggregate( { $limit:5} ) 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" }
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" }
    

    $project
    不显示_id字段,显示 name和city字段

    > db.mycollection.aggregate( [ {$project :{_id:0,name:1,city:1} } ] ) 
    { "name" : "zhaoyun1", "city" : "BJ" } 
    { "name" : "zhaoyun2", "city" : "BJ" } 
    { "name" : "zhaoyun3", "city" : "BJ" } 
    { "name" : "zhaoyun4", "city" : "BJ" } 
    { "name" : "zhaoyun5", "city" : "BJ" } 
    { "name" : "zhaoyun6", "city" : "BJ" } 
    { "name" : "zhaoyun7", "city" : "TJ" } 
    { "name" : "zhaoyun8", "city" : "TJ" } 
    { "name" : "zhaoyun9", "city" : "TJ" } 
    { "name" : "zhaoyun10", "city" : "TJ" }
    

    $lookup
    用于多文档关联,类似于SQL的多表关联
    建立新的集合

    > db.sex.find() 
    { "_id" : 1, "name" : "male" } 
    { "_id" : 2, "name" : "female" }
    

    ​ 给mycollection新增字段sex

    > db.mycollection.update({},{$set:{sex:1}},{multi:1}) 
    WriteResult({ "nMatched" : 10, "nUpserted" : 0, "nModified" : 10 }) 
    > db.mycollection.find() 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ", "sex" : 1 } 
    { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ", "sex" : 1 }
    

    ​ 将两个文档关联

    > db.mycollection.aggregate([{$lookup: {from:"sex",localField:"sex",foreignField:"_id",as:"docs"}},{$project: {"_id":0}}])
    { "name" : "zhaoyun1", "age" : 1, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun2", "age" : 2, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] }
    { "name" : "zhaoyun3", "age" : 3, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun4", "age" : 4, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun5", "age" : 5, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun6", "age" : 6, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun7", "age" : 7, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun8", "age" : 8, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun9", "age" : 9, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
    { "name" : "zhaoyun10", "age" : 10, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] }
    

    ​ mycollection中的数据字段sex关联sex中的数据字段_id,在mycollection中显示sex对应的中文,显示在docs中,不显示mycollection中的__id
    ​ $lookup中的参数:
    ​ from:需要关联的表【sex】
    ​ localField: 【mycollection】表需要关联的键。
    ​ foreignField:【sex】的matching key 主键
    ​ as:对应的外键集合的数据,【因为是一对多的】

    3 MongoDB Java客户端

    3.1 mongodb-java-API

    <dependency>
        <groupId>org.mongodb</groupId> 
        <artifactId>mongo-java-driver</artifactId> 
        <version>3.10.1</version> 
    </dependency>
    
    public class MongodbDemo { 
        
        private MongoClient client; 
        
        @Before public void init() { 
            client = new MongoClient("192.168.10.135",27017); 
        }
        
        @Test public void connectDB() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            System.out.println("connect successful----"+database.getName()); 
        }
        
        @Test public void createCollection() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            database.createCollection("mycollection"); 
            System.out.println("集合创建成功"); 
        }
        
        @Test public void getCollection() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            MongoCollection<Document> collection = database.getCollection("mycollection");
            System.out.println("获取集合成功:"+collection.getNamespace());
            MongoIterable<String> collectionNames = database.listCollectionNames(); 
            for (String string : collectionNames) { 
                System.out.println("collection name : "+ string); 
            } 
        }
        
        @Test public void insertDocument() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            MongoCollection<Document> collection = database.getCollection("mycollection");
            Document document = new Document("name", "James"); 
            document.append("age", 34); 
            document.append("sex", "男"); 
            Document document2 = new Document("name", "wade"); 
            document2.append("age", 36); 
            document2.append("sex", "男"); 
            Document document3 = new Document("name", "cp3"); 
            document3.append("age", 32); 
            document3.append("sex", "男"); 
            List<Document> documents = new ArrayList<>(); 
            documents.add(document); 
            documents.add(document2); 
            documents.add(document3); 
            collection.insertMany(documents);
            System.out.println("文档插入成功"); 
        }
        
        @Test public void findDocuments() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            MongoCollection<Document> collection = database.getCollection("mycollection");
            FindIterable<Document> iterable = collection.find(); 
            for (Document document : iterable) { 
                System.out.println(document.toJson()); 
            } 
            // MongoCursor<Document> mongoCursor = iterable.iterator(); 
            // while (mongoCursor.hasNext()) { 
            // Document document = mongoCursor.next(); 
            // System.out.println(document.toJson()); 
            // } 
        }
        
        @Test public void updateDocuments() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            MongoCollection<Document> collection = database.getCollection("mycollection");
            collection.updateMany(
                Filters.eq("age",18), new Document("$set", new Document("age", 20))
            ); 
            FindIterable<Document> iterable = collection.find(); 
            for (Document document : iterable) { 
                System.out.println(document.toJson()); 
            } 
        }
        
        @Test public void deleteDocuments() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            MongoCollection<Document> collection = database.getCollection("mycollection"); 
            // 删除符合条件的第一个文档 
            collection.deleteOne(Filters.eq("age",20));
            collection.deleteOne(Filters.eq("name","James")); 
            // 删除符合条件的所有文档 
            collection.deleteMany(Filters.eq("age",20)); 
            FindIterable<Document> iterable = collection.find(); 
            for (Document document : iterable) { 
                System.out.println(document.toJson()); 
            } 
        }
        
        @Test
        public void testQuery1() { 
            MongoDatabase database = client.getDatabase("zhoutian"); 
            MongoCollection<Document> collection = database.getCollection("mycollection"); 
            //获取第一条记录 
            Document first = collection.find().first(); 
            //根据key值获得数据 
            System.out.println(first.get("name")); 
            //查询指定字段 
            Document qdoc=new Document(); 
            qdoc.append("_id", 0);//0是不包含字段 
            qdoc.append("name", 1);//1是包含字段
            FindIterable<Document> findIterable = collection.find().projection(qdoc); 
            for (Document document : findIterable) { 
                System.out.println(document.toJson()); 
            } 
        }
        
        @Test public void testQuery2() { 
            MongoDatabase database = client.getDatabase("zhoutian");
            MongoCollection<Document> collection = database.getCollection("mycollection"); 
            //按指定字段排序 
            Document sdoc=new Document(); 
            //按年龄的倒序 
            sdoc.append("age", -1); 
            FindIterable<Document> findIterable = collection.find().sort(sdoc); 
            for (Document document : findIterable) { 
                System.out.println(document.toJson()); 
            } 
        } 
    }
    

    Filters
    利用Filters可以进行条件过滤,比如:eq、ne、gt、lt、gte、lte、in、nin、and、or、not、nor、exists、type、mod、regex、text、where、all、elemMatch、size、bitsAllClear、bitsAllSet、bitsAnyClear、bitsAnySet、geoWithin、geoWithin、geoWithinBox、geoWithinPolygon、geoWithinCenter、geoWithinCenterSphere、geoIntersects、near、nearSphere 等。
    ​ 需要引入com.mongodb.client.model.Filters类

    ​ 介绍几个常用的过滤操作。

    @Test public void testFilters1() { 
        MongoDatabase database = client.getDatabase("zhoutian");
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //获得name等于zhaoyun1的记录 
        FindIterable<Document> findIterable =collection.find(Filters.eq("name", "zhaoyun1"));
        for (Document document : findIterable) { 
            System.out.println(document.toJson()); 
        }  
    }
    
    @Test public void testFilters2() { 
        MongoDatabase database = client.getDatabase("zhoutian");
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //获得age大于3的记录 
        FindIterable<Document> findIterable =collection.find(Filters.gt("age", 3)); 
        for (Document document : findIterable) { 
            System.out.println(document.toJson()); 
        } 
    }
    
    @Testpublic void testFilters3() {
        MongoDatabase database = client.getDatabase("zhoutian");
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //获得age大于3的记录 或者 name=zhaoyun1 
        FindIterable<Document> findIterable = 
            collection.find(Filters.or(Filters.eq("name", "zhaoyun1"),Filters.gt("age", 3))); 
        for (Document document : findIterable) { 
            System.out.println(document.toJson());
        } 
    }
    

    BasicDBObject
    利用BasicDBObject可以实现模糊查询和分页查询

    @Test public void testLike() { 
        MongoDatabase database = client.getDatabase("zhoutian");
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //利用正则 模糊匹配 包含zhaoyun1 
        Pattern pattern = Pattern.compile("^.*zhaoyun1.*$", Pattern.CASE_INSENSITIVE);
        BasicDBObject query = new BasicDBObject(); 
        //name包含zhaoyun1 
        query.put("name",pattern); 
        FindIterable<Document> findIterable = collection.find(query); 
        for (Document document : findIterable) { 
            System.out.println(document.toJson()); 
        } 
    }
    
    @Test public void testPage() { 
        MongoDatabase database = client.getDatabase("zhoutian");
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //利用正则 模糊匹配 name包含zhaoyun1 
        Pattern pattern = Pattern.compile("^.*zhaoyun.*$", Pattern.CASE_INSENSITIVE); 
        //查询条件 
        BasicDBObject query = new BasicDBObject(); 
        query.put("name",pattern);
        //排序 
        BasicDBObject sort = new BasicDBObject(); 
        //按年龄倒序 
        sort.put("age", -1); 
        //获得总条数 
        System.out.println("共计:"+collection.count()+"条记录"); 
        /** 取出第1至3条记录 
        * query : 查询条件 
        * sort: 排序 
        * skip : 起始数 从0开始 
        * limit:取几条 
        */ 
        FindIterable<Document> findIterable =           collection.find(query).sort(sort).skip(0).limit(3); 
        for (Document document : findIterable) { 
            System.out.println(document.toJson()); 
        } 
    }
    

    相关文章

      网友评论

          本文标题:MongoDB入门

          本文链接:https://www.haomeiwen.com/subject/xiriwktx.html