Java 如何在Spring引导中初始化MongoClient一次并使用其方法？

您好，在Spring Boot中成功连接后，我正在尝试导出

MongoClient

，并尝试在其他文件中使用它，这样我就不必每次需要在MongoDB数据库中进行更改时都调用连接

连接非常简单，但目标是将应用程序连接到我的数据库一次，然后通过在任何Java文件中导入它，在任何地方使用它

---

谢谢

这里有两种方法可以创建

MongoClient

的实例，在Spring引导应用程序中配置和使用它

（1）使用基于Java的元数据注册Mongo实例：

@Configuration
public class AppConfig {
    public @Bean MongoClient mongoClient() {
        return MongoClients.create();
    }
}

@Configuration
public class MongoClientConfiguration extends AbstractMongoClientConfiguration {

    @Override
    public MongoClient mongoClient() {
        return MongoClients.create();
    }

    @Override
    protected String getDatabaseName() {
        return "newDB";
    }
}

来自

CommandLineRunner

的

run

方法的用法（所有示例都以类似方式运行）：

注意：您可以设置可以连接到的数据库名称（

newDB

）。此配置用于使用Spring数据MongoDB API处理MongoDB数据库：

MongoOperations

（及其实现

MongoTemplate

）和

MongoRepository

@Autowired 
MongoOperations mongoOps;

// Connects to "newDB" database, and gets a count of all documents in the "test2" collection.
// Uses the MongoOperations interface methods.
private void getCollectionSize() {
    Query query = new Query();
    long n = mongoOps.count(query, "test2");
    System.out.println("Collection size: " + n);
}

（3）使用AbstractMongoClient配置类进行配置，并与MongoRepository一起使用

使用相同的配置

MongoClientConfiguration

类（见主题2中的上文），但另外使用

@enablemongorepositions

进行注释。在本例中，我们将使用

MongoRepository

接口方法来获取作为Java对象的收集数据

存储库：

@Repository
public interface MyRepository extends MongoRepository<Test3, String> {

}

获取文档并作为Java对象打印的以下方法：

@Autowired 
MyRepository repository;

// Method to get all the `test3` collection documents as Java objects.
private void getCollectionObjects() {
    List<Test3> list = repository.findAll();
    list.forEach(System.out::println);
}

@Autowired
我的知识库；
//方法将所有“test3”集合文档作为Java对象获取。
私有void getCollectionObjects（）{
List=repository.findAll（）；
list.forEach（System.out:：println）；
}

**Pom更改：**
org.springframework.boot
spring启动程序数据mongodb
org.springframework.boot
spring引导启动器数据jpa
**主要用途：**
@SpringBootApplication（排除={
MongoutoConfiguration.class，
MongoDataAutoConfiguration.class
})
公共类应用程序{
公共静态void main（字符串[]args）{
SpringApplication.run（Application.class，args）；
}
}
**MongoConfig类别：**
@配置
@EnableMongorPositories（{“com.repository.mongo”}）
公共类MongoConfig{
私人物业；
公共MongoConfig（MongoProperties属性）{
这个。属性=属性；
}
@豆子
公共MongoClient mongo（）引发IOException{
log.info（“创建mongo客户端.套接字超时：{}，请求超时：{}”，
properties.getSocketTimeout（），properties.getConnectTimeout（）
);
MongoCredential credential=MongoCredential.createCredential（properties.getUsername（）、properties.getDatabase（）、readPassword（properties.getPasswordFilePath（））.ToCharray（））；
MongoClientSettings=MongoClientSettings.builder（）
.凭证（凭证）
.applyToSocketSettings（builder->builder.readTimeout（properties.getSocketTimeout（）.intValue（），TimeUnit.毫秒）。connectTimeout（properties.getConnectTimeout（）.intValue（），TimeUnit.毫秒））
.applyToClusterSettings（生成器->
builder.hosts（Arrays.asList（新服务器地址（properties.getHost（），properties.getPort（）））。requiredReplicaSetName（properties.getReplicaSet（））
.build（）；
返回MongoClient.create（设置）；
}
@豆子
公共MongoDatabase数据库（）引发IOException{
//允许对POJO进行（反）序列化
CodeRegistry extendedRegistry=fromRegistries(
MongoClientSettings.getDefaultCodecRegistry（），
fromProviders（PojoCodecProvider.builder（）.automatic（true.build（））
);
返回mongo（）.getDatabase（properties.getDatabase（））.WithCodeRegistry（extendedRegistry）；
}
@豆子
公共MongoTemplate MongoTemplate（）引发IOException{
返回新的MongoTemplate（mongo（），properties.getDatabase（））；
}
@发情前期
public void destroy（）引发IOException{
mongo（）.close（）；
}
私有字符串读取密码（字符串路径）引发IOException{
//返回Files.readString（path.get（path））；
返回“****”；
}
}

