O middleware fornece um mecanismo conveniente para inspecionar e filtrar solicitações HTTP que entram em seu aplicativo. Por exemplo, o Lithe inclui middleware que verifica se o usuário está autenticado. Caso contrário, o middleware redirecionará o usuário para a tela de login. Se o usuário estiver autenticado, o middleware permite que a solicitação prossiga.

Como funciona o middleware no Lithe

No Lithe, middleware são funções com acesso ao objeto de solicitação ($req), ao objeto de resposta ($res) e à função $next no ciclo de solicitação-resposta da aplicação. A função $next, quando invocada, chama o próximo middleware na pilha atual.

As funções de middleware fornecem uma maneira conveniente de inspecionar, filtrar e manipular solicitações HTTP recebidas em seu aplicativo. Eles podem:

• Execute qualquer código.
• Modifique os objetos de solicitação e resposta.
• Encerre o ciclo de solicitação-resposta.
• Chame o próximo middleware na pilha.

Se o middleware atual não encerrar o ciclo de solicitação-resposta, ele deverá chamar $next() para passar o controle para o próximo middleware. Caso contrário, a solicitação permanecerá pendente.

Elementos de uma função de middleware

O código a seguir demonstra os elementos de uma função de middleware:

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

Onde:

• $req: argumento de solicitação HTTP, convencionalmente chamado de $req.
• $res: argumento de resposta HTTP, convencionalmente chamado de $res.
• $next: Argumento de retorno de chamada, convencionalmente chamado de $next.

Definindo Middleware

Aqui está um exemplo simples de middleware chamado myLogger. Este middleware imprime a mensagem LOGGED toda vez que uma solicitação passa por ele. É definido como uma função atribuída a uma variável chamada myLogger:

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

Observe a chamada $next() acima. Esta função chama o próximo middleware no aplicativo. $next() não é uma função PHP ou Lithe integrada, mas é o terceiro argumento passado para a função de middleware. Embora $next() possa ter qualquer nome, por convenção, ele é sempre chamado de “próximo”. Para evitar confusão, siga esta convenção.

Imagine o middleware como uma série de "camadas" pelas quais as solicitações HTTP passam antes de chegar ao seu aplicativo. Cada camada pode examinar ou rejeitar a solicitação.

Carregando Middleware

Para carregar o middleware, você chama o método use() da classe \Lithe\App, especificando a função do middleware. Por exemplo:

$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!');
});

Sempre que o app receber uma solicitação, a mensagem "LOGGED" será impressa. A ordem de carregamento do middleware é importante: aqueles carregados primeiro são executados primeiro.

O middleware myLogger simplesmente imprime uma mensagem e depois passa a solicitação para o próximo middleware usando $next().

Usando Middleware

Um aplicativo Lithe pode usar os seguintes tipos de middleware:

• Middleware em nível de aplicativo
• Middleware em nível de roteador
• Middleware de terceiros

Middleware em nível de aplicativo

Você anexa middleware de nível de aplicativo a uma instância do aplicativo usando os métodos use() ou METHOD(), onde METHOD se refere ao método HTTP (por exemplo, GET, PUT, POST) em letras minúsculas.

Este exemplo mostra middleware sem caminho. O middleware é executado sempre que uma solicitação é recebida:

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

No exemplo abaixo, o middleware lida com uma solicitação GET para o caminho /user/:id:

$app->get('/user/:id', function ($req, $res, $next) {
    if ($req->param('id') === '0') {
        return $next();
    } 
    $res->send('ID is not 0');
}, function ($req, $res) {
    $res->send('regular');
});

Middleware em nível de roteador

O middleware em nível de roteador funciona como o middleware em nível de aplicativo, mas é anexado a uma instância de \Lithe\Http\Router:

$router = new \Lithe\Http\Router;

Você carrega middleware em nível de roteador usando as funções use() e METHOD().

Aqui está um exemplo de middleware em nível de roteador:

$router = new \Lithe\Http\Router;

$router->use(function ($req, $res, $next) {
    echo 'Time: ', Date('H:i:s'), '
';
    $next();
});

$router->get('/user/:id', function ($req, $res, $next) {
    if ($req->param('id') === '0') {
        $res->redirect('/');
    }
    $next();
}, function ($req, $res) {
    echo $req->param('id');
    $res->render('special');
});

$app->use('/api', $router);

Middleware de terceiros

Você pode usar middleware de terceiros para adicionar funcionalidade aos seus aplicativos Lithe. Instale o módulo PHP necessário e carregue-o no nível do aplicativo ou roteador.

Aqui está um exemplo de carregamento de middleware de sessão com \Lithe\Middleware\Session\session:

use function Lithe\Middleware\Session\session;

$app = new \Lithe\App;

$app->use(session([
    'secure' => true
]));

Para obter uma lista de middleware de terceiros comumente usados ​​com o Lithe, verifique o recurso Middleware de terceiros.

Middleware configurável

Se você precisa que seu middleware seja configurável, você pode criar uma função que aceite uma variedade de opções ou outros parâmetros e então retorne a implementação do middleware com base nesses parâmetros. Veja o exemplo abaixo:

Agora, você pode usar o middleware com configurações personalizadas:


$app->use(my_middleware(['option1' => '1', 'option2' => '2']));




Para criar middleware que outros desenvolvedores possam instalar via Composer, existe um pacote chamado lithemod/flow. Ele fornece interfaces e utilitários para lidar com solicitações e respostas HTTP no Lithe, o que facilita a criação de middlewares padronizados e prontos para uso em vários aplicativos.

lithemod/flow ajuda a construir middlewares robustos, fornecendo uma interface unificada para solicitação e resposta, tornando o desenvolvimento mais eficiente e organizado. Isso simplifica a integração do seu middleware em outros projetos e garante que o código siga padrões consistentes.