lumen 的路由具体实现

lumen 的路由实现

前言

       最近公司项目中使用的框架换成了 lumen , 想到以前面试的时候，面试官都喜欢问一些框架的底层的逻辑，也提到过，laravel 的controller 路由事怎么实现的。
       虽然对于它的路由配置已经很是熟悉了，但是对它的底层原理却很陌生，所以下决心把路由的完整的注册过程，以及分发过程给捋一遍。

代码分析

首先看看我们一般使用时候的配置：
bootstrap/app.php

/** api */
$app->group(['namespace' => 'App\Http\Controller\Api','prefix' =>'/api'], function ($app) {
    require __DIR__ . '/../routes/api.php';
});

route/api.php

/** api */
$app->group(['prefix' => '/xx', 'middleware' => ['param.xx', 'xx']], function () use ($app) {
    $app->get('/user/login', 'UserController@login');
    $app->get('/user/record', 'UserController@userRecord');
}

具体的路由配置不详细解释，可以参考 https://learnku.com/docs/lumen/5.3/routing/1880 。
大概写完上面两步，然后我们就去建 UserController 控制器，在控制器里面建 login 和 userRecord 方法，然后访问URI资源为 /api/xx/user/login （或 /api/user/record）就可以看到我们写的东西了

但是如何通过这两个URI资源访问到这个里面呢？相信很多忙于写业务代码的同行们所忽略的，下面是我对路由的注册和分发的一些理解，如果有什么理解不对的地方，请各位大神斧正 [手动抱拳]

路由的注册

根据上面的两段代码，我们来看看lumen的代码具体是怎么执行的，具体类 vendor/laravel/lumen-framework/src/Concerns/RoutesRequests.php
首先调用了路由的group方法

public function group(array $attributes, Closure $callback)
{
    if (isset($attributes['middleware']) && is_string($attributes['middleware'])) {
        $attributes['middleware'] = explode('|', $attributes['middleware']);
    }

    $this->updateGroupStack($attributes);

    call_user_func($callback, $this);

    array_pop($this->groupStack);
}

在group方法中，首先将middleware属性非数组的形式拆分成数组的形式，然后调用updateGroupStack方法

protected function updateGroupStack(array $attributes)
{
    if (! empty($this->groupStack)) {
        $attributes = $this->mergeWithLastGroup($attributes);
    }

    $this->groupStack[] = $attributes;
}

使用新增加的属性更新当前路由对象中的groupStack属性。更新的时候，是与当前groupStack中最后一个元素进行合并，然后将合并后的属性添加到groupStack的尾部（代码参考mergeWithLastGroup方法，这里就不贴出来了）。一般来说groupStack属性都为空，存在这种情况只会在group嵌套的时候发生，子group会拥有父group的所有属性（我们前面的两段代码则属于子父group嵌套的），兄弟group之间，他们的属性之间没有任何关系（在最后调用了array_pop方法）。当更新好当前的groupStack后，会立即调用当前group所定义的闭包，在这个闭包中我们通常就是调用相关的路由方法，或者定义子group。这样，在当前group中所定义的路由，都会拥有group所定义的路由属性。

嵌套group的groupStack属性值

array (size=2)
  0 => 
    array (size=2)
      'namespace' => string 'App\Http\Controller\Api' 
      'prefix' => string '/api' 
  1 => 
    array (size=3)
      'middleware' => 
        array (size=2)
          0 => string 'param.xx' 
          1 => string 'xx' 
      'prefix' => string 'api/xx' 
      'namespace' => string 'App\Http\Controller\Api' 

未嵌套group的groupStack属性值

$this->groupStack 组信息中的属性，包含中间件，命名空间，路由前缀，路由后缀，as（别名？）

array (size=3)
  'prefix' => string 'api'
  'suffix' => string ''
  'middleware' => 
    array (size=2)
      0 => string 'param.valid' 
      1 => string 'logdb.send' 
  'namespace' => string 'App\Http\Controller\Api' 

接着看我们经常所使用的 get,post,put,delete,option 等一系列 http 动作的方法，他们的原型都是路由中的 addRoute 方法，来添加路由

public function addRoute($method, $uri, $action)
{
	// 把 action 解析为数组形式
	$action = $this->parseAction($action);
	//包含中间件，命名空间，前缀
	$attributes = null;
	
	if ($this->hasGroupStack()) {
	    $attributes = $this->mergeWithLastGroup([]);
	}
	
	if (isset($attributes) && is_array($attributes)) {
	    if (isset($attributes['prefix'])) {
	        $uri = trim($attributes['prefix'], '/').'/'.trim($uri, '/');
	    }
	
	    if (isset($attributes['suffix'])) {
	        $uri = trim($uri, '/').rtrim($attributes['suffix'], '/');
	    }
	
	    $action = $this->mergeGroupAttributes($action, $attributes);
	}
	
	$uri = '/'.trim($uri, '/');
	
	if (isset($action['as'])) {
	    $this->namedRoutes[$action['as']] = $uri;
	}
	
	if (is_array($method)) {
	    foreach ($method as $verb) {
	        $this->routes[$verb.$uri] = ['method' => $verb, 'uri' => $uri, 'action' => $action];
	    }
	} else {
	    $this->routes[$method.$uri] = ['method' => $method, 'uri' => $uri, 'action' => $action];
	}
}

首先调用parseAction把我们定义的行为action解析成数组形式，从parseAction方法中可以看出我们定义行为action也可以写成['uses' => 'UseController@login', 'middleware' => ['param.xx']]

protected function parseAction($action)
{
    if (is_string($action)) {
        return ['uses' => $action];
    } elseif (! is_array($action)) {
        return [$action];
    }

    if (isset($action['middleware']) && is_string($action['middleware'])) {
        $action['middleware'] = explode('|', $action['middleware']);
    }

    return $action;
}

然后判断是否存在group，存在的话需要把组的属性，赋给当前的行为，并且对行为action合并当前组的属性，再判断是否存在别名，存在别名则加入到nameRoutes中，最后把路由放进routes中

$this->nameRoutes 别名路由中的信息

array (size=1)
  'user.login' => string '/api/xx/user/login'

$this->routes 路由数组中的属性，method + uri 作为键

'POST/api/user/login' => 
    array (size=3)
      'method' => string 'POST' 
      'uri' => string '/api/user/login' 
      'action' => 
        array (size=1)
          'uses' => string 'App\Http\Controllers\Api\UserController@login' 
          'middleware' => 
		    array (size=2)
		      0 => string 'param.valid'
		      1 => string 'logdb.send'
'GET/api/user/record' => 
    array (size=3)
      'method' => string 'GET' 
      'uri' => string '/api/user/record'
      'action' => 
        array (size=1)
          'uses' => string 'App\Http\Controllers\Api\UserController@userRecord'
          'middleware' => 
			    array (size=1)
			      0 => string 'logdb.send'

到这里基本上就知道，lumen里面的路由是如何注册的了。它把所有的路由都放在属性routes中

路由的分发

public function run($request = null)
{
    $response = $this->dispatch($request);

    if ($response instanceof SymfonyResponse) {
        $response->send();
    } else {
        echo (string) $response;
    }

    if (count($this->middleware) > 0) {
        $this->callTerminableMiddleware($response);
    }
}

路由注册完成之后，调用了$app->run()，运行程序并发送response，首先调用dispatch分发获取到的请求，然后输出结果信息，最后判断是否有中间件，调用结束进程的中间件

首先看看路由分发dispatch方法

public function dispatch($request = null)
{
    list($method, $pathInfo) = $this->parseIncomingRequest($request);

    try {
        return $this->sendThroughPipeline($this->middleware, function () use ($method, $pathInfo) {
            if (isset($this->routes[$method.$pathInfo])) {
                return $this->handleFoundRoute([true, $this->routes[$method.$pathInfo]['action'], []]);
            }

            return $this->handleDispatcherResponse(
                $this->createDispatcher()->dispatch($method, $pathInfo)
            );
        });
    } 
    //处理异常
    ...
}

首先解析了request请求，获取到method、pathInfo，调用sendThroughPipeline方法使用给定的回调函数，通过管道发送request请求，存在中间件的时候，需要使用管道（管道后面再说吧），不存在则直接调用传入的函数

protected function sendThroughPipeline(array $middleware, Closure $then)
{
    if (count($middleware) > 0 && ! $this->shouldSkipMiddleware()) {
        return (new Pipeline($this))
            ->send($this->make('request'))
            ->through($middleware)
            ->then($then);
    }

    return $then();
}

回调函数中处理的是：存在method + pathInfo的路由，直接调用handleFoundRoute处理转发的路由，否则调用handleDispatcherResponse（根据动态路由来确定，是否存在路由信息？）

先看看直接找到的路由信息的处理方式

protected function handleFoundRoute($routeInfo)
{
    $this->currentRoute = $routeInfo;

    $this['request']->setRouteResolver(function () {
        return $this->currentRoute;
    });

    $action = $routeInfo[1];

    // Pipe through route middleware...
    if (isset($action['middleware'])) {
        $middleware = $this->gatherMiddlewareClassNames($action['middleware']);

        return $this->prepareResponse($this->sendThroughPipeline($middleware, function () {
            return $this->callActionOnArrayBasedRoute($this['request']->route());
        }));
    }

    return $this->prepareResponse(
        $this->callActionOnArrayBasedRoute($routeInfo)
    );
}

这里的核心处理方法就是调用callActionOnArrayBasedRoute处理请求，调用这个方法，判断是否存在uses，存在的话调用callControllerAction，不存在的话，调用执行绑定的回调函数

protected function callActionOnArrayBasedRoute($routeInfo)
{
    $action = $routeInfo[1];

    if (isset($action['uses'])) {
        return $this->prepareResponse($this->callControllerAction($routeInfo));
    }

    foreach ($action as $value) {
        if ($value instanceof Closure) {
            $closure = $value->bindTo(new RoutingClosure);
            break;
        }
    }

    try {
        return $this->prepareResponse($this->call($closure, $routeInfo[2]));
    } catch (HttpResponseException $e) {
        return $e->getResponse();
    }
}

这个方法里面再执行行为绑定的类方法或者回调函数

执行业务方法的核心方法callControllerAction

protected function callControllerAction($routeInfo)
{
    $uses = $routeInfo[1]['uses'];

    if (is_string($uses) && ! Str::contains($uses, '@')) {
        $uses .= '@__invoke';
    }

    list($controller, $method) = explode('@', $uses);

    if (! method_exists($instance = $this->make($controller), $method)) {
        throw new NotFoundHttpException;
    }

    if ($instance instanceof LumenController) {
        return $this->callLumenController($instance, $method, $routeInfo);
    } else {
        return $this->callControllerCallable(
            [$instance, $method], $routeInfo[2]
        );
    }
}

其实路由走到最后都会调用两个核心的方法，调用类方法，或者执行回调的函数，call以及callClass，callClass最后也是会调用call方法

//调用给定的函数方法或者类方法，并注入其中的依赖
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
    if (static::isCallableWithAtSign($callback) || $defaultMethod) {
        return static::callClass($container, $callback, $parameters, $defaultMethod);
    }

    return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
        return call_user_func_array(
            $callback, static::getMethodDependencies($container, $callback, $parameters)
        );
    });
}

