前言

上一篇文章我们说到路由的正则编译，正则编译的目的就是和请求的 url 来匹配，只有匹配上的路由才是我们真正想要的，此外也会通过正则匹配来获取路由的参数。

路由的匹配

路由进行正则编译后，就要与请求 request 来进行正则匹配，并且进行一些验证，例如 UriValidator、MethodValidator、SchemeValidator、HostValidator。

class RouteCollection implements Countable, IteratorAggregate
{
    public function match(Request $request)
    {
        $routes = $this->get($request->getMethod());

        $route = $this->matchAgainstRoutes($routes, $request);

        if (! is_null($route)) {
            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;
    }

    public static function getValidators()
    {
        if (isset(static::$validators)) {
            return static::$validators;
        }

        return static::$validators = [
            new UriValidator, new MethodValidator,
            new SchemeValidator, new HostValidator,
        ];
    }
}

UriValidator uri 验证

UriValidator 验证主要是目的是查看路由正则与请求是否匹配：

class UriValidator implements ValidatorInterface
{
    public function matches(Route $route, Request $request)
    {
        $path = $request->path() == '/' ? '/' : '/'.$request->path();

        return preg_match($route->getCompiled()->getRegex(), rawurldecode($path));
    }
}

值得注意的是，在匹配路径之前，程序使用了 rawurldecode 来对请求进行解码。

MethodValidator 验证

请求方法验证：

class MethodValidator implements ValidatorInterface
{
    public function matches(Route $route, Request $request)
    {
        return in_array($request->getMethod(), $route->methods());
    }
}

SchemeValidator 验证

路由 scheme 协议验证：

class SchemeValidator implements ValidatorInterface
{
    public function matches(Route $route, Request $request)
    {
        if ($route->httpOnly()) {
            return ! $request->secure();
        } elseif ($route->secure()) {
            return $request->secure();
        }

        return true;
    }
}

public function httpOnly()
{
    return in_array('http', $this->action, true);
}

public function secure()
{
    return in_array('https', $this->action, true);
}

HostValidator 验证

主域验证：

class HostValidator implements ValidatorInterface
{
    public function matches(Route $route, Request $request)
    {
        if (is_null($route->getCompiled()->getHostRegex())) {
            return true;
        }

        return preg_match($route->getCompiled()->getHostRegex(), $request->getHost());
    }
}

也就是说，如果路由中并不设置 host 属性，那么这个验证并不进行。

路由的参数绑定

一旦某个路由符合请求的 uri 四项认证，就将会被返回，接下来就要对路由的参数进行绑定与赋值：

class RouteCollection implements Countable, IteratorAggregate
{
    public function bind(Request $request)
    {
        $this->compileRoute();

        $this->parameters = (new RouteParameterBinder($this))
                        ->parameters($request);

        return $this;
    }
}

bind 函数负责路由参数与请求 url 的绑定工作:

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);
    }
}

可以看出，路由参数绑定分为主域参数绑定与路径参数绑定，我们先看路径参数绑定：

路径参数绑定

class RouteParameterBinder
{
    protected function bindPathParameters($request)
    {
          preg_match($this->route->compiled->getRegex(), '/'.$request->decodedPath(), $matches);

         return $this->matchToKeys(array_slice($matches, 1));
    }
}

例如，{foo}/{baz?}.{ext?} 进行正则编译后结果：

#^/(?P<foo>[^/]++)(?:/(?P<baz>[^/\.]++)(?:\.(?P<ext>[^/]++))?)?$#s

其与 request 匹配后的结果为：

$matches = array (
    0   = "/foo/baz.ext",
    1   = "foo",
    foo = "foo",
    2   = "baz",
    baz = "baz",
    3   = "ext",
    ext = "ext",
)

array_slice($matches, 1) 取出了 $matches 数组 1 之后的结果，然后调用了 matchToKeys 函数，

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 Route
{
    public function parameterNames()
    {
        if (isset($this->parameterNames)) {
            return $this->parameterNames;
        }

        return $this->parameterNames = $this->compileParameterNames();
    }


    protected function compileParameterNames()
    {
        preg_match_all('/\{(.*?)\}/', $this->domain().$this->uri, $matches);

        return array_map(function ($m) {
            return trim($m, '?');
        }, $matches[1]);
    }
}

可以看出，获取路由参数的正则表达式采用了勉强模式，意图提取出所有的路由参数。否则，对于路由 {foo}/{baz?}.{ext?},贪婪型正则表达式 /\{(.*)\}/ 将会匹配整个字符串，而不是各个参数分组。

提取出的参数结果为：

$matches = array (
    0 = array (
        0 = "{foo}".
        1 = "{baz?}",
        2 = "{ext?}",
    )
    1 = array (
        0 = "foo".
        1 = "baz?",
        2 = "ext?",
    )
)

得出的结果将会去除 $matches[1]，并且将会删除结果中最后的 ?。

之后，在 matchToKeys 函数中，

$parameters = array_intersect_key($matches, array_flip($parameterNames));

获取了匹配结果与路由所有参数的交集：

 $parameters = array (
    foo = "foo",
    baz = "baz",
    ext = "ext",
 )

主域参数绑定

protected function bindHostParameters($request, $parameters)
{
    preg_match($this->route->compiled->getHostRegex(), $request->getHost(), $matches);

    return array_merge($this->matchToKeys(array_slice($matches, 1)), $parameters);
}

步骤与路由参数绑定一致。

替换默认值

进行参数绑定后，有一些可选参数并没有在 request 中匹配到，这时候就要用可选参数的默认值添加到变量 parameters 中：

protected function replaceDefaults(array $parameters)
{
    foreach ($parameters as $key => $value) {
        $parameters[$key] = isset($value) ? $value : Arr::get($this->route->defaults, $key);
    }

    foreach ($this->route->defaults as $key => $value) {
        if (! isset($parameters[$key])) {
            $parameters[$key] = $value;
        }
    }

    return $parameters;
}

匹配异常处理

如果 url 匹配失败，没有找到任何路由与请求相互匹配，就会切换 method 方法，以求任意路由来匹配：

protected function checkForAlternateVerbs($request)
{
    $methods = array_diff(Router::$verbs, [$request->getMethod()]);

    $others = [];

    foreach ($methods as $method) {
        if (! is_null($this->matchAgainstRoutes($this->get($method), $request, false))) {
            $others[] = $method;
        }
    }

    return $others;
}

如果使用其他方法匹配成功，就要判断当前方法是否是 options，如果是则直接返回，否则报出异常：

protected function getRouteForMethods($request, array $methods)
{
    if ($request->method() == 'OPTIONS') {
        return (new Route('OPTIONS', $request->path(), function () use ($methods) {
            return new Response('', 200, ['Allow' => implode(',', $methods)]);
        }))->bind($request);
    }

    $this->methodNotAllowed($methods);
}

protected function methodNotAllowed(array $others)
{
    throw new MethodNotAllowedHttpException($others);
}