Controller middleware is a mechanism bound to the controller or its method to execute specific logic before and after request processing. 1. It is a function that runs before or after the request reaches the controller, used to implement functions such as authentication, permission control, logging, etc.; 2. Common usage scenarios include user authentication, permission checking, parameter processing, current limit and anti-brushing, etc., for example, access is restricted through the custom ensureAdmin function in Express; 3. The usage methods are slightly different in different frameworks, such as Laravel binds middleware through constructors, Express uses app.use or specified in routes, and NestJS uses the decorator method; 4. Practical suggestions include reasonably splitting logic, paying attention to middleware order, ensuring call next(), improving reusability and doing a good job of testing, thereby improving project structure clarity and maintenance efficiency.

Controller middleware is a mechanism for executing specific logic before or after a controller request is processed. It is commonly used in web development frameworks, such as Laravel, Express.js, or NestJS. Its function is similar to the "middleman". It can do some preprocessing (such as authentication, logging, etc.) before actually executing the controller method, or do some subsequent operations after execution.

1.What is controller middleware?

Simply put, controller middleware is a function bound to a controller or its method, which will be called before (or after) the request reaches the controller. You can understand it as a level. Only after passing this level can the request continue to move down.

For example: You have a user management page that only administrators can access. At this time, you can use middleware to check whether the user has permissions. If there is no permission, the error will be returned directly, and the request will not be allowed to enter the real controller logic.

2. Common usage scenarios

• Authentication : Check whether the user is logged in
• Permission control : determines whether the user has the right to access a resource
• Logging : Record request information for easy debugging and monitoring
• Parameter filtering or conversion : uniform processing of request parameters
• Current limit/anti-brushing : limit the number of requests by a user within a unit time

For example, in Express you can add a simple middleware like this:

 function ensureAdmin(req, res, next) {
  if (req.user && req.user.role === 'admin') {
    next(); // Continue to the next middleware or controller} else {
    res.status(403).send('No permission');
  }
}

Then use it in the route:

 app.get('/admin/dashboard', ensureAdmin, (req, res) => {
  res.send('Welcome to the background');
});

3. How to use it in different frameworks?

Different frameworks implement middleware slightly differently, but the basic ideas are the same. Here are a few common frameworks to use:

Laravel (PHP)

Laravel's middleware can be bound to the entire controller or to a method. For example:

 // Add middleware public function __construct() in the controller constructor
{
    $this->middleware('auth');
}

It can also be effective only for certain methods:

 $this->middleware('auth')->only(['create', 'edit']);

Express.js (Node.js)

Express's middleware is very flexible, and can be placed in the route or written as global middleware. For example:

 app.use('/api', authMiddleware, apiRoutes);

NestJS (Node.js)

NestJS binds middleware using decorators, which is closer to the object-oriented style:

 @UseGuards(AuthGuard)
@Controller('users')
export class UsersController {}

4. Some practical suggestions

• Reasonable split logic : Don’t stuff too much logic into a middleware and keep the responsibilities single.
• The order is important : multiple middlewares are executed in sequence, and the wrong order may lead to problems.
• Remember to call next() : otherwise the request will be "stuck".
• Reusability priority : Try to write reusable middleware as much as possible to avoid duplicate code.
• Test middleware behavior : Especially for the part involving permission control, be sure to do a good job of testing the boundary situation.

Basically that's it. Mastering the controller middleware can make your project structure clearer, more controllable, and easier to maintain.

The above is the detailed content of What are controller middleware, and how do I use them?. For more information, please follow other related articles on the PHP Chinese website!