SpringBoot集成MongoDB

            org.springframework.boot
            spring-boot-starter-data-mongodb
        

springboot版本 2.0.4.RELEASE

@Configuration
public class MongoDBSimpleConfig {

    private final String url = "mongodb://root:root@127.0.0.1:27017/?authSource=admin";
    private final String db = "zhangmr";
    @Bean
    public MongoDbFactory mongoDbFactory(){
        MongoClientURI mongoClientURI = new MongoClientURI(url);
        MongoClient mongoClient = new MongoClient(mongoClientURI);
        return new SimpleMongoDbFactory(mongoClient,db);
    }
    @Bean
    public MongoTemplate getMongoTemplate() {
        return new MongoTemplate(mongoDbFactory());
    }

}

# mongodb-配置
#要连接的数据库
mongodb.database=zhangmr
#spring.data.mongodb.uri=mongodb://139.224.43.3:27017/测试
#用户名
mongodb.username=root
#spring.data.mongodb.username=root
#密码
mongodb.password=root
#spring.data.mongodb.password=root
#IP和端口（host:port），例如127.0.0.1:27017。集群模式用,分隔开，例如host1:port1,host2:port2
mongodb.servers=127.0.0.1:27017
#设置认证数据库，如果有的话
mongodb.authenticationDatabase=admin
# 客户端连接池参数
#客户端的标识，用于定位请求来源等，一般用程序名
# mongodb.clientName=${spring.application.name}
#TCP（socket）连接超时时间，毫秒
mongodb.connectionTimeoutMs=5000
#TCP（socket）连接闲置时间，毫秒
mongodb.maxConnectionIdleTimeMs=60000
#TCP（socket）连接最多可以使用多久，毫秒
mongodb.maxConnectionLifeTimeMs=300000
#TCP（socket）读取超时时间，毫秒
mongodb.readTimeoutMs=15000
#当连接池无可用连接时客户端阻塞等待的最大时长，毫秒
mongodb.maxWaitTimeMs=5000
#心跳检测发送频率，毫秒
mongodb.heartbeatFrequencyMs=20000
#最小的心跳检测发送频率，毫秒
mongodb.minHeartbeatFrequencyMs=8000
#心跳检测连接超时时间，毫秒
mongodb.heartbeatConnectionTimeoutMs=10000
#心跳检测读取超时时间，毫秒
mongodb.heartbeatReadTimeoutMs=15000
#线程池允许的最大连接数
mongodb.connectionsPerHost=100
#线程池空闲时保持的最小连接数
mongodb.minConnectionsPerHost=20
#计算允许多少个线程阻塞等待时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*maxConnectionsPerHost
mongodb.threadsAllowedToBlockForConnectionMultiplier=10

@Configuration
public class MongoDBConfig {
    @Value("${mongodb.servers}")
    private String servers; //IP和端口（host:port），例如127.0.0.1:27017。集群模式用,分隔开，例如host1:port1,host2:port2
    @Value("${mongodb.username}")
    private String username; //用户名
    @Value("${mongodb.password}")
    private String password; //密码
    @Value("${mongodb.database}")
    private String database; //要连接的数据库
    @Value("${mongodb.authenticationDatabase}")
    private String authenticationDatabase;  //认证用户的数据库

    @Value("${mongodb.connectionTimeoutMs}")
    private int connectionTimeoutMs;  //连接超时时间 毫秒
    @Value("${mongodb.maxConnectionIdleTimeMs}")
    private int maxConnectionIdleTimeMs; //连接闲置时间 毫秒
    @Value("${mongodb.maxConnectionLifeTimeMs}")
    private int maxConnectionLifeTimeMs; //连接最多可以使用多久 毫秒
    @Value("${mongodb.readTimeoutMs}")
    private int readTimeoutMs; //读取超时时间 毫秒
    @Value("${mongodb.maxWaitTimeMs}")
    private int maxWaitTimeMs; //当连接池无可用连接时客户端阻塞等待的最大时长 毫秒
    @Value("${mongodb.heartbeatFrequencyMs}")
    private int heartbeatFrequencyMs; //心跳检测发送频率 毫秒
    @Value("${mongodb.minHeartbeatFrequencyMs}")
    private int minHeartbeatFrequencyMs; //最小的心跳检测发送频率 毫秒
    @Value("${mongodb.heartbeatConnectionTimeoutMs}")
    private int heartbeatConnectionTimeoutMs; //心跳检测连接超时时间 毫秒
    @Value("${mongodb.heartbeatReadTimeoutMs}")
    private int heartbeatReadTimeoutMs; //心跳检测读取超时时间 毫秒
    @Value("${mongodb.connectionsPerHost}")
    private int connectionsPerHost; //线程池允许的最大连接数
    @Value("${mongodb.minConnectionsPerHost}")
    private int minConnectionsPerHost; //线程池空闲时保持的最小连接数
    @Value("${mongodb.threadsAllowedToBlockForConnectionMultiplier}")
    private int threadsAllowedToBlockForConnectionMultiplier; //计算允许多少个线程阻塞等待时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*maxConnectionsPerHost

