Multiple Connections in a Single Application单个应用程序中的多个连接

Create a New Project创建新项目

Create a new directory for your project and initialize a new Node.js project:为您的项目创建一个新目录并初始化一个新的Node.js项目：

mkdir mongodb-multiple-connections
cd mongodb-multiple-connections
npm init -y

Install Dependencies安装依赖项

Install the required dependencies for this tutorial:安装本教程所需的依赖项：

npm install express mongoose

This tutorial uses Express.js for the web framework and Mongoose for MongoDB object modeling.本教程使用Expressjs作为web框架，使用Mongoose进行MongoDB对象建模。

Set Up Environment Variables设置环境变量

Create a .env file in your project root directory to store your MongoDB connection strings:在项目根目录中创建一个.env文件来存储MongoDB连接字符串：

touch .env

Add the following environment variables to your .env file:将以下环境变量添加到.env文件中：

:orphan:

PRIMARY_CONN_STR=<your-primary-connection-string>
SECONDARY_CONN_STR=<your-secondary-connection-string>

Replace the placeholder values with your actual MongoDB Atlas connection strings. To learn how to find your MongoDB Atlas connection string, see the Connect to Your Cluster tutorial.将占位符值替换为实际的MongoDB Atlas连接字符串。要了解如何查找MongoDB Atlas连接字符串，请参阅连接到集群教程。

Install the dotenv package to load your environment variables:安装dotenv包以加载环境变量：

npm install dotenv

Create the Primary Connection File创建主连接文件

In a new file named db.primary.js, define a connection method to use in your main application file, index.js. This method configures the MongoDB connection and handles events. Copy and paste the following code into the db.primary.js file:在名为db.primary.js的新文件中，定义一个在主应用程序文件index.js中使用的连接方法。此方法配置MongoDB连接并处理事件。将以下代码复制并粘贴到db.primary.js文件中：

require('dotenv').config();
const mongoose = require("mongoose");

module.exports = async (uri, options = {}) => {
  // By default, Mongoose skips properties not defined in the schema (strictQuery). 默认情况下，Mongoose跳过模式中未定义的属性（strictQuery）。
  // You can adjust it based on your configuration.您可以根据配置进行调整。
  mongoose.set('strictQuery', true);

  // Connect to MongoDB连接到MongoDB
  try {
    await mongoose.connect(uri, options);
    console.info("MongoDB primary connection initiated");
  } catch (err) {
    console.error("MongoDB primary connection failed, " + err);
  }

  // Event handling事件处理
  mongoose.connection.once('open', () => console.info("MongoDB primary connection opened!"));
  mongoose.connection.on('connected', () => console.info("MongoDB primary connection succeeded!"));
  mongoose.connection.on('error', (err) => {
    console.error("MongoDB primary connection failed, " + err);
    mongoose.disconnect();
  });
  mongoose.connection.on('disconnected', () => console.info("MongoDB primary connection disconnected!"));

  // Graceful exit优雅退出
  process.on('SIGINT', async () => {
    try {
      await mongoose.connection.close();
      console.info("Mongoose primary connection disconnected through app termination!");
      process.exit(0);
    } catch (err) {
      console.error("Error during graceful shutdown:", err);
      process.exit(1);
    }
  });
}

Create the Product Schema创建产品架构

Create schemas for performing operations in your application. Write the schema in a separate file named product.schema.js and export it, as shown in the following code:创建用于在应用程序中执行操作的模式。将模式写入名为product.schema.js的单独文件中并导出，如下代码所示：

const mongoose = require("mongoose");

module.exports = (options = {}) => {
  // Schema for Product产品架构
  return new mongoose.Schema(
    {
      store: {
        _id: mongoose.Types.ObjectId, // Reference-id to the store collection商店集合的引用id
        name: String
        },
        name: String,
        price: Number,
        category: String,
        description: String
        // add required properties添加所需属性
  }, 
      options
  );
}

Use the Primary Connection使用主连接

Import the db.primary.js file in your main index.js file and use the method defined there to establish the primary MongoDB connection. You can also pass an optional connection options object if needed.将db.primary.js文件导入到主index.js文件中，并使用其中定义的方法建立主MongoDB连接。如果需要，您还可以传递可选的连接选项对象。

Then, import the product.schema.js file to access the product schema. This lets you create a model and perform operations related to products in your application. Copy and paste the following code into your index.js file to set up the primary connection and perform operations on sample product data:然后，导入product.schema.js文件以访问产品模式。这使您可以创建模型并执行与应用程序中的产品相关的操作。将以下代码复制并粘贴到index.js文件中，以设置主连接并对示例产品数据执行操作：

// Load environment variables加载环境变量
require('dotenv').config();
const mongoose = require("mongoose");

// Async function to establish the primary MongoDB connection异步函数用于建立主MongoDB连接
async function establishPrimaryConnection() {
    try {
        await require("./db.primary.js")(process.env.PRIMARY_CONN_STR, {
            // (optional) connection options（可选）连接选项
        });
    } catch (error) {
        console.error('Failed to establish primary connection:', error);
        process.exit(1);
    }
}

// Initialize connection初始化连接
establishPrimaryConnection();

// Import Product Schema导入产品架构
const productSchema = require("./product.schema.js")({
    collection: "products",
    // Pass configuration options if needed如果需要，传递配置选项
});

// Create Model创建模型
const ProductModel = mongoose.model("Product", productSchema);

// Sample products data样品产品数据
const sampleProducts = [
    {
        name: "Laptop Pro",
        price: 1299.99,
        category: "Electronics",
        description: "High-performance laptop for professionals"
    },
    {
        name: "Wireless Headphones",
        price: 199.99,
        category: "Electronics",
        description: "Premium noise-cancelling headphones"
    },
    {
        name: "Coffee Maker",
        price: 89.99,
        category: "Kitchen",
        description: "Automatic drip coffee maker"
    }
];

