SpringBoot中使用MongoDB的连接池配置及解决启动报错问题

在SpringBoot中，可以通过引入 spring-boot-starter-data-mongodb 依赖来实现spring-data-mongodb 的自动配置。但是，默认情况下，该依赖并没有提供连接池配置的功能。因此，需要自行重写 MongoDbFactory，实现MongoDB客户端连接的参数配置扩展。

引入依赖

        
            org.springframework.boot
            spring-boot-starter-data-mongodb
        

配置文件
 

@Setter
@Getter
@Component
@PropertySource(value = "classpath:application-mongodb.yml")
@ConfigurationProperties(prefix = "spring.data.mongodb")
public class MongoSettingsProperties
{
    private List 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;


}

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

        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;
    }
    @Bean(name = "mongoTemplate")
    @Autowired
    public MongoTemplate getMongoTemplate(MongoDbFactory mongoDbFactory) {
        return new MongoTemplate(mongoDbFactory);

    }
}

启动类

@SpringBootApplication
@ComponentScan(basePackages = {"com.tellhow.sjhjpt"})
@EnableMongoRepositories(basePackages = {"com.tellhow.sjhjpt"})
@EnableTransactionManagement
public class StartApplication extends SpringBootServletInitializer {

    public static void main(String[] args) throws Exception {
        ConfigurableApplicationContext context = SpringApplication.run(StartApplication.class, args);
        GetSpringBeanUtil springBean = new GetSpringBeanUtil();
        springBean.setApplicationContext(context);
        TopologyApp app = GetSpringBeanUtil.getBean(TopologyApp.class);

        app.main(args);

    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(StartApplication.class);
    }

}

其中@EnableMongoRepositories是配置继承MongoRepository的类包地址，@Bean(name = "mongoTemplate")这个类一定要，否则会报错：A component required a bean named 'mongoTemplate' that could not be found。

另外如果出现 'Field required a bean of type that could not be found.'（找不到继承MongoRepository的类） 这个问题也是通过这个方式解决。如果不用连接池的话，采用框架默认配置就不用考虑了。