java操作mongoDB工具类：

 package com.nxin.iot.cloud.common.util;
 
 import com.google.common.collect.Lists;
 import com.mongodb.MongoClient;
 import com.mongodb.MongoCredential;
 import com.mongodb.ServerAddress;
 import com.mongodb.client.FindIterable;
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.MongoCursor;
 import com.mongodb.client.MongoDatabase;
 import com.mongodb.client.model.Filters;
 
 import com.nxin.iot.cloud.common.constant.MongoConstant;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.log4j.Logger;
 import org.bson.Document;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 /**
 * create by 黄建和 2018/5/28
 */
 public class MongoDBUtil {
 
     private static final String PLEASE_SEND_IP = "没有传入ip或者端口号";
     private static final String PWD_UN_ERR = "用户账号密码不匹配";
     private static final String PLEASE_INSTANCE_MONGOCLIENT = "请实例化MongoClient";
     private static final String PLEASE_SEND_MONGO_REPOSITORY = "请指定要删除的mongo库";
     private static final String DELETE_MONGO_REPOSITORY_EXCEPTION = "删除mongo库异常";
     private static final String DELETE_MONGO_REPOSITORY_SUCCESS = "批量删除mongo库成功";
     private static final String NOT_DELETE_MONGO_REPOSITORY = "未删除mongo库";
     private static final String DELETE_MONGO_REPOSITORY = "成功删除mongo库：";
     private static final String CREATE_MONGO_COLLECTION_NOTE = "请指定要创建的库";
     private static final String NO_THIS_MONGO_DATABASE = "未找到指定mongo库";
     private static final String CREATE_MONGO_COLLECTION_SUCCESS = "创建mongo库成功";
     private static final String CREATE_MONGO_COLLECTION_EXCEPTION = "创建mongo库错误";
     private static final String NOT_CREATE_MONGO_COLLECTION = "未创建mongo库collection";
     private static final String CREATE_MONGO_COLLECTION_SUCH = "创建mongo库collection：";
     private static final String NO_FOUND_MONGO_COLLECTION = "未找到mongo库collection";
     private static final String INSERT_DOCUMEN_EXCEPTION = "插入文档失败";
     private static final String INSERT_DOCUMEN_SUCCESSS = "插入文档成功";
     private static final String COLLECTION_IS_NULL = "documentMongoCollection为空";
 
 
     private static final Logger logger = Logger.getLogger(MongoDBUtil.class);
 
     private MongoDBUtil(){
 
     }
 
     private static class SingleHolder{
         private static MongoDBUtil mongoDBUtil = new MongoDBUtil();
     }
 
     public static MongoDBUtil instance(){
 
         return SingleHolder.mongoDBUtil;
     }
 
     /**
     * 获取mongoDB连接
     * @param host
     * @param port
     * @return
     */
     public MongoClient getMongoConnect(String host,Integer port){
 
         if(StringUtils.isBlank(host) || null == port){
             logger.error(PLEASE_SEND_IP);
             return null;
         }
 
         return new MongoClient(host, port);
     }
 
     /**
     * 获取mongoDB连接
     * @param serverAddress
     * @param credentials
     * @return
     */
     @SuppressWarnings("deprecation")
     public MongoClient getMongoConnect(ServerAddress serverAddress,List<MongoCredential> credentials){
 
         if(null == serverAddress){
             logger.error(PLEASE_SEND_IP);
             return null;
         }
 
         if(null == credentials || credentials.size() == 0) {
             logger.error(PWD_UN_ERR);
             return null;
         }
 
         return new MongoClient(serverAddress, credentials);
     }
 
 
     /**
     * 批量删除mongo库
     * @param mongoClient
     * @param dbNames
     * @return
     */
     public String bulkDropDataBase(MongoClient mongoClient,String...dbNames){
 
         if(null == mongoClient) return PLEASE_INSTANCE_MONGOCLIENT;
 
         if(null==dbNames || dbNames.length==0){
             return PLEASE_SEND_MONGO_REPOSITORY;
         }
         try {
             Arrays.asList(dbNames).forEach(dbName -> mongoClient.dropDatabase(dbName));
             logger.info(DELETE_MONGO_REPOSITORY_SUCCESS);
         }catch (Exception e){
             e.printStackTrace();
             logger.error(DELETE_MONGO_REPOSITORY_EXCEPTION);
         }
         return dbNames == null ? NOT_DELETE_MONGO_REPOSITORY:DELETE_MONGO_REPOSITORY + String.join(",",dbNames);
     }
 
 
     /**
     * 创建指定database的collection
     * @param mongoClient
     * @param dbName
     * @param collections
     * @return
     */
     public String createCollections(MongoClient mongoClient,String dbName,String...collections){
 
         if(null == mongoClient) return PLEASE_INSTANCE_MONGOCLIENT;
 
         if(null==collections || collections.length==0){
             return CREATE_MONGO_COLLECTION_NOTE;
         }
 
         MongoDatabase mongoDatabase = mongoClient.getDatabase(dbName);
         if(null == mongoDatabase) return NO_THIS_MONGO_DATABASE;
 
         try {
             Arrays.asList(collections).forEach(collection ->  mongoDatabase.createCollection(collection));
             logger.info(CREATE_MONGO_COLLECTION_SUCCESS);
             return collections == null ? NOT_CREATE_MONGO_COLLECTION:CREATE_MONGO_COLLECTION_SUCH + String.join(",",collections);
         }catch (Exception e){
             e.printStackTrace();
             logger.error(CREATE_MONGO_COLLECTION_EXCEPTION);
         }
 
         return null;
     }
 
     /**
     * 获取MongoCollection
     * @param mongoClient
     * @param dbName
     * @param collection
     * @return
     */
     public MongoCollection<Document> getMongoCollection(MongoClient mongoClient,String dbName,String collection){
 
         if(null == mongoClient) return null;
 
         if(StringUtils.isBlank(dbName)) return null;
 
         if(StringUtils.isBlank(collection)) return null;
 
         MongoDatabase mongoDatabase = mongoClient.getDatabase(dbName);
 
         MongoCollection<Document> collectionDocuments = mongoDatabase.getCollection(collection);
 
         if(null == collectionDocuments) return null;
 
         return collectionDocuments;
     }
 
 
     /**
     * 插入文档数据
     * @param mongoCollection
     * @param params
     */
     public void insertDoucument(final MongoCollection<Document> mongoCollection, final Map<String,Object> params){
 
 
         if(null == mongoCollection) return;
 
 
         try {
             Document document = new Document();
             params.keySet().stream().forEach(field -> document.append(field, params.get(field)));
 
             List<Document> documents = Lists.newArrayList();
             documents.add(document);
             mongoCollection.insertMany(documents);
             logger.info(INSERT_DOCUMEN_SUCCESSS);
         }catch (Exception e){
             e.printStackTrace();
             logger.error(INSERT_DOCUMEN_EXCEPTION);
         }
     }
 
     /**
     * 更新文档
     * @param mongoCollection
     * @param conditionParams
     * @param updateParams
     */
     public void updateDocument(final MongoCollection<Document> mongoCollection,final Map<String,Object> conditionParams,
                             final Map<String,Object> updateParams
     ){
 
         if(null == mongoCollection) return;
 
         if (null == conditionParams) return;
 
         if (null == updateParams) return;
 
 
         Document conditonDocument = new Document();
         conditionParams.keySet().stream().filter(p -> null != p).forEach(o -> {
             conditonDocument.append(o,conditionParams.get(o));
         });
 
 
         Document updateDocument = new Document();
         updateParams.keySet().stream().filter(p -> null != p).forEach(o -> {
             updateDocument.append(o,updateParams.get(o));
         });
         mongoCollection.updateMany(conditonDocument,new Document("$set",updateDocument));
     }
 
     /**
     *删除文档
     * @param mongoCollection
     * @param multiple
     * @param conditionParams
     * @return
     */
     public long deleteDocument(final MongoCollection<Document> mongoCollection,final boolean multiple,
                             final Map<String,Object> conditionParams){
 
         if(null == mongoCollection) return 0;
 
         if(null == conditionParams) return 0;
 
         Document document = new Document();
 
         conditionParams.keySet().stream().filter(p -> null != p).forEach(o -> {
             document.append(o,conditionParams.get(o));
         });
 
         if(multiple) {
             return mongoCollection.deleteMany(document).getDeletedCount();
         }
 
         //删除文档第一条
         return mongoCollection.deleteOne(document).getDeletedCount();
     }
 
     /**
     * 查询文档
     * @param mongoCollection
     * @param conditionParams
     * @param limit
     * @param skip
     * @param sortParams
     */
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams,
                                             final Integer limit, final Integer skip, final Map<String,Integer> sortParams,
                                             final Map<String,Integer> gtLtOrOtherParams,final String compareField
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(Filters.and(document,compareDocument));
 
         Document sortDocument = new Document();
         if(null != sortParams && !sortParams.isEmpty()) {
             sortParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) sortDocument.append(k,v);
             });
             findIterable.sort(sortDocument);
         }
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
 
         return findIterable.iterator();
 
     }
 
     /**
     * 查询文档
     * @param mongoCollection
     * @return
     */
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         FindIterable<Document> findIterable = mongoCollection.find();
 
         return findIterable.iterator();
 
     }
 
     /**
     * 查询文档
     * @param mongoCollection
     * @param conditionParams
     * @return
     */
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         return mongoCollection.find(Filters.and(document)).iterator();
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams,
                                             final Integer limit, final Integer skip){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(Filters.and(document));
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
         return findIterable.iterator();
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection,final Integer limit, final Integer skip){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         FindIterable<Document> findIterable = mongoCollection.find();
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
         return findIterable.iterator();
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Integer> sortParams,boolean sort){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
 
         FindIterable<Document> findIterable = mongoCollection.find();
 
         Document sortDocument = new Document();
         if(null != sortParams && !sortParams.isEmpty()) {
             sortParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) sortDocument.append(k,v);
             });
             findIterable.sort(sortDocument);
         }
 
         return findIterable.iterator();
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams,
                                             final Integer limit, final Integer skip,final Map<String,Integer> sortParams){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(Filters.and(document));
 
         Document sortDocument = new Document();
         if(null != sortParams && !sortParams.isEmpty()) {
             sortParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) sortDocument.append(k,v);
             });
             findIterable.sort(sortDocument);
         }
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
         return findIterable.iterator();
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection,
                                             final Integer limit, final Integer skip,final Map<String,Integer> sortParams){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         FindIterable<Document> findIterable = mongoCollection.find();
 
         Document sortDocument = new Document();
         if(null != sortParams && !sortParams.isEmpty()) {
             sortParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) sortDocument.append(k,v);
             });
             findIterable.sort(sortDocument);
         }
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
         return findIterable.iterator();
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection,
                                             final Map<String,Integer> gtLtOrOtherParams,final String compareField
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         return mongoCollection.find(Filters.and(compareDocument)).iterator();
 
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection,final Integer limit,
                                             final Integer skip,final Map<String,Integer> gtLtOrOtherParams,final String compareField
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(compareDocument);
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
 
         return findIterable.iterator();
 
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection,
                                             final Integer limit, final Integer skip, final Map<String,Integer> sortParams,
                                             final Map<String,Integer> gtLtOrOtherParams,final String compareField
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(compareDocument);
 
         Document sortDocument = new Document();
         if(null != sortParams && !sortParams.isEmpty()) {
             sortParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) sortDocument.append(k,v);
             });
             findIterable.sort(sortDocument);
         }
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
 
         return findIterable.iterator();
 
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams,
                                             final Map<String,Integer> gtLtOrOtherParams,final String compareField
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(Filters.and(document,compareDocument));
 
         return findIterable.iterator();
 
     }
 
     public MongoCursor<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams,
                                             final Integer limit, final Integer skip,final Map<String,Integer> gtLtOrOtherParams,final String compareField
     ){
 
         if(null == mongoCollection) return null;
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         FindIterable<Document> findIterable = mongoCollection.find(Filters.and(document,compareDocument));
 
         if(null != limit) findIterable = findIterable.limit(limit);
 
         if(null != skip) findIterable = findIterable.skip(skip);
 
         return findIterable.iterator();
 
     }
 
     /**
     * 统计指定表的数量
     * @param documentMongoCollection
     * @param conditionParams
     * @param gtLtOrOtherParams
     * @param compareField
     * @return
     */
     public Long countTable(final MongoCollection<Document> documentMongoCollection,final Map<String,Object> conditionParams,
                         final Map<String,Integer> gtLtOrOtherParams,final String compareField){
 
 
         if(null == documentMongoCollection) {
             logger.error(COLLECTION_IS_NULL);
             return 0L;
         }
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         return documentMongoCollection.count(Filters.and(document,compareDocument));
     }
 
     /**
     * 统计指定表的数量
     * @param documentMongoCollection
     * @param conditionParams
     * @return
     */
     public Long countTable(final MongoCollection<Document> documentMongoCollection,final Map<String,Object> conditionParams){
 
 
         if(null == documentMongoCollection) {
             logger.error(COLLECTION_IS_NULL);
             return 0L;
         }
 
         Document document = new Document();
         if(null != conditionParams && !conditionParams.isEmpty()) {
 
             conditionParams.forEach((k,v)  -> {
                 if(StringUtils.isNotBlank(k)) document.append(k,v);
             });
         }
 
         return documentMongoCollection.count(Filters.and(document));
     }
 
     /**
     * 统计指定表的数量
     * @param documentMongoCollection
     * @param gtLtOrOtherParams
     * @param compareField
     * @return
     */
     public Long countTable(final MongoCollection<Document> documentMongoCollection,
                         final Map<String,Integer> gtLtOrOtherParams,final String compareField){
 
 
         if(null == documentMongoCollection) {
             logger.error(COLLECTION_IS_NULL);
             return 0L;
         }
 
 
         Document compareDocument = null;
         if(null != gtLtOrOtherParams && !gtLtOrOtherParams.isEmpty()) {
 
             Document gtOrLtDoc = new Document();
             gtLtOrOtherParams.forEach((k,v) -> {
                 if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
             });
             compareDocument = new Document(compareField,gtOrLtDoc);
         }else {
             compareDocument = new Document();
         }
 
         return documentMongoCollection.count(Filters.and(compareDocument));
     }
 }

