根据精细手册，createConnection() * 可以 * 用于连接到多个数据库。
但是，您需要为每个连接/数据库创建单独的模型：

var conn      = mongoose.createConnection('mongodb://localhost/testA');
var conn2     = mongoose.createConnection('mongodb://localhost/testB');

// stored in 'testA' database
var ModelA    = conn.model('Model', new mongoose.Schema({
  title : { type : String, default : 'model in testA database' }
}));

// stored in 'testB' database
var ModelB    = conn2.model('Model', new mongoose.Schema({
  title : { type : String, default : 'model in testB database' }
}));

字符串
我非常确定您可以在它们之间共享模式，但您必须检查以确保。

很晚了，但这可能会对某些人有所帮助。当前的答案假设您正在为您的连接和模型使用相同的文件。
在真实的生活中，你很有可能会将你的模型分割成不同的文件。你可以在主文件中使用这样的东西：

mongoose.connect('mongodb://localhost/default');

const db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {
  console.log('connected');
});

字符串
这就是文档中描述的方式。然后在模型文件中，执行以下操作：

import mongoose, { Schema } from 'mongoose';

const userInfoSchema = new Schema({
  createdAt: {
    type: Date,
    required: true,
    default: new Date(),
  },
  // ...other fields
});

const myDB = mongoose.connection.useDb('myDB');

const UserInfo = myDB.model('userInfo', userInfoSchema);

export default UserInfo;

型
其中myDB是数据库名称。

你可以做的一件事是，你可能为每个项目都安装了一个目录。所以，在那个目录中安装mongoose，并从每个子应用程序中的自己的文件夹中要求（）mongoose。不是从项目根目录或全局目录。所以一个子项目，一个mongoose安装和一个mongoose示例。

-app_root/
--foo_app/
---db_access.js
---foo_db_connect.js
---node_modules/
----mongoose/
--bar_app/
---db_access.js
---bar_db_connect.js
---node_modules/
----mongoose/

字符串
在foo_db_connect.js中

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/foo_db');
module.exports = exports = mongoose;

型
在bar_db_connect.js中

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bar_db');
module.exports = exports = mongoose;

型
在db_access. js文件中

var mongoose = require("./foo_db_connect.js"); // bar_db_connect.js for bar app

型
现在，您可以使用mongoose访问多个数据库。

作为一种替代方法，Mongoose确实在默认示例上导出了一个新示例的构造函数。

var Mongoose = require('mongoose').Mongoose;

var instance1 = new Mongoose();
instance1.connect('foo');

var instance2 = new Mongoose();
instance2.connect('bar');

字符串
这在使用单独的数据源时非常有用，并且当您希望为每个用户或请求使用单独的数据库上下文时也非常有用。您需要小心，因为这样做可能会创建大量连接。确保在不需要示例时调用disconnect（），并且限制每个示例创建的池大小。

Mongoose和多个数据库在一个node.js项目中

使用useDb解决此问题
例如

//product databse 
const myDB = mongoose.connection.useDb('product');
module.exports = myDB.model("Snack", snackSchema);
//user databse
const myDB = mongoose.connection.useDb('user');
module.exports = myDB.model("User", userSchema);

字符串

• 一个有点优化的（至少对我来说）解决方案。* 将此写入文件db.js，并在需要的地方要求此，并通过函数调用调用它，你就可以开始了。

const MongoClient = require('mongodb').MongoClient;
    async function getConnections(url,db){
        return new Promise((resolve,reject)=>{
            MongoClient.connect(url, { useUnifiedTopology: true },function(err, client) {
                if(err) { console.error(err) 
                    resolve(false);
                }
                else{
                    resolve(client.db(db));
                }
            })
        });
    }

    module.exports = async function(){
        let dbs      = [];
        dbs['db1']     = await getConnections('mongodb://localhost:27017/','db1');
        dbs['db2']     = await getConnections('mongodb://localhost:27017/','db2');
        return dbs;
    };

字符串

我一直在使用这种方法，它对我很有效，直到现在。

const mongoose = require('mongoose');

function makeNewConnection(uri) {
    const db = mongoose.createConnection(uri, {
        useNewUrlParser: true,
        useUnifiedTopology: true
    });

    db.on('error', function (error) {
        console.log(`MongoDB :: connection ${this.name} ${JSON.stringify(error)}`);
        db.close().catch(() => console.log(`MongoDB :: failed to close connection ${this.name}`));
    });

    db.on('connected', function () {
        mongoose.set('debug', function (col, method, query, doc) {
            console.log(`MongoDB :: ${this.conn.name} ${col}.${method}(${JSON.stringify(query)},${JSON.stringify(doc)})`);
        });
        console.log(`MongoDB :: connected ${this.name}`);
    });

    db.on('disconnected', function () {
        console.log(`MongoDB :: disconnected ${this.name}`);
    });

    return db;
}

// Use

const db1 = makeNewConnection(MONGO_URI_DB1);
const db2 = makeNewConnection(MONGO_URI_DB2);

module.exports = {
   db1,
   db2
}

字符串

我不知道这是否会帮助任何人，但这是我在尝试使用Mongoose处理多个连接后最终做的事情，并最终在这里（从许多位置）。
const mongoose = require("mongoose");（参考Mongoose v.8）返回的对象有一个“connections”属性，一个连接数组。这又包含一个id属性，数组的id，当连接建立时返回。
所以我做了这样的事情：

// db001URL is the MongoDB connection URL, with optional database
const db001conn = await mongoose.createConnection(db001URL).asPromise();
console.log("connected to db001conn");
// set id variable into something: here I used a closure
mongoID({ db001: db001conn.id });
    
    
// db002URL is a different MongoDB connection string
const db002conn = await mongoose.createConnection(db002URL).asPromise();
console.log("connected to db002");
// set id variable into something: here I used a closure
mongoID({ db002: db002conn.id });

字符串
存储id允许我使用mongoose.connections[id]调用多个连接中的一个，这也意味着我可以将Mongoose对象保留为可变的，并继续我的生活而不用担心。