Middleware in Lithe: How It Works and How to Create Your Own

Middlewares provide a convenient mechanism for inspecting and filtering HTTP requests coming into your application. For example, Lithe includes middleware that checks whether your application user is authenticated. If the user is not authenticated, the middleware will redirect the user to your application's login screen. However, if the user is authenticated, the middleware will allow the request to proceed within the application.

---

How middleware works in Lithe

In Lithe, Middleware are functions that have access to the request object ($req), response object ($res) and the $next function in the application's request-response loop. The $next function is a function in the Lithe router that, when invoked, executes the middleware next to the current middleware.

Middleware functions provide a convenient mechanism for inspecting, filtering, and handling HTTP requests entering your application.

Middleware functions can perform the following tasks:

• Run any code.
• Make changes to request and response objects.
• End the request-response cycle.
• Call the next middleware in the stack.

If the current middleware function does not end the request-response cycle, it must call $next() to pass control to the next middleware function. Otherwise, the request will be pending.

---

Elements of a Middleware Function

The following code shows the elements of a middleware function call:

$app->use(function ($req, $res, $next) {
    $next();
});

Where:
- $req: HTTP request argument for the middleware function, called "$req" by convention.
- $res: HTTP response argument for the middleware function, called "$res" by convention.
- $next: Callback argument for the middleware function, called "$next" by convention.

---

Defining Middleware

Let's start with a simple middleware example called myLogger. This middleware prints the LOGGED message every time a request passes through it. Middleware is defined as a function assigned to a variable called myLogger:

$myLogger = function ($req, $res, $next) {
  echo 'LOGGED';
  $next();
};

Note the call to $next() above. Calling this function invokes the next middleware function in the application. The $next() function is not part of PHP or Lithe, but it is the third argument passed to the middleware function. The $next() function could have any name, but by convention it is always called "next". To avoid confusion, always use this convention.

It's best to think of middleware as a series of "layers" that HTTP requests must traverse before reaching your application. Each layer can examine the request and even reject it completely.

---

Loading Middleware

To load a middleware function, you can call the use() method of the LitheApp class, specifying the desired middleware function. For example, the following code loads the myLogger middleware function before executing the route to the root path (/):

$app->use(function ($req, $res, $next) {
    $next();
});

Whenever the application receives a request, it prints the message "LOGGED".

The middleware loading order is important: middleware functions that are loaded first are also executed first.

The myLogger middleware function simply prints a message and then passes the request to the next middleware function on the stack by calling the $next() function.

---

Using Middleware

A Lithe application can use the following types of middleware:

• Application-level middleware
• Router-grade middleware
• Third-party middleware

Application-level middleware

Bind application-level middleware to an instance of the application object using the use() and METHOD() methods, where METHOD is the HTTP method of the request that the middleware function handles (such as GET, PUT, or POST) in lowercase.

This example shows a middleware function with no assembly path. The function is executed every time the application receives a request.

$myLogger = function ($req, $res, $next) {
  echo 'LOGGED';
  $next();
};

The example below shows a middleware that handles GET requests in the path /user/:id.

$app = new \Lithe\App;

$myLogger = function ($req, $res, $next) {
    echo 'LOGGED';
    $next();
};

$app->use($myLogger);

$app->get('/', function ($req, $res, $next) {
    $res->send('Hello World!');
});

Router-level middleware

Router-level middleware works the same way as application-level middleware, except that it is tied to an instance of LitheHttpRouter.

$app->use(function ($req, $res, $next) {
    echo 'Hello World!';
    $next();
});

Load router-level middleware using the USE and METHOD functions.

The following example code shows a middleware system using router-level middleware:

$app->get('/user/:id', function ($req, $res, $next) {
    // Se o ID do usuário for '0', passa para o próximo middleware
    if ($req->param('id') === '0') {
        return $next();
    } 

    // Caso contrário, envia uma resposta específica
    $res->send('ID não é 0');
}, function ($req, $res) {
    // Envia uma resposta quando o ID for '0'
    $res->send('regular');
});

Third-party middleware

Use third-party middleware to add functionality to Lithe apps.

Install the PHP module required for the desired functionality and then load it into your application at the application level or at the router level.

The following example illustrates loading the session middleware, the LitheMiddlewareSessionsession function.

$router = new \Lithe\Http\Router;

For a partial list of third-party middleware functions commonly used with Lithe, see: Third-Party Middleware.

Configurable middleware

If you need your middleware to be configurable, create a function that accepts an array of options or other parameters, and then returns the middleware implementation based on the input parameters.

$app->use(function ($req, $res, $next) {
    $next();
});

Now the middleware can be used as shown below.

$myLogger = function ($req, $res, $next) {
  echo 'LOGGED';
  $next();
};

The above is the detailed content of Middleware in Lithe: How It Works and How to Create Your Own. For more information, please follow other related articles on the PHP Chinese website!