javascript - axios 请求有express、node、ejs

Question

我正在使用 Express.js、node.js、Axios 和 ejs 开发一个网站。我正在使用 Axios 对 Oracle SQL REST 服务进行 REST 调用。我在使用 Promises 或 Async/Await 时遇到问题。如果可能的话，我可以使用一些指导。

我有一个与 Oracle DB 接口(interface)的存储库层。例如:

dataaccess.js

const axios = require('axios');

exports.IsManufacturerCategory = function (categoryId) {
    axios.get(`DB ADDRESS ${categoryId}`)
        .then(response => {
            console.error('GET IsManufacturerCategory categoryId = ' + categoryId);
            console.error('Response = ' + JSON.stringify(response.data));

            return (response.data);
        })
        .catch(rej => {
            console.error('ERROR IsManufacturerCategory categoryId = ' + categoryId);
            console.error('ERR = \n' + rej.data);
            return (rej.data);
        });
}

这在我的中间件中被调用。当我调用 var isManufacturerCat =exports.IsManufacturerCategory(categoryId); 时，它是未定义的。我正在尝试使用从 Axios 调用检索到的数据将 ejs View 返回到我的路由器，如果需要，我可以提供该 View 。

category.js

var isManufacturerCat = exports.IsManufacturerCategory(categoryId);
if (isManufacturerCat) {
    var models = dataaccess.GetCategorySubCategories(categoryId);
    return ("manufacturers", {
        data: {
            Canonical: cononical, 
            Category: category, 
            IsAManufacturerCategory: iAManufacturerCat, 
            Models: models
        }
    });
}

我愿意接受有关我的项目结构、Promises、Async/Await 等的使用的任何建议。

提前谢谢您。

编辑

在处理了一些给出的答案之后，我取得了一些进展，但我遇到了异步调用层的问题。我最终进入了一个需要等待调用的地方，但我处于一个我无法/不想这样做的功能中(即我的路由器)。

indexMiddleware.js

exports.getRedirectURL = async function (fullOrigionalpath) {

    if (fullOrigionalpath.split('.').length == 1 || fullOrigionalpath.indexOf(".aspx") != -1) {
        if (fullOrigionalpath.indexOf(".aspx") != -1) { 
            //some string stuff to get url

        }
        else if (fullOrigionalpath.indexOf("/solutions/") != -1) {
            if (!fullOrigionalpath.match("/solutions/$")) {
                if (fullOrigionalpath.indexOf("/t-") != -1) {
                    //some stuff
                }
                else {
                    var solPart = fullOrigionalpath.split("/solutions/");
                    solPart = solPart.filter(function (e) { return e });

                    if (solPart.length > 0) {
                        var solParts = solPart[solPart.length - 1].split("/");
                        solParts = solParts.filter(function (e) { return e });
                        if (solParts.length == 1) {
                            waitForRespose = true;

                            const isASolutionCategory = await dataaccess.isASolutionCategory(solParts[0]); // returns void

                            if (isASolutionCategory != undefined && isASolutionCategory.length > 0 && isASolutionCategory[0].Count == 1) {
                                 // set redirecturl   
                            }
                        }
                        else {
                            redirecturl = "/solutions/solutiontemplate";
                        }
                    }
                }
            }
        }
        else if (URL STUFF) {
            // finally if none of the above fit into url condition then verify current url with Category URL or product url into database and if that matches then redirect to proper internal URL
            if (fullOrigionalpath.lastIndexOf('/') == (fullOrigionalpath.length - 1)) {
                fullOrigionalpath = fullOrigionalpath.substring(0, fullOrigionalpath.lastIndexOf('/'));
            }

            waitForRespose = true;

            const originalURL = await exports.getOriginalUrl(fullOrigionalpath); //returns string
            redirecturl = originalURL;
            return redirecturl;
        }
    }

    if (!waitForRespose) {
        return redirecturl; 
    }
}

