The method of passing parameters in middleware depends on the framework or environment used, but is usually implemented by factory functions, option classes, or directly providing parameters at application time. 1. In Express.js, you can return the middleware through factory functions and pass parameters when applying, such as logAction('User visited page'); 2. In Laravel, you can define parameters in the handle method of the middleware class, and use colons to pass values ??in the route, such as middleware('check-role:admin'); 3. In ASP.NET Core, you can encapsulate the configuration through the option class, inject the configuration into the middleware constructor, and then pass the instance through the UseMiddleware method. In addition, attention should be paid to whether the parameters are static or dynamic, maintain middleware decoupling and testability, and properly handle invalid or missing parameters.

Passing parameters to middleware depends on the framework or environment you're using, but the general idea is to provide additional data or configuration when applying the middleware. Here's how to do it in a few common environments.

In Express.js (Node.js)

In Express, middleware functions can accept parameters beyond the standard req , res , and next . You can wrap your middleware in a factory function that takes parameters and returns the actual middleware function.

Example:

 function logAction(message) {
  return function(req, res, next) {
    console.log(`Action: ${message}`);
    next();
  };
}

app.get('/route', logAction('User visited page'), (req, res) => {
  res.send('Hello World');
});

• The logAction function is a factory that returns the middleware.
• You pass the message parameter when applying the middleware.
• This lets you customize behavior per route or use case.

This pattern is especially useful for reusable logic like logging, authentication with roles, or rate limiting.

In Laravel (PHP)

Laravel allows passing parameters to middleware both when defining the middleware class and when applying it in routes.

Define middleware with parameters:

In your middleware class, the handle method can accept additional parameters:

 public function handle($request, $next, $role) {
    if ($request->user()->hasRole($role)) {
        return $next($request);
    }

    return redirect('/home');
}

Register middleware with parameter in kernel:

 'check-role' => \App\Http\Middleware\CheckRole::class,

Apply middleware with parameter in route:

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

• You define what parameters the middleware expects.
• You pass values ??when applying the middleware.
• It's commonly used for role-based access control.

In ASP.NET Core (C#)

ASP.NET Core supports passing parameters to middleware via options classes or directly in the pipeline setup.

Using an options class:

Define an options class:

 public class GreetingOptions {
    public string Message { get; set; }
}

Create middleware that uses the options:

 public class GreetingMiddleware {
    private readonly RequestDelegate _next;
    private readonly GreetingOptions _options;

    public GreetingMiddleware(RequestDelegate next, IOptions<GreetingOptions> options) {
        _next = next;
        _options = options.Value;
    }

    public async Task Invoke(HttpContext context) {
        await context.Response.WriteAsync(_options.Message);
        await _next(context);
    }
}

Use it in Startup.cs :

 app.UseMiddleware<GreetingMiddleware>(new GreetingOptions { Message = "Hello from middleware!" });

• You encapsulate configuration in a class.
• Middleware receives the configured object at runtime.
• This keeps your middleware clean and testable.

General Tips

• Always consider whether the parameter is static (known at startup) or dynamic (determined during request).
• Use wrapper functions or factories when you need to pass values ??dynamically.
• Avoid tightly coupling your middleware to specific business logic—keep it configurable.
• Make sure your middleware gracefully handles missing or invalid parameters.

Basically that's it.

The above is the detailed content of How do I pass parameters to middleware?. For more information, please follow other related articles on the PHP Chinese website!