SpringBoot中使用MongoDB的连接池配置

编辑: admin 分类: java 发布时间: 2021-12-03 来源:互联网

在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

到此这篇关于SpringBoot中使用MongoDB的连接池配置的文章就介绍到这了,更多相关SpringBoot MongoDB连接池配置内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！

【本文由http://www.nextecloud.cn/hk.html首发,转载请保留出处，谢谢】

海外服务器