springboot集成mongodb 连接池 多数据库源,源码demo

最新推荐文章于 2024-07-26 22:10:38 发布
最新推荐文章于 2024-07-26 22:10:38 发布
阅读量4.7k 收藏 8
点赞数
分类专栏： springboot mongodb 文章标签： springboot mongodb 连接池 多数据源 demo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a704397849/article/details/97247447
版权

上一篇介绍了 springboot集成mongodb 多数据库源切换 源码demo

开发环境:

windows 7
idea
windows64 mongodb 如果没安装运行 点这里
navicat for mongodb 下面介绍用的是这个图形工具，命令行客户端或其他图形工具都是可以的，如果需要这个 点这里

创建mongodb测试的数据

首先连接mongodb
新建第一个mongodb数据库 testdb
在这里插入图片描述
打开数据库testdb,然后点击新建查询，在查询栏中 新建数据库testdb的集合user 并添加一条记录，点击运行
在这里插入图片描述
查询栏内容:

db.createCollection('user')

db.user.insert({
    account: '110',
    password: '123456',
    phone: '188xxxxxxxx',
    name: 'zhangsan'
})

新建第二个数据库 testdb2
在这里插入图片描述
打开数据库testdb2,然后点击新建查询，在查询栏中 新建数据库testdb2的集合music并添加一条记录，点击运行
在这里插入图片描述
查询栏内容:

db.createCollection('music')

db.music.insert({
    name: '喜欢你',
    singer: '邓紫棋'
})
springboot mongodb 配置连接池 多数据库源 测试源码

springboot 项目 mongodb_demo3 目录结构,如下
在这里插入图片描述
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mongodb_demo3</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mongodb_demo3</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件 application.properties

server.port=8088
#第一个数据库
spring.data.mongodb.testdb.database=testdb
spring.data.mongodb.testdb.addresses=localhost:27017
spring.data.mongodb.testdb.username=root
spring.data.mongodb.testdb.password=123456
#spring.data.mongodb.testdb.port=27017

#第二个数据库
spring.data.mongodb.testdb2.database=testdb2
spring.data.mongodb.testdb2.addresses=localhost:27017
spring.data.mongodb.testdb2.username=root
spring.data.mongodb.testdb2.password=123456
#spring.data.mongodb.testdb2.port=27017

mongodb 连接池配置文件 mongodb_pool.properties

# 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

数据库连接池的配置类 MongoSettingsProperties

package com.example.mongodb_demo3.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

/**
 * 配置文件映射为JavaBean
 */
@Component
@PropertySource(value = "classpath:mongodb_pool.properties")
@ConfigurationProperties(prefix = "spring.data.mongodb")
public class MongoSettingsProperties {
    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;

    public Integer getMinConnectionsPerHost() {
        return minConnectionsPerHost;
    }

    public void setMinConnectionsPerHost(Integer minConnectionsPerHost) {
        this.minConnectionsPerHost = minConnectionsPerHost;
    }

    public Integer getMaxConnectionsPerHost() {
        return maxConnectionsPerHost;
    }

    public void setMaxConnectionsPerHost(Integer maxConnectionsPerHost) {
        this.maxConnectionsPerHost = maxConnectionsPerHost;
    }

    public Integer getThreadsAllowedToBlockForConnectionMultiplier() {
        return threadsAllowedToBlockForConnectionMultiplier;
    }

    public void setThreadsAllowedToBlockForConnectionMultiplier(Integer threadsAllowedToBlockForConnectionMultiplier) {
        this.threadsAllowedToBlockForConnectionMultiplier = threadsAllowedToBlockForConnectionMultiplier;
    }

    public Integer getServerSelectionTimeout() {
        return serverSelectionTimeout;
    }

    public void setServerSelectionTimeout(Integer serverSelectionTimeout) {
        this.serverSelectionTimeout = serverSelectionTimeout;
    }

    public Integer getMaxWaitTime() {
        return maxWaitTime;
    }

    public void setMaxWaitTime(Integer maxWaitTime) {
        this.maxWaitTime = maxWaitTime;
    }

    public Integer getMaxConnectionIdleTime() {
        return maxConnectionIdleTime;
    }

    public void setMaxConnectionIdleTime(Integer maxConnectionIdleTime) {
        this.maxConnectionIdleTime = maxConnectionIdleTime;
    }

    public Integer getMaxConnectionLifeTime() {
        return maxConnectionLifeTime;
    }

    public void setMaxConnectionLifeTime(Integer maxConnectionLifeTime) {
        this.maxConnectionLifeTime = maxConnectionLifeTime;
    }

