使用MongoClient连接Mongodb问题

更新时间：2024年05月20日 09:44:50 作者：Ryan_Wanghh

这篇文章主要介绍了使用MongoClient连接Mongodb问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

MongoClient连接Mongodb

使用

pom文件引入依赖

在pom文件中引入客服端依赖

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>3.6.0</version>
</dependency>

配置相关信息

在无密码情况下，使用MongoClient直接建立连接，仅需提供IP、端口信息。

MongoClient client = new MongoClient("127.0.0.1",27017);

在需要密码的情况下，使用MongoCredential配置密码信息，使用ServerAddress配置服务信息。

ServerAddress serverAddress = new ServerAddress("192.168.1.55", 27017);
MongoCredential mongoCredential = MongoCredential.createCredential("admin", "admin", "123456".toCharArray());
// 第一个"admin" 为账号，第二个"admin"为创建账户时的数据库名称，第三个参数为密码
MongoClient mongoClient = new MongoClient(serverAddress,mongoCredential, MongoClientOptions.builder().build());
// MongoClientOptions 是连接的相关配置，类似数据库连接池的相关配置,使用默认即可

开启连接，访问数据

调试运行，检查是否报错，如果账户密码都正确，提示鉴权失败，可能是配置鉴权的第二个参数设置不对

import com.mongodb.*;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
 
/**
 * @author Ryan
 * @version 1.0
 * @date 2021/9/6
 */
public class MongoDemo {
 
    public static void main(String[] args) {
        ServerAddress serverAddress = new ServerAddress("192.168.1.55", 27017);
        MongoCredential mongoCredential = MongoCredential.createCredential("admin", "admin", "123456".toCharArray());
        MongoClient mongoClient = new MongoClient(serverAddress,mongoCredential, MongoClientOptions.builder().build());
        MongoDatabase database = mongoClient.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("survey");
        System.out.println(collection.find().first());
    }
}

运行结果：

16:57:24.124 [cluster-ClusterId{value='6135d7f32719bd3878607cbd', description='null'}-192.168.1.55:27017] DEBUG org.mongodb.driver.cluster - Updating cluster description to {type=STANDALONE, servers=[{address=192.168.1.55:27017, type=STANDALONE, roundTripTime=5.9 ms, state=CONNECTED}]
16:57:24.184 [main] INFO org.mongodb.driver.connection - Opened connection [connectionId{localValue:2, serverValue:136}] to 192.168.1.55:27017
16:57:24.193 [main] DEBUG org.mongodb.driver.protocol.command - Sending command {find : BsonString{value='survey'}} to database test on connection [connectionId{localValue:2, serverValue:136}] to server 192.168.1.55:27017
16:57:24.200 [main] DEBUG org.mongodb.driver.protocol.command - Command execution completed
Document{{_id=6135b83698a8ae31e4cec754, name=a, date=Fri Feb 19 08:00:00 CST 2016, results=[Document{{product=abc, score=10.0}}, Document{{product=xyz, score=5.0}}]}}

mongodb java客户端的使用，即MongoClient

Java 连接 MongoDB

MongoDB 提供了一系列的驱动用于支持各种语言连接 mongodb 数据库，包括：Java，Python，C++，Scala，PHP 等，完整的驱动列表：

https://docs.mongodb.com/manual/applications/drivers/index.html

其中对于 Java 提供了 mongo-java-driver 库支持 Mongo JDBC 驱动，使用该驱动只要在项目依赖中导入：org.mongodb:mongo-java-driver

如在使用 gradle 构建的项目中，如下导入：

compile 'org.mongodb:mongo-java-driver:3.6.3'

Mongo JDBC 驱动文档主页：http://mongodb.github.io/mongo-java-driver/；

可以在驱动主页查询该驱动的详细用法，一下示例基本使用，包括：数据库连接、CURD 操作，使用版本为：mongodb 3.6，mongo-java-driver 3.6，不同版本的驱动的 API 由一些差异，详细请查询驱动文档；

示例用的数据库集合 testdb.blog 文档示例如下：

{
    "_id" : ObjectId("5a8d519a07c9086ee823f15d"),
    "title" : "Mysql Overview",
    "description" : "Musql is a RDBMS",
    "author" : "assad",
    "url" : "http://blog.assad.article/233",
    "tages" : [ "mysql", "RDBMS", "sql" ],
    "likes" : 200
}

数据库连接

1）无验证连接

MongoClient mongoClient = new MongoClient("127.0.0.1",27017);
//或者使用 mongo uri
MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://127.0.0.1:27017"));

2）验证连接

String user = "assad";                   //用户名
String database = "testdb";              //数据库
char[] password = "123".toCharArray();   //密码

MongoCredential credential = MongoCredential.createCredential(user,database,password);   //验证对象
MongoClientOptions options = MongoClientOptions.builder().sslEnabled(false).build();     //连接操作对象
MongoClient mongoClient = new MongoClient(new ServerAddress("127.0.0.1",27017),credential,options);   //连接对象

//或者使用 mongo uri
MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:123@127.0.0.1:27017/?authSource=testdb&ssl=false"));
其中 mongo uri 的验证连接格式如下：
mongodb://userName:password@host/?authSource=databaseName&ssh=true;

获取数据库 & 集合

//获取指定数据库对象
MongoDatabase db = mongoClient.getDatabase("testdb");
//获取指定集合对象
MongoCollection<Document> blogs = db.getCollection("blog");

//列举所有数据库名称
for(String dbName : blogs.listDatabaseNames()
    System.out.println(dbName);
    
//列举指定数据库中所有集合名称
for(String colName: db.listCollectionNames())
    System.out.println(colName);

以下示例中，对于文档结果的输出都使用 Log4j2 进行标准输出；

select 查询操作

1）查询结果遍历

在 MongoDB JDBC 中，会对查询结果生成一个 FindIterable<Document> 对象，可以通过获取其迭代器对其进行迭代，同时该对象也提供了 foreach 方法，通过传入一个 Block 对象，可以对结果进行阻塞迭代；

//数据库连接
MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:123@127.0.0.1:27017/?authSource=testdb&ssl=false"));
MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog");

//查询所有文档，遍历输出结果
for (Document document1 : blogs.find())
    log.debug(document1.toJson());

//查询所有文档，使用遍历器遍历结果
MongoCursor<Document> cursor = blogs.find().iterator();
while(cursor.hasNext())
    log.debug(cursor.next().toJson());

//查询所有文档，对所有结果使用阻塞回调方法
blogs.find().forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});