mongo用到的比较常量定义

 package constant;
 
 public enum MongoConstant {
 
     GT("$gt"),LT("$lt"),GTE("$gte"),LTE("$lte");
     
     private String compareIdentify;  
     
     MongoConstant(String compareIdentify) {  
         this.compareIdentify = compareIdentify;  
     }  
     
     public String getCompareIdentify() {
         return compareIdentify;
     }
 }

工具类的测试类

 package com.nxin.iot.cloud.common;
 
 import com.google.common.collect.Maps;
 import com.mongodb.MongoClient;
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.MongoCursor;
 import com.mongodb.client.model.Filters;
 import com.nxin.iot.cloud.common.constant.MongoConstant;
 import com.nxin.iot.cloud.common.util.MongoDBUtil;
 import org.bson.Document;
 
 import java.util.Date;
 import java.util.Map;
 
 /**
 * Created by Nxin on 2018/5/28.
 */
 public class TestMongo {
 
     public static void main(String[] args) {
 
         try {
 
             //无用户密码验证实例
             MongoClient client = MongoDBUtil.instance().getMongoConnect("127.0.0.1",27017);
             //需要用户密码实例
             //         MongoCredential credential = MongoCredential.createCredential("user", "database", "password".toCharArray());
             //         MongoDBUtil.instance().getMongoConnect(new ServerAddress("ip", 27017), Arrays.asList(credential));
 
             MongoCollection<Document> documentMongoCollection = MongoDBUtil.instance().getMongoCollection(client,"hjh","test");
 
 
             //插入文档
 //                    for(int i=0;i<=10;i++) {
 //                         Map<String, Object> params = Maps.newHashMap();
 //                         params.put("qq", "hjh");
 //                         params.put("time", new Date());
 //                         params.put("name", "bb" + i);
 //                        params.put("num", i);
 //                         MongoDBUtil.instance().insertDoucument(documentMongoCollection, params);
 //                     }
 //
 //                    for(int i=0;i<=10;i++) {
 //                         Map<String, Object> params = Maps.newHashMap();
 //                         params.put("qq", "hh");
 //                         params.put("time", new Date());
 //                         params.put("name", "cc" + i);
 //                        params.put("num", i);
 //                         MongoDBUtil.instance().insertDoucument(documentMongoCollection, params);
 //                     }
 
             //更改文档
             //         Map<String,Object> condParams = Maps.newHashMap();
             //         condParams.put("description","database");
             //         condParams.put("aa","bbb");
             //         Map<String,Object> updateParams = Maps.newHashMap();
             //         updateParams.put("description","eee");
             //         MongoDBUtil.instance().updateDocument(documentMongoCollection,condParams,updateParams);
 
             //删除文档数据
             //         Map<String,Object> condParams = Maps.newHashMap();
             //         condParams.put("qq",1111);
             //
             //         MongoDBUtil.instance().deleteDocument(documentMongoCollection,true,condParams);
 
             //查询文档
 //            Map<String,Object> condParams = Maps.newHashMap();
 //            condParams.put("qq","hjh");
 //
 //            Map<String,Integer> sortParams = Maps.newHashMap();
 //            sortParams.put("num",-1);
 //            //         sortParams.put("name",1);
 //            Map<String,Integer> compareParams = Maps.newHashMap();
 //            compareParams.put(MongoConstant.GT.getCompareIdentify(),5);
 //            compareParams.put(MongoConstant.LTE.getCompareIdentify(),10);
 //            MongoCursor<Document> mongoCursor = MongoDBUtil.instance().queryDocument(documentMongoCollection,condParams,2,2,sortParams,compareParams,"num");
 //            while(mongoCursor.hasNext()){
 //                System.out.println(mongoCursor.next());
 //            }
 
             //统计数量
             Map<String,Object> condParams = Maps.newHashMap();
             condParams.put("qq","hjh");
             Map<String,Integer> compareParams = Maps.newHashMap();
             compareParams.put(MongoConstant.GT.getCompareIdentify(),5);
             compareParams.put(MongoConstant.LTE.getCompareIdentify(),10);
             long l = MongoDBUtil.instance().countTable(documentMongoCollection,condParams,compareParams,"num");
             System.err.print(l);
 
         } catch (Exception e) {
             System.err.println(e.getClass().getName() + ": " + e.getMessage());
         }
 
     }
 }