What does middleware mean in nodejs

In nodejs, middleware mainly refers to the method that encapsulates the detailed processing of all HTTP requests. It is the processing method from the initiation of the HTTP request to the end of the response. The behavior of middleware is similar to the working principle of filters in Java, which is to let the filter handle it before entering specific business processing.

The operating environment of this tutorial: windows7 system, nodejs version 12.19.0, Dell G3 computer.

Middleware concept

In NodeJS, middleware mainly refers to the method that encapsulates all Http request details. An HTTP request usually includes a lot of work, such as logging, IP filtering, query strings, request body parsing, cookie processing, permission verification, parameter verification, exception handling, etc., but for web applications, they do not want to be exposed to so much Detailed processing, so middleware is introduced to simplify and isolate the details between these infrastructure and business logic, so that developers can focus on business development to achieve the purpose of improving development efficiency.

The behavior of middleware is similar to the working principle of filters in Java, which is to let the filter handle it before entering specific business processing. Its working model is shown in the figure below.

##                                                                                                                                                                                                                     Middleware working model

Core implementation of the middleware mechanism

Middleware is initiated from the Http request to The processing method during the end of the response usually requires processing the request and response, so a basic middleware is in the following form:

const middleware = (req, res, next) => {
  // TODO
  next()
}

The following is an understanding of the middleware through the implementation of the middleware mechanism in two ways. How it works.

Method 1

Define three simple middleware as follows:

const middleware1 = (req, res, next) => {
  console.log('middleware1 start')
  next()
}

const middleware2 = (req, res, next) => {
  console.log('middleware2 start')
  next()
}

const middleware3 = (req, res, next) => {
  console.log('middleware3 start')
  next()
}

// 中间件数组
const middlewares = [middleware1, middleware2, middleware3]
function run (req, res) {
  const next = () => {
    // 获取中间件数组中第一个中间件
    const middleware = middlewares.shift()
    if (middleware) {
      middleware(req, res, next)
    }
  }
  next()
}
run() // 模拟一次请求发起

Execute the above code, you can see the following Result:

middleware1 start
middleware2 start
middleware3 start

If there is an asynchronous operation in the middleware, the

next() method needs to be called after the asynchronous operation process ends, otherwise the middleware cannot be executed in sequence. Rewrite middleware2 middleware:

const middleware2 = (req, res, next) => {
  console.log('middleware2 start')  new Promise(resolve => {
    setTimeout(() => resolve(), 1000)
  }).then(() => {
    next()
  })
}

The execution result is the same as before, but middleware3 will be executed after middleware2 is completed asynchronously.

middleware1 start
middleware2 start
middleware3 start

Some middleware not only needs to be executed before business processing, but also needs to be executed after business processing, such as log middleware for statistical time. In the case of method 1, other codes of the current middleware cannot be executed as callbacks when

next() is an asynchronous operation. Therefore, the subsequent operations of the next() method can be encapsulated into a Promise object, and the next.then() form can be used inside the middleware to complete the business processing. subsequent callback. Rewrite the run() method as follows:

function run (req, res) {
  const next = () => {
    const middleware = middlewares.shift()    if (middleware) {      // 将middleware(req, res, next)包装为Promise对象
      return Promise.resolve(middleware(req, res, next))
    }
  }
  next()
}

The calling method of the middleware needs to be rewritten as:

const middleware1 = (req, res, next) => {
  console.log('middleware1 start')  // 所有的中间件都应返回一个Promise对象
  // Promise.resolve()方法接收中间件返回的Promise对象，供下层中间件异步控制
  return next().then(() => {
    console.log('middleware1 end')
  })
}

