SpringBoot?整合mongoDB并自定義連接池的示例代碼

更新時間：2022年02月25日 15:21:33 作者：上帝愛吃蘋果-

這篇文章主要介紹了SpringBoot?整合mongoDB并自定義連接池?,整合mongoDB的目的就是想用它給我們提供的mongoTemplate，它可以很容易的操作mongoDB數(shù)據(jù)庫，對整合過程及實例代碼感興趣的朋友跟隨小編一起看看吧

Maven 依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

配置文件

mongodb:
  database: bfa_mongo
  username: "xxx"
  password: "xxxxx"
  address: "host:port"
  authenticationDatabase: [設置你的認證數(shù)據(jù)庫，如果有的話]
  # 連接池配置
  clientName: ${spring.application.name} # 客戶端的標識，用于定位請求來源等
  connectionTimeoutMs: 10000     # TCP連接超時，毫秒
  readTimeoutMs: 15000       # TCP讀取超時，毫秒
  poolMaxWaitTimeMs: 3000        #當連接池無可用連接時客戶端阻塞等待的時長，單位毫秒
  connectionMaxIdleTimeMs: 60000   #TCP連接閑置時間，單位毫秒
  connectionMaxLifeTimeMs: 120000    #TCP連接最多可以使用多久，單位毫秒
  heartbeatFrequencyMs: 20000      #心跳檢測發(fā)送頻率，單位毫秒
  minHeartbeatFrequencyMs: 8000    #最小的心跳檢測發(fā)送頻率，單位毫秒
  heartbeatConnectionTimeoutMs: 10000  #心跳檢測TCP連接超時，單位毫秒
  heartbeatReadTimeoutMs: 15000    #心跳檢測TCP連接讀取超時，單位毫秒
  connectionsPerHost: 20       # 每個host的TCP連接數(shù)
  minConnectionsPerHost: 5     #每個host的最小TCP連接數(shù)
  #計算允許多少個線程阻塞等待可用TCP連接時的乘數(shù)，算法：threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost，當前配置允許10*20個線程阻塞
  threadsAllowedToBlockForConnectionMultiplier: 10

注意:其中的address參數(shù)可以配置為一個數(shù)組（代表集群模式）

 address: 
    - "host:port"
    - "host2:port2"

MongoConfig配置類

配置類中使用了lombok，如果你沒有用lombok依賴和IDE插件，你要重寫getter、Setter方法：
代碼稍長，可以復制在IDEA中查看：

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.DbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@Slf4j
@Configuration
@EnableConfigurationProperties(MongoConfig.MongoClientOptionProperties.class)
public class MongoConfig {

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

    /**
     * 自定義mongo連接池
     * @param properties
     * @return
     */
    @Bean
    public MongoDbFactory mongoDbFactory(MongoClientOptionProperties properties) {
        //創(chuàng)建客戶端參數(shù)
        MongoClientOptions options = mongoClientOptions(properties);

        //創(chuàng)建客戶端和Factory
        List<ServerAddress> serverAddresses = new ArrayList<>();
        for (String address : properties.getAddress()) {
            String[] hostAndPort = address.split(":");
            String host = hostAndPort[0];
            Integer port = Integer.parseInt(hostAndPort[1]);
            ServerAddress serverAddress = new ServerAddress(host, port);
            serverAddresses.add(serverAddress);
        }

        //創(chuàng)建認證客戶端
        MongoCredential mongoCredential = MongoCredential.createScramSha1Credential(properties.getUsername(),
                properties.getAuthenticationDatabase() != null ? properties.getAuthenticationDatabase() : properties.getDatabase(),
                properties.getPassword().toCharArray());

        MongoClient mongoClient = new MongoClient(serverAddresses.get(0), mongoCredential, options);
        //集群模式
        if (serverAddresses.size() > 1) {
            mongoClient = new MongoClient(serverAddresses, new ArrayList<>(Arrays.asList(mongoCredential)));
        }
        /** ps: 創(chuàng)建非認證客戶端*/
        //MongoClient mongoClient = new MongoClient(serverAddresses, mongoClientOptions);
        return new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
    }

