SpringBoot中使用MongoDB的连接池配置

小鱼儿 2022-04-16 07:07 1118阅读 0赞

在SpringBoot中，我们可以通过引入 spring-boot-starter-data-mongodb 依赖来实现spring-data-mongodb 的自动配置。但是，默认情况下，该依赖并没有像使用MySQL或者Redis那样为我们提供连接池配置的功能。因此，我们需要自行重写 MongoDbFactory，实现MongoDB客户端连接的参数配置扩展。需要说明的是，MongoDB的客户端本身就是一个连接池，因此，我们只需要配置客户端即可。

# 引入依赖 #

<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.0.2.RELEASE</version>
    	</parent>
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-mongodb</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    	</dependencies>

# 配置文件 #

为了方便对Mongodb进行统一管理，我们将相关的配置抽取到 mongo-pool.properties 中，前缀为spring.data.mongodb（前缀可自己随意配置）：

spring.data.mongodb.address=172.16.250.234:27017,172.16.250.239:27017,172.16.250.240:27017
    spring.data.mongodb.replica-set=rs0
    spring.data.mongodb.database=test
    spring.data.mongodb.username=admin
    spring.data.mongodb.password=admin
    
    # Configure spring.data.mongodbDB Pool
    spring.data.mongodb.min-connections-per-host=10
    spring.data.mongodb.max-connections-per-host=100
    spring.data.mongodb.threads-allowed-to-block-for-connection-multiplier=5
    spring.data.mongodb.server-selection-timeout=30000
    spring.data.mongodb.max-wait-time=120000
    spring.data.mongodb.max-connection-idel-time=0
    spring.data.mongodb.max-connection-life-time=0
    spring.data.mongodb.connect-timeout=10000
    spring.data.mongodb.socket-timeout=0
    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=20000
    spring.data.mongodb.heartbeat-connect-timeout=20000
    spring.data.mongodb.min-heartbeat-frequency=500
    spring.data.mongodb.heartbeat-frequency=10000
    spring.data.mongodb.local-threshold=15
    spring.data.mongodb.authentication-database=auth_dev

# 配置文件映射为JavaBean #

为方便调用，将上述配置包装成一个配置实体类，代码如下:

import java.util.List;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    @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 = 0;
    	private Integer maxConnectionsPerHost = 100;
    	private Integer threadsAllowedToBlockForConnectionMultiplier = 5;
    	private Integer serverSelectionTimeout = 30000;
    	private Integer maxWaitTime = 120000;
    	private Integer maxConnectionIdleTime = 0;
    	private Integer maxConnectionLifeTime = 0;
    	private Integer connectTimeout = 10000;
    	private Integer socketTimeout = 0;
    	private Boolean socketKeepAlive = false;
    	private Boolean sslEnabled = false;
    	private Boolean sslInvalidHostNameAllowed = false;
    	private Boolean alwaysUseMBeans = false;
    	private Integer heartbeatConnectTimeout = 20000;
    	private Integer heartbeatSocketTimeout = 20000;
    	private Integer minHeartbeatFrequency = 500;
    	private Integer heartbeatFrequency = 10000;
    	private Integer localThreshold = 15;
    	private String authenticationDatabase;
    
    	// 省略Getters和Setters方法
    
    }

# 覆盖MongoDbFactory #

自定义创建一个MongoDbFactory用来替代Springboot为我们自动装配的MongoDbFactory，代码如下：

