Laravel middleware is a filtering layer that handles HTTP requests, which is used to uniformly process logic before the request reaches the controller. It is suitable for scenarios such as authentication, permission control, logging, cross-domain processing and current limiting. To create custom middleware, you can use the Artisan command: 1. Execute php artisan make:middleware CheckToken to generate middleware; 2. Write logic in the handle method, such as verifying the request header token; 3. Register the middleware, and add it to the Kernel's $middleware array for global use, and register it to $routeMiddleware and specify it in the route. For example, the current limiting middleware can combine Redis to implement request frequency control. Pay attention to: 1. Register as needed to avoid unnecessary performance losses; 2. The middleware execution order affects the logic process; 3. Retrieve general logic to improve reusability; 4. Avoid time-consuming operations in the middleware.

Laravel middleware is an excellent tool for handling requests and responses, especially when certain logic needs to be handled uniformly. For example, in scenarios such as verification, logging, permission control, etc., middleware can play a good role.

What is middleware?

Simply put, middleware is a layer for filtering HTTP requests. You can think of it as a pipeline, and every request passes here before it comes in, and you can do something before it reaches the controller, such as checking whether the user is logged in, logging access logs, setting the locale, etc.

Laravel comes with some commonly used middleware, such as auth , csrf , throttle , etc. Of course, you can also create custom middleware according to your business needs.

How to create and use custom middleware?

Creating middleware in Laravel is very simple, you just need to run the Artisan command:

 php artisan make:middleware CheckToken

This command will generate a middleware file in app/Http/Middleware directory. Then you can write your logic in it. For example, determine whether there is a token in the request header:

 public function handle($request, Closure $next)
{
    if (!$request->header('Authorization')) {
        return response('Missing token', 401);
    }

    return $next($request);
}

After creation is complete, don't forget to register the middleware. If it is global middleware, add it to the $middleware array of app/Http/Kernel.php ; if you only want to take effect on certain routes, add it to $routeMiddleware and use it through the route.

For example, in routing:

 Route::get('/api/data', [DataController::class, 'index'])->middleware('check.token');

What can middleware do?

There are actually quite a lot of scenarios that middleware is suitable, and the common ones are as follows:

• Authentication : For example, check whether the user is logged in or whether the token is valid.
• Permission control : For example, restrict some interfaces to be accessed only by administrators.
• Logging : Records the time, IP, parameters and other information of each request.
• Cross-domain processing (CORS) : Although Laravel provides configuration methods, it can also be flexibly processed using middleware.
• Current limit : Prevent the interface from being called frequently, such as up to 60 requests per minute.

For example, if you want to make a stream-limiting middleware, you can combine Redis to record the number of requests:

 public function handle($request, Closure $next)
{
    $key = 'rate_limit_' . $request->ip();
    $count = Redis::get($key);

    if ($count >= 60) {
        return response('Too many requests', 429);
    }

    Redis::incr($key);
    Redis::expire($key, 60); // Reset return $next($request);
}

This approach is more flexible and controllable than simply relying on the throttle that comes with the framework.

Tips and notes

• If middleware is only used for specific routes, it is recommended to register as routing middleware instead of global middleware to avoid affecting other interfaces.
• There is an order between multiple middlewares, and the execution order is to enter from top to bottom and then return from bottom to top.
• Some general logic can be extracted and made into reusable middleware to improve the cleanliness of the code.
• Don't do too many time-consuming operations in middleware, such as large number of database queries or complex calculations, which will affect performance.

Basically that's it. Middleware is a very practical function. If used properly, it can greatly improve the structural clarity and maintainability of the project.

The above is the detailed content of Using Middleware for Request Handling in Laravel?. For more information, please follow other related articles on the PHP Chinese website!