Middleware in Express

Middleware in Express refers to functions that process requests before reaching the route handlers. These functions can modify the request and response objects, end the request-response cycle, or call the next middleware function. Middleware functions are executed in the order they are defined. They can perform tasks like authentication, logging, or error handling. Middleware helps separate concerns and manage complex routes efficiently.

Syntax

app.use((req, res, next) => {
    console.log('Middleware executed');
    next();
});

• (req, res, next) => {}: This is the middleware function where you can perform actions on the request and response objects before the final handler is executed.
• next(): This function is called to pass control to the next middleware in the stack if the current one doesn't end the request-response cycle.

What Middleware Does in Express.js

Middleware functions in Express.js can perform several important tasks:

1. Execute Code: Middleware can run any code when a request is received.
2. Modify Request and Response: Middleware can modify both the request (req) and response (res) objects.
3. End the Request-Response Cycle: Middleware can send a response to the client, ending the cycle.
4. Call the Next Middleware: Middleware can call next() to pass control to the next function in the middleware stack.

How Middleware Works in Express.js?

In Express.js, middleware functions are executed sequentially in the order they are added to the application. Here’s how the typical flow works:

1. Request arrives at the server.
2. Middleware functions are applied to the request, one by one.
3. Each middleware can either:
   • Send a response and end the request-response cycle.
   • Call next() to pass control to the next middleware.
4. If no middleware ends the cycle, the route handler is reached, and a final response is sent.

Types of Middleware

ExpressJS offers different types of middleware and you should choose the middleware based on functionality required.

1. Application-level Middleware

Application-level middleware is bound to the entire Express application using app.use() or app.METHOD(). It executes for all routes in the application, regardless of the specific path or HTTP method.

This type of middleware is commonly used for tasks like logging, body parsing, authentication checks, or setting headers for every incoming request.

app.use(express.json()); // Parses JSON data for every incoming request
app.use((req, res, next) => {
  console.log('Request received:', req.method, req.url);
  next();
});

2. Router-level Middleware

Router-level middleware is applied to a specific router instance using router.use() or router.METHOD(). It only applies to routes defined within that particular router, making it perfect for modular applications where middleware is only relevant to specific groups of routes.

This type of middleware is often used to group related routes (e.g., all routes related to authentication or user management) and apply middleware logic to them.

const router = express.Router();

// Apply middleware to only this router's routes
router.use((req, res, next) => {
  console.log('Router-specific middleware');
  next();
});

router.get('/dashboard', (req, res) => {
  res.send('Dashboard Page');
});

app.use('/user', router); // The middleware applies only to routes under "/user"

3. Error-handling Middleware

Error-handling middleware is a special type of middleware used to catch and respond to errors during the request-response cycle. It is defined with four parameters: err, req, res, next.

This middleware is essential for sending a consistent error response and avoiding unhandled exceptions that might crash the server.

app.use((err, req, res, next) => {
  console.error(err.stack); // Log the error stack
  res.status(500).send('Something went wrong!');
});

4. Built-in Middleware

Express provides built-in middleware to help with common tasks, like serving static files or parsing data.

For example, express.static() serves files like images, and express.json() helps parse incoming JSON data.

app.use(express.static('public')); // Serves static files from the "public" folder
app.use(express.json()); // Parses JSON payloads in incoming requests

5. Third-party Middleware

Third-party middleware is developed by external developers and packaged as npm modules. These middleware packages add additional functionality to your application, such as request logging, security features, or data validation.

For example, the morgan middleware logs HTTP requests, and body-parser helps parse incoming request bodies for easier handling of form data.

const morgan = require('morgan');
app.use(morgan('dev')); // Logs HTTP requests using the "dev" format

const bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: true })); // Parses URL-encoded bodies

Steps to Implement Middleware in Express

Step 1: Initialize the Node.js Project

npm init -y

Step 2: Install the required dependencies.

npm install express

Step 3: Set Up the Express Application

// Filename: index.js
const express = require('express');
const app = express();
const port = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('<div><h2>Welcome to GeeksforGeeks</h2><h5>Tutorial on Middleware</h5></div>');
});

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});

Step 4: Start the Application:

node index.js

Output:

When you navigate to http://localhost:3000/, you will see:

Welcome to GeeksforGeeksTutorial on Middleware

Middleware Chaining

Middleware can be chained from one to another, Hence creating a chain of functions that are executed in order. The last function sends the response back to the browser. So, before sending the response back to the browser the different middleware processes the request.

The next() function in the express is responsible for calling the next middleware function if there is one.

Modified requests will be available to each middleware via the next function

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

// Middleware 1: Log request method and URL
app.use((req, res, next) => {
    console.log(`${req.method} request to ${req.url}`);
    next();
});

// Middleware 2: Add a custom header
app.use((req, res, next) => {
    res.setHeader('X-Custom-Header', 'Middleware Chaining Example');
    next();
});

// Route handler
app.get('/', (req, res) => {
    res.send('Hello, World!');
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

• Middleware 1: Logs the HTTP method and URL of the incoming request.
• Middleware 2: Sets a custom header X-Custom-Header in the response.
• Route Handler: Sends a "Hello, World!" message as the response.

Output

When a client makes a GET request to http://localhost:3000/, the server responds with:

Hello, World!

Advantages of using Middleware

• Modularity: Breaks down complex tasks into smaller, manageable functions.
• Reusability: Middleware functions can be reused across different routes or applications.
• Maintainability: Organizes code logically, making it easier to manage and update.
• Error Handling: Centralizes error handling, improving the application's robustness.
• Performance Optimization: Allows for tasks like caching, compression, and security checks to be handled efficiently.

Best Practices for Middleware in ExpressJS

• Always call next() to pass control to the next middleware unless you are ending the request-response cycle.
• Use specific middleware for different tasks (e.g., authentication, logging) to keep the code modular and clean.
• Place error-handling middleware at the end of the middleware stack to catch any unhandled errors.
• Avoid using synchronous code in middleware to prevent blocking the event loop.

_mukul_

Follow

Improve

Article Tags :

• Web Technologies
• Node.js
• TrueGeek
• Express.js
• TrueGeek-2021
• NodeJS-Questions
• ExpressJS-Middlewares

+3 More