    public Integer getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(Integer connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public Integer getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(Integer socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public Boolean getSocketKeepAlive() {
        return socketKeepAlive;
    }

    public void setSocketKeepAlive(Boolean socketKeepAlive) {
        this.socketKeepAlive = socketKeepAlive;
    }

    public Boolean getSslEnabled() {
        return sslEnabled;
    }

    public void setSslEnabled(Boolean sslEnabled) {
        this.sslEnabled = sslEnabled;
    }

    public Boolean getSslInvalidHostNameAllowed() {
        return sslInvalidHostNameAllowed;
    }

    public void setSslInvalidHostNameAllowed(Boolean sslInvalidHostNameAllowed) {
        this.sslInvalidHostNameAllowed = sslInvalidHostNameAllowed;
    }

    public Boolean getAlwaysUseMBeans() {
        return alwaysUseMBeans;
    }

    public void setAlwaysUseMBeans(Boolean alwaysUseMBeans) {
        this.alwaysUseMBeans = alwaysUseMBeans;
    }

    public Integer getHeartbeatConnectTimeout() {
        return heartbeatConnectTimeout;
    }

    public void setHeartbeatConnectTimeout(Integer heartbeatConnectTimeout) {
        this.heartbeatConnectTimeout = heartbeatConnectTimeout;
    }

    public Integer getHeartbeatSocketTimeout() {
        return heartbeatSocketTimeout;
    }

    public void setHeartbeatSocketTimeout(Integer heartbeatSocketTimeout) {
        this.heartbeatSocketTimeout = heartbeatSocketTimeout;
    }

    public Integer getMinHeartbeatFrequency() {
        return minHeartbeatFrequency;
    }

    public void setMinHeartbeatFrequency(Integer minHeartbeatFrequency) {
        this.minHeartbeatFrequency = minHeartbeatFrequency;
    }

    public Integer getHeartbeatFrequency() {
        return heartbeatFrequency;
    }

    public void setHeartbeatFrequency(Integer heartbeatFrequency) {
        this.heartbeatFrequency = heartbeatFrequency;
    }

    public Integer getLocalThreshold() {
        return localThreshold;
    }

    public void setLocalThreshold(Integer localThreshold) {
        this.localThreshold = localThreshold;
    }

    public String getAuthenticationDatabase() {
        return authenticationDatabase;
    }

    public void setAuthenticationDatabase(String authenticationDatabase) {
        this.authenticationDatabase = authenticationDatabase;
    }
}

testdb数据库的配置类 TestdbMongoConfiguration

package com.example.mongodb_demo3.config;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import org.springframework.beans.factory.annotation.Autowired;
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.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Configuration
//读取配置文件中spring.data.mongodb.testdb 开头的属性如database，通过反射调用setDatabase()保存从配置文件中读取的database值
//需要maven依赖 spring-boot-configuration-processor
@ConfigurationProperties(prefix = "spring.data.mongodb.testdb")
public class TestdbMongoConfiguration {
    // MongoDB Properties

    private ArrayList<String> addresses;
    private String database, username, password;
    private int port;

    public ArrayList<String> getAddresses() {
        return addresses;
    }
    public void setAddresses(ArrayList<String> addresses) {
        this.addresses = addresses;
    }
    public String getDatabase() {
        return database;
    }
    public void setDatabase(String database) {
        this.database = database;
    }
    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 int getPort() {
        return port;
    }
    public void setPort(int port) {
        this.port = port;
    }

    @Autowired
    MongoSettingsProperties properties;

    /**
     * 覆盖容器中默认的MongoDbFacotry Bean
     */
    public MongoDbFactory mongoDbFactory() {
        MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
        builder.connectionsPerHost(properties.getMaxConnectionsPerHost());
        builder.minConnectionsPerHost(properties.getMinConnectionsPerHost());
        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 : addresses) {
            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 = null;
        // 	mongoCredential = MongoCredential.createScramSha1Credential(MongoCredential.createCredential(username, database, password.toCharArray()));
        // 创建认证客户端
        // MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredential, mongoClientOptions);

        // 创建非认证客户端
        MongoClient mongoClient = new MongoClient(serverAddresses, mongoClientOptions);

        // 创建MongoDbFactory
        MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, database);
        return mongoDbFactory;
    }

    //第一个数据库 默认作为主数据库 需要添加注解 @Primary ，后面的数据库不需要这个注解
    @Primary
    @Bean(name = "testdbMongoTemplate")
    public  MongoTemplate getMongoTemplate() throws Exception {
        return new MongoTemplate(mongoDbFactory());
    }
}

testdb2数据库的配置类 Testdb2MongoConfiguration

package com.example.mongodb_demo3.config;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
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 java.util.ArrayList;
import java.util.List;

@Configuration
//读取配置文件中spring.data.mongodb.testdb 开头的属性如database，通过反射调用setDatabase()保存从配置文件中读取的database值
//需要maven依赖 spring-boot-configuration-processor
@ConfigurationProperties(prefix = "spring.data.mongodb.testdb2")
public class Testdb2MongoConfiguration {
    // MongoDB Properties

