Nodejs node-oracle的问题

Nodejs node-oracle的问题

几天把node-oralce模块安装好了，也能够链接数据库但是我有个问题，如果按照以下代码来链接数据库的话,那每一操作都要链接以下数据库，我想能否把链接数据库的操作独立出来?我自己尝试写了下,没搞定,有没有前辈有写好了的借我看看

var oracle = require('oracle');
var connectData = {
    hostname: "xxx",
    port: 1521,
    database: "orcl", // System ID (SID)
    user: "xxx",
    password: "xxx"
}
oracle.connect(connectData, function(err, connection) {
    if (err) { console.log("Error connecting to db:", err); return; }

    connection.execute("call procvarchar2outparam(:1,:2)", ["node", new oracle.OutParam(oracle.OCCISTRING, {size: 40})], function(err, results) {
        if (err) { console.log("Error executing query:", err); return; }

        console.log(results);
        connection.close(); // call only when query is finished executing
    });
});

4 回复

当然可以！在Node.js中使用node-oracle模块时，通常希望将数据库连接逻辑封装在一个独立的函数或模块中，以便在整个应用程序中复用。这样可以避免每次需要执行数据库操作时都重新连接数据库。

下面是一个简单的示例，展示了如何将数据库连接逻辑封装起来，并在需要时重用该连接。

示例代码

首先，我们创建一个单独的文件来处理数据库连接：

db.js

const oracle = require('oracle');

// 数据库连接配置
const connectData = {
    hostname: "xxx",
    port: 1521,
    database: "orcl", // System ID (SID)
    user: "xxx",
    password: "xxx"
};

let connection;

async function connect() {
    return new Promise((resolve, reject) => {
        oracle.connect(connectData, function(err, conn) {
            if (err) {
                reject(err);
            } else {
                connection = conn;
                resolve(connection);
            }
        });
    });
}

async function closeConnection() {
    if (connection) {
        await new Promise((resolve, reject) => {
            connection.close(function(err) {
                if (err) {
                    reject(err);
                } else {
                    resolve();
                }
            });
        });
    }
}

module.exports = {
    connect,
    closeConnection
};

然后，在你的主应用文件中使用这个数据库连接模块：

app.js

const { connect, closeConnection } = require('./db');

async function main() {
    try {
        const connection = await connect();

        // 执行查询
        await connection.execute("call procvarchar2outparam(:1,:2)", ["node", new oracle.OutParam(oracle.OCCISTRING, { size: 40 })],
            function (err, results) {
                if (err) {
                    console.log("Error executing query:", err);
                    return;
                }

                console.log(results);
            });

        // 关闭连接
        await closeConnection();
    } catch (error) {
        console.error("Error:", error);
    }
}

main();

解释

  1. db.js 文件:

    • connectData 是数据库连接的配置信息。
    • connect 函数用于建立数据库连接，并返回一个Promise，以便我们可以使用 await 来等待连接完成。
    • closeConnection 函数用于关闭数据库连接，并返回一个Promise。

  2. app.js 文件:

    • 使用 require 导入 db.js 中的 connect 和 closeConnection 函数。
    • 在 main 函数中，先调用 connect 获取数据库连接，然后执行SQL查询，最后调用 closeConnection 关闭连接。

通过这种方式，你可以将数据库连接逻辑与具体的业务逻辑分离，使得代码更加整洁和可维护。


把connection赋值给一个全局变量

https://github.com/coopernurse/node-pool

你可以将数据库连接逻辑独立出来，创建一个全局连接实例或者使用连接池。下面是两种方案的示例：

方案一：全局连接实例

const oracle = require('oracle');

let connection;

oracle.connect({
    hostname: "xxx",
    port: 1521,
    database: "orcl",
    user: "xxx",
    password: "xxx"
}, function(err, conn) {
    if (err) {
        console.error("Error connecting to db:", err);
        return;
    }
    connection = conn;
});

function executeQuery(sql, params, callback) {
    if (!connection) {
        return callback(new Error("Database not connected"));
    }
    connection.execute(sql, params, function(err, results) {
        if (err) {
            return callback(err);
        }
        callback(null, results);
    });
}

// 使用示例
executeQuery("call procvarchar2outparam(:1,:2)", ["node", new oracle.OutParam(oracle.OCCISTRING, {size: 40})], function(err, results) {
    if (err) {
        console.error("Error executing query:", err);
        return;
    }
    console.log(results);
});

方案二：连接池

const oracle = require('oracle');

const pool = new oracle.Pool({
    user: "xxx",
    password: "xxx",
    connectString: "xxx:1521/orcl"
}, 10, 3); // 第三个参数是连接池大小

function getConnection(callback) {
    pool.acquire(function(err, conn) {
        if (err) {
            return callback(err);
        }
        callback(null, conn);
    });
}

function releaseConnection(conn) {
    pool.release(conn);
}

function executeQuery(sql, params, callback) {
    getConnection(function(err, conn) {
        if (err) {
            return callback(err);
        }
        conn.execute(sql, params, function(err, results) {
            if (err) {
                releaseConnection(conn);
                return callback(err);
            }
            releaseConnection(conn);
            callback(null, results);
        });
    });
}

// 使用示例
executeQuery("call procvarchar2outparam(:1,:2)", ["node", new oracle.OutParam(oracle.OCCISTRING, {size: 40})], function(err, results) {
    if (err) {
        console.error("Error executing query:", err);
        return;
    }
    console.log(results);
});

这两种方案都可以避免每次执行查询时都重新连接数据库。选择哪种方案取决于你的应用场景和需求。连接池通常更适合高并发场景。

回到顶部