//根据字符串调用类方法
protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
{
    $segments = explode('@', $target);

    $method = count($segments) == 2
                    ? $segments[1] : $defaultMethod;

    if (is_null($method)) {
        throw new InvalidArgumentException('Method not provided.');
    }

    return static::call(
        $container, [$container->make($segments[0]), $method], $parameters
    );
}

注入依赖

下面是获取依赖的参数的方法，使用反射类获取方法的参数，根据参数来赋值或实例化不同的参数

//获取注入的参数
protected static function getMethodDependencies($container, $callback, array $parameters = [])
{
    $dependencies = [];

    foreach (static::getCallReflector($callback)->getParameters() as $parameter) {
        static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);
    }

    return array_merge($dependencies, $parameters);
}
//获取类的反射信息
protected static function getCallReflector($callback)
{
    //...
    return is_array($callback)
                    ? new ReflectionMethod($callback[0], $callback[1])
                    : new ReflectionFunction($callback);
}
//添加依赖的参数信息
protected static function addDependencyForCallParameter($container, $parameter,
                                                            array &$parameters, &$dependencies)
{
    if (array_key_exists($parameter->name, $parameters)) {
        $dependencies[] = $parameters[$parameter->name];

        unset($parameters[$parameter->name]);
    } elseif ($parameter->getClass()) {
        $dependencies[] = $container->make($parameter->getClass()->name);
    } elseif ($parameter->isDefaultValueAvailable()) {
        $dependencies[] = $parameter->getDefaultValue();
    }
}

