Previous

Express.js What is Middleware

Middleware in Express.js is a function that has access to the request object (req), the response object (res), and the next middleware function in the application's request-response cycle. Middleware functions are executed in sequence, and they are essential for tasks such as logging, authentication, request validation, and error handling.

 

Key Features of Middleware

  • Request Handling: Middleware functions can modify the request and response objects before passing them to the next handler.
  • Sequence Execution: Middleware functions are executed in the order they are defined.
  • Reusable: Middleware can be modularized and reused across routes and applications.
  • Error Handling: Middleware can be used for catching errors and managing exceptions.

 

Types of Middleware

Application-Level Middleware:
This type of middleware is bound to the app instance and applies to all routes or specific routes:

app.use((req, res, next) => {
    console.log('This middleware runs for every request');
    next();  // Pass control to the next middleware
});

Router-Level Middleware:
Applied to specific routes using express.Router() to group related middleware:

const router = express.Router();

router.use((req, res, next) => {
    console.log('Middleware for /user routes');
    next();
});

router.get('/:id', (req, res) => {
    res.send(`User ID: ${req.params.id}`);
});

Built-in Middleware:
Express provides several built-in middleware functions such as express.json() for parsing JSON requests and express.static() for serving static files:

app.use(express.json());  // Built-in middleware to parse JSON bodies
app.use(express.static('public'));  // Serve static files from the 'public' folder

Error-Handling Middleware:
This type of middleware is used to catch errors in the request-response cycle:

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

Third-Party Middleware:
You can use third-party middleware to handle specific tasks, such as cors for enabling cross-origin resource sharing:

const cors = require('cors');
app.use(cors());  // Enable CORS for all routes

 

Steps to Implement Middleware in Express.js

Set up a Basic Express Application
First, initialize a Node.js project and install Express:

npm init -y
npm install express --save

Define Middleware Functions
In your app.js file, create middleware that processes requests:

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

// Simple middleware function
app.use((req, res, next) => {
    console.log('Request received');
    next();  // Pass control to the next middleware
});

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

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

Test Middleware Functionality
Run the application by executing node app.js and access the route through a browser or API tool like Postman:

  • Visiting http://localhost:3000/ will log "Request received" and send "Hello, World!" as the response.

Use Middleware for Error Handling
You can also add error-handling middleware at the end:

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

Middleware Flow

  1. Request enters the server: The request hits the application, and the middleware functions are executed in the order they are defined.
  2. Each middleware function runs: If a middleware calls next(), the next function in the stack is executed.
  3. Response is sent to the client: After all middleware and route handlers have been executed, the final response is sent to the client.

 

Summary

Middleware in Express.js is a core part of handling requests and responses. It allows you to define reusable logic that can run for specific routes or globally. Middleware functions can modify request and response objects, perform operations like authentication, logging, and error handling, or even terminate the request-response cycle. By chaining multiple middleware functions, you can build complex applications in a modular and maintainable way.

Previous