    private ArrayList<String> addresses;
    private String database, username, password;
    private int port;

    public ArrayList<String> getAddresses() {
        return addresses;
    }
    public void setAddresses(ArrayList<String> addresses) {
        this.addresses = addresses;
    }
    public String getDatabase() {
        return database;
    }
    public void setDatabase(String database) {
        this.database = database;
    }
    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 int getPort() {
        return port;
    }
    public void setPort(int port) {
        this.port = port;
    }

    @Autowired
    MongoSettingsProperties properties;

    /**
     * 覆盖容器中默认的MongoDbFacotry Bean
     */
    public MongoDbFactory mongoDbFactory() {
        MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
        builder.connectionsPerHost(properties.getMaxConnectionsPerHost());
        builder.minConnectionsPerHost(properties.getMinConnectionsPerHost());
        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 : addresses) {
            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 = null;
        // 	mongoCredential = MongoCredential.createScramSha1Credential(MongoCredential.createCredential(username, database, password.toCharArray()));
        // 创建认证客户端
        // MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredential, mongoClientOptions);

        // 创建非认证客户端
        MongoClient mongoClient = new MongoClient(serverAddresses, mongoClientOptions);

        // 创建MongoDbFactory
        MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, database);
        return mongoDbFactory;
    }

    //这是第二个数据库源，不需要注解 @Primary
    @Bean(name = "testdb2MongoTemplate")
    public  MongoTemplate getMongoTemplate() throws Exception {
        return new MongoTemplate(mongoDbFactory());
    }
}

User

package com.example.mongodb_demo3.pojo;

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

//user 是mongodb数据库中集合名
@Document(collection="user")
public class User {
    private String account;
    private String password;
    private String name;
    private String phone;

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "User{" +
                "account='" + account + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}

Music

package com.example.mongodb_demo3.pojo;

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

//music 是mongodb数据库中集合名
@Document(collection="music")
public class Music {
    private String name;
    private String singer;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSinger() {
        return singer;
    }

    public void setSinger(String singer) {
        this.singer = singer;
    }

    @Override
    public String toString() {
        return "Music{" +
                "name='" + name + '\'' +
                ", singer='" + singer + '\'' +
                '}';
    }
}

web测试类 TestController

package com.example.mongodb_demo3.controller;

import com.example.mongodb_demo3.pojo.Music;
import com.example.mongodb_demo3.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    @Qualifier(value = "testdbMongoTemplate")
    protected MongoTemplate testdbMongoTemplate;

    @Autowired
    @Qualifier(value = "testdb2MongoTemplate")
    protected MongoTemplate testdb2MongoTemplate;

    @RequestMapping("/test")
    public String test(){
        //第一个数据库源testdb
        Query query = new Query();
        query.addCriteria(Criteria.where("name").is("zhangsan"));
        User user = testdbMongoTemplate.findOne(query, User.class);

        //第二个数据库源testdb2
        Query query2 = new Query();
        query2.addCriteria(Criteria.where("name").is("喜欢你"));
        Music music = testdb2MongoTemplate.findOne(query2, Music.class);
        return "来自第一个数据库源 " + user.toString() + "<br/>来自第二个数据库源 " + music.toString();
    }
}

启动类 MongodbDemo3Application

package com.example.mongodb_demo3;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MongodbDemo3Application {

    public static void main(String[] args) {
        SpringApplication.run(MongodbDemo3Application.class, args);
    }

}
idea 启动程序

