首页 / MONGODB / SpringBoot 整合mongoDB并自定义连接池

SpringBoot 整合mongoDB并自定义连接池

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了SpringBoot 整合mongoDB并自定义连接池，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8745字，纯文字阅读大概需要13分钟。

内容图文

SpringBoot 整合mongoDB并自定义连接池

得力于SpringBoot的特性，整合mongoDB是很容易的，我们整合mongoDB的目的就是想用它给我们提供的mongoTemplate，它可以很容易的操作mongoDB数据库。

为了自定义连接池，我们在配置类中主要与MongoClientOptions、MongoCredential、MongoClient、MongoDbFactory打交道。最终的目的就是配置好一个MongoDbFactory的bean交由Spring管理。

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: [设置你的认证数据库，如果有的话]
  # 连接池配置
  clientName: ${spring.application.name} # 客户端的标识，用于定位请求来源等
  connectionTimeoutMs: 10000     # TCP连接超时，毫秒
  readTimeoutMs: 15000       # TCP读取超时，毫秒
  poolMaxWaitTimeMs: 3000        #当连接池无可用连接时客户端阻塞等待的时长，单位毫秒
  connectionMaxIdleTimeMs: 60000   #TCP连接闲置时间，单位毫秒
  connectionMaxLifeTimeMs: 120000    #TCP连接最多可以使用多久，单位毫秒
  heartbeatFrequencyMs: 20000      #心跳检测发送频率，单位毫秒
  minHeartbeatFrequencyMs: 8000    #最小的心跳检测发送频率，单位毫秒
  heartbeatConnectionTimeoutMs: 10000  #心跳检测TCP连接超时，单位毫秒
  heartbeatReadTimeoutMs: 15000    #心跳检测TCP连接读取超时，单位毫秒
  connectionsPerHost: 20       # 每个host的TCP连接数
  minConnectionsPerHost: 5     #每个host的最小TCP连接数
  #计算允许多少个线程阻塞等待可用TCP连接时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost，当前配置允许10*20个线程阻塞
  threadsAllowedToBlockForConnectionMultiplier: 10

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.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.List;

@Slf4j
@Configuration
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);
        // 删除 _class field
//    mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
        mappingConverter.setCustomConversions(conversions);
        return mappingConverter;
    }

    /**
     * 自定义mongo连接池
     * @param properties
     * @return
     */
    @Bean
    public MongoDbFactory mongoDbFactory(MongoClientOptionProperties properties) {
        //创建客户端参数
        MongoClientOptions options = mongoClientOptions(properties);

        //创建客户端和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);
        }

        //创建认证客户端
        MongoCredential mongoCredential = MongoCredential.createScramSha1Credential(properties.getUsername(),
                properties.getAuthenticationDatabase() != null ? properties.getAuthenticationDatabase() : properties.getDatabase(),
                properties.getPassword().toCharArray());

        MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredential, options);

        /** ps: 创建非认证客户端*/
        //MongoClient mongoClient = new MongoClient(serverAddresses, mongoClientOptions);
        return new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
    }

    /**
     * mongo客户端参数配置
     * @return
     */
    @Bean
    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();
    }

    @Primary
    @Bean
    @ConfigurationProperties(prefix = "mongodb")
    public MongoClientOptionProperties mongoClientOptionProperties() {
        return new MongoClientOptionProperties();
    }

    @Getter
    @Setter
    @Validated
    @Configuration
    public static class MongoClientOptionProperties {

        /** 基础连接参数 */
        private String database;
        private String username;
        private String password;
        @NotNull
        private List<String> address;
        private String authenticationDatabase;

        /** 客户端连接池参数 */
        @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;
        /** 心跳检测发送频率 */
        @Min(value = 2000)
        private int heartbeatFrequencyMs;

        /** 最小的心跳检测发送频率 */
        @Min(value = 300)
        private int minHeartbeatFrequencyMs;
        /** 计算允许多少个线程阻塞等待时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost */
        @Min(value = 1)
        private int threadsAllowedToBlockForConnectionMultiplier;
        /** 心跳检测连接超时时间 */
        @Min(value = 200)
        private int heartbeatConnectionTimeoutMs;
        /** 心跳检测读取超时时间 */
        @Min(value = 200)
        private int heartbeatReadTimeoutMs;

        /** 每个host最大连接数 */
        @Min(value = 1)
        private int connectionsPerHost;
        /** 每个host的最小连接数 */
        @Min(value = 1)
        private int minConnectionsPerHost;
    }
}

