我有两个数据库：

• test：包含一个名为 people 的集合，其中存放表示 Person 和 Author 类的文档
• test2：包含一个名为 somethingElse 的集合，其中存放表示 SomethingElse 类的文档

我的问题是，当使用自动装配的 MongoTemplate 时，我只能与位于 test 中的集合交互。保存一个新的 SomethingElse 实体会创建该集合并把它插入到 test 数据库中。如何确保 SomethingElse 类的文档只在test2数据库中进行获取、映射和保存？

下面是生成测试数据、查询数据以及它们映射到的类的代码。

MongoConfig.java

package com.example.demo;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import lombok.Getter;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.mongodb.config.AbstractMongoClientConfiguration;

@SpringBootApplication
public class MongoConfig extends AbstractMongoClientConfiguration {

    @Getter
    MongoClient client;
    @Override
    protected String getDatabaseName() {
        return "test";
    }

    @Override
    public MongoClient mongoClient() {

        MongoClient client = MongoClients.create("mongodb://127.0.0.1:27017/test");

        this.client = client;

        return client;
    }

}

TestData.java

package com.example.demo;

import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

@Component
public class TestData {

    @Autowired
    MongoConfig config;

    private static String FIRST_DB = "test";
    private static String SECOND_DB = "test2";
    private void insertFirstDatabase(){
        MongoDatabase database = config.getClient().getDatabase(FIRST_DB);

        MongoCollection collection = database.getCollection("people");

        Document person = new Document().append("_id",UUID.randomUUID().toString())
                .append("name","Larry").append("email","[email protected]").append("_class","person");

        Document author = new Document().append("_id",UUID.randomUUID().toString())
                .append("name","Frank").append("email","[email protected]").append("articleCount",1).append("active",true)
                .append("_class","author");

        collection.insertOne(person);
        collection.insertOne(author);

    }

    private void insertSecondDatabase(){
        Document somethingElseDocument = new Document().append("_id",UUID.randomUUID().toString())
                .append("name","example document").append("_class","somethingElse");
        config.getClient().getDatabase(SECOND_DB).getCollection("somethingElse").insertOne(somethingElseDocument);
    }

    public void insert(){
        insertFirstDatabase();
        insertSecondDatabase();
    }

    public void cleanUp() {
        MongoDatabase firstDatabase = config.getClient().getDatabase(FIRST_DB);
        firstDatabase.drop();
        MongoDatabase secondDatabase = config.getClient().getDatabase(SECOND_DB);
        secondDatabase.drop();

    }
}

Test.java

package com.example.demo;

import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.UUID;

@Component
public class Test {

    @Autowired
    TestData testData;
    @Autowired
    MongoTemplate mongoTemplate;

    @PostConstruct
    public void startTest(){
        testData.insert();

        List<Person> allPeople = mongoTemplate.findAll(Person.class);
        for (Person person : allPeople) {
            System.out.println(person.toString());
        }
        List<SomethingElse> otherEntities = mongoTemplate.findAll(SomethingElse.class);
        for (SomethingElse entity : otherEntities) {
            System.out.println(entity.toString());
        }

        SomethingElse newEntity = new SomethingElse(UUID.randomUUID().toString(),"wrong database");
        mongoTemplate.insert(newEntity);

        //Breakpoint here to view DB
        testData.cleanUp();

    }
}

Person.java

package com.example.demo;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.TypeAlias;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "people")
@TypeAlias("person")
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
public class Person {
    @Id
    private String id;

    private String name;

    private String email;

    @Override
    public String toString(){
        return this.getName() + " (PERSON)";
    }
}

Author.java

package com.example.demo;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.springframework.data.annotation.PersistenceCreator;
import org.springframework.data.annotation.TypeAlias;

@TypeAlias("author")
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
class Author extends Person{
    private Integer articleCount;

    private Boolean active;

    @PersistenceCreator
    public Author(String id, String name, String email, int articleCount, boolean active) {
        super(id,name,email);
        this.articleCount = articleCount;
        this.active = active;
    }

    @Override
    public String toString(){
        return this.getName() + " (AUTHOR)";
    }
}

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 https://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>4.0.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>MongoDb Multiple DBs</name>
    <description>Demo project for Spring Boot</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <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>

        <!-- Source: https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-mongodb -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <version>4.1.0-M2</version>
            <scope>compile</scope>
        </dependency>

        <!-- Source: https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.42</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>

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

</project>

解决方案

为了解决多数据库的问题，你需要定义两个独立的MongoTemplate bean，并指示你的仓库（或手动调用）使用哪个。

@Configuration
public class MongoConfig {

    @Primary
    @Bean(name = "testMongoTemplate")
    public MongoTemplate testMongoTemplate() {
        return new MongoTemplate(MongoClients.create("mongodb://127.0.0.1:27017"), "test");
    }

    @Bean(name = "test2MongoTemplate")
    public MongoTemplate test2MongoTemplate() {
        return new MongoTemplate(MongoClients.create("mongodb://127.0.0.1:27017"), "test2");
    }
}