idea启动程序，可以看到 每个数据库都初始创建了10个连接放在各自的连接池中,配置文件中设置的连接池最小个数就是10
在这里插入图片描述
具体启动信息:

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe" -XX:TieredStopAtLevel=1 -noverify -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=57353 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=localhost -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true "-javaagent:D:\Program Files\IntelliJ_IDEA\lib\idea_rt.jar=57354:D:\Program Files\IntelliJ_IDEA\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_201\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_201\jre\lib\rt.jar;E:\workspace_idea\mongodb_demo3\target\classes;E:\maven_repository_new\org\springframework\boot\spring-boot-configuration-processor\2.0.4.RELEASE\spring-boot-configuration-processor-2.0.4.RELEASE.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-starter-data-mongodb\2.0.4.RELEASE\spring-boot-starter-data-mongodb-2.0.4.RELEASE.jar;E:\maven_repository_new\org\mongodb\mongodb-driver\3.6.4\mongodb-driver-3.6.4.jar;E:\maven_repository_new\org\mongodb\bson\3.6.4\bson-3.6.4.jar;E:\maven_repository_new\org\mongodb\mongodb-driver-core\3.6.4\mongodb-driver-core-3.6.4.jar;E:\maven_repository_new\org\springframework\data\spring-data-mongodb\2.0.9.RELEASE\spring-data-mongodb-2.0.9.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-tx\5.0.8.RELEASE\spring-tx-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-context\5.0.8.RELEASE\spring-context-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-beans\5.0.8.RELEASE\spring-beans-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-expression\5.0.8.RELEASE\spring-expression-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\data\spring-data-commons\2.0.9.RELEASE\spring-data-commons-2.0.9.RELEASE.jar;E:\maven_repository_new\org\slf4j\slf4j-api\1.7.25\slf4j-api-1.7.25.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-starter-web\2.0.4.RELEASE\spring-boot-starter-web-2.0.4.RELEASE.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-starter-json\2.0.4.RELEASE\spring-boot-starter-json-2.0.4.RELEASE.jar;E:\maven_repository_new\com\fasterxml\jackson\core\jackson-databind\2.9.6\jackson-databind-2.9.6.jar;E:\maven_repository_new\com\fasterxml\jackson\core\jackson-annotations\2.9.0\jackson-annotations-2.9.0.jar;E:\maven_repository_new\com\fasterxml\jackson\core\jackson-core\2.9.6\jackson-core-2.9.6.jar;E:\maven_repository_new\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.9.6\jackson-datatype-jdk8-2.9.6.jar;E:\maven_repository_new\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.9.6\jackson-datatype-jsr310-2.9.6.jar;E:\maven_repository_new\com\fasterxml\jackson\module\jackson-module-parameter-names\2.9.6\jackson-module-parameter-names-2.9.6.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-starter-tomcat\2.0.4.RELEASE\spring-boot-starter-tomcat-2.0.4.RELEASE.jar;E:\maven_repository_new\org\apache\tomcat\embed\tomcat-embed-core\8.5.32\tomcat-embed-core-8.5.32.jar;E:\maven_repository_new\org\apache\tomcat\embed\tomcat-embed-el\8.5.32\tomcat-embed-el-8.5.32.jar;E:\maven_repository_new\org\apache\tomcat\embed\tomcat-embed-websocket\8.5.32\tomcat-embed-websocket-8.5.32.jar;E:\maven_repository_new\org\hibernate\validator\hibernate-validator\6.0.11.Final\hibernate-validator-6.0.11.Final.jar;E:\maven_repository_new\javax\validation\validation-api\2.0.1.Final\validation-api-2.0.1.Final.jar;E:\maven_repository_new\org\jboss\logging\jboss-logging\3.3.2.Final\jboss-logging-3.3.2.Final.jar;E:\maven_repository_new\com\fasterxml\classmate\1.3.4\classmate-1.3.4.jar;E:\maven_repository_new\org\springframework\spring-web\5.0.8.RELEASE\spring-web-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-webmvc\5.0.8.RELEASE\spring-webmvc-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-aop\5.0.8.RELEASE\spring-aop-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-starter\2.0.4.RELEASE\spring-boot-starter-2.0.4.RELEASE.jar;E:\maven_repository_new\org\springframework\boot\spring-boot\2.0.4.RELEASE\spring-boot-2.0.4.RELEASE.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-autoconfigure\2.0.4.RELEASE\spring-boot-autoconfigure-2.0.4.RELEASE.jar;E:\maven_repository_new\org\springframework\boot\spring-boot-starter-logging\2.0.4.RELEASE\spring-boot-starter-logging-2.0.4.RELEASE.jar;E:\maven_repository_new\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;E:\maven_repository_new\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;E:\maven_repository_new\org\apache\logging\log4j\log4j-to-slf4j\2.10.0\log4j-to-slf4j-2.10.0.jar;E:\maven_repository_new\org\apache\logging\log4j\log4j-api\2.10.0\log4j-api-2.10.0.jar;E:\maven_repository_new\org\slf4j\jul-to-slf4j\1.7.25\jul-to-slf4j-1.7.25.jar;E:\maven_repository_new\javax\annotation\javax.annotation-api\1.3.2\javax.annotation-api-1.3.2.jar;E:\maven_repository_new\org\springframework\spring-core\5.0.8.RELEASE\spring-core-5.0.8.RELEASE.jar;E:\maven_repository_new\org\springframework\spring-jcl\5.0.8.RELEASE\spring-jcl-5.0.8.RELEASE.jar;E:\maven_repository_new\org\yaml\snakeyaml\1.19\snakeyaml-1.19.jar" com.example.mongodb_demo3.MongodbDemo3Application

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.4.RELEASE)