exports.getOriginalUrl = async function (friendlyUrl) {
    var originalUrl = '';
    var urlParts = friendlyUrl.split('/');
    urlParts = urlParts.filter(function (e) { return e });
    if (urlParts.length > 0) {
        var skuID = urlParts[urlParts.length - 1];

        const parts = await dataaccess.getFriendlyUrlParts(skuID); //returns void
        console.log("Inside GetOriginalUrl (index.js middleware) FriendlyUrlParts: " + parts);//undefined

        if (parts != undefined && parts != null && parts.length > 0) {
            //some stuff
        }
        else {
            // verify whether it's category URL then return the category local URL
            console.log('Getting CategoryLocalUrl');
            const categoryLocalUrl = await dataaccess.getCategoryLocalUrl(friendlyUrl); // returns void
            console.log('CategoryLocalUrl Gotten ' + JSON.stringify(categoryLocalUrl)); //undefined
            if (categoryLocalUrl != undefined && categoryLocalUrl.length > 0) {
                //set originalUrl
                return originalUrl;
            }

        }
    }
    else { return ''; }
}

index.js 路由器

router.use(function (req, res, next) {
   //bunch of stuff
   index.getRedirectURL(url)
      .then(res => {
        req.url = res;
      })
      .catch(error => {
        console.error(error);
      })
      .finally(final => {
        next();
      });
}

在 await 之后，我的 console.log 中出现 undefined。我猜我不太确定我在做什么。

Answer 1

让我们从 dataaccess.js 开始。基本上，您正在导出一个正在执行异步工作的函数，但该函数不是异步的。大多数人希望能够使用 async/await，因此与其让 IsManufacturerCategory 接受回调函数，不如让该函数返回一个 Promise。最简单的方法是将函数设为异步函数。异步函数返回的 promise 比返回显式 promise 更容易解决/拒绝。以下是重写方法:

const axios = require('axios');

exports.IsManufacturerCategory = async function (categoryId) {
  try {
    const response = await axios.get(`DB ADDRESS ${categoryId}`);

    console.log('GET IsManufacturerCategory categoryId = ' + categoryId);
    console.log('Response = ' + JSON.stringify(response.data));
  } catch (err) {
    console.error('ERROR IsManufacturerCategory categoryId = ' + categoryId);
    console.error('ERR = \n' + rej.data);

    throw err;
  }
}

请注意，我仅使用 console.error 来处理错误。因为您想记录一些与错误相关的详细信息，所以我使用了 try/catch 语句。如果您不关心这样做，该函数可以简化为:

const axios = require('axios');

exports.IsManufacturerCategory = async function (categoryId) {
    const response = await axios.get(`DB ADDRESS ${categoryId}`);

    console.log('GET IsManufacturerCategory categoryId = ' + categoryId);
    console.log('Response = ' + JSON.stringify(response.data));
}

这是因为异步函数会自动吞下错误并将其视为拒绝 - 因此 IsManufacturerCategory 返回的 promise 将被拒绝。类似地，当异步函数返回一个值时，promise 将通过返回的值来解析。

转到category.js...这看起来很奇怪，因为当我认为您打算从 dataaccess 模块的导入访问它时，您正在从该模块的导出访问它，对吗？

在此函数内，您应该将所有异步工作放入异步函数中，以便可以将await 与返回promise 的函数一起使用。重写方法如下:

const dataaccess = require('dataccess.js');

async function validateManufacturerCat(categoryId) {
  const isManufacturerCat = await dataaccess.IsManufacturerCategory(categoryId);

  if (isManufacturerCat) {
    const models = await dataaccess.GetCategorySubCategories(categoryId);

    return ({
      manufacturers: {
        data: {
          Canonical: cononical, 
          Category: category, 
          IsAManufacturerCategory: iAManufacturerCat, 
          Models: models
        }
      }
    });
  }
}

validateManufacturerCat(categoryId)
  .then(res => {
    console.log(res);
  })
  .catch(err => {
    console.error(err);
  });

一些注意事项:

1. 我将 if 语句中的返回值更改为单个值。在使用 Promise 和 async/await 时，您应该尝试始终返回单个值(因为您只能解析/返回一个值)。
2. 我看到很多函数都以​​大写字母开头。 JavaScript 中有一个约定，其中大写字母的函数是构造函数(意味着使用 new 关键字调用)。