how to perform validation using middleware in laravel9

In Laravel, you can use middleware to perform validation on incoming HTTP requests. This allows you to keep your validation logic separate from your controller logic.

You can create a new middleware class using the make:middleware command:

php artisan make:middleware ExampleValidation

This will create a new file in the app/Http/Middleware directory.

In this class, you can define a handle method that will receive the request and the next closure to be executed. Here is an example of how to validate a request with a name and email field:

public function handle($request, Closure $next)
{
    $validator = Validator::make($request->all(), [
        'name' => 'required|string|min:3',
        'email' => 'required|email',
    ]);

    if ($validator->fails()) {
        return response()->json($validator->errors(), 400);
    }

    return $next($request);
}

You can then apply this middleware to specific routes or controllers using the middleware property or the middleware method:

Route::middleware(ExampleValidation::class)->group(function () {
    // routes that require validation
});

class ExampleController extends Controller
{
    public function __construct()
    {
        $this->middleware(ExampleValidation::class);
    }
}

Alternatively you can use it globally in app/Http/Kernel.php by adding it to $middleware array

protected $middleware = [
    // ...
    ExampleValidation::class,
];

You can also use the except or only properties to specify which routes should not be affected by the middleware.

In this example, the validation middleware will validate the request data against the rules defined in the validator, and if it fails, it will return a JSON response with the error messages.

Keep in mind that, you should import the Validator facade at the top of the file use Illuminate\Support\Facades\Validator;

You can use other validation methods as well like validate which will automatically redirect the user with error messages if validation fails.

In Laravel, validation can be performed using middleware by creating a custom middleware class and defining the validation logic within the handle method. The middleware can then be assigned to a route or a group of routes.

Here is an example of a custom middleware class that performs validation on the request data:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Validation\ValidationException;

class ValidateRequest
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  array  $rules
     * @return mixed
     */
    public function handle($request, Closure $next, array $rules)
    {
        $validator = \Validator::make($request->all(), $rules);

        if ($validator->fails()) {
            throw new ValidationException($validator);
        }

        return $next($request);
    }
}

Here is an example of a custom middleware class that performs validation on the request data:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Validation\ValidationException;

class ValidateRequest
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  array  $rules
     * @return mixed
     */
    public function handle($request, Closure $next, array $rules)
    {
        $validator = \Validator::make($request->all(), $rules);

        if ($validator->fails()) {
            throw new ValidationException($validator);
        }

        return $next($request);
    }
}

You can then assign the middleware to a route by listing it in the middleware property of the $route array, like so:

Route::post('/submit', [ValidateRequest::class, 'rules' => ['name' => 'required', 'email' => 'required|email']], function() {
    // handle the request
});

You can also assign the middleware to a group of routes in the Kernel.php file:

protected $routeMiddleware = [
    'validate' => ValidateRequest::class,
];

Route::middleware(['validate' => ['rules' => ['name' => 'required', 'email' => 'required|email']]])->group(function () {
    Route::post('/submit', function() {
        // handle the request
    });

    Route::put('/submit', function() {
        // handle the request
    });
});

This is a simple example, You can also use the validate helper function in the controller's method

public function store(Request $request)
{
    $validatedData = $request->validate([
        'name' => 'required',
        'email' => 'required|email',
    ]);

    // handle the request
}

It's also possible to use the validate method on the request instance, like this:

$request->validate([
    'name' => 'required',
    'email' => 'required|email',
]);

You can pick the one that fits your needs.

Debug School

how to perform validation using middleware in laravel9

Latest comments (0)