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

最新推荐文章于 2024-08-23 23:36:39 发布
最新推荐文章于 2024-08-23 23:36:39 发布
阅读量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数据库连接数和最大连接数

无、涯
关注
专栏目录
Springboot配置MongoDB连接池源代码
01-04
在本文中，我们将深入探讨如何在Spring Boot应用中配置MongoDB连接池，同时也会涉及到Spring Boot与MyBatis以及MySQL数据库的整合。Spring Boot以其简洁的配置和强大的自动化配置功能，已经成为Java开发者构建微服务...
mongodb 连接池配置
Men-DD
05-23 5150
mongodb 连接池配置 spring.data.mongodb.address=127.0.0.1:27017 # 为集群设置所需的副本集名称 # spring.data.mongodb.replica-set=rs0 spring.data.mongodb.database=test spring.data.mongodb.username spring.data.mongodb.passw...
Spring Boot中使用MongoDB的连接池配置
一个有情怀的程序猿博客
08-08 2030
因为今天开发遇到了性能问题，可能与MongoDB的连接有关，所以稍稍深入看了一下，正好搜到原来有人写过这篇相关的内容，所以转载过来。回头有时间可以写个扩展到SpringForAll里，主体思路还是一样的。感谢这位美女程序媛的文章！ 说明 Spring Boot中通过依赖spring-boot-starter-data-mongodb，来实现spring-data-mongodb的自动配置。但是默认情况下，Spring Boot 中，并没有像使用MySQL或者Redis一样，提供了连接池配置的功能...
在SpringBoot中优雅整合MongoDB——让你的数据存储更灵活
最新发布
Takumilove的博客
08-23 1500
通过这篇博客，你已经了解了如何在SpringBoot中整合MongoDB，并通过两种不同的方式（MongoRepository和MongoTemplate）进行数据操作。对于简单的CRUD操作，MongoRepository可以让你的代码更加简洁；而MongoTemplate则在你需要更复杂的查询或更新操作时提供了更大的灵活性。
springboot+mongoDB整合demo
萝卜坑
07-17 966
springboot+mongoDB整合 1、安装mongoDB 去MongoDB官网下载一个合适的安装包，下载地址： https://www.mongodb.com/download-center?jmp=nav#community 完成下载后进行安装，具体安装教程不展开，可参考如下博文： https://blog.csdn.net/qq_42908549/article/details/814...
SpringBoot中使用MongoDB的连接池配置
热门推荐
pengjunlee的博客
11-19 9万+
在SpringBoot中，我们可以通过引入 spring-boot-starter-data-mongodb 依赖来实现spring-data-mongodb 的自动配置。但是，默认情况下，该依赖并没有像使用MySQL或者Redis那样为我们提供连接池配置的功能。因此，我们需要自行重写 MongoDbFactory，实现MongoDB客户端连接的参数配置扩展。需要说明的是，MongoDB的客户端本...
SpringBoot+Mongodb不同用户动态切换数据源(MongoTemplate)(二)
偏偏行
12-07 3412
目录开发(业务)环境业务处理核心代码核心配置文件Mongo抽象类默认Mongo数据源私有库数据源AOP切面打通Mongo测试多数据源接口(供参考)联系博主方式 开发(业务)环境 数据库表名(tianfu_tenant)主要字段如下 `id` bigint(64) UNSIGNED NOT NULL COMMENT '主键', `tenant_code` varchar(12) CHARAC...
SpringBoot整合MongoDB实现对数据库的CRUD小demo.zip
04-25
MongoDB中的一个文档相当于关系型数据库中的一行，多个文档构成了集合（collection），集合类似于关系型数据库中的表。 （3）文档 （行数据）： 文档则相当于传统关系型数据的行数据，对于集合中的介绍，我们基本...
springboot-mongodb整合源码
04-26
首先，`springboot-mongodb`这个标题暗示我们要讨论的是一个关于Spring Boot集成MongoDB的示例或项目。在这个项目中，开发者可能已经实现了将MongoDB数据库连接到Spring Boot应用程序中，以便进行数据操作。 `pom....
Springboot开发-将springboot与mongodb数据库相结合.zip
05-09
在Spring Boot的配置文件`application.properties`或`application.yml`中，我们设定MongoDB的连接信息，如主机地址、端口、数据库名称等。例如： ```properties spring.data.mongodb.uri=mongodb://localhost:27017...
springboot +mongodb多数据源
01-18
spring.data.primary.mongodb.uri= mongodb://192.168.10.136:27017/eqt #spring.data.secondary.mongodb.uri= mongodb:...切换mongodb数据源 可以同一台机器，或者不同机器 实现动态插入 。 该例是根据companyId来处理
springboot整合MongDB实现增删查改
letterss的博客
01-30 186
springboot整合MongDB实现增删查改
Springboot 2.X 整合mongo 多数据源动态切换
lin06051180的博客
08-19 2545
初始化工作 加入如下依赖 <!--mongodb依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> <version>2.2.5.RELEASE&
SpringBoot 集成 Spring Data Mongodb 操作 MongoDB 详解
baidu_37366055的博客
03-22 4505
SpringBoot 集成 Spring Data Mongodb 操作 MongoDB 详解
SpringBoot中配置多个MongoDB数据源
qq_41936224的博客
10-29 1764
下面是SpringBoot中实现多个数据源的步骤： 1、application.properties文件下的配置信息如下： #数据源1 spring.data.mongodb.manag.database=management spring.data.mongodb.manag.host=192.168.11.234 spring.data.mongodb.manag.port=27017 spring.data.mongodb.manag.password=lisi-123321 spring.data
Spring Data MongoDB 使用
Gefangenes的博客
07-18 1496
在 Spring Data MongoDB 中，可以使用自定义的查询语句来满足特定的查询需求。
c++使用SQL Server相关配置及密码修改
weixin_45482816的博客
01-18 392
一．连接配置 1.打开SQL Sever 配置管理器 2.SQL Sever 配置管理器 -> SQL Server服务 -> 启动SQL Server (MSSQLSERVER)服务 3.SQL Server 网络配置—>MSSQLSERVER的协议，启动TCP/IP 二．账号密码更改，数据库创建 1.打开SQL Server Management Studio 2.默认先用Windows身份验证 3.右击属性，勾选 4.右击“数据库”创建自己的数据库并命名（数据库登录用的数
springboot集成mongodb连接池配置
08-27
Spring Boot集成MongoDB连接池配置非常简单。你只需按照以下步骤进行配置： 1. 首先，确保你已经在`pom.xml`文件中添加了Spring Boot与MongoDB的依赖项。通常情况下，你可以添加以下依赖项： ```xml <groupId>...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值