MappingMongoConverter可以自定义mongo转换器，主要自定义存取mongo数据时的一些操作，例如 mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null)) 方法会将mongo数据中的_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创建MongoTemplate实例
    @Bean
    @ConditionalOnMissingBean
    public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory, MongoConverter converter) {
        return new MongoTemplate(mongoDbFactory, converter);
    }

    @Bean
    @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配置类中生成的，所以我们自定义的连接池参数也就生效了。

内容总结

以上是互联网集市为您收集整理的SpringBoot 整合mongoDB并自定义连接池全部内容，希望文章能够帮你解决SpringBoot 整合mongoDB并自定义连接池所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/880078.html

来源：【匿名】

【上一篇】MongoDB数据操作练习【下一篇】在MongoDB上如何进行数据的导入与导出

更多 ►

【SpringBoot 整合mongoDB并自定义连接池】教程文章相关的互联网学习教程文章

mongodb or操作与连接池【代码】

mongodb# 类似于sql中的in或者or操作 mulites field query: db.cool.find({$or:[{field1:’val’},{‘field2’:’val’}…]}) # 类似于sql中的like操作 db.coo.find(‘name’: /m/) == sql like pymongo 使用 {‘field’:{$regex: keyword}} http://stackoverflow.com/questions/3305561/how-do-i-query-mongodb-with-like?rq=1 db.serverStatus().connections 查看当前连接数sudo lsof -i -n -P | grep TCP | grep mongo ...

PHP-FPM模式下可怕的MongoDB-PHP-Driver连接池无节制连接问题_PHP教程

问题发生环境： Nginx PHP 5.3.10 as php-fpm extension to nginx mongodb-php-driver 1.2.12 MongoDB 2.2 此问题是 MongoDB PHP Driver 1.2.x 的官方特性导致的，描述请看 PHP-202 和 PHP-347 。简单地说，PHP-FPM模式下，每一个 PHP Worker 进程都有自己独立的 mongodb 连接池，从而导致连接数极易超标，内存数也随之倍增。一，PHP服务背景：某个 Web 应用是通过 Nginx+factcgi 运行的 PHP 程序提供服务的。 PHP-FPM的最大子进...

java操作mongodb（连接池）（转）【图】

Mongo的实例其实就是一个数据库连接池，这个连接池里默认有10个链接。我们没有必要重新实现这个链接池，但是我们可以更改这个连接池的配置。因为Mongo的实例就是一个连接池，所以，项目中最好只存在一个Mongo的实例。常见的配置参数： connectionsPerHost：每个主机的连接数 threadsAllowedToBlockForConnectionMultiplier：线程队列数，它以上面connectionsPerHost值相乘的结果就是线程队列最大值。如果连接线程排满了队列就会抛...

Spring Boot配置MongoDB连接池【代码】

com.feidiao.jancee.fdiot.api.config.mongo; import org.hibernate.validator.constraints.NotBlank; import org.hibernate.validator.constraints.NotEmpty; import org.springframework.stereotype.Component; import org.springframework.validation.annotation.Validated; import java.util.List;@Component @Validated public class MongoSettingsProperties {@NotBlankprivate String database;@NotEmptyprivate List<Strin...

mongodb的连接池管理

https://blog.csdn.net/lin_tuer/article/details/78480203 用单例模式建立mongoDB的连接，需要每次操作完关闭连接吗？关于建立单例模式的MongoDB连接，参考这里MongoClient连接池用法建立了之后，每次操作调用同一个实例，MongoClient又是线程安全的，貌似就没有什么问题了。但是突然想到，这些连接获取后，操作完不主动释放，会不会一直被占有？ – 于是开始找各种资料，这篇文章给出了很形象的说明，MongoDB的连接池和管理 ...

MongoDB数据库连接池设置

MongoDB数据库连接池设置关键词： com.mongodb.DBPortPool$SemaphoresOut: Out of semaphores to get db 今天做MongoDB并发测试，报出上述错误。究其原因，是数据库连接数太少，资源耗MongoDB数据库连接池设置关键词：com.mongodb.DBPortPool$SemaphoresOut: Out of semaphores to get db今天做MongoDB并发测试，报出上述错误。究其原因，是数据库连接数太少，资源耗尽。查看com.mongodb.MongoOptions源代码，其中有connectionsPe...

MongoDBJava连接池的注意事项【图】

内部实现了一个连接池。Mongo对象是线程安全的，因此可以只创建一个，在多线程环境下安全使用。因此，我们可以用将Mongo变量作为 1.Mongo对象内部实现了一个连接池。Mongo对象是线程安全的，因此可以只创建一个，在多线程环境下安全使用。因此，我们可以用将Mongo变量作为一个Singleton类的成员变量，从而保证只创建一个连接池。Mongo.close方法将关闭当前所有活跃的连接。所以要在web工程被从Tomcat或者GlassFish容器中注销的时候...