Dans Laravel, le routage est le moyen permettant au monde extérieur d'accéder aux applications Laravel, ou le routage définit la manière spécifique dont les applications Laravel fournissent des services au monde extérieur. Routage soumettra la demande de l'utilisateur au contrôleur spécifié et à la méthode de traitement selon le plan pré-planifié.
L'environnement d'exploitation de ce tutoriel : système Windows 7, version Laravel 6, ordinateur DELL G3.
Le routage est le moyen permettant au monde extérieur d'accéder aux applications Laravel, ou le routage définit la manière spécifique dont les applications Laravel fournissent des services au monde extérieur : ce n'est que via l'URI spécifié, la méthode de requête HTTP et les paramètres de routage (facultatif) que le la définition de routage soit correctement accessible.
Peu importe que le gestionnaire correspondant à l'URI soit une simple fermeture ou que la méthode du contrôleur n'ait pas de route correspondante, le monde extérieur ne peut pas y accéder
Aujourd'hui, nous allons voir comment Laravel conçoit et implémente le routage.
Nous définissons généralement la route comme suit dans le fichier de routage :
Route::get('/user', 'UsersController@index');
Grâce au routage ci-dessus, nous pouvons savoir que lorsque le client demande l'URI "/user" via HTTP GET, Laravel finalisera la demande vers le. méthode d'index de la classe UsersController pour le traitement, puis renvoie la réponse au client dans la méthode d'index.
La classe Route utilisée lors de l'enregistrement de la route ci-dessus s'appelle Facade dans Laravel. Elle fournit un moyen simple d'accéder au routeur de service lié au conteneur de service. Je prévois d'utiliser le concept de conception et la méthode d'implémentation de Let's. écrivez un article de blog séparé. Ici, nous avons seulement besoin de savoir que les méthodes statiques de la façade Route qui sont appelées correspondent aux méthodes du service de routeur dans le conteneur de services, vous pouvez donc également voir la route ci-dessus comme enregistrée comme ceci :
app()->make('router')->get('user', 'UsersController@index');
router Ce service est lié au conteneur de service en enregistrant le RoutingServiceProvider dans le constructeur lors de l'instanciation de l'application Application :
//bootstrap/app.php
$app = new Illuminate\Foundation\Application(
realpath(__DIR__.'/../')
);
//Application: 构造方法
public function __construct($basePath = null)
{
if ($basePath) {
$this->setBasePath($basePath);
}
$this->registerBaseBindings();
$this->registerBaseServiceProviders();
$this->registerCoreContainerAliases();
}
//Application: 注册基础的服务提供器
protected function registerBaseServiceProviders()
{
$this->register(new EventServiceProvider($this));
$this->register(new LogServiceProvider($this));
$this->register(new RoutingServiceProvider($this));
}
//\Illuminate\Routing\RoutingServiceProvider: 绑定router到服务容器
protected function registerRouter()
{
$this->app->singleton('router', function ($app) {
return new Router($app['events'], $app);
});
}Grâce au code ci-dessus, nous savons que les méthodes statiques appelées par Route correspondent toutes à IlluminateRoutingRouter</ code> Méthodes en classe, la classe Router contient des méthodes liées à l'enregistrement, à l'adressage et à la planification du routage. <code>IlluminateRoutingRouter类里的方法，Router这个类里包含了与路由的注册、寻址、调度相关的方法。
下面我们从路由的注册、加载、寻址这几个阶段来看一下laravel里是如何实现这些的。
路由加载
注册路由前需要先加载路由文件，路由文件的加载是在AppProvidersRouteServiceProvider这个服务器提供者的boot方法里加载的:
class RouteServiceProvider extends ServiceProvider
{
public function boot()
{
parent::boot();
}
public function map()
{
$this->mapApiRoutes();
$this->mapWebRoutes();
}
protected function mapWebRoutes()
{
Route::middleware('web')
->namespace($this->namespace)
->group(base_path('routes/web.php'));
}
protected function mapApiRoutes()
{
Route::prefix('api')
->middleware('api')
->namespace($this->namespace)
->group(base_path('routes/api.php'));
}
}namespace Illuminate\Foundation\Support\Providers;
class RouteServiceProvider extends ServiceProvider
{
public function boot()
{
$this->setRootControllerNamespace();
if ($this->app->routesAreCached()) {
$this->loadCachedRoutes();
} else {
$this->loadRoutes();
$this->app->booted(function () {
$this->app['router']->getRoutes()->refreshNameLookups();
$this->app['router']->getRoutes()->refreshActionLookups();
});
}
}
protected function loadCachedRoutes()
{
$this->app->booted(function () {
require $this->app->getCachedRoutesPath();
});
}
protected function loadRoutes()
{
if (method_exists($this, 'map')) {
$this->app->call([$this, 'map']);
}
}
}
class Application extends Container implements ApplicationContract, HttpKernelInterface
{
public function routesAreCached()
{
return $this['files']->exists($this->getCachedRoutesPath());
}
public function getCachedRoutesPath()
{
return $this->bootstrapPath().'/cache/routes.php';
}
}laravel 首先去寻找路由的缓存文件，没有缓存文件再去进行加载路由。缓存文件一般在 bootstrap/cache/routes.php 文件中。
方法loadRoutes会调用map方法来加载路由文件里的路由，map这个函数在AppProvidersRouteServiceProvider类中，这个类继承自IlluminateFoundationSupportProvidersRouteServiceProvider。通过map方法我们能看到laravel将路由分为两个大组：api、web。这两个部分的路由分别写在两个文件中：routes/web.php、routes/api.php。
Laravel5.5里是把路由分别放在了几个文件里，之前的版本是在app/Http/routes.php文件里。放在多个文件里能更方便地管理API路由和与WEB路由
路由注册
我们通常都是用Route这个Facade调用静态方法get, post, head, options, put, patch, delete......等来注册路由，上面我们也说了这些静态方法其实是调用了Router类里的方法:
public function get($uri, $action = null)
{
return $this->addRoute(['GET', 'HEAD'], $uri, $action);
}
public function post($uri, $action = null)
{
return $this->addRoute('POST', $uri, $action);
}
....可以看到路由的注册统一都是由router类的addRoute方法来处理的：
//注册路由到RouteCollection
protected function addRoute($methods, $uri, $action)
{
return $this->routes->add($this->createRoute($methods, $uri, $action));
}
//创建路由
protected function createRoute($methods, $uri, $action)
{
if ($this->actionReferencesController($action)) {
//controller@action类型的路由在这里要进行转换
$action = $this->convertToControllerAction($action);
}
$route = $this->newRoute(
$methods, $this->prefix($uri), $action
);
if ($this->hasGroupStack()) {
$this->mergeGroupAttributesIntoRoute($route);
}
$this->addWhereClausesToRoute($route);
return $route;
}
protected function convertToControllerAction($action)
{
if (is_string($action)) {
$action = ['uses' => $action];
}
if (! empty($this->groupStack)) {
$action['uses'] = $this->prependGroupNamespace($action['uses']);
}
$action['controller'] = $action['uses'];
return $action;
}注册路由时传递给addRoute的第三个参数action可以闭包、字符串或者数组，数组就是类似['uses' => 'Controller@action', 'middleware' => '...']这种形式的。如果action是Controller@action类型的路由将被转换为action数组, convertToControllerAction执行完后action的内容为：
[
'uses' => 'App\Http\Controllers\SomeController@someAction',
'controller' => 'App\Http\Controllers\SomeController@someAction'
]可以看到把命名空间补充到了控制器的名称前组成了完整的控制器类名，action数组构建完成接下里就是创建路由了，创建路由即用指定的HTTP请求方法、URI字符串和action数组来创建IlluminateRoutingRoute
IlluminateFoundationSupportProvidersRouteServiceProvider. Grâce à la méthode map, nous pouvons voir que laravel divise le routage en deux grands groupes : api et web. Les routes de ces deux parties sont écrites respectivement dans deux fichiers : routes/web.php et routes/api.php. Dans Laravel 5.5, les routes sont placées dans plusieurs fichiers. La version précédente était dans le fichier app/Http/routes.php. Le mettre dans plusieurs fichiers peut faciliter la gestion du routage API et du routage WEB
Enregistrement de l'itinéraire< / strong>
Nous utilisons généralement la Route Facade pour appeler les méthodes statiques get, post, head, options, put, patch, delete... etc. pour enregistrer les routes. Nous avons également dit ci-dessus que ces méthodes statiques sont en fait la méthode dans le. La classe de routeur s'appelle :
class RouteCollection implements Countable, IteratorAggregate
{
public function add(Route $route)
{
$this->addToCollections($route);
$this->addLookups($route);
return $route;
}
protected function addToCollections($route)
{
$domainAndUri = $route->getDomain().$route->uri();
foreach ($route->methods() as $method) {
$this->routes[$method][$domainAndUri] = $route;
}
$this->allRoutes[$method.$domainAndUri] = $route;
}
protected function addLookups($route)
{
$action = $route->getAction();
if (isset($action['as'])) {
//如果时命名路由，将route对象映射到以路由名为key的数组值中方便查找
$this->nameList[$action['as']] = $route;
}
if (isset($action['controller'])) {
$this->addToActionList($action, $route);
}
}
}Vous pouvez voir que l'enregistrement des routes est géré par la méthode addRoute de la classe de routeur :
[
'GET' => [
$routeUri1 => $routeObj1
...
]
...
]Controller@action, elle sera convertie en un tableau d'actions. Après l'exécution de convertToControllerAction, le contenu de l'action est : 🎜[
'GET' . $routeUri1 => $routeObj1
'GET' . $routeUri2 => $routeObj2
...
]IlluminateRoutingRoute : 🎜 [
$routeName1 => $routeObj1
...
][
'App\Http\Controllers\ControllerOne@ActionOne' => $routeObj1
]//Illuminate\Foundation\Http\Kernel
class Kernel implements KernelContract
{
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());
}
protected function dispatchToRouter()
{
return function ($request) {
$this->app->instance('request', $request);
return $this->router->dispatch($request);
};
}
}$destination = function ($request) {
$this->app->instance('request', $request);
return $this->router->dispatch($request);
};class Router implements RegistrarContract, BindingRegistrar
{
public function dispatch(Request $request)
{
$this->currentRequest = $request;
return $this->dispatchToRoute($request);
}
public function dispatchToRoute(Request $request)
{
return $this->runRoute($request, $this->findRoute($request));
}
protected function findRoute($request)
{
$this->current = $route = $this->routes->match($request);
$this->container->instance(Route::class, $route);
return $route;
}
}class RouteCollection implements Countable, IteratorAggregate
{
public function match(Request $request)
{
$routes = $this->get($request->getMethod());
$route = $this->matchAgainstRoutes($routes, $request);
if (! is_null($route)) {
//找到匹配的路由后，将URI里的路径参数绑定赋值给路由(如果有的话)
return $route->bind($request);
}
$others = $this->checkForAlternateVerbs($request);
if (count($others) > 0) {
return $this->getRouteForMethods($request, $others);
}
throw new NotFoundHttpException;
}
protected function matchAgainstRoutes(array $routes, $request, $includingMethod = true)
{
return Arr::first($routes, function ($value) use ($request, $includingMethod) {
return $value->matches($request, $includingMethod);
});
}
}
class Route
{
public function matches(Request $request, $includingMethod = true)
{
$this->compileRoute();
foreach ($this->getValidators() as $validator) {
if (! $includingMethod && $validator instanceof MethodValidator) {
continue;
}
if (! $validator->matches($this, $request)) {
return false;
}
}
return true;
}
}class UriValidator implements ValidatorInterface
{
public function matches(Route $route, Request $request)
{
$path = $request->path() == '/' ? '/' : '/'.$request->path();
return preg_match($route->getCompiled()->getRegex(), rawurldecode($path));
}
}路由寻址
中间件的文章里我们说过HTTP请求在经过Pipeline通道上的中间件的前置操作后到达目的地:
//Illuminate\Foundation\Http\Kernel
class Kernel implements KernelContract
{
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());
}
protected function dispatchToRouter()
{
return function ($request) {
$this->app->instance('request', $request);
return $this->router->dispatch($request);
};
}
}上面代码可以看到Pipeline的destination就是dispatchToRouter函数返回的闭包:
$destination = function ($request) {
$this->app->instance('request', $request);
return $this->router->dispatch($request);
};在闭包里调用了router的dispatch方法，路由寻址就发生在dispatch的第一个阶段findRoute里：
class Router implements RegistrarContract, BindingRegistrar
{
public function dispatch(Request $request)
{
$this->currentRequest = $request;
return $this->dispatchToRoute($request);
}
public function dispatchToRoute(Request $request)
{
return $this->runRoute($request, $this->findRoute($request));
}
protected function findRoute($request)
{
$this->current = $route = $this->routes->match($request);
$this->container->instance(Route::class, $route);
return $route;
}
}寻找路由的任务由 RouteCollection 负责，这个函数负责匹配路由，并且把 request 的 url 参数绑定到路由中：
class RouteCollection implements Countable, IteratorAggregate
{
public function match(Request $request)
{
$routes = $this->get($request->getMethod());
$route = $this->matchAgainstRoutes($routes, $request);
if (! is_null($route)) {
//找到匹配的路由后，将URI里的路径参数绑定赋值给路由(如果有的话)
return $route->bind($request);
}
$others = $this->checkForAlternateVerbs($request);
if (count($others) > 0) {
return $this->getRouteForMethods($request, $others);
}
throw new NotFoundHttpException;
}
protected function matchAgainstRoutes(array $routes, $request, $includingMethod = true)
{
return Arr::first($routes, function ($value) use ($request, $includingMethod) {
return $value->matches($request, $includingMethod);
});
}
}
class Route
{
public function matches(Request $request, $includingMethod = true)
{
$this->compileRoute();
foreach ($this->getValidators() as $validator) {
if (! $includingMethod && $validator instanceof MethodValidator) {
continue;
}
if (! $validator->matches($this, $request)) {
return false;
}
}
return true;
}
}$routes = $this->get($request->getMethod());会先加载注册路由阶段在RouteCollection里生成的routes属性里的值，routes中存放了HTTP请求方法与路由对象的映射。
然后依次调用这堆路由里路由对象的matches方法， matches方法, matches方法里会对HTTP请求对象进行一些验证，验证对应的Validator是：UriValidator、MethodValidator、SchemeValidator、HostValidator。
在验证之前在$this->compileRoute()里会将路由的规则转换成正则表达式。
UriValidator主要是看请求对象的URI是否与路由的正则规则匹配能匹配上:
class UriValidator implements ValidatorInterface
{
public function matches(Route $route, Request $request)
{
$path = $request->path() == '/' ? '/' : '/'.$request->path();
return preg_match($route->getCompiled()->getRegex(), rawurldecode($path));
}
}MethodValidator验证请求方法, SchemeValidator验证协议是否正确(http|https), HostValidator验证域名, 如果路由中不设置host属性，那么这个验证不会进行。
一旦某个路由通过了全部的认证就将会被返回，接下来就要将请求对象URI里的路径参数绑定赋值给路由参数:
路由参数绑定
class Route
{
public function bind(Request $request)
{
$this->compileRoute();
$this->parameters = (new RouteParameterBinder($this))
->parameters($request);
return $this;
}
}
class RouteParameterBinder
{
public function parameters($request)
{
$parameters = $this->bindPathParameters($request);
if (! is_null($this->route->compiled->getHostRegex())) {
$parameters = $this->bindHostParameters(
$request, $parameters
);
}
return $this->replaceDefaults($parameters);
}
protected function bindPathParameters($request)
{
preg_match($this->route->compiled->getRegex(), '/'.$request->decodedPath(), $matches);
return $this->matchToKeys(array_slice($matches, 1));
}
protected function matchToKeys(array $matches)
{
if (empty($parameterNames = $this->route->parameterNames())) {
return [];
}
$parameters = array_intersect_key($matches, array_flip($parameterNames));
return array_filter($parameters, function ($value) {
return is_string($value) && strlen($value) > 0;
});
}
}赋值路由参数完成后路由寻址的过程就结束了，结下来就该运行通过匹配路由中对应的控制器方法返回响应对象了。
class Router implements RegistrarContract, BindingRegistrar
{
public function dispatch(Request $request)
{
$this->currentRequest = $request;
return $this->dispatchToRoute($request);
}
public function dispatchToRoute(Request $request)
{
return $this->runRoute($request, $this->findRoute($request));
}
protected function runRoute(Request $request, Route $route)
{
$request->setRouteResolver(function () use ($route) {
return $route;
});
$this->events->dispatch(new Events\RouteMatched($route, $request));
return $this->prepareResponse($request,
$this->runRouteWithinStack($route, $request)
);
}
protected function runRouteWithinStack(Route $route, Request $request)
{
$shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
$this->container->make('middleware.disable') === true;
//收集路由和控制器里应用的中间件
$middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
return (new Pipeline($this->container))
->send($request)
->through($middleware)
->then(function ($request) use ($route) {
return $this->prepareResponse(
$request, $route->run()
);
});
}
}
namespace Illuminate\Routing;
class Route
{
public function run()
{
$this->container = $this->container ?: new Container;
try {
if ($this->isControllerAction()) {
return $this->runController();
}
return $this->runCallable();
} catch (HttpResponseException $e) {
return $e->getResponse();
}
}
}这里我们主要介绍路由相关的内容，runRoute的过程通过上面的源码可以看到其实也很复杂， 会收集路由和控制器里的中间件，将请求通过中间件过滤才会最终到达目的地路由，执行目的路由地run()方法，里面会判断路由对应的是一个控制器方法还是闭包然后进行相应地调用，最后把执行结果包装成Response对象返回给客户端。这个过程还会涉及到我们以前介绍过的中间件过滤、服务解析、依赖注入方面的信息。
相关推荐：最新的五个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!
Que signifie le routage Java ?
Introduction aux composants Laravel
Introduction au middleware Laravel
Quels sont les modèles de conception utilisés par Laravel ?
Lequel est le plus simple, thinkphp ou laravel ?
Tutoriel Laravel
Utilisation de PathFileExists
Comment se connecter à la base de données en utilisant VB
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