2019-07-25 11:02:00.022  INFO 104472 --- [           main] c.e.m.MongodbDemo3Application            : Starting MongodbDemo3Application on jujumao-456437486 with PID 104472 (E:\workspace_idea\mongodb_demo3\target\classes started by Administrator in E:\workspace_idea\mongodb_demo3)
2019-07-25 11:02:00.025  INFO 104472 --- [           main] c.e.m.MongodbDemo3Application            : No active profile set, falling back to default profiles: default
2019-07-25 11:02:00.057  INFO 104472 --- [           main] ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@2aa3cd93: startup date [Thu Jul 25 11:02:00 CST 2019]; root of context hierarchy
2019-07-25 11:02:00.789  INFO 104472 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8088 (http)
2019-07-25 11:02:00.802  INFO 104472 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2019-07-25 11:02:00.802  INFO 104472 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.32
2019-07-25 11:02:00.805  INFO 104472 --- [ost-startStop-1] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [C:\Program Files\Java\jdk1.8.0_201\bin;C:\Windows\Sun\Java\bin;C:\Windows\system32;C:\Windows;E:\w我的资料\软件\apache-maven-3.5.0-bin\apache-maven-3.5.0\bin;C:\Program Files\Java\jdk1.8.0_201\bin;C:\Program Files\Java\jdk1.8.0_201\lib\dt.jar;C:\Program Files\Java\jdk1.8.0_201\jre\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\IDM Computer Solutions\UltraCompare;C:\Program Files\Microsoft SQL Server\110\Tools\Binn\;C:\Program Files\nodejs\;%ZOOKEEPER_HOME%\bin;C:\Users\Administrator\AppData\Local\Programs\Fiddler;C:\Users\Administrator\AppData\Roaming\npm;.]
2019-07-25 11:02:00.872  INFO 104472 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2019-07-25 11:02:00.872  INFO 104472 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 817 ms
2019-07-25 11:02:00.909  INFO 104472 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Servlet dispatcherServlet mapped to [/]
2019-07-25 11:02:00.912  INFO 104472 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
2019-07-25 11:02:00.913  INFO 104472 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2019-07-25 11:02:00.913  INFO 104472 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2019-07-25 11:02:00.913  INFO 104472 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
2019-07-25 11:02:01.316  INFO 104472 --- [           main] org.mongodb.driver.cluster               : Cluster created with settings {hosts=[localhost:27017], mode=MULTIPLE, requiredClusterType=UNKNOWN, serverSelectionTimeout='30000 ms', maxWaitQueueSize=500}
2019-07-25 11:02:01.316  INFO 104472 --- [           main] org.mongodb.driver.cluster               : Adding discovered server localhost:27017 to client view of cluster
2019-07-25 11:02:01.343  INFO 104472 --- [localhost:27017] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:2, serverValue:185}] to localhost:27017
2019-07-25 11:02:01.343  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:1, serverValue:184}] to localhost:27017
2019-07-25 11:02:01.345  INFO 104472 --- [localhost:27017] org.mongodb.driver.cluster               : Monitor thread successfully connected to server with description ServerDescription{address=localhost:27017, type=STANDALONE, state=CONNECTED, ok=true, version=ServerVersion{versionList=[4, 0, 10]}, minWireVersion=0, maxWireVersion=7, maxDocumentSize=16777216, logicalSessionTimeoutMinutes=30, roundTripTimeNanos=1547899}
2019-07-25 11:02:01.346  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:3, serverValue:186}] to localhost:27017
2019-07-25 11:02:01.346  INFO 104472 --- [localhost:27017] org.mongodb.driver.cluster               : Discovered cluster type of STANDALONE
2019-07-25 11:02:01.348  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:4, serverValue:187}] to localhost:27017
2019-07-25 11:02:01.350  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:5, serverValue:188}] to localhost:27017
2019-07-25 11:02:01.352  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:6, serverValue:189}] to localhost:27017
2019-07-25 11:02:01.354  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:7, serverValue:190}] to localhost:27017
2019-07-25 11:02:01.355  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:8, serverValue:191}] to localhost:27017
2019-07-25 11:02:01.356  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:9, serverValue:192}] to localhost:27017
2019-07-25 11:02:01.358  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:10, serverValue:193}] to localhost:27017
2019-07-25 11:02:01.359  INFO 104472 --- [imer-1-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:11, serverValue:194}] to localhost:27017
2019-07-25 11:02:01.426  INFO 104472 --- [           main] org.mongodb.driver.cluster               : Cluster created with settings {hosts=[localhost:27017], mode=MULTIPLE, requiredClusterType=UNKNOWN, serverSelectionTimeout='30000 ms', maxWaitQueueSize=500}
2019-07-25 11:02:01.427  INFO 104472 --- [           main] org.mongodb.driver.cluster               : Adding discovered server localhost:27017 to client view of cluster
2019-07-25 11:02:01.429  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:12, serverValue:195}] to localhost:27017
2019-07-25 11:02:01.429  INFO 104472 --- [localhost:27017] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:13, serverValue:196}] to localhost:27017
2019-07-25 11:02:01.429  INFO 104472 --- [localhost:27017] org.mongodb.driver.cluster               : Monitor thread successfully connected to server with description ServerDescription{address=localhost:27017, type=STANDALONE, state=CONNECTED, ok=true, version=ServerVersion{versionList=[4, 0, 10]}, minWireVersion=0, maxWireVersion=7, maxDocumentSize=16777216, logicalSessionTimeoutMinutes=30, roundTripTimeNanos=263831}
2019-07-25 11:02:01.429  INFO 104472 --- [localhost:27017] org.mongodb.driver.cluster               : Discovered cluster type of STANDALONE
2019-07-25 11:02:01.430  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:14, serverValue:197}] to localhost:27017
2019-07-25 11:02:01.432  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:15, serverValue:198}] to localhost:27017
2019-07-25 11:02:01.434  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:16, serverValue:199}] to localhost:27017
2019-07-25 11:02:01.435  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:17, serverValue:200}] to localhost:27017
2019-07-25 11:02:01.437  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:18, serverValue:201}] to localhost:27017
2019-07-25 11:02:01.439  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:19, serverValue:202}] to localhost:27017
2019-07-25 11:02:01.441  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:20, serverValue:203}] to localhost:27017
2019-07-25 11:02:01.444  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:21, serverValue:204}] to localhost:27017
2019-07-25 11:02:01.445  INFO 104472 --- [imer-3-thread-1] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:22, serverValue:205}] to localhost:27017
2019-07-25 11:02:01.477  INFO 104472 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2019-07-25 11:02:01.710  INFO 104472 --- [           main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@2aa3cd93: startup date [Thu Jul 25 11:02:00 CST 2019]; root of context hierarchy
2019-07-25 11:02:01.751  INFO 104472 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/test]}" onto public java.lang.String com.example.mongodb_demo3.controller.TestController.test()
2019-07-25 11:02:01.757  INFO 104472 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2019-07-25 11:02:01.758  INFO 104472 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2019-07-25 11:02:01.777  INFO 104472 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2019-07-25 11:02:01.777  INFO 104472 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2019-07-25 11:02:01.843  INFO 104472 --- [           main] org.mongodb.driver.cluster               : Cluster created with settings {hosts=[localhost:27017], mode=SINGLE, requiredClusterType=UNKNOWN, serverSelectionTimeout='30000 ms', maxWaitQueueSize=500}
2019-07-25 11:02:01.845  INFO 104472 --- [localhost:27017] org.mongodb.driver.connection            : Opened connection [connectionId{localValue:23, serverValue:206}] to localhost:27017
2019-07-25 11:02:01.846  INFO 104472 --- [localhost:27017] org.mongodb.driver.cluster               : Monitor thread successfully connected to server with description ServerDescription{address=localhost:27017, type=STANDALONE, state=CONNECTED, ok=true, version=ServerVersion{versionList=[4, 0, 10]}, minWireVersion=0, maxWireVersion=7, maxDocumentSize=16777216, logicalSessionTimeoutMinutes=30, roundTripTimeNanos=329149}
2019-07-25 11:02:01.940  INFO 104472 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2019-07-25 11:02:01.963  INFO 104472 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8088 (http) with context path ''
2019-07-25 11:02:01.967  INFO 104472 --- [           main] c.e.m.MongodbDemo3Application            : Started MongodbDemo3Application in 2.196 seconds (JVM running for 3.054)
测试