    //MongoClientOptions

    
    @Bean
    public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory, MappingMongoConverter converter) {
        MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory, converter);
        // 设置读从库优先
        mongoTemplate.setReadPreference(ReadPreference.secondaryPreferred());
        return mongoTemplate;
    }

    
    @Bean
    public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context,
                                                       MongoCustomConversions conversions) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
        mappingConverter.setCustomConversions(conversions);
        // remove _class field
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return mappingConverter;
    }

    
    @Bean
    public MongoDbFactory mongoDbFactory() {

        MongoClient mongoClient;

        // 创建客户端参数
        MongoClientOptions mongoClientOptions = mongoClientOptions();

        // 解析获取mongo服务地址
        List serverAddressList = getServerAddress(servers);

        // 创建认证
        MongoCredential mongoCredential = getCredential();

        // 创建客户端
        if (null == mongoCredential) {
            mongoClient = new MongoClient(serverAddressList, mongoClientOptions);
        } else {
            mongoClient = new MongoClient(serverAddressList, mongoCredential, mongoClientOptions);
        }

        return new SimpleMongoDbFactory(mongoClient, database);
    }
    
    private MongoCredential getCredential() {
        if (!StringUtils.isEmpty(username) && !StringUtils.isEmpty(password)) {
            // 没有专用认证数据库则取当前数据库
            String authDatabase = StringUtils.isEmpty(authenticationDatabase) ?
                    database : authenticationDatabase;
            return MongoCredential.createCredential(username, authDatabase,password.toCharArray());
        }
        return null;
    }

    
    private List getServerAddress(String mongoAddress) {
        String[] mongoAddressArray = mongoAddress.trim().split(",");
        List serverAddressList = new ArrayList<>();
        for (String address : mongoAddressArray) {
            String[] hostAndPort = address.split(":");
            serverAddressList.add(new ServerAddress(hostAndPort[0], Integer.parseInt(hostAndPort[1])));
        }
        return serverAddressList;
    }

    
    private MongoClientOptions mongoClientOptions() {
        return MongoClientOptions.builder().connectTimeout(connectionTimeoutMs)
                .maxConnectionIdleTime(maxConnectionIdleTimeMs)
                .maxConnectionLifeTime(maxConnectionLifeTimeMs)
                .socketTimeout(readTimeoutMs)
                .maxWaitTime(maxWaitTimeMs)
                .heartbeatFrequency(heartbeatFrequencyMs)
                .minHeartbeatFrequency(minHeartbeatFrequencyMs)
                .heartbeatConnectTimeout(heartbeatConnectionTimeoutMs)
                .heartbeatSocketTimeout(heartbeatReadTimeoutMs)
                .connectionsPerHost(connectionsPerHost)
                .minConnectionsPerHost(minConnectionsPerHost)
                .threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier)
                .readPreference(ReadPreference.secondaryPreferred())
                .build();
    }
}

package com.zhangmr;

import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.zhangmr.rabbit.provider.MyProvider;
import org.bson.document;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ThreadApplicationTests {

    @Autowired
    private MongoTemplate mongoTemplate;
    @Test
    public void contextLoadsMongo() {
        MongoDatabase db = mongoTemplate.getDb();
        MongoCollection collection = db.getCollection("zhangmr");
        FindIterable documents = collection.find();
        List list = new ArrayList<>();
        MongoCursor iterator = documents.iterator();
        while (iterator.hasNext()){
            list.add(iterator.next().toJson());
        }
        System.out.println(list);
    }

}