spring.data.mongodb.address=127.0.0.1:,127.0.0.1:,127.0.0.1:

spring.data.mongodb.replica-set=mySet

spring.data.mongodb.database=test

spring.data.mongodb.username=test

spring.data.mongodb.password=test

# Configure spring.data.mongodbDB Pool

spring.data.mongodb.min-connections-per-host=

spring.data.mongodb.max-connections-per-host=

spring.data.mongodb.threads-allowed-to-block-for-connection-multiplier=

spring.data.mongodb.server-selection-timeout=

spring.data.mongodb.max-wait-time=

spring.data.mongodb.max-connection-idel-time=

spring.data.mongodb.max-connection-life-time=

spring.data.mongodb.connect-timeout=

spring.data.mongodb.socket-timeout=

spring.data.mongodb.socket-keep-alive=false

spring.data.mongodb.ssl-enabled=false

spring.data.mongodb.ssl-invalid-host-name-allowed=false

spring.data.mongodb.always-use-m-beans=false

spring.data.mongodb.heartbeat-socket-timeout=

spring.data.mongodb.heartbeat-connect-timeout=

spring.data.mongodb.min-heartbeat-frequency=

spring.data.mongodb.heartbeat-frequency=

spring.data.mongodb.local-threshold=

spring.data.mongodb.authentication-database=admin

import java.util.List;

import lombok.Data;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.PropertySource;

import org.springframework.stereotype.Component;

@Data

@Component

@PropertySource(value = "classpath:mongo-pool.properties")

@ConfigurationProperties(prefix = "spring.data.mongodb")

public class MongoSettingsProperties {

    private List<String> address;

    private String replicaSet;

    private String database;

    private String username;

    private String password;

    private Integer minConnectionsPerHost = ;

    private Integer maxConnectionsPerHost = ;

    private Integer threadsAllowedToBlockForConnectionMultiplier = ;

    private Integer serverSelectionTimeout = ;

    private Integer maxWaitTime = ;

    private Integer maxConnectionIdleTime = ;

    private Integer maxConnectionLifeTime = ;

    private Integer connectTimeout = ;

    private Integer socketTimeout = ;

    private Boolean socketKeepAlive = false;

    private Boolean sslEnabled = false;

    private Boolean sslInvalidHostNameAllowed = false;

    private Boolean alwaysUseMBeans = false;

    private Integer heartbeatConnectTimeout = ;

    private Integer heartbeatSocketTimeout = ;

    private Integer minHeartbeatFrequency = ;

    private Integer heartbeatFrequency = ;

    private Integer localThreshold = ;

    private String authenticationDatabase;

}

import java.util.ArrayList;

import java.util.List;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.mongodb.MongoDbFactory;

import org.springframework.data.mongodb.core.SimpleMongoDbFactory;

import com.mongodb.MongoClient;

import com.mongodb.MongoClientOptions;

import com.mongodb.MongoCredential;

import com.mongodb.ServerAddress;

@Configuration

public class MongoConfig {

    // 覆盖默认的MongoDbFactory

    @Bean

    MongoDbFactory mongoDbFactory(MongoSettingsProperties mongoSettingsProperties) {

        // 客户端配置（连接数、副本集群验证）

        MongoClientOptions.Builder builder = new MongoClientOptions.Builder();

        builder.connectionsPerHost(mongoSettingsProperties.getMaxConnectionsPerHost());

        builder.minConnectionsPerHost(mongoSettingsProperties.getMinConnectionsPerHost());

        if (mongoSettingsProperties.getReplicaSet() != null) {

            builder.requiredReplicaSetName(mongoSettingsProperties.getReplicaSet());

        }

        builder.threadsAllowedToBlockForConnectionMultiplier(

                mongoSettingsProperties.getThreadsAllowedToBlockForConnectionMultiplier());

        builder.serverSelectionTimeout(mongoSettingsProperties.getServerSelectionTimeout());

        builder.maxWaitTime(mongoSettingsProperties.getMaxWaitTime());

        builder.maxConnectionIdleTime(mongoSettingsProperties.getMaxConnectionIdleTime());

        builder.maxConnectionLifeTime(mongoSettingsProperties.getMaxConnectionLifeTime());

        builder.connectTimeout(mongoSettingsProperties.getConnectTimeout());

        builder.socketTimeout(mongoSettingsProperties.getSocketTimeout());

        builder.sslEnabled(mongoSettingsProperties.getSslEnabled());

        builder.sslInvalidHostNameAllowed(mongoSettingsProperties.getSslInvalidHostNameAllowed());

        builder.alwaysUseMBeans(mongoSettingsProperties.getAlwaysUseMBeans());

        builder.heartbeatFrequency(mongoSettingsProperties.getHeartbeatFrequency());

        builder.minHeartbeatFrequency(mongoSettingsProperties.getMinHeartbeatFrequency());

        builder.heartbeatConnectTimeout(mongoSettingsProperties.getHeartbeatConnectTimeout());

        builder.heartbeatSocketTimeout(mongoSettingsProperties.getHeartbeatSocketTimeout());

        builder.localThreshold(mongoSettingsProperties.getLocalThreshold());

        MongoClientOptions mongoClientOptions = builder.build();

        // MongoDB地址列表

        List<ServerAddress> serverAddresses = new ArrayList<>();

        for (String address : mongoSettingsProperties.getAddress()) {

            String[] hostAndPort = address.split(":");

            String host = hostAndPort[];

            Integer port = Integer.parseInt(hostAndPort[]);

            ServerAddress serverAddress = new ServerAddress(host, port);

            serverAddresses.add(serverAddress);

        }

        System.out.println("serverAddresses:" + serverAddresses.toString());

        // 连接认证

        List<MongoCredential> mongoCredentialList = new ArrayList<>();

        if (mongoSettingsProperties.getUsername() != null) {

            mongoCredentialList.add(MongoCredential.createScramSha1Credential(

                            mongoSettingsProperties.getUsername(),

                            mongoSettingsProperties.getAuthenticationDatabase() != null ? mongoSettingsProperties

                                    .getAuthenticationDatabase() : mongoSettingsProperties.getDatabase(),

                            mongoSettingsProperties.getPassword().toCharArray()));

        }

        System.out.println("mongoCredentialList:" + mongoCredentialList.toString());

        // 创建客户端和Factory

        MongoClient mongoClient = new MongoClient(serverAddresses,mongoCredentialList, mongoClientOptions);

        MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient,mongoSettingsProperties.getDatabase());

        return mongoDbFactory;

    }

}

        DBObject query = new BasicDBObject(); //setup the query criteria 设置查询条件

        query.put("method", method);

        query.put("ctime", (new BasicDBObject("$gte", bTime)).append("$lt", eTime));

        logger.debug("query: {}", query);

        DBObject fields = new BasicDBObject(); //only get the needed fields. 设置需要获取哪些域

        fields.put("_id", );

        fields.put("uId", );

        fields.put("ctime", );

        DBCursor dbCursor = mongoTemplate.getCollection("collectionName").find(query, fields);

        while (dbCursor.hasNext()){

            DBObject object = dbCursor.next();

            logger.debug("object: {}", object);

            //do something.

        }

Query query = new Query();
 query.addCriteria(Criteria.where("_id").is(orderId));

mongoTemplate.find(query, this.getEntityClass(), collectionName);

插入40万 耗时大约10秒

查询70万总数 耗时3毫秒