Hello当您使用

MongoDatabase=client.getDatabase（“test”）时，
client
变量来自哪里？这位于
getDocument（）
方法的第二个代码块中。您如何在公共静态方法中使用Autowired
MongoClient
？请尝试搜索：“spring boot如何在公共静态方法中使用Autowired（MongoClient）”。您将找到许多答案-取决于您的需要。@Alience您需要
Test3
POJO类、
MyRepository
接口、
MongoClient配置
类。然后，实现
CommandLineRunner
接口（可以从Spring Boot应用程序的类中执行），并从实现的
run
方法调用
getCollectionObjects（）
。注意：这是针对（3）示例的。
public class Test3 {

    private String id;
    private String fld;

    public Test3() {    
    }

    // Getter and setter methods for the two fields
    // Override 'toString' method
    ...
}

@Autowired 
MyRepository repository;

// Method to get all the `test3` collection documents as Java objects.
private void getCollectionObjects() {
    List<Test3> list = repository.findAll();
    list.forEach(System.out::println);
}

    **Pom Changes :**
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-mongodb</artifactId>
            </dependency>
    
            <!-- jpa, crud repository -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
    
    **Main Application :**
    
    @SpringBootApplication(exclude = {
            MongoAutoConfiguration.class,
            MongoDataAutoConfiguration.class
    })
    public class Application {
    public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }
    
**MongoConfig Class :**

@Configuration
@EnableMongoRepositories({"com.repository.mongo"})
public class MongoConfig {

    private final MongoProperties properties;

    public MongoConfig(MongoProperties properties) {
        this.properties = properties;
    }

    @Bean
    public MongoClient mongo() throws IOException {
        log.info("Creating mongo client. Socket timeout: {}, request timeout: {}",
                properties.getSocketTimeout(), properties.getConnectTimeout()
        );
        MongoCredential credential = MongoCredential.createCredential(properties.getUsername(), properties.getDatabase(), readPassword(properties.getPasswordFilePath()).toCharArray());

        MongoClientSettings settings = MongoClientSettings.builder()
                .credential(credential)
                .applyToSocketSettings(builder -> builder.readTimeout(properties.getSocketTimeout().intValue(), TimeUnit.MILLISECONDS).connectTimeout(properties.getConnectTimeout().intValue(), TimeUnit.MILLISECONDS))
                .applyToClusterSettings(builder ->
                        builder.hosts(Arrays.asList(new ServerAddress(properties.getHost(), properties.getPort()))).requiredReplicaSetName(properties.getReplicaSet()))
                .build();

        return MongoClients.create(settings);
    }


    @Bean
    public MongoDatabase database() throws IOException {
        // Allow POJOs to be (de)serialized
        CodecRegistry extendedRegistry = fromRegistries(
                MongoClientSettings.getDefaultCodecRegistry(),
                fromProviders(PojoCodecProvider.builder().automatic(true).build())
        );
        return mongo().getDatabase(properties.getDatabase()).withCodecRegistry(extendedRegistry);
    }

    @Bean
    public MongoTemplate mongoTemplate() throws IOException {
        return new MongoTemplate(mongo(), properties.getDatabase());
    }

    @PreDestroy
    public void destroy() throws IOException {
        mongo().close();
    }

    private String readPassword(String path) throws IOException {
       // return Files.readString(Paths.get(path));
        return "****";
    }

}