MongoDBJavaAPI操作很全的整理以及共享分⽚模式下的常见操作整理MongoDB 是⼀个基于分布式⽂件存储的数据库。由 C++ 语⾔编写，⼀般⽣产上建议以共享分⽚的形式来部署。但是MongoDB官⽅也提供了其它语⾔的客户端操作API。如下图所⽰：
提供了C、C++、C#、、GO、java、Node.js、PHP、python、scala等各种语⾔的版本，如下图所⽰：
MongoDB的操作分为同步操作和异步操作以及响应式编程操作
⼀、同步操作API
官⽅JAVA API的路径：我们这⾥以3.11的java 版本为例。各个版本的API对MongoDB服务的⽀持情况。
使⽤API时，先引⼊maven依赖
<!-- mvnrepository/db/mongo-java-driver -->
<dependency>
<groupId&db</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.11.1</version>
</dependency>
1、关于MongoDB Client的初始化和关闭。
从官⽅介绍来看，⼀般建议Client只需要⼀个建⽴⼀个长连接实例，然后使⽤时，都使⽤这个实例就可以，也就是可以⽤java的单例模式来创建连接实例。
//mongoClient连接
protected static MongoClient mongoClient;
public synchronized static MongodbClient getInstance(String mongodbUrl) {
if (null == mongoClient) {
mongoClient = ate(mongodbUrl);
if(null != mongoClient){
log.info("mongoClient init success!");
}
else{
log.info("mongoClient init failed!");
}
}
return mongodbClient;
}　
直接通过mongodb的host和port来创建client：　
MongoClient mongoClient = ate("mongodb://host1:27017");
client连接到⼀个 Replica Set：
本⽂作者：张永清，转载请注明出处：
MongoClient mongoClient = ate("mongodb://host1:27017,host2:27017,host3:27017");
MongoClient mongoClient = ate("mongodb://host1:27017,host2:27017,host3:27017/?replicaSet=myReplicaSet");
　或者通过MongoClientSettings.builder() 来辅助⽣成连接字符串来创建client：
MongoClient mongoClient = ate( MongoClientSettings.builder() .applyToClusterSett
ings(builder -> builder.hosts(Arrays.asList( new ServerAddress("host1", 27017), new ServerAddress("host2", 27017), new ServerAddress("host3"  连接关闭：
public void close() {
if(null!=mongoClient){
mongoClient.close();
mongoClient=null;
}
}
  2、关于MongoDB 的基本操作
//创建Collection
public void createCollection(String dataBaseName,String collectionName){
getDatabase(dataBaseName).createCollection(collectionName);
}
//查询dataBaseName
public MongoDatabase getDatabase(String dataBaseName){ Database(dataBaseName); }
//查询Collection
public List<String> listCollectionNames(String dataBaseName){
List<String> stringList = new ArrayList<String>();
return stringList; }
public MongoCollection<Document> getCollectionByName(String dataBaseName, String collectionName){ return getDatabase(dataBaseName).getCollection(collectionName); }
3、关于MongoDB 的查询操作
//通过id（objectid）精确查询
public FindIterable<Document>  findMongoDbDocById(String dataBaseName, String collectionName, String id){
BasicDBObject searchDoc = new BasicDBObject().append("_id", id);
return getCollectionByName(dataBaseName,collectionName).find(searchDoc);
}
//通过id（objectid）模糊查询
public FindIterable<Document>  findMongoDbDocByIdRegex(String dataBaseName, String collectionName, String id){
BasicDBObject searchDoc = new BasicDBObject().append("_id", new BasicDBObject("$regex",id));
return getCollectionByName(dataBaseName,collectionName).find(searchDoc);
}
//通过开始id和结束id 查询（根据objectId范围查询）
public FindIterable<Document>  findMongoDbDocById(String dataBaseName, String collectionName, String startId,String endId){
BasicDBObject searchDoc = new BasicDBObject().append("_id", new BasicDBObject("$gte", startId).append("$lte", endId));
return getCollectionByName(dataBaseName,collectionName).find(searchDoc);
}
public FindIterable<Document> findMongoDbDoc(String dataBaseName, String collectionName,BasicDBObject basicDBObject){
return getCollectionByName(dataBaseName,collectionName).find(basicDBObject);
}
/
/限制查询返回的条数
public FindIterable<Document> findMongoDbDoc(String dataBaseName, String collectionName,BasicDBObject basicDBObject,Integer limitNum){
return findMongoDbDoc(dataBaseName,collectionName,basicDBObject).limit(limitNum) ;
}
public FindIterable<Document>  findMongoDbDocById(String dataBaseName, String collectionName, String startId,String endId,Integer limitNum){
return findMongoDbDocById(dataBaseName,collectionName,startId,endId).limit(limitNum);
}
/**
* 降序查询（排序）
* @param dataBaseName
* @param collectionName
* @param startId
* @param endId
* @param sortField  排序字段
* @return
*/
public FindIterable<Document>  findMongoDbDocByIdDescSort(String dataBaseName, String collectionName, String startId,String endId,String sortField){
return findMongoDbDocById(dataBaseName,collectionName,startId,endId).sort(new Document().append(sortField, -1));
}
public FindIterable<Document>  findMongoDbDocByIdDescSort(String dataBaseName, String collec
tionName, String startId,String endId,String sortField,Integer limitNum){
return findMongoDbDocByIdDescSort(dataBaseName,collectionName,startId,endId,sortField).limit(limitNum);
}
/**
* 降序查询（排序）
* @param dataBaseName
* @param collectionName
* @param startId
* @param endId
* @param sortField  排序字段
* @return
*/
public FindIterable<Document>  findMongoDbDocByIdAscSort(String dataBaseName, String collectionName, String startId,String endId,String sortField){
return findMongoDbDocById(dataBaseName,collectionName,startId,endId).sort(new Document().append(sortField, 1));
}
public FindIterable<Document>  findMongoDbDocByIdAscSort(String dataBaseName, String collectionName, String startId,String endId,String sortField,Integer limitNum){
return findMongoDbDocByIdAscSort(dataBaseName,collectionName,startId,endId,sortField).limit(limitNum);
}
  4、关于MongoDB 的插⼊操作
//插⼊操作，注意插⼊时，如果数据已经存在会报错，插⼊时必须数据不存在，不会⾃动进⾏覆盖
//插⼊单条记录
public void insertDoc(String dataBaseName, String collectionName, Document document){
getCollectionByName(dataBaseName,collectionName).insertOne(document);
}
//插⼊多条记录
public void insertDoc(String dataBaseName, String collectionName,List<? extends Document> listData){
getCollectionByName(dataBaseName,collectionName).insertMany(listData);
}
  5、关于MongoDB 的更新操作
//更新单条
public void updateDoc(String dataBaseName, String collectionName, Bson var1, Bson var2){
getCollectionByName(dataBaseName,collectionName).updateOne(var1,var2);
}
public void updateDoc(String dataBaseName, String collectionName, Bson var1, List<? extends Bson> list){
getCollectionByName(dataBaseName,collectionName).updateOne(var1,list);
}
//批量更新
public void updateDocs(String dataBaseName, String collectionName, Bson var1, Bson var2){
getCollectionByName(dataBaseName,collectionName).updateMany(var1,var2);
}
public void updateDocs(String dataBaseName, String collectionName, Bson var1, List<? extends Bson> list){
getCollectionByName(dataBaseName,collectionName).updateMany(var1,list);
}
  6、关于MongoDB 的删除操作　
//单条删除
public DeleteResult deleteDoc(String dataBaseName, String collectionName, Bson var1){
return getCollectionByName(dataBaseName,collectionName).deleteOne(var1);
}
//批量删除
public DeleteResult deleteDocs(String dataBaseName, String collectionName,Bson var1){
return getCollectionByName(dataBaseName,collectionName).deleteMany(var1);
}
7、关于MongoDB 的替换操作
本⽂作者：张永清，转载请注明出处：
//存在就替换，不存在的话就插⼊
public UpdateResult replaceDoc(String dataBaseName, String collectionName, Bson var1, Document var2,ReplaceOptions var3){
return getCollectionByName(dataBaseName,collectionName).replaceOne(var1,var2,var3);
}
public UpdateResult replaceDoc(String dataBaseName, String collectionName, Bson var1, Document var2){ return getCollectionByName(dataBaseName,collectionName).replaceOne(var1,var2); }
//调⽤⽰例(设置存在就替换，不存在的话就插⼊)
Document documentQuery = new Document("_id", docId);
Document document = new Document("_id", docId);
ReplaceOptions replaceOptions = new ReplaceOptions();
replaceOptions.upsert(true);
String dataBaseName="zhangyonqing";
String collectionName="zhangyonqing";
replaceDoc(dataBaseName,collectionName,documentQuery,document,replaceOptions);
8、关于MongoDB 的bulkWrite操作　（批量写⼊），对于数据很多时，效率很⾼
public BulkWriteResult bulkWrite(String dataBaseName, String collectionName, List<? extends WriteModel<? extends Document>> listData){
return getCollectionByName(dataBaseName,collectionName).bulkWrite(listData);
}
9、关于MongoDB 的分页查询
mongodb的分页查询可以有多种思路来实现。
思路⼀：采⽤类似mysql的limit start end 的这种。
获取到总的数量：
//查询总数
public long countDocs(String dataBaseName, String collectionName,Bson var1){
if(null==var1){
return getCollectionByName(dataBaseName,collectionName).countDocuments();
}
return getCollectionByName(dataBaseName,collectionName).countDocuments(var1);
}
//  分页查询，采⽤skip+limit的⽅式，在⽤了总数后，就可以分页了，skip的意思是前⾯跳过多少数据。
但是这种⽅式在数据量⼤的时候效率不⾼，因为skip会导致全表扫描。    public FindIterable<Document> findMongoDbDoc(String dataBaseName, String collectionName,BasicDBObject basicDBObject,Integer skip,Integer limit){
return getCollectionByName(dataBaseName,collectionName).find(basicDBObject).skip(skip).limit(limit);
}
python单例模式思路⼆：利⽤limit 以及排序的⽅式，获取分页的上⼀页的最后⼀条记录的objectId，然后使⽤排序+$gte操作（⼤于）+limit 来获取当页的数据。到⼀个可以排序的字段，⽐如objectId或者时间字段都可以排序。这个也是mongodb官⽅推荐的⽅式，这种做饭可以避免全表扫描。
思路三：在数据量不⼤的时候，使⽤代码进⾏分页。⽐如从mongodb中查询出⼀个list对象后，对list对象做代码分页。
public class ListUtil {
public static List getPagingList(List list,Integer start,Integer length){
start = start<0?0:start;
//默认为10
length = length<=0?10:length;
Integer size = list.size();
if(start>size){
start = size;
}
Integer toIndex = (start+length-1)>=size?size:(start+length-1);
if(toIndex<=0){
toIndex = size;
}
return list.subList(start,toIndex);
}
⼆、异步操作API 
　mongodb异步驱动程序提供了异步api，可以利⽤netty或java 7的asynchronoussocketchannel实现快速、⽆阻塞的i/o，maven依赖
<dependencies>
<dependency>
<groupId&db</groupId>
<artifactId>mongodb-driver-async</artifactId>
<version>3.11.1</version>
</dependency>
</dependencies>
官⽅地址：
异步操作必然会涉及到回调，回调时采⽤ResultCallback<Document>
本⽂作者：张永清，转载请注明出处：
SingleResultCallback<Document> callbackPrintDocuments = new SingleResultCallback<Document>() {
@Override
public void onResult(final Document document, final Throwable t) {
System.out.Json());
}
};
SingleResultCallback<Void> callbackWhenFinished = new SingleResultCallback<Void>() {
@Override
public void onResult(final Void result, final Throwable t) {
System.out.println("Operation Finished!");
}
};
  异步insert操作
collection.insertMany(documents, new SingleResultCallback<Void>() {
@Override
public void onResult(final Void result, final Throwable t) {
System.out.println("Documents inserted!");
}
});
  异步删除操作
collection.deleteMany(gte("i", 100), new SingleResultCallback<DeleteResult>() {
@Override
public void onResult(final DeleteResult result, final Throwable t) {
System.out.DeletedCount());
}
});
  异步更新操作
collection.updateMany(lt("i", 100), inc("i", 100),
new SingleResultCallback<UpdateResult>() {
@Override
public void onResult(final UpdateResult result, final Throwable t) {
System.out.ModifiedCount());
}
});
  异步统计操作
new SingleResultCallback<Long>() {
@Override
public void onResult(final Long count, final Throwable t) {
System.out.println(count);
}
});
三、MongoDB Reactive Streams 操作API
官⽅的MongoDB reactive streams Java驱动程序，为MongoDB提供异步流处理和⽆阻塞处理。
完全实现reactive streams api，以提供与jvm⽣态系统中其他reactive streams的互操作，⼀般适合于⼤数据的处理，⽐如spark，flink，storm等。
<dependencies>
<dependency>
<groupId&db</groupId>
<artifactId>mongodb-driver-reactivestreams</artifactId>
<version>1.12.0</version>
</dependency>
</dependencies>
  官⽅地址：
会包含如下三部分：
1. Publisher：Publisher 是数据的发布者。Publisher 接⼝只有⼀个⽅法 subscribe，⽤于添加数据的订阅者，也就是 Subscriber。
2. Subscriber：是数据的订阅者。Subscriber 接⼝有4个⽅法，都是作为不同事件的处理器。在订阅者成功订阅到发布者之后，其 onSubscribe(Subscription s) ⽅法会被调
⽤。
3. Subscription：表⽰的是当前的订阅关系。
API问的地址：
代码⽰例：
//建⽴连接
MongoClient mongoClient = ate(mongodbUrl);
//获得数据库对象
MongoDatabase database = Database(databaseName);
//获得集合
MongoCollection collection = Collection(collectionName);
//异步返回Publisher
FindPublisher publisher = collection.find();
//订阅实现
publisher.subscribe(new Subscriber() {
@Override
public void onSubscribe(Subscription str) {
System.out.println("");
//执⾏请求
}
@Override
public void onNext(Document document) {
//获得⽂档
System.out.println("Document:" + Json());
}
@Override
public void onError(Throwable t) {
System.out.println("error occurs.");
}
@Override
public void onComplete() {
System.out.println("finished.");
}
});
个⼈github参考代码：
四、MongoDB 共享分⽚模式安装
这⾥以mongodb4.2.0版本和操作系统CentOS Linux release 7.6.1810 (Core) 为例：1、从官⽹下载mongodb-linux-x86_64-rhel7的安装包。分⽚模式安装包括三部分：shard、config、router
MongoDB分⽚模式下的架构图如下：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。