import java.util.ArrayList;
    import java.util.List;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    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.SimpleMongoDbFactory;
    
    import com.mongodb.MongoClient;
    import com.mongodb.MongoClientOptions;
    import com.mongodb.MongoCredential;
    import com.mongodb.ServerAddress;
    
    @Configuration
    public class MongoConfig {
    
    	private static final Logger logger = LoggerFactory.getLogger(MongoConfig.class);
    
    	// 覆盖容器中默认的MongoDbFacotry Bean
    	@Bean
    	@Autowired
    	public MongoDbFactory mongoDbFactory(MongoSettingsProperties properties) {
    
    		// 客户端配置（连接数，副本集群验证）
    		MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
    		builder.connectionsPerHost(properties.getMaxConnectionsPerHost());
    		builder.minConnectionsPerHost(properties.getMinConnectionsPerHost());
    		if (properties.getReplicaSet() != null) {
    			builder.requiredReplicaSetName(properties.getReplicaSet());
    		}
    		builder.threadsAllowedToBlockForConnectionMultiplier(
    				properties.getThreadsAllowedToBlockForConnectionMultiplier());
    		builder.serverSelectionTimeout(properties.getServerSelectionTimeout());
    		builder.maxWaitTime(properties.getMaxWaitTime());
    		builder.maxConnectionIdleTime(properties.getMaxConnectionIdleTime());
    		builder.maxConnectionLifeTime(properties.getMaxConnectionLifeTime());
    		builder.connectTimeout(properties.getConnectTimeout());
    		builder.socketTimeout(properties.getSocketTimeout());
    		// builder.socketKeepAlive(properties.getSocketKeepAlive());
    		builder.sslEnabled(properties.getSslEnabled());
    		builder.sslInvalidHostNameAllowed(properties.getSslInvalidHostNameAllowed());
    		builder.alwaysUseMBeans(properties.getAlwaysUseMBeans());
    		builder.heartbeatFrequency(properties.getHeartbeatFrequency());
    		builder.minHeartbeatFrequency(properties.getMinHeartbeatFrequency());
    		builder.heartbeatConnectTimeout(properties.getHeartbeatConnectTimeout());
    		builder.heartbeatSocketTimeout(properties.getHeartbeatSocketTimeout());
    		builder.localThreshold(properties.getLocalThreshold());
    		MongoClientOptions mongoClientOptions = builder.build();
    
    		// MongoDB地址列表
    		List<ServerAddress> serverAddresses = new ArrayList<ServerAddress>();
    		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);
    		}
    
    		logger.info("serverAddresses:" + serverAddresses.toString());
    
    		// 连接认证
    		// MongoCredential mongoCredential = null;
    		// if (properties.getUsername() != null) {
    		// 	mongoCredential = MongoCredential.createScramSha1Credential(
    		// 			properties.getUsername(), properties.getAuthenticationDatabase() != null
    		// 					? properties.getAuthenticationDatabase() : properties.getDatabase(),
    		// 			properties.getPassword().toCharArray());
    		// }
    
    		// 创建认证客户端
    		// MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredential, mongoClientOptions);
    
    		// 创建非认证客户端
    		MongoClient mongoClient = new MongoClient(serverAddresses, mongoClientOptions);
    
    		// 创建MongoDbFactory
    		MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
    		return mongoDbFactory;
    	}
    }

# MongoDB测试 #

## 创建数据实体 ##

import java.io.Serializable;
    
    public class UserEntity implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    
    	private Long id;
    	private String userName;
    	private String passWord;
    
    	public Long getId() {
    		return id;
    	}
    
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	public String getUserName() {
    		return userName;
    	}
    
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    
    	public String getPassWord() {
    		return passWord;
    	}
    
    	public void setPassWord(String passWord) {
    		this.passWord = passWord;
    	}
    
    	public String toString() {
    		return "id: " + id + ",userName: " + userName + ",passWord: " + passWord;
    	}
    }

## 创建Dao接口及实现 ##

public interface UserDao {
    
    	void saveUser(UserEntity user);
    
    	UserEntity findUserByName(String userName);
    }

import org.springframework.beans.factory.annotation.Autowired;
    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.stereotype.Component;
    
    @Component
    public class UserDaoImpl implements UserDao {
    
    	@Autowired
    	private MongoTemplate mongoTemplate;
    
    	@Override
    	public void saveUser(UserEntity user) {
    		mongoTemplate.save(user);
    	}
    
    	@Override
    	public UserEntity findUserByName(String userName) {
    		Query query = new Query(Criteria.where("userName").is(userName));
    		UserEntity user = mongoTemplate.findOne(query, UserEntity.class);
    		return user;
    	}
    
    }

## 编写测试代码 ##

import java.util.Optional;
    
    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.domain.Example;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import com.pengjunlee.UserDao;
    import com.pengjunlee.UserEntity;
    import com.pengjunlee.UserRepository;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class MongoTest {
    	@Autowired
    	private UserDao userDao;
    
    	@Autowired
    	private UserRepository userRepository;
    
    	@Test
    	public void testSaveUser() {
    		UserEntity user = new UserEntity();
    		user.setId(88L);
    		user.setUserName("XiaoMing");
    		user.setPassWord("123456");
    		userDao.saveUser(user);
    	}
    
    	@Test
    	public void testFindUser01() {
    		UserEntity user = userDao.findUserByName("XiaoMing");
    		System.out.println(user);
    	}
    
    	@Test
    	public void testFindUser02() {
    		UserEntity queryUser = new UserEntity();
    		queryUser.setUserName("XiaoMing");
    		Example<UserEntity> example = Example.of(queryUser);
    		Optional<UserEntity> optional = userRepository.findOne(example);
    		System.out.println(optional.get());
    	}
    }

查询结果：

id: 88,userName: XiaoMing,passWord: 123456