What is Express middleware? How to use it in Node?

What is Express middleware? How to use it in Node? The following article will introduce you to the simple use of Express middleware. I hope it will be helpful to you!

1. What is Express middleware

Middleware specifically refers to the intermediate processing link of the business process.

2. The calling process of Express middleware

When a request reaches the Express server, multiple middlewares can be called continuously to prepare the request. deal with.

3. Middleware format

Essentially it is the function processing function

Note: formal parameter list of the middleware function , must contain the next parameter. The routing processing function only contains req and res,

// next参数必须在最后一个传入
const mw = (req, res, next) => {
    ...
    // next()必须在最后调用
    next()
}

4. The role of next() function

next function is the key to realizing continuous calls of multiple middlewares , which means transferring the flow relationship to the next middleware or route.

5. Globally effective middleware

Any request initiated by the client will trigger the middleware after reaching the server, which is called globally effective middleware. By calling server.use (middleware function), you can define a globally effective middleware. The sample code is as follows:

const mw = (req, res, next) => {
    next()
}

const mw1 = (req, res, next) => {
    next()
}

// 全局生效的中间件,中间件调用顺序以传入顺序为准
server.use(mw,mw1)

6. Locally effective middleware

Partial middleware only takes effect in a specified routing path

const mw = (req, res, next) => {
    next()
}
const mw1 = (req, res, next) => {
    next()
}
// 局部生效的中间件
server.get('/',mw,(req,res)=>{
    res.send('路径：/')
})



// 定义多个局部生效的中间件
// 1、直接逗号分隔
server.get('/',mw,mw1,(req,res)=>{
    res.send('路径：/')
})
// 2、或者使用数组包含
server.get('/',[mw,mw1],(req,res)=>{
    res.send('路径：/')
})

7. The role of middleware

Multiple middlewares share the same req and res. Based on this feature, we can uniformly add custom attributes or methods to the req or res objects in the upstream middleware for use by downstream middleware or routing.

const mw = (req, res, next) => {
    // 添加属性
    req.startTime=new Date()
    next()
}

8. Five points to note about Express middleware

• Be sure to register the middleware before routing

• Requests sent from the client can be processed by calling multiple middlewares continuously

• After executing the business code of the middleware, don’t forget to call the next() function

• In order to prevent code logic confusion, do not write additional code after calling the next() function

• When calling multiple middlewares continuously, multiple Sharing req and res objects between middleware

9. Classification of Express middleware

• Application level Middleware

• Routing level middleware

• Error level middleware

• Express Built-in middleware

• Third-party middleware

Detailed introduction:

• Application level The middleware

  The middleware that is bound to the app instance through app.use() or app.get() or app.post() is called application-level middleware. The code example is as follows:

  // 全局生效的中间件(应用级别的中间件)
  server.use(mw,mw1)
  // 局部生效的中间件(应用级别的中间件)
  server.get('/',mw,mw1,(req,res)=>{
      res.send(`请求进入服务器的时间：${req.startTime}`)
  })

  Copy after login

• Routing-level middleware

  Middleware bound to the express.Router() instance is called routing-level middleware. Its usage is no different from application-level middleware. However, application-level middleware is bound to the app instance, and routing-level middleware is bound to the router instance. The code example is as follows:

  const router = require('./router/router')
  // 路由级别的中间件
  router.use((req,res,next)=>{
      next()
  })

  Copy after login

• Error-level middleware

  The role of error level middleware: It is specially used to capture abnormal errors that occur in the entire project, thereby preventing the project from crashing abnormally.

  Format: The function processing function of the error level middleware must have 4 formal parameters. The order of the formal parameters from front to back is (err, req, res, next).

  Note: Error level middleware must be registered after all routes!

  // 人为制造错误
  server.get('/err', (req, res) => {
      throw new Error('人为抛出错误！！！')
      res.send('err Page')
  })
  // 定义错误级别的中间件
  server.use((err, req, res, next) => {
      console.log('发生了错误：' + err.message);
      res.send('Error:'+err.message)
      next()
  })

  Copy after login

• Express built-in middleware

  Since Express 4.16.0 version, Express has built-in 3 commonly used middleware, which greatly improves the development efficiency and experience of Express projects:

  • express.static fast hosting static Built-in middleware for resources, such as: HTML files, images, CSS styles, etc. (no compatibility)

  • express.json parses the request body data in JSON format (with compatibility, only in Available in version 4.16.0)

  • express.urlencoded parses request body data in URL-encoded format (compatible, only available in version 4.16.0)

  // 配置解析application/json格式数据的内置中间件
  server.use(express.json())
  // 配置解析application/x-www-form-urlencoded格式数据的内置中间件
  server.use(express.urlencoded({
      extended: false
  }))
  // 测试解析json的内置中间件
  server.post('/user',(req,res)=>{
      // 在服务器，可以使用req.body这个属性来接受客户端发送过来的请求数据
      // 默认情况下，如果不配置解析表单数据的中间件，则req.body默认等于undefined
      console.log(req.body);
      res.send('ok')
  })
  
  // 测试解析urlencoded的内置中间件
  server.post('/book',(req,res)=>{
      console.log(req.body)
      res.send('book ok')
  })

  Copy after login

• Third-party middleware

  is not officially built into Express, but is developed by a third party, called third-party middleware. In the project, you can download and configure third-party middleware on demand, thereby improving the development efficiency of the project. For example: In versions before express@4.16.0, the third-party middleware body-parser was often used to parse request body data. The usage steps are as follows:

  • Runnpm install body-parserInstall middleware

  • Use require to import middleware

  • Call server.use()Register and use middleware

  Note: Express’s built-in express.urlencoded middleware is further encapsulated based on the third-party middleware body-parser.

For more node-related knowledge, please visit: nodejs tutorial!

The above is the detailed content of What is Express middleware? How to use it in Node?. For more information, please follow other related articles on the PHP Chinese website!