// Wait for connection to be ready before executing operations执行操作前等待连接就绪
mongoose.connection.once('open', async () => {
    console.log('Primary database connected, executing operations...');

    try {
        // Check if products already exist检查产品是否已存在
        const existingCount = await ProductModel.countDocuments();
        console.log(`Existing products in primary DB: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into primary database...');
            await ProductModel.insertMany(sampleProducts);
            console.log('Sample products inserted into primary database!');
        }

        // Find and display a product查找并显示产品
        let product = await ProductModel.findOne();
        console.log('Product found in primary DB:', product);
        
        // Display all products显示所有产品
        const allProducts = await ProductModel.find();
        console.log(`Total products in primary DB: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with primary database operations:', error);
    }
});

Primary database connected, executing operations...
MongoDB primary connection initiated
Existing products in primary DB: 3
Product found in primary DB: {
_id: new ObjectId('...'),
name: 'Laptop Pro',
__v: 0
}
Total products in primary DB: 3

Create the Secondary Connection File创建辅助连接文件

Create a connection code in a db.secondary.js file by using the mongoose.createConnection() method. 使用mongoose.createConnection()方法在db.secondary.js文件中创建连接代码。This method allows you to establish separate connection pools each tailored to a specific use case or data access pattern, unlike the mongoose.connect() method that you used previously for the primary MongoDB connection:此方法允许您建立单独的连接池，每个连接池都根据特定的用例或数据访问模式进行定制，这与您之前用于主MongoDB连接的mongoose.connect()方法不同：

const mongoose = require("mongoose");

module.exports = (uri, options = {}) => {
    // Connect to MongoDB连接到MongoDB
    const db = mongoose.createConnection(uri, options);
    
    // By default, Mongoose skips properties not defined in the schema (strictQuery). 默认情况下，Mongoose跳过模式中未定义的属性（strictQuery）。
    // Adjust it based on your configuration.根据您的配置进行调整。
    db.set('strictQuery', true);
    
    // Event handling事件处理
    db.once('open', () => console.info("MongoDB secondary connection opened!"));
    db.on('connected', () => console.info(`MongoDB secondary connection succeeded!`));
    db.on('error', (err) => {
        console.error(`MongoDB secondary connection failed, ` + err);
        db.close();
    });
    db.on('disconnected', () => console.info(`MongoDB secondary connection disconnected!`));

    // Graceful exit
    process.on('SIGINT', async () => {
        try {
            await db.close();
            console.info(`Mongoose secondary connection disconnected through app termination!`);
            process.exit(0);
        } catch (err) {
            console.error("Error during graceful shutdown:", err);
            process.exit(1);
        }
    });

    // Export db object导出数据库对象
    return db;
}

Use the Secondary Connection使用辅助连接

Import the db.secondary.js file in your main index.js file, create the connection object with a variable named db, and use the method defined there to establish the secondary MongoDB connection. 在主index.js文件中导入db.secondary.js文件，使用名为db的变量创建连接对象，并使用其中定义的方法建立辅助MongoDB连接。You can also pass an optional connection options object if needed. Add the following code to the end of the index.js file:如果需要，您还可以传递可选的连接选项对象。将以下代码添加到index.js文件的末尾：

// Load environment variables加载环境变量
require('dotenv').config();

// Establish the secondary MongoDB connection建立二级MongoDB连接
const db = require("./db.secondary.js")(process.env.SECONDARY_CONN_STR, {
    // (optional) connection options（可选）连接选项
});

// Import Product Schema导入产品架构
const SecondaryProductSchema = require("./product.schema.js")({
    collection: "products",
    // Pass configuration options if needed如果需要，传递配置选项
});

// Create Model using the secondary connection使用辅助连接创建模型
const SecondaryProductModel = db.model("Product", SecondaryProductSchema);

// Sample products data for secondary database辅助数据库的示例产品数据
const SecondarySampleProducts = [
    {
        name: "Smart Watch",
        price: 199.99,
        category: "Electronics",
        description: "Advanced fitness tracking smartwatch"
    },
    {
        name: "Bluetooth Speaker",
        price: 79.99,
        category: "Electronics", 
        description: "Portable wireless speaker with premium sound"
    },
    {
        name: "Desk Lamp",
        price: 49.99,
        category: "Home",
        description: "LED desk lamp with adjustable brightness"
    }
];

// Wait for secondary connection to be ready before executing operations在执行操作之前，等待辅助连接就绪
db.once('open', async () => {
    console.log('Secondary database connected, executing operations...');

    try {
        // Check if products already exist检查产品是否已存在
        const existingCount = await SecondaryProductModel.countDocuments();
        console.log(`Existing products in secondary DB: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into secondary database...');
            await SecondaryProductModel.insertMany(SecondarySampleProducts);
            console.log('Sample products inserted into secondary database!');
        }

        // Find and display a product查找并显示产品
        let product = await SecondaryProductModel.findOne();
        console.log('Product found in secondary DB:', product);
        
        // Display all products显示所有产品
        const allProducts = await SecondaryProductModel.find();
        console.log(`Total products in secondary DB: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with secondary database operations:', error);
    }
});

Primary database connected, executing operations...
MongoDB primary connection initiated
MongoDB secondary connection succeeded!
MongoDB secondary connection opened!
Secondary database connected, executing operations...
Existing products in primary DB: 3
Existing products in secondary DB: 6
Product found in primary DB: {
_id: new ObjectId('...'),
name: 'Laptop Pro',
__v: 0
}
Product found in secondary DB: {
_id: new ObjectId('...'),
name: 'Smart Watch',
__v: 0
}
Total products in primary DB: 3
Total products in secondary DB: 3