The steps for creating and using custom middleware in Laravel are as follows: 1. Use the Artisan command to generate middleware classes, such as php artisan make:middleware CheckAge; 2. Write logic in the generated middleware class, such as checking whether the age parameters are less than 18, and redirect to the specified page if the conditions are met, otherwise continue to execute subsequent logic; 3. Register the middleware and add mappings to the $routeMiddleware array in the Kernel.php file; 4. Apply the middleware to the route or controller, and call the middleware method through ->middleware('check.age') or in the constructor; 5. Parameters can be passed to the middleware. If used for role checking, parameters need to be provided during route definition and modify the handle method to receive these parameters; 6. When using middleware, you should pay attention to order, avoid complex logic, and simulate request data during testing.

Laravel's middleware is a very practical tool to filter HTTP requests into the application. Although Laravel comes with some commonly used middleware, such as authentication, CSRF protection, etc., many times we also need to create custom middleware based on our own business logic. This article will talk about how to create and use custom middleware in Laravel.

Create custom middleware

Creating middleware in Laravel is very simple, you can use the Artisan command to automatically generate a middleware class:

 php artisan make:middleware CheckAge

This command will generate a file named CheckAge.php in app/Http/Middleware directory. Open this file and you will see a class containing handle method. This method receives the request and the next middleware as parameters and returns the response or continues to execute the next middleware.

For example, we can write a simple age check logic:

 public function handle($request, Closure $next)
{
    if ($request->input(&#39;age&#39;) < 18) {
        return redirect(&#39;no-access&#39;);
    }

    return $next($request);
}

The meaning of this code is: if the user submits the age parameter less than 18, it will jump to the no-access page; otherwise, the subsequent logic will continue.

Register and apply middleware

After creating the middleware, the next step is to register it and apply it to a route or controller.

First, register the middleware in the app/Http/Kernel.php file. If you want this middleware to be multiplexed by multiple routes, you can add it to the $routeMiddleware array:

 'check.age' => \App\Http\Middleware\CheckAge::class,

Then you can use it in the route like this:

 Route::get('/welcome', function () {
    return view('welcome');
})->middleware('check.age');

Or it can be used directly in the controller constructor:

 public function __construct()
{
    $this->middleware('check.age');
}

This allows you to control which pages need to be processed through this middleware.

Tips for middleware parameter transfer

Sometimes you may need to pass some parameters to the middleware. For example, you want the middleware to check whether the user's role is "administrator" or "editor", rather than writing dead judgment conditions.

At this time, you can add parameters when defining the middleware:

 Route::get('/admin', function () {
    // ...
})->middleware('role:admin,editor');

Then receive these parameters in the handle method of the middleware:

 public function handle($request, Closure $next, ...$roles)
{
    if (! in_array($request->user()->role, $roles)) {
        return redirect('no-permission');
    }

    return $next($request);
}

This approach is very flexible and is suitable for functions such as permission control and role restrictions.

A few tips for using

• The order of middleware is important : in Kernel's $middlewarePriority or $middlewareGroups , the execution order of middleware will affect the results, especially logic involving dependency states such as session and auth.
• Don't stuff too much logic into middleware : middleware is suitable for unified processing, such as logging and permission verification. It is better to place too complex business logic in the controller or service layer.
• Remember to simulate request data when testing middleware : especially middleware that relies on input parameters or user identity. When testing with PHPUnit, you must prepare relevant data.

Basically that's all. Custom middleware is not complicated, but it is very useful in actual projects. Reasonable use can greatly improve the clarity of the code structure.

The above is the detailed content of Creating and applying custom middleware in Laravel. For more information, please follow other related articles on the PHP Chinese website!