Analyse du code source du middleware basé sur laravel5.2

Dans laravel5.2, la fonction principale de Http est de filtrer les requêtes Http (php aritsan n'a pas de mécanisme middleware) Cela rend également le niveau du système (couche de filtrage Http) plus clair. a l'air élégant aussi. Cependant, le code pour implémenter le middleware est très compliqué. Analysons le contenu du code source du middleware.

Code source du middleware

Le middleware lui-même est divisé en deux types, l'un pour tout http et l'autre pour la route. Un cycle de requête avec middleware est le suivant : La requête doit d'abord passer par le Middleware HTTP avant de pouvoir aller au routeur, puis passer par le Middleware de route, et enfin le Code contrôleur correspondant sera saisi. Laravel divise les requêtes en deux types : http et console. Différentes méthodes de requête utilisent son propre pour conduire Kernel. Les requêtes HTTP sont pilotées par la classe Application
, qui définit tous les middlewares. Sa classe parent IlluminateFoundationHttpKernel est le point d'entrée pour le traitement des requêtes IlluminateFoundationHttpKernel::handle

Middleware HTTP<.>En traçant la méthode d'entrée

, il est facile de trouver la fonction (

) : handle()IlluminateFoundationHttpKernel::sendRequestThroughRouter

Cette fonction distribuera Requset au routeur (vous pouvez la connaître par le nom de la méthode) , la logique principale est complétée via

protected function sendRequestThroughRouter($request)
{
    $this->app->instance('request', $request);

    Facade::clearResolvedInstance('request');

    $this->bootstrap();

    return (new Pipeline($this->app))
                ->send($request)
                ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
                ->then($this->dispatchToRouter());
}

, sa fonction est de laisser le Requset passer la détection du middleware Http, puis d'atteindre le routeur. Le code ici semble élégant mais n'est pas très compréhensible. Par conséquent, si vous comprenez le mécanisme de fonctionnement de

, vous comprendrez l'utilisation du middleware. IlluminateRoutingPipelinePipeline

L'implémentation en cours de Pipeline

la classe de base est

, et son exécution se fait dans la méthode Pipleline : IlluminatePipelinePipelinethen

Pour comprendre le but de cette exécution de code, vous devez savoir ce que fait array_reduce(). Afin de comprendre comment

public function then(Closure $destination)
{
    $firstSlice = $this->getInitialSlice($destination);

    $pipes = array_reverse($this->pipes);

    return call_user_func(
        array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
    );
}

fonctionne, réécrivez d'abord

 : array_reducearray_reduce

Donc, le

//将数组中的元素，依次执行$func函数，且上一次的$func的返回值作为下一次调用$func的第一个参数输入
function array_reduce_back($arr, callable $func, $firstResult = null)
{
    $result = $firstResult;
    
    foreach ($arr as $v) {
        $result = $func($result, $v);
    }
    
    return $result;
}

dans le code source est

, et il renvoie une fonction de rappel : $func (getSlice() et function($passable) use ($stack, $pipe){...} sont remplacés par les valeurs spécifiques saisies), c'est-à-dire que le premier paramètre entré dans le $stack suivant comme dernier résultat de retour est la fonction de rappel mentionnée ci-dessus dans cette boucle. , lorsque le tableau est parcouru Une fois terminé, $pipe renverra une fonction de rappel. La clé est maintenant de comprendre à quoi ressemble cette fonction de rappel et comment l'exécuter ? Pour faciliter la discussion, le code suivant peut être analysé : $funcarray_reduce

call_user_func(
        array_reduce([1, 2, 3], $this->getSlice(), $firstSlice), $this->passable
    );

Instructions d'exécution :

1 est la valeur initialisée, qui est

. , c'est-à-dire que c'est le rappel de retour de
$result_02. Chaque fois qu'un élément est traversé, le rappel de $firstSlice sera exécuté, et un rappel IlluminatePipelinePipeline::getInitialSlice3 sera également renvoyé le code d'exécution spécifique. dans
est dans IlluminatePipelinePipeline::getSlice
4. Le résultat final $result est getSlice(), qui est une fonction de rappel de fermeture multicouche
5. Ce qui est exécuté est array_reduce, c'est-à-dire. , $result_3
call_user_func($result_3, $this->passable) est exécuté À ce stade, le fonctionnement de function($this->passable) use ($result_2, 3){...} est clair. Si vous souhaitez continuer, vous devez comprendre comment la fonction de rappel est exécutée. Suivez maintenant

dans.

pour voir comment il est exécuté. then()sendRequestThroughRouterPipelineA l'aide du processus d'exécution

analysé ci-dessus, il sera bientôt analysé que la dernière exécution est

// 把具体的参数带进来
return (new Pipeline($this->app))
                ->send($request)
                ->through(['\Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode'])
                ->then($this->dispatchToRouter());

PipelineLe traitement logique a atteint

, et son code C'est :

function($requset) use (\Illuminate\Foundation\Http\Kernel::dispatchToRouter(), '\Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode') {

            if ($pipe instanceof Closure) {
                return call_user_func($pipe, $passable, $stack);
            }
            
            // $name和$parameters很容易得到
            // $name = '\Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode';
            // $parameters = [];
            list($name, $parameters) = $this->parsePipeString($pipe);


            // 执行的就是\Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::handle($request, \Illuminate\Foundation\Http\Kernel::dispatchToRouter())
            return call_user_func_array([$this->container->make($name), $this->method],
                        array_merge([$passable, $stack], $parameters));
}

IlluminateFoundationHttpMiddlewareCheckForMaintenanceMode::handleIci, il traite les conditions de filtrage requises par ce middleware, et en même temps exécute

, c'est-à-dire

public function handle($request, Closure $next)
{
    if ($this->app->isDownForMaintenance()) {
        throw new HttpException(503);
    }

    return $next($request);
}

De cette manière, la Requête est transférée vers. le routeur, et c'est terminé. Tout le travail de traitement du middleware Http est éliminé, et

est une opération indispensable pour tout middleware, car le rappel est imbriqué dans le rappel, ce qui signifie que le middleware passe $next($request) au routeur. prochain rappel, c'est-à-dire sera résolu vers le prochain middleware jusqu'au dernier. Suivez le processus d'exécution IlluminateFoundationHttpKernel::dispatchToRouter() analysé ci-dessus et complétez-le : $next($request)Request6 Exécutez le rappel dans $result_3, Pipeline instanciez le middleware, exécutez son

, dans le middleware Exécutez le rappel pendant le traitement <.>

7. S'il y a des rappels imbriqués dans le rappel, chaque middleware doit avoir le code pour exécuter le rappel getSlice pour garantir que les rappels dans le rappel seront exécutés. L'ordre d'exécution est 3 :: handel, 2 ::handel, 1 ::handel, $firsthandle

8.最里面一层，一定是传递给then()的参数,then执行的就是最后一步

9.执行的顺序是由数组中的最后一个，向前，到then()的参数，为了使其执行顺序是数组中的第一个到最后一个，再到then()中的参数，then()方法中就做了一个反转array_reverse

Pipeline小结

现在，Pipeline的所有执行流程就都分析完了。实现代码真的很绕，但理解之后编写自定义的中间件应该就很容易了。现在再把Pipeline的使用翻译成汉语，应该是这样的

// 使用管道，发送$request,使之通过middleware ，再到$func
(new Pipeline($this->app))->send($request)->through($this->middleware)->then($func);

这样的代码不管是从语义上，还是使用上都很优雅，高！确实是高！再回到源码，Requset的流程就通过dispatchToRouter进入到了Router

Route中间件

在Router中，\Illuminate\Routing\Router::dispatch就承接了来自Http中间件的Requset, Router把Request分发到了具体的Route,再进行处理，主要代码如下:

public function dispatchToRoute(Request $request)
{
    // 找到具体的路由对象，过程略
    $route = $this->findRoute($request);

    $request->setRouteResolver(function () use ($route) {
        return $route;
    });

    // 执行Request匹配到Route的事件，具体的代码在这里：\Illuminate\Foundation\Providers\FoundationServiceProvider::configureFormRequests
    $this->events->fire(new Events\RouteMatched($route, $request));
    
    // 这里就运行路由中间件了
    $response = $this->runRouteWithinStack($route, $request);

    return $this->prepareResponse($request, $response);
}


protected function runRouteWithinStack(Route $route, Request $request)
{
    // 获取该路由上的中间件
    // 简单就点可这样写：
    // $middleware = App::shouldSkipMiddleware() ? [] : $this->gatherRouteMiddlewares($route);
    $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                         $this->container->make('middleware.disable') === true;

    $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddlewares($route);
    
    // 了解Pipeline后，这里就好理解了，应该是通过管道，发送$request,经过$middleware，再到then中的回调
    return (new Pipeline($this->container))
                    ->send($request)
                    ->through($middleware)
                    ->then(function ($request) use ($route) {
                        return $this->prepareResponse(
                            $request,
                            $route->run($request)
                        );
                    });
}

如何获取Route中间件的，就可以跟gatherRouteMiddlewares,这个代码并不难，很好跟。接下来,Request就到到达至于Controller, Request是如何到达Controller的代码就不难了，这里就不说了

Controller后执行中间件

成功获取Response后,在public/index.php58行执行了$kernel->terminate($request, $response);, 也就是在主要逻辑处理完成之后,再执行此代码,它实际上调用是的\Illuminate\Foundation\Http\Kernel::terminate, 跟进去就很容易发现,它处理了这此请求所涉及到的中间件,并执行了各自的terminate方法,到这里,中间件的另一个功能就展现出来了,就是主要逻辑完成之后的收尾工作.到这里为止,中间件就完成了它的使命(一个请求也就完成了)

如何使用中间件

在官方文档上讲解的很清楚注册中间

中间件小结

至此,中间件的实现逻辑与使用就清晰了.从执行的顺序来分,一个在Controller之前,一个在Controller之后,所以它一个很重要的作用就是可以让Controller专注于自己的主要逻辑的职责更明确. 奇怪的是,但前后两种中间件的执行方式却不一样, \Illuminate\Foundation\Http\Kernel::terminate,中间件的结束却没有使用Pipeline, 而是直接foreach.相同的工作却用两种代码来实现.现在看来,中间件本身并不复杂,但它带给了我两个启发,1.层次明确 2,Pipeline所带来的优雅.

相关推荐：

laravel5.4中自定义包开发的实例

Laravel 5.1框架中如何创建自定义Artisan控制台命令

laravel框架的启动过程分析

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!