MongoDB第一个简单的案例（Java连接MongoDB，高并发模拟，生产级Java连接MongoDB公共架构）

本文链接：https://blog.youkuaiyun.com/WBXNBNBNB/article/details/144067194

1.用Java连接MongoDB
开发环境：MongoDB8.0 Jdk1.8 IDEA2022.3.3
(1).简易连接MongoDB
新建maven项目
名字自定义这里为MongoDBDemo

并加入Pom依赖如下所示

 <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-sync</artifactId>
            <version>4.10.2</version>
        </dependency>
    </dependencies>

编写JAVA连接MongoDB服务的测试代码(记得先打开MongoDB服务)
编写HelloWorld类

package org.example;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
public class HelloWorld {
    public static void main(String[] args) {
        try {
            // 连接到MongoDB服务，try为Java出错捕捉机制
            MongoClient mongoClient = MongoClients.create("mongodb://localhost:27017");
            // 连接到本地数据库，端口号为27017
            MongoDatabase mongoDatabase = mongoClient.getDatabase("goodsdb");
            // 连接到 goodsdb 数据库实例，若没有goodsdb 数据库实例，系统将自动建立新数据库
            MongoCollection<Document> collection = mongoDatabase.getCollection("book");
            // 新增一条数据
            collection.insertOne(new Document().append("name", "zhangsan"));
            System.out.println("Connect to database successfully"); // 数据库连接成功提示
        } catch (Exception e) {
            // 连接出错提示
            System.err.println(e.getClass().getName() + ":" + e.getMessage());
        }
    }
}

运行结果：

2. 生产级Java连接MongoDB公共架构
2.1. 公共配置文件的建立
在src/main/resources下创建mongo-config.properties

配置文件常用内容如下：

connectionsPerHost: 10 # 每个主机的最大连接数
connectTimeout: 10000 # 连接超时时间，单位为毫秒
cursorFinalizerEnabled: true # 是否启用游标终结器
maxWaitTime: 120000 # 当连接池中没有可用连接时，客户端等待的最长时间，单位为毫秒
threadsAllowedToBlockForConnectionMultiplier: 5 # 在获取连接时允许阻塞的线程数乘数
readSecondary: false # 是否从副本集的从节点读取数据
socketTimeout: 0 # 套接字超时时间，单位为毫秒，0 表示没有超时限制
socketKeepAlive: false # 是否保持套接字连接
write: 0 # 写操作的模式，0 表示默认模式
writeTimeout: 0 # 写操作的超时时间，单位为毫秒，0 表示没有超时限制
journal: false # 是否启用日记功能
host: 127.0.0.1 # MongoDB 服务器的主机地址
port: 27017 # MongoDB 服务器的主机端口

2.2. 初始化MongoDB连接Java工具类
在IDEA上实现下述代码内容
编写MongoDBUtil类

package org.example;

import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;


import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

/**
 * MongoDB 客户端 Java 版本开发包支持类，自动生成。
 * 如果遇到编译错误，确保已经正确安装了 MongoDB 客户端开发包
 * 建立 MongoDB 客户端配置类
 */
public class MongoDBUtil {

    /**
     * 初始化 MongoDB 客户端
     * @return MongoClient
     * @throws IOException
     */
    public static MongoClient initMongo() throws IOException {
        // 加载 mongo 配置文件
        InputStream inputStream = MongoDBUtil.class.getClassLoader().getResourceAsStream("/mongo-config.properties");
        Properties properties = new Properties();
        properties.load(inputStream);

        // 读取配置参数
        int writeConcernW = Integer.valueOf(properties.getProperty("write"));
        int writeTimeout = Integer.valueOf(properties.getProperty("writeTimeout"));
        boolean journal = Boolean.valueOf(properties.getProperty("journal"));
        int connectTimeout = Integer.valueOf(properties.getProperty("connectTimeout"));
        int socketTimeout = Integer.valueOf(properties.getProperty("socketTimeout"));
        boolean readSecondary = Boolean.valueOf(properties.getProperty("readSecondary"));
        String hostConfString = properties.getProperty("hostConfString");

        // 构建 MongoClientSettings
        MongoClientSettings.Builder builder = MongoClientSettings.builder()
                .applyConnectionString(new ConnectionString("mongodb://" + hostConfString))
                .applyToClusterSettings(settings -> settings
                        .serverSelectionTimeout(connectTimeout, TimeUnit.MILLISECONDS))
                .applyToSocketSettings(settings -> settings
                        .connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
                        .readTimeout(socketTimeout, TimeUnit.MILLISECONDS));

        if (readSecondary) {
            builder.readPreference(com.mongodb.ReadPreference.secondaryPreferred());
        }

        // 创建 WriteConcern 对象
        builder.writeConcern(com.mongodb.WriteConcern.MAJORITY.withJournal(journal).withWTimeout(writeTimeout, TimeUnit.MILLISECONDS));

        return MongoClients.create(builder.build()); // 创建 MongoClient
    }
}

3. 高并发模拟
在IDEA上实现下面内容

HighConcurrencyTest类

package org.example;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

public class HighConcurrencyTest {

    private static MongoClient client;

    public static void main(String[] args) {
        try {
            // 初始化 MongoDB 客户端
            client = MongoClients.create("mongodb://127.0.0.1:27017");

            // 获取数据库和集合
            MongoDatabase database = client.getDatabase("test");
            MongoCollection<Document> collection = database.getCollection("test");

            // 创建固定线程池，线程池大小为50
            ExecutorService executor = Executors.newFixedThreadPool(50);

            // 创建三个MongoThread实例
            MongoThread t1 = new MongoThread(collection);
            MongoThread t2 = new MongoThread(collection);
            MongoThread t3 = new MongoThread(collection);

            // 向线程池提交任务
            executor.execute(t1);
            executor.execute(t2);
            executor.execute(t3);

            // 关闭线程池并等待任务完成
            executor.shutdown();
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow(); // 如果超时则强制关闭
            }

            // 关闭 MongoDB 客户端
            client.close();

        } catch (Exception e) {
            e.printStackTrace();
            // 确保在出现异常时客户端被关闭
            if (client != null) {
                client.close();
            }
        }
    }
}

MongoThread类

package org.example;

import org.bson.Document;
import com.mongodb.client.MongoCollection;

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

public class MongoThread implements Runnable {
    private MongoCollection<Document> collection;

    public MongoThread(MongoCollection<Document> collection) {
        this.collection = collection;
    }

    /**
     * 初始化文档列表
     * @return List<Document>
     */
    private List<Document> init() {
        List<Document> list = new ArrayList<>(100000);
        for (int i = 0; i < 100000; i++) {
            Document doc = new Document("test", i);
            list.add(doc);
        }
        return list;
    }

    /**
     * 执行插入操作
     */
    @Override
    public void run() {
        try {
            collection.insertMany(this.init());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

编写完成后执行HighConcurrencyTest类
执行插入操作后，在MongoDBCompass中查询记录，如下所示则成功

以上则为一个简单的案例包括Java连接MongoDB服务;生产级Java连接MongoDB公共架构;高并发模拟！！！