方法最后执行的就是我们写的业务代码了，路由分析到这里大概就差不多了，还有动态路由什么的这里没有具体看

request、response 对象解析

在一个http生命周期中，我们最关心的还是输入request，以及输出response，下面简单的看看lumen里面的输入和输出

requset 处理

在前面parseIncomingRequest方法中，我们看到了对request的赋值：Request::capture();，我们来看看这个方法里面捕获了些什么，具体赋值应该是在：vendor/symfony/http-foundation/Request.php:460没有具体分析

public static function capture()
{
	//开启方法参数覆盖？
    static::enableHttpMethodParameterOverride();
	//创建一个 SymfonyRequest 的request
    return static::createFromBase(SymfonyRequest::createFromGlobals());
}
//根据 SymfonyRequest的实例创建一个 Illuminate的实例 request
public static function createFromBase(SymfonyRequest $request)
{
    if ($request instanceof static) {
        return $request;
    }

    $content = $request->content;

    $request = (new static)->duplicate(
        $request->query->all(), $request->request->all(), $request->attributes->all(),
        $request->cookies->all(), $request->files->all(), $request->server->all()
    );

    $request->content = $content;

    $request->request = $request->getInputSource();

    return $request;
}

response 处理

在看路由分发的时候，最后一直是调用prepareResponse这个方法的，方法里面有三个if判断，分别处理PsrResponseInterface、SymfonyResponse、BinaryFileResponse

