JAVA mongodb工具类

package com.tanbao.util;

import com.mongodb.*;
import com.mongodb.client.AggregateIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.util.JSON;
import org.apache.logging.log4j.LogManager;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.springframework.util.Assert;

import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * 
 */
public class MongoUtil {
    protected final org.apache.logging.log4j.Logger logger = LogManager.getLogger(getClass());

    private MongoClient mongoClient;

 
  
    private String database;
    private String user;
    private String host;
    private String password;
    private int port;



    private MongoDatabase getDatabase() {
        if (mongoClient == null) {
            Assert.notNull(database, "[getDatabase failed] - database is required; it must not be null");
            Assert.notNull(user, "[getDatabase failed] - user is required; it must not be null");
            Assert.notNull(password, "[getDatabase failed] - password is required; it must not be null");
            Assert.notNull(host, "[getDatabase failed] - host is required; it must not be null");
            Assert.notNull(port, "[getDatabase failed] - port is required; it must not be null");

            MongoClientOptions.Builder options = new MongoClientOptions.Builder();
            // options.autoConnectRetry(true);// 自动重连true
            // options.maxAutoConnectRetryTime(10); // the maximum auto connect retry time
            options.connectionsPerHost(300);// 连接池设置为300个连接,默认为100
            options.connectTimeout(15000);// 连接超时，推荐>3000毫秒
            options.maxWaitTime(5000); //
            options.socketTimeout(0);// 套接字超时时间，0无限制
            options.threadsAllowedToBlockForConnectionMultiplier(5000);// 线程队列数，如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误。
            options.writeConcern(WriteConcern.SAFE);//
            options.build();
            MongoClientOptions myOptions = options.build();

            ServerAddress sa = new ServerAddress(host, port);
            List<MongoCredential> mongoCredentialList = new ArrayList<>();
            mongoCredentialList.add(MongoCredential.createScramSha1Credential(user, database, password.toCharArray()));
            this.mongoClient = new MongoClient(sa, mongoCredentialList, myOptions);
        }
        return mongoClient.getDatabase(database);
    }


    @PreDestroy
    public void destroy() {
        if(mongoClient != null){
            mongoClient.close();
        }
    }


    public String save(Object obj){
        String collectionName=obj.getClass().getSimpleName();
        return save(obj,collectionName);
    }

    public String save(Object obj,String collectionName){
        MongoCollection collection= getDatabase().getCollection(collectionName);
        Document doc=convertObjToDocument(obj);
        collection.insertOne(doc);
        return doc.get("_id").toString();
    }

    public void update(Bson filters, Object obj){
        String collectionName=obj.getClass().getSimpleName();
        MongoCollection collection= getDatabase().getCollection(collectionName);
        Document update = convertObjToDocument(obj);
        update.remove("dis");
        update.remove("distance");
        collection.updateMany(filters,new Document("$set",update));
    }

    public void update(String query,Object obj){
        String collectionName=obj.getClass().getSimpleName();
        update(query, obj,collectionName);
    }

    public void update(String query,Object obj,String collectionName){
        MongoCollection collection= getDatabase().getCollection(collectionName);
        Document queryDoc= Document.parse(query);
        Document update=convertObjToDocument(obj);
        update.remove("dis");
        update.remove("distance");
        collection.updateMany(queryDoc,new Document("$set",update));
    }

    public void delete(Class mongoClass, Bson filters){
        MongoCollection<Document> collection = getDatabase().getCollection(mongoClass.getSimpleName());
        collection.deleteMany(filters);
    }

    public void delete(String collectionName, Bson filters){
        MongoCollection<Document> collection = getDatabase().getCollection(collectionName);
        collection.deleteMany(filters);
    }

    public long count(Class mongoClass, Bson filters) {
        MongoCollection<Document> collection = getDatabase().getCollection(mongoClass.getSimpleName());
        return collection.count(filters);
    }

    public <T> List<Map> findToMap(Class<T> mongoClass, Bson filters) {
        MongoCollection<Document> collection = getDatabase().getCollection(mongoClass.getSimpleName());
        MongoCursor<Document> cursor;
        if (filters != null) {
            cursor = collection.find(filters).iterator();
        } else {
            cursor = collection.find().iterator();
        }
        List<Map> returnList = new ArrayList<Map>();
        while (cursor.hasNext()) {
            Map o = com.alibaba.fastjson.JSON.parseObject(cursor.next().toJson(), Map.class);
            returnList.add(o);
        }
        return returnList;
    }

