python mongodb连接池_springboot配置mongodb连接池

application.yml 配置mongodb:

address: localhost:27017

database: soms

username: admin

password: 123456

# 连接池配置

clientName: soms-task # 客户端的标识，用于定位请求来源等

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: 100 # 每个host的TCP连接数

minConnectionsPerHost: 5 #每个host的最小TCP连接数

#计算允许多少个线程阻塞等待可用TCP连接时的乘数，算法： threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost，当前配置允许10*20个线程阻塞

threadsAllowedToBlockForConnectionMultiplier: 10

用来获取配置参数的类import lombok.Data;

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

import org.springframework.stereotype.Component;

import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Min;

import javax.validation.constraints.NotNull;

import javax.validation.constraints.Size;

import java.util.List;

@Data

@Validated

@Component

@ConfigurationProperties(prefix = "mongodb")

public class MongoClientOptionProperties {

/** 基础连接参数 */

private String database;

private String username;

private String password;

@NotNull

private List address;

/** 客户端连接池参数 */

@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;

}

配置类package com.alkin.soms.common.mongo;

import com.mongodb.MongoClient;

import com.mongodb.MongoClientOptions;

import com.mongodb.MongoCredential;

import com.mongodb.ServerAddress;

import org.apache.commons.lang.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.mongodb.MongoDbFactory;

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

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

import org.springframework.data.mongodb.core.convert.*;

import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

import java.util.ArrayList;

import java.util.List;

@Configuration

public class MongoConfig {

private final Logger log = LoggerFactory.getLogger(MongoConfig.class);

/**

* 自定义mongo连接池 * * @param properties

* @return

*/

@Bean

@Autowired public MongoDbFactory mongoDbFactory(MongoClientOptionProperties properties) {

//创建客户端参数

MongoClientOptions options = mongoClientOptions(properties);

//创建客户端和Factory

List serverAddresses = new ArrayList<>();

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

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

String host = hostAndPort[0];

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

ServerAddress serverAddress = new ServerAddress(host, port);

serverAddresses.add(serverAddress);

}

String username = properties.getUsername();

String password = properties.getPassword();

String database = properties.getDatabase();

MongoClient mongoClient;

if (StringUtils.isNotEmpty(username) && StringUtils.isNotEmpty(password)) {

//创建认证客户端

MongoCredential mongoCredential = MongoCredential.createScramSha1Credential(

username,

database,

password.toCharArray());

mongoClient = new MongoClient(serverAddresses.get(0), mongoCredential, options);

} else {

//创建非认证客户端

mongoClient = new MongoClient(serverAddresses, options);

}

SimpleMongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, database);

log.info("mongodb注入成功");

return mongoDbFactory;

}

@Bean(name = "mongoTemplate")

@Autowired

public MongoTemplate getMongoTemplate(MongoDbFactory mongoDbFactory) {

return new MongoTemplate(mongoDbFactory);

}

/**

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

}

@Bean

public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context, BeanFactory beanFactory) {

DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);

MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);

try {

mappingConverter.setCustomConversions(beanFactory.getBean(MongoCustomConversions.class));

} catch (NoSuchBeanDefinitionException ignore) {

}

// Don't save _class to dao

mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));

return mappingConverter;

}

}