//查询所有文档，获取结果文档中的 title 字段（string）、likes 字段（int32）、tags 字段（array）
blogs.find().forEach((Block<Document>) document ->{
    String title = document.getString("title");
    int likes = document.getInteger("likes");
    List<String> tags = (List<String>) document.get("tags");
    log.debug(title + " - " + likes + " - " + tags);
});

2）条件查询

对于条件查询，可以通过构造一个个嵌套的 Document 对象，产生类似 mongodb 查询语法的 Document 链来进行查询；或者使用 Filters 中的各种静态方法（如 eq，lte等）来进行函数式地查询，MongoDB JDBC 已经将绝大部分的 mongodb 查询条件操作符封装为函数式调用；

//条件查询: db.blog.find({"author":"assad"})
blogs.find(new Document("author","assad")).forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});

blogs.find(eq("author","assad")).forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});


//条件查询: db.blog.find({"likes":{$gte:200,$lte:500}})
blogs.find(new Document("likes",new Document("$gte",200).append("$lte",500)))
        .forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});
blogs.find(and(gte("likes",200), lte("likes",500)))
        .forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});

//条件查询：db.blog.find({"author":"assad","title":/mongodb*/i })
blogs.find(new Document("author","assad").append("title",new Document("$regex","mongodb*").append("$options","i")))
        .forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});
blogs.find(and(eq("author","assad"), regex("title","mongodb*","i")))
        .forEach((Block<Document>) document -> {
    log.debug(document.toJson());
});

3）查询结果映射，排序，限制

//映射操作, db.blog.find({"author:"assad""},{"title":1,"url":1,"likes":1,"_id":0})
blogs.find(new Document("author","assad"))
        .projection(new Document("title",1).append("url",1).append("likes",1).append("_id",0))
        .forEach((Block<Document>) document -> {
            log.debug(document.toJson());
        });
blogs.find(eq("author","assad"))
        .projection(fields(include("title","url","likes"),excludeId()))
        .forEach((Block<Document>) document -> {
            log.debug(document.toJson());
        });

//查询排序、限制： db.blog.find().sort({"likes":1,"title":-1}).limit(5)
blogs.find()
        .sort(and(ascending("likes"),descending("title")))
        .limit(5)
        .forEach((Block<Document>) document -> {
            log.debug(document.toJson());
        });

blogs.find()
        .sort(new Document("likes",1).append("title",-1))
        .limit(5)
        .forEach((Block<Document>) document -> {
            log.debug(document.toJson());
        });

4）aggregate 数据聚合操作