    public <T> List<Map> findToMap(Class<T> mongoClass, Bson filters, Bson sort, int pageNum, int pageSize) {
        int skip = pageNum > 0 ? (pageNum - 1) * pageSize : 0;

        MongoCollection<Document> collection = getDatabase().getCollection(mongoClass.getSimpleName());
        MongoCursor<Document> cursor;
        cursor = collection.find(filters).sort(sort).skip(skip).limit(pageSize).iterator();
        List<Map> returnList = new ArrayList<Map>();
        while (cursor.hasNext()) {
            Map o = com.alibaba.fastjson.JSON.parseObject(cursor.next().toJson(), Map.class);
            returnList.add(o);
        }
        return returnList;
    }

    public <T> List<T> find(Class<T> mongoClass,Bson filters){
        MongoCollection<Document> collection = getDatabase().getCollection(mongoClass.getSimpleName());
        MongoCursor<Document> cursor;
        if (filters != null){
            cursor = collection.find(filters).iterator();
        }else {
            cursor = collection.find().iterator();
        }
        List<T> returnList = new ArrayList<T>();
        while (cursor.hasNext()){
            T o= com.alibaba.fastjson.JSON.parseObject(cursor.next().toJson(), mongoClass);
            returnList.add(o);
        }
        return returnList;
    }
    /**
     * 获取附近数据
     * @param lon  经
     * @param lat   维
     * @param skip 跳过的数据
     * @param limit 取出的数据
     * @param collectionClass
     * @param locPropertyName 经纬度属性名
     * @param disProperty 距离属性名
     * @param <T>
     * @return
     */
    public <T> List<T> near(double lon,double lat,int skip,int limit,Class<T> collectionClass,String locPropertyName,String disProperty){
        //此处page size 需要改成原来的limit skip
//        int startPostion=page*size;
//        int stopPostion=(page-1)*size;

        String aggregateStr= String.format("[{$geoNear:{near:[%f,%f],distanceField:\"%s\",includeLocs:\"%s\",spherical:true,distanceMultiplier: 6378137,num:%d}},{$skip:%d}]",
                lon,
                lat,
                disProperty,
                locPropertyName,
                limit+skip,
                skip
                );

        logger.warn("near aggreateStr: {}",aggregateStr);
        List result= aggregate(aggregateStr,collectionClass.getSimpleName(),collectionClass);
        return result;
    }

    public <T> List<T> near(double lon,double lat,int skip,int limit,Class<T> collectionClass,String locPropertyName,String disProperty,String query){

//        int startPostion=page*size;
//        int stopPostion=(page-1)*size;

        String aggregateStr= String.format("[{$geoNear:{near:[%f,%f],distanceField:\"%s\",includeLocs:\"%s\",spherical:true,distanceMultiplier: 6378137,num:%d}},{$skip:%d},{$match:%s}]",
                lon,
                lat,
                disProperty,
                locPropertyName,
                limit+skip,
                skip,
                query);
        logger.warn("near and query aggreateStr: {}",aggregateStr);
        List result= aggregate(aggregateStr,collectionClass.getSimpleName(),collectionClass);
        return result;
    }

    /**
     * mongodb管道查询
     * @param aggregateStr 管道语句，必须是json数组形式
     * @param collectionName 集合名称
     * @param resultType 返回类型
     * @param <T>
     * @return
     */
    private <T> List<T> aggregate(String aggregateStr, String collectionName, Class<T> resultType){
        MongoCollection collection= getDatabase().getCollection(collectionName);
        BasicDBList basicDBList=(BasicDBList) JSON.parse(aggregateStr);
        AggregateIterable result= collection.aggregate(basicDBList);
        Iterator iterator= result.iterator();

        List<T> returnList=new ArrayList<>();
        while (iterator.hasNext()){
            Object obj=iterator.next();
            Document doc=(Document) obj;
            String json = doc.toJson();
            T o= com.alibaba.fastjson.JSON.parseObject(doc.toJson(),resultType);
            returnList.add(o);
        }
        return returnList;
    }



    public Document convertObjToDocument(Object obj){
        String json= com.alibaba.fastjson.JSON.toJSONString(obj);
        Document doc= Document.parse(json);
        return doc;
    }


    public void setDatabase(String database) {
        this.database = database;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
}