const middleware1 = (req, res, next) => {
    console.log('middleware1 start')    // 所有的中间件都应返回一个Promise对象
    // Promise.resolve()方法接收中间件返回的Promise对象，供下层中间件异步控制
    return next().then((res) => {
      console.log("1",res)      return 'middleware1 end';
    })
  }
  
  const middleware2 = (req, res, next) => {
    console.log('middleware2 start')    // 所有的中间件都应返回一个Promise对象
    // Promise.resolve()方法接收中间件返回的Promise对象，供下层中间件异步控制
    // console.log("next()",next())
    return next().then((res) => {
      console.log("2",res)      return 'middleware2 end'
    })
  }
  const middleware3 = (req, res, next) => {
    console.log('middleware3 start')    return next().then((res) => {
      console.log("3",res)      return 'middleware3 end'
    })
  }

const middlewares = [middleware1, middleware2, middleware3]function run (req, res) {
    const next = () => {
      const middleware = middlewares.shift()      if (middleware) {        //   console.log("next",next)
        // 将middleware(req, res, next)包装为Promise对象
        return Promise.resolve(middleware(req, res, next))
      }else {        return Promise.resolve("结束");
      }
    }
    next()
  }
run() // 模拟一次请求发起

Result:

async await implementation

const middleware1 = async (req, res, next) => {
    console.log('middleware1 start')
    let result = await next();
    console.log("1",result)
  }
  
  const middleware2 = async (req, res, next) => {
    console.log('middleware2 start')
    let result = await next();
    console.log("2",result)
    return 'middleware2 end';
  }
  const middleware3 = async (req, res, next) => {
    console.log('middleware3 start')
    let result = await next();
    console.log("3",result)
    return 'middleware3 end';
  }

const middlewares = [middleware1, middleware2, middleware3]

function run (req, res) {
    const next = () => {
      const middleware = middlewares.shift()
      if (middleware) {
        //   console.log("next",next)
        // 将middleware(req, res, next)包装为Promise对象
        return Promise.resolve(middleware(req, res, next))
      }else {
        return Promise.resolve("结束");
      }
    }
    next()
  }
run() // 模拟一次请求发起

The above describes the calling process of multiple asynchronous middleware in the middleware mechanism. The actual implementation of the middleware mechanism also needs to be considered. Exception handling, routing, etc.

In the

express framework, the middleware is implemented in method 1, and the global middleware and the middleware defined according to the request path in the built-in routing middleware work together, but they cannot be used in the business After the processing is completed, the code in the current middleware is called. koa2The implementation method of middleware in the framework is method two. The return value of the next() method is encapsulated into a Promise to facilitate subsequent asynchronous process control of the middleware. , implements the onion ring model proposed by the koa2 framework, that is, each layer of middleware is equivalent to a sphere. When penetrating the entire model, each sphere will actually penetrate twice.

koa2 middleware onion ring model

koa2The middleware mechanism of the framework is very simple and elegant. Let’s learn about the framework here. The core code that combines multiple middlewares.

function compose (middleware) {
  if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
  for (const fn of middleware) {
    if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
  }
  return function (context, next) {
    let index = -1
    return dispatch(0)
    function dispatch (i) {
      // index会在next()方法调用后累加，防止next()方法重复调用
      if (i <= index) return Promise.reject(new Error(&#39;next() called multiple times&#39;))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        // 核心代码
        // 包装next()方法返回值为Promise对象
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
        // 遇到异常中断后续中间件的调用
        return Promise.reject(err)
      }
    }
  }
}

koa middleware list address: https://github.com/koajs/koa/wiki

Summary

This article mainly introduces the concept of middleware and why it is introduced Middleware and the core implementation of the middleware mechanism. The middleware mechanism makes Web applications have good scalability and composability.

When implementing middleware, a single middleware should be simple enough and have a single responsibility. Since each request will call the middleware-related code, the middleware code should be efficient and can cache repeatedly obtained data when necessary. When using middleware for different routes, you should also consider that different middleware applies to different routes.

[Recommended learning: "nodejs tutorial"]

The above is the detailed content of What does middleware mean in nodejs. For more information, please follow other related articles on the PHP Chinese website!