    /**
     * mongo客戶端參數(shù)配置
     * @return
     */
    public MongoClientOptions mongoClientOptions(MongoClientOptionProperties properties) {
        return MongoClientOptions.builder()
                .connectTimeout(properties.getConnectionTimeoutMs())
                .socketTimeout(properties.getReadTimeoutMs()).applicationName(properties.getClientName())
                .heartbeatConnectTimeout(properties.getHeartbeatConnectionTimeoutMs())
                .heartbeatSocketTimeout(properties.getHeartbeatReadTimeoutMs())
                .heartbeatFrequency(properties.getHeartbeatFrequencyMs())
                .minHeartbeatFrequency(properties.getMinHeartbeatFrequencyMs())
                .maxConnectionIdleTime(properties.getConnectionMaxIdleTimeMs())
                .maxConnectionLifeTime(properties.getConnectionMaxLifeTimeMs())
                .maxWaitTime(properties.getPoolMaxWaitTimeMs())
                .connectionsPerHost(properties.getConnectionsPerHost())
                .threadsAllowedToBlockForConnectionMultiplier(
                        properties.getThreadsAllowedToBlockForConnectionMultiplier())
                .minConnectionsPerHost(properties.getMinConnectionsPerHost()).build();
    }

    @Getter
    @Setter
    @Validated
    @ConfigurationProperties(prefix = "mongodb")
    public static class MongoClientOptionProperties {

        /** 基礎連接參數(shù) */
        private String database;
        private String username;
        private String password;
        @NotNull
        private List<String> address;
        private String authenticationDatabase;

        /** 客戶端連接池參數(shù) */
        @NotNull
        @Size(min = 1)
        private String clientName;
        /** socket連接超時時間 */
        @Min(value = 1)
        private int connectionTimeoutMs;
        /** socket讀取超時時間 */
        @Min(value = 1)
        private int readTimeoutMs;
        /** 連接池獲取鏈接等待時間 */
        @Min(value = 1)
        private int poolMaxWaitTimeMs;
        /** 連接閑置時間 */
        @Min(value = 1)
        private int connectionMaxIdleTimeMs;
        /** 連接最多可以使用多久 */
        @Min(value = 1)
        private int connectionMaxLifeTimeMs;
        /** 心跳檢測發(fā)送頻率 */
        @Min(value = 2000)
        private int heartbeatFrequencyMs;

        /** 最小的心跳檢測發(fā)送頻率 */
        @Min(value = 300)
        private int minHeartbeatFrequencyMs;
        /** 計算允許多少個線程阻塞等待時的乘數(shù)，算法：threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost */
        @Min(value = 1)
        private int threadsAllowedToBlockForConnectionMultiplier;
        /** 心跳檢測連接超時時間 */
        @Min(value = 200)
        private int heartbeatConnectionTimeoutMs;
        /** 心跳檢測讀取超時時間 */
        @Min(value = 200)
        private int heartbeatReadTimeoutMs;

        /** 每個host最大連接數(shù) */
        @Min(value = 1)
        private int connectionsPerHost;
        /** 每個host的最小連接數(shù) */
        @Min(value = 1)
        private int minConnectionsPerHost;
    }
}

MappingMongoConverter可以自定義mongo轉換器，主要自定義存取mongo數(shù)據(jù)時的一些操作，例如 mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null)) 方法會將mongo數(shù)據(jù)中的_class字段去掉。

最后通過 new SimpleMongoDbFactory(mongoClient, properties.getDatabase())方法配置了一個MongoDbFactory交由Spring管理，Springboot會拿這個MongoDbFactory工廠bean來new一個MongoTemplate，在MongoDbFactoryDependentConfiguration類下可以看到SpringBoot幫你做得事：

/**
 * Configuration for Mongo-related beans that depend on a {@link MongoDbFactory}.
 *
 * @author Andy Wilkinson
 */
@Configuration
@ConditionalOnBean(MongoDbFactory.class)
class MongoDbFactoryDependentConfiguration {

	private final MongoProperties properties;
	MongoDbFactoryDependentConfiguration(MongoProperties properties) {
		this.properties = properties;
	}
    
    //SpringBoot創(chuàng)建MongoTemplate實例
	@Bean
	@ConditionalOnMissingBean
	public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory, MongoConverter converter) {
		return new MongoTemplate(mongoDbFactory, converter);
	@ConditionalOnMissingBean(MongoConverter.class)
	public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context,
			MongoCustomConversions conversions) {
		DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
		MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
		mappingConverter.setCustomConversions(conversions);
		return mappingConverter;
	
	//...
}

SpringBoot利用我們配置好的MongoDbFactory在配置類中生成一個MongoTemplate，之后我們就可以在項目代碼中直接@Autowired了。因為用于生成MongoTemplate的MongoDbFactory是我們自己在MongoConfig配置類中生成的，所以我們自定義的連接池參數(shù)也就生效了。

到此這篇關于SpringBoot 整合mongoDB并自定義連接池的文章就介紹到這了,更多相關SpringBoot自定義連接池內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: