在框架的入口文件中,实例化Illuminate\Foundation\Application类后,调用这个类的make方法,获取一个对象$kernel(核心)。这个核心像一个“黑盒子”,接受用户(浏览器)的请求,调用“盒子”的handle方法处理请求,获得一个响应,再把响应发送给用户(浏览器):$response->send()。最终调用“盒子”的terminate方法做一些收尾的工作,至此一个完整的http请求就完成了。看下来,也只是简单的几句代码,这是laravel的优雅之处,也是laravel晦涩难懂的原因。作者把处理请求的所有逻辑进行了封装。所以要深入理解这个框架,就得进入这个“盒子”,看看这个盒子是如何工作的。
中间件,顾名思义,是发生在收到请求、处理请求之间或者处理完请求、发送请求之间的一段逻辑,可能是对方法的调用,或者是对函数的调用。因此,中间件可以对用户的请求进行过滤,把非法的、不合理的请求过滤掉,最简单的应用就是检验用户的登陆状态,或者对用户的身份进行验证。再有,就是将响应报文做些处理之后发送给用户。
本篇文章的内容,尝试深入源码,看看中间件的实现过程,和实现原理。
$app->make(Illuminate\Contracts\Http\Kernel::class);
make方法接收了一个“接口”名称,返回了一个对象。这个方法定义在Application类的父类Container类(服务容器)中。Application类实例化后,调用了singleton方法进行绑定:
$app->singleton(
Illuminate\Contracts\Http\Kernel::class,
App\Http\Kernel::class
);
因此$kernel变量实际保存的是App\Http\Kernel类的实例。找到这个类的定义文件,我们发现这个类中定义了我们要找的中间件,同时继承了类Illuminate\Foundation\Http\Kernel。
<?php
namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
/**
* The application's global HTTP middleware stack.
*
* These middleware are run during every request to your application.
*
* @var array
*/
protected $middleware = [
\Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
\Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
\App\Http\Middleware\TrimStrings::class,
\Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
\App\Http\Middleware\TrustProxies::class,
];
/**
* The application's route middleware groups.
*
* @var array
*/
protected $middlewareGroups = [
'web' => [
\App\Http\Middleware\EncryptCookies::class,
\Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
\Illuminate\Session\Middleware\StartSession::class,
// \Illuminate\Session\Middleware\AuthenticateSession::class,
\Illuminate\View\Middleware\ShareErrorsFromSession::class,
\App\Http\Middleware\VerifyCsrfToken::class,
\Illuminate\Routing\Middleware\SubstituteBindings::class,
],
'api' => [
'throttle:60,1',
'bindings',
],
];
/**
* The application's route middleware.
*
* These middleware may be assigned to groups or used individually.
*
* @var array
*/
protected $routeMiddleware = [
'auth' => \Illuminate\Auth\Middleware\Authenticate::class,
'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
'can' => \Illuminate\Auth\Middleware\Authorize::class,
'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
];
}
找到父类中的handle方法。这个方法接受一个\Illuminate\Http\Request对象(请求),返回一个\Illuminate\Http\Response对象(响应),在方法中也只有几行代码,一个try catch块、一个事件调用、一个return:
public function handle($request)
{
try {
$request->enableHttpMethodParameterOverride();
$response = $this->sendRequestThroughRouter($request);
} catch (Exception $e) {
$this->reportException($e);
$response = $this->renderException($request, $e);
} catch (Throwable $e) {
$this->reportException($e = new FatalThrowableError($e));
$response = $this->renderException($request, $e);
}
$this->app['events']->dispatch(
new Events\RequestHandled($request, $response)
);
return $response;
}
重点关注下获取$response的语句:$response = $this->sendRequestThroughRouter($request);
/**
* Send the given request through the middleware / router.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
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());
}
首先在容器中绑定了request,之后调用Facade类的静态方法清理已解析的request记录,之后启动框架。最后return语句中,实例化Illuminate\Routing\Pipeline类(管道类),并且链式调用三个方法,send、through、then,最后得到\Illuminate\Http\Response(响应)。
定位到Pipeline类:Illuminate\Routing\Pipeline类继承了父类Illuminate\Pipeline\Pipeline。send、through、then三个方法都定义在父类中,send、through方法设置参数,重点在then方法,这个方法是实现中间件的关键所在。这个实现“管道”的关键是运用了php中的数组处理方法:array_reduce。和php中闭包。
利用这两个特性,框架的请求request对象,像通过管道一样通过中间件组:一个又一个的中间件像一节又一节的管道,请求对象在管道中穿过,每一节管道都可以对请求做些处理,最终把请求交给“destination”处理(通常是路由类实例)。我们在管道类的carry方法中可以看到中间件是怎么处理请求的:若中间件是闭包,则调用它,若不是,则实例化中间件,然后调用handle方法处理请求。
框架在app\Http\Middleware目录下预先定义了很多中间件。用户也可以自己定义,实现handle方法后,再把中间件注册到核心kernel类就可以实现自己的中间件了。