//数据聚合: db.blog.aggregate([ {$group:{_id:"$author",likes_count:{$sum:"$likes"}}} ])
blogs.aggregate(asList( group("$author",sum("likes_count","$likes")) ))
        .forEach((Block<Document>) document -> {
            log.debug(document.toJson());
        });

//数据聚合: db.blog.aggregate([ {$group:{_id:"$author",likes_avg:{$avg:"$likes"}}}, {$match:{_id:"assad"}} ])
blogs.aggregate(asList(
            group("$author",avg("likes_avg","$likes")),
            match(eq("_id","assad")) ))
        .forEach((Block<Document>) document -> {
            log.debug(document.toJson());
        });

insert 插入操作

//数据库连接
MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:123@127.0.0.1:27017/?authSource=testdb&ssl=false"));
MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog");

//插入一个文档
Document doc = new Document("title","Mysql Overview")
        .append("description","Musql is a RDBMS")
        .append("author","assad")
        .append("url","http://blog.assad.article/233")
        .append("tages", Arrays.asList("mysql","RDBMS","sql"))
        .append("likes",100);
blogs.insertOne(doc);

//插入多个文档
Document doc1 = new Document("title","DB2 Overview")
                .append("author","Alex");
Document doc2 = new Document("title","Redis Overview")
                .append("author","Orlda");
List<Document> docList = new ArrayList<>();
docList.add(doc1);
docList.add(doc2);
blogs.insertMany(docList);

update 操作

//数据库连接
MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:123@127.0.0.1:27017/?authSource=testdb&ssl=false"));
MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog");

//更改第一条匹配条件的文档记录,对应 update(<query>,{muti:false}) 方法
blogs.updateOne(and(eq("author","assad"),eq("title","SqlLite Overview"))
        ,combine(set("author","assad_1"),set("likes",0)));

//更改所有匹配条件的文档记录,对应 update(<query>,{muti:true}) 方法
blogs.updateMany(lte("likes",300)
        , inc("likes",100));


//完全替换一条文档记录，对应 save() 方法
Document doc = new Document("title","Mysql Overview")
        .append("description","Musql is a RDBMS")
        .append("author","assad")
        .append("url","http://blog.assad.article/233")
        .append("tages", Arrays.asList("mysql","RDBMS","sql"))
        .append("likes",100);
blogs.replaceOne(eq("author","Alex"),doc);

delete 操作

//数据库连接
MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:123@127.0.0.1:27017/?authSource=testdb&ssl=false"));
MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog");

//删除第一条满足查询条件的文档记录，对应 delete(<query>,{justOne:true}) 方法
blogs.deleteOne(eq("author","Alex"));

//删除所有满足查询条件的文档记录，对应 delete(<query>,{justOne:false}) 方法
blogs.deleteMany(gte("likes",900));

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Java后台判断ajax请求及处理过程详解
这篇文章主要介绍了Java后台判断ajax请求及处理过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-03-03
SpringBoot项目集成Flyway进行数据库版本控制的详细教程
这篇文章主要介绍了SpringBoot项目集成Flyway进行数据库版本控制,本文分步骤通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-07-07
Java分页查询--分页显示(实例讲解)
下面小编就为大家带来一篇Java分页查询--分页显示(实例讲解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-08-08
Java 手写LRU缓存淘汰算法
本文主要讲了如何通过哈希链表这种数据结构来实现LRU算法，提供了三种实现思路，第一种从双向链表开始，借助于HashMap来实现满足要求的LRUCache
2021-05-05
Java中循环冗余校验（CRC32）的实现
CRC校验实用程序库在数据存储和数据通讯领域，为了保证数据的正确，就不得不采用检错的手段，下面这篇文章主要给大家介绍了关于Java中循环冗余校验（CRC32）实现的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
2017-10-10
Java中的ArrayList容量及扩容方式
这篇文章主要介绍了Java中的ArrayList容量及扩容方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-09-09
springboot整合Nginx实现负载均衡反向代理的方法详解
这篇文章主要给大家介绍了关于springboot整合Nginx实现负载均衡反向代理的相关资料,文中通过图文以及实例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2022-01-01
Java中数组容器(ArrayList)设的计与实现
本篇文章主要跟大家介绍我们最常使用的一种容器ArrayList、Vector的原理，并且自己使用Java实现自己的数组容器MyArrayList，让自己写的容器能像ArrayList那样工作,感兴趣的可以了解一下
2022-07-07
Sentinel实现动态配置的集群流控的方法
这篇文章主要介绍了Sentinel实现动态配置的集群流控,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-04-04
Springmvc异常映射2种实现方法
这篇文章主要介绍了Springmvc异常映射2种实现方法以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。,需要的朋友可以参考下
2020-05-05