public function prepareResponse($response)
{
    if ($response instanceof PsrResponseInterface) {
        $response = (new HttpFoundationFactory)->createResponse($response);
    } elseif (! $response instanceof SymfonyResponse) {
        $response = new Response($response);
    } elseif ($response instanceof BinaryFileResponse) {
        $response = $response->prepare(Request::capture());
    }

    return $response;
}

处理PsrResponseInterface

public function createResponse(ResponseInterface $psrResponse)
{
    $response = new Response(
        $psrResponse->getBody()->__toString(),
        $psrResponse->getStatusCode(),
        $psrResponse->getHeaders()
    );
    $response->setProtocolVersion($psrResponse->getProtocolVersion());

    foreach ($psrResponse->getHeader('Set-Cookie') as $cookie) {
        $response->headers->setCookie($this->createCookie($cookie));
    }

    return $response;
}

处理SymfonyResponse

前两个最后都是处理成Symfony\Component\HttpFoundation\Response类

$response = new Response($response);

use Symfony\Component\HttpFoundation\Response as BaseResponse;

class Response extends BaseResponse
{
...

处理BinaryFileResponse

有兴趣的去看看吧，我没有深入研究
vendor/symfony/http-foundation/Response.php:265

后记

有些地方可能写的不是特别清晰，大家自己最照着源码大概看一看吧！有什么可以指教的，欢迎联系我。QQ：1109563194