Question

我已经建立了，使用express（），各种方法。为简单起见，我假设我构建了2个POST（）函数，我希望能够自己使用它们，并通过中间件将它们连接起来以便结合使用。

app.post('/create_obj_1' , function (req,res) {
    //create Object_type_1
    // send Object_type_1 via EXTERNAL API to somewhere
    res.json({{ "statusCode": 200, "message": "OK" }
}
app.post('/create_obj_2' , function (req,res) {
    //create Object_type_2
    // send Object_type_2 via EXTERNAL API to somewhere
    res.json({{ "statusCode": 200, "message": "OK" }
}

我希望有一个新的POST（）可以调用其他2个（但仍然支持独立调用原来的2个）我认为可以通过中间件，但我不知道如何 - 这就是我认为新的POST（）应该是这样的 -

app.post('/create_obj_all' , function (req,res) {
   //I want to invoke the create_obj_1 & create_obj_2 , check all OK, and finish
    res.json({{ "statusCode": 200, "message": "OK" }
}

在这种情况下，我不确定如何处理中间件的使用。

在顶部 - 我如何连接它们以使用彼此res？假设EXTERNAL API从obj_1创建中返回一些值，我想在obj_2 post（）函数中使用它。

我尝试在middlware_1中使用request（）的伪代码 -

var middle_1 = function (req, res, next) {
        req.middle_1_output  = {
            statusCode : 404,
            message : "fail_1"
        }
        var options = { 
                method: 'PUT', url: `EXTERNAL_API`, headers: 
                { 
                    'cache-control': 'no-cache',
                    'content-type': 'application/x-www-form-urlencoded',
                    apikey: `KEY`
                }
            };
        request(options, function (error, response, body) {
            if (error) throw new Error(error);

            // CODE THAT DO SOMETHING AND GET INFORMATION

            // OLD WAY OF res.send here , to allow using in post.POST() was - res.status(200).send(body);

            //res.status(200).send(body);
            req.middle_1_output.statusCode = 200;
            req.middle_1_output.message = "hello world";
        });
     next(); // trigger next middleware
}

Answer 1

鉴于目前的例子，除非你稍微调整前两条路线的中间件，否则我认为你不能这样做：

var middleware1 = function(req, res, next) {
  //create Object_type_1
  // send Object_type_1 via EXTERNAL API to somewhere

  next(); // calling next() triggers the next middleware
};

var middleware2 = function(req, res, next) {
  //create Object_type_2
  // send Object_type_2 via EXTERNAL API to somewhere

  next(); // calling next() triggers the next middleware
};

/**
 * This middleware is only used to send success response
 */
var response_success = function(req, res) {

    res.json({ "statusCode": 200, "message": "OK" });
}

app.post('/create_obj_1', middleware1, response_success);

app.post('/create_obj_2', middleware2, response_success);

app.post('/create_obj_all', middleware1, middleware2, response_success);

注意这是我从您的示例中做出的非常简单的解决方案。实际实现将取决于每个中间件期望的输入以及它们生成的输出。与此不同的是，可能还有不同的中间件用于发送响应。

第二部分解决问题的第二部分，如果我找到了你想要将middleware1的输出传递给middleware2。您可以在调用req之前将输出简单地附加到next();对象。像这样：

var middleware1 = function(req, res, next) {

  // do something

  some_external_api_call(function(error, data) {

    if (error) {
      // handle the error yourself or call next(error);
    } else {

      req.middleware1_output = data; // set the output of the external api call into a property of req
      next();
    }
  });
};

var middleware2 = function(req, res, next) {

  // check to see if the middleware1_output has been set 
  // (meaning that the middleware has been called from /create_obj_all )
  if (req.middleware1_output) {

    // do something with the data

  } else {

    // handle scenario when /create_obj_2 is called by itself

  }

  next(); // calling next() triggers the next middleware
};

请注意您必须考虑从middleware2或直接从POST /create_obj_all调用POST /create_obj_2的两种情况。

第3部分您应该在回调中调用next。看我上面的例子。这是由于javascript的异步/非阻塞特性。

function middleware(req, res, next) {

    // do something

    call_1st_external_api(some_options, function(error, data) {

        // executed after call_1st_external_api completes

        req.output_of_1st_external_api = data; // store the data of this api call for access from next middleware

        next(); // calls the next middleware

        // nothing here will be executed as next has already been called
    });

    // anything here will be executed before call_1st_external_api is completed
    next(); // this will call the next middleware before call_1st_external_api completes
}

要在相同的中间件中处理两个外部API，您必须将它们嵌套（或使用异步或承诺）：

function middleware(req, res, next) {

    // do something

    call_1st_external_api(some_options, function(error1, data1) {

        // executed after call_1st_external_api completes

        req.output_of_1st_external_api = data1; // store the data of this api call for access from next middleware

        // executed after call_2nd_external_api completes

        call_2nd_external_api(some_options, function(error2, data2) {

            req.output_of_2nd_external_api = data2; // store the data of this api call for access from next middleware

            next();
        });

        // anything here will be executed before call_2nd_external_api is completed
    });

    // anything here will be executed before call_1st_external_api is completed
}

你必须处理上面的所有错误，就像我在 2nd Part 中所显示的那样，为了简单起见，我在上面的例子中没有显示。

NODEJS如何通过中间件连接几个express.method（）

1 个答案: