How to use nodejs middleware

In recent years, Node.js has become a very popular technology that allows front-end developers to write, run and build web applications through the JavaScript language. The middleware in Node.js is an indispensable part of the development process. It allows developers to easily manage functions and routing, while also providing security and performance optimizations. In this article, we’ll take a deeper look at how to use middleware in Node.js.

What is middleware?

In Node.js, middleware is a powerful and easily reusable piece of code. It can intercept and filter between HTTP requests and responses, which makes it easy for developers to add some processing logic and modify the content of requests or responses. Middleware can help us achieve some common development needs, such as:

• Authentication and Authorization
• Input validation and data conversion
• Request analysis and logging
• Routing control and resource management
• Caching and compression

Since middleware is an extremely important part of Node.js, Node.js comes with a lot of Built-in middleware, such as body-parser, express, etc., and there are also many third-party middleware packages for us to choose and use.

Usage of Node.js middleware

Installation and introduction of middleware

Before using middleware, we need to install it into our project first. The middleware can be installed using the Node.js package manager (such as npm):

npm install 中间件名称

After the installation is complete, we need to introduce it to us through require or import In the code:

const 中间件名称 = require('中间件名称')
// 或者
import 中间件名称 from '中间件名称'

Next we can start using middleware.

Application middleware

Middleware in Node.js needs to be used through the application. We can use an Express application to demonstrate the use of middleware:

const express = require('express')
const app = express()

// 使用中间件
app.use(中间件名称)

In the above code, we created an Express application and introduced the express middleware. Next, we apply the middleware name to our application using the app.use() method. This way, every HTTP request is processed by the middleware before reaching our application.

Writing custom middleware

If we do not find a suitable third-party middleware or built-in middleware, we can write custom middleware to meet our needs. Writing middleware requires the use of a middleware function, which has three parameters related to HTTP requests and responses:

function 中间件名称(req, res, next) {
  // ...
}

• req: Represents the request object, including the information sent by the client. Data and request information.
• res: Represents the response object, used to send response data and response information to the client.
• next: Indicates the next middleware or router passing this middleware and must be called explicitly.

In the middleware, we can access and modify the request req object and response res object, and can also implement arbitrary functional processing. For example, the following is a simple sample middleware that outputs the accessed URL address and timestamp:

function logger(req, res, next) {
  console.log(`[${new Date()}]: ${req.url}`)
  next()
}

Concatenated use of multiple middleware

In the actual development process, we It may be necessary to use multiple middleware simultaneously to implement various functions and requirements. At this time, you can use app.use() to concatenate multiple middlewares, and the Node.js middlewares will be executed in the order in which they are added. For example, the following code demonstrates the use of multiple middlewares to implement simple authentication:

// 身份验证中间件
function auth(req, res, next) {
  if (req.headers.auth === '123456') {
    // 授权通过，执行后续中间件
    next()
  } else {
    // 授权失败
    res.status(401).send('Authorization Failed')
  }
}

// 日志记录中间件
function logger(req, res, next) {
  console.log(`[${new Date()}]: ${req.url}`)
  next()
}

// 中间件串联
app.use(logger)
app.use(auth)

In the above code, we define two middlewares: auth and logger . auth The middleware is used to verify whether authorization is successful, and the logger middleware is used to record the log information of HTTP requests. Through app.use(), these two middlewares are connected in series to implement a simple authentication function.

In general, middleware is an important part of the Node.js development process. With the help of middleware, we can easily implement various common functions and requirements while also improving the security and performance of web applications. Therefore, it is important to learn how to use middleware, which will help us improve the efficiency and quality of Node.js development.

The above is the detailed content of How to use nodejs middleware. For more information, please follow other related articles on the PHP Chinese website!