浏览器输入 127.0.0.1:8088/test
在这里插入图片描述
观察idea运行日志 : 没有出现新建数据库连接，也就是说从连接池获取了连接。

源码

链接：https://pan.baidu.com/s/1riLsysiVFUg0A_quipDqCA
提取码：ijvq

最后

上一章最后提到过多个数据源配置有重复代码可以提取出一个抽象类，这里也是一样,自己去实现吧。

如果还想更直观的看连接池是否生效或者观察数据库连接数变化，可以通过观察数据库连接数。
下一章介绍 如何查看mongodb数据库连接数和最大连接数

无、涯
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
python mongodb连接池_mongoDB中的连接池（转载）
weixin_39989949的博客
02-09 1941
一.mongoDB中的连接池刚上手MongoDB，在做应用时，受以前使用关系型数据库的影响，会考虑数据库连接池的问题！关系型数据库中，我们做连接池无非就是事先建立好N个连接(connection)，并构建成一个连接池(connection pool)，提供去连接和归还连接等操作。而在MongoDB中，我们先来看看怎么进行操作，以insert为例：Mongo m =newMongo("localh...
超详细：springboot2 + mongodb4.0操作 + 下载源码
xyb0926的博客
07-01 677
超详细：windows下安装多个mysql本文总共安装了3个版本的mysql 本文总共安装了3个版本的mysql 分别是 MYSQL 5.5.62 MYSQL 5.6.44 MYSQL 5.7.25
Spring Boot中使用MongoDB的连接池配置的方法
08-27
本文介绍了Spring Boot中使用MongoDB的连接池配置的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Mongodb之Springboot整合
qq_43654581的博客
01-28 1230
整合
Spring Boot 与 MongoDB 整合指南
最新发布
栉风沐雪的博客
07-26 1306
MongoDB 是一种基于文档的NoSQL数据库，以其高性能、高可用性和易扩展性而著称。它使用 BSON（类似 JSON 的二进制格式）来存储数据，提供了灵活的数据模型，使得开发者可以更轻松地存储和查询复杂的数据结构。将MongoDB与Spring Boot应用程序整合可以大大增强应用程序的数据处理能力。本指南将带你一步步完成如何通过Docker或Flapdoodle嵌入式MongoDB库来设置MongoDB与Spring Boot的整合。
Springboot集成mongodb
知识的灯塔，梦想的航船
10-16 267
1、MongoDB介绍 NoSQL(NoSQL = Not Only SQL )，意即"不仅仅是SQL"。在现代的计算系统上每天网络上都会产生庞大的数据量。这些数据有很大一部分是由关系数据库管理系统(RDBMS)来处理。 1970年 E.F.Codd's提出的关系模型的论文 "A relational model of data for large shared data banks"，这使得数...
SpringBoot集成MongoDB
xiaozhi146的博客
12-26 530
环境 1.安装好MongoDB 2.maven改造成SpringBoot项目或者直接创建SpringBoot项目 集成springboot 依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.3&lt
Spring Boot集成mongoDB
qq_47716720的博客
06-24 203
SpringBoot集成mongoDB 1. 集成简介 spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongoDB（都能对mongoDB进行CRUD操作），MongoRepository操作简单，MongoTemplate操作灵活，我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足。 2.具体步骤 第一步：引入依赖 第二步：在yml中配置mong
SpringBoot2源码学习笔记 续
qq_43836796的博客
06-24 558
SpringBoot2雷神源码讲解学习笔记
SpringBoot
AyinMars的博客
04-10 4303
SpringBoot 什么是SpringBoot？ SpringBoot呢，就是一个javaweb的开发框架，和SpringMVC类似，对比其他javaweb框架的好处，官方说是简化开发，约定大于配置， you can “just run”，能迅速的开发web应用，几行代码开发一个http接口。 所有的技术框架的发展似乎都遵循了一条主线规律：从一个复杂应用场景 衍生 一种规范框架，人们只需要进行各种配置而不需要自己去实现它，这时候强大的配置功能成了优点；发展到一定程度之后，人们根据实际生产应用情况，选取其
mongodb入门到应用（三）--设计应用篇（golang类库+企业实例及优化）
duringnone的博客
03-17 952
MongoDB的设计和应用 本篇内容简介： ​ 一、MongoDB简介 1. MongoDB和MySQL 的名词映射 ​ 2. MySQL的数据迁移到MongoDB (通过CSV文件) ​ 二、MongoDB的Golang类库使用 （demo+常用功能封装，详见下载：https://download.csdn.net/download/duringnone/12245262） ​ 三、使用注意事...
springboot整合mongodb
07-23
mongodb版本号3.2,需手动开启http服务，启动时使用命令 ./mongod --httpinterface 新增 修改 删除 查询 排序 分页 可查看： https://blog.csdn.net/m0_37132783/article/details/96992439
springboot配置多个数据库(oracle,mongodb)
YYpawn的博客
07-14 2070
1.依赖 2.数据源配置 3.配置包扫描 @MapperScan("")注解配置oracle包扫描路径 @EnableMongoRepositories("")注解配置mongodb包扫描路径 没有配置mongodb扫描的时候会报错，之前把两个dao文件放在一个文件夹下了，导致mongodb的dao被当成oracle的解析了，导致启动报错，这里记录一下！ ...
springboot集成mongodb，实现文件上传下载
热门推荐
FinelyYang的专栏
06-06 1万+
一、linux上安装mongodb 1、下载安装包：https://www.mongodb.com/download-center#atlas，上传包mongodb-linux-x86_64-rhel70-3.6.5.tgz到服务器 2、创建mongodb文件夹，作为安装目标文件夹   cd /usr/local;mkdir mongodb 3、解压，移动解压缩后的文件夹下的所有文件到mo...
Springboot配置MongoDB连接池
Hot__Coffee的博客
01-04 1755
第一步：src/main/resources下新建配置文件application.properties #spring.data.mongodb是前缀，任意写 spring.data.mongodb.uri = mongodb://account:password@192.168.0.0:27017/test?maxPoolSize=1000 第二步：pom文件添加依赖 <pare...
使用Spring Data来操作MongoDB
杜雷的技术博客
10-30 1253
原文来自: http://www.open-open.com/lib/view/open1342877356974.html         MongoDB 是一个可扩展的、高性能的、开源的NoSQL数据库，跟传统的数据库不一样，MongoDB并不是将数据存储在表中，他将数据结构化为一个类似于JSON的文档中。这篇文章就是展示如何使用Java基于MongoDB和Spring Data
Springboot 2.X 整合mongo 多数据源动态切换
lin06051180的博客
08-19 2536
初始化工作 加入如下依赖 <!--mongodb依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> <version>2.2.5.RELEASE&
SpringBoot+Mongodb不同用户动态切换数据源(MongoTemplate)(二)
偏偏行
12-07 3405
目录开发(业务)环境业务处理核心代码核心配置文件Mongo抽象类默认Mongo数据源私有库数据源AOP切面打通Mongo测试多数据源接口(供参考)联系博主方式 开发(业务)环境 数据库表名(tianfu_tenant)主要字段如下 `id` bigint(64) UNSIGNED NOT NULL COMMENT '主键', `tenant_code` varchar(12) CHARAC...
springboot集成mongodb连接池配置
08-27
Spring Boot集成MongoDB连接池配置非常简单。你只需按照以下步骤进行配置： 1. 首先，确保你已经在`pom.xml`文件中添加了Spring Boot与MongoDB的依赖项。通常情况下，你可以添加以下依赖项： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> ``` 2. 在`application.properties`文件中添加MongoDB的连接配置。你可以根据你的MongoDB实例的具体情况进行配置。例如： ```properties spring.data.mongodb.uri=mongodb://localhost:27017/mydatabase ``` 其中，`mongodb://localhost:27017`是你的MongoDB实例的连接URL，`mydatabase`是你要连接的数据库名称。 3. （可选）如果你想自定义连接池的配置，例如设置最大连接数、最小空闲连接数等，可以在`application.properties`文件中添加更多的配置项。例如： ```properties spring.data.mongodb.connection-pool.max-size=20 spring.data.mongodb.connection-pool.min-size=5 ``` 这样，你就可以设置MongoDB连接池的最大连接数为20，最小空闲连接数为5。 4. 在你的应用程序中，使用`@Autowired`注解将`MongoTemplate`注入到你的服务类中。`MongoTemplate`提供了许多用于操作MongoDB的方法。例如： ```java @Autowired private MongoTemplate mongoTemplate; ``` 使用`mongoTemplate`对象，你可以执行MongoDB的各种操作，如插入数据、查询数据等。 总之，通过以上步骤，你就成功地将MongoDB与Spring Boot集成，并进行了连接池的配置。这样，你就可以轻松地在你的应用程序中使用MongoDB进行数据存储和查询。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值