lumen路由源码解析


by: nestor 邵泰深

保护私人版权，尊重他人版权。转载请注明出处并附带页面链接

本文从Lumen的源码入手，说一下Request -> Response 的解析过程，这里用到的是Lumen5.8

入口

bootstrap/app.php

1
2
3
4
5
6
7
$app->router->group([
    'namespace' => 'App\Http\Controllers',
], function ($router) {
    require __DIR__.'/../routes/web.php';
});

return $app;

先从Lumen的入口文件开始，这里可以看到我们的router变量，router就是负责将我们的method、uri、action关联起来，用于解析Request

那么接下来看一下router是从哪里来的：

vendor/laravel/lumen-framework/src/Application.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
 * Create a new Lumen application instance.
 *
 * @param  string|null  $basePath
 * @return void
 */
public function __construct($basePath = null)
{
    if (! empty(env('APP_TIMEZONE'))) {
        date_default_timezone_set(env('APP_TIMEZONE', 'UTC'));
    }
    $this->basePath = $basePath;
    $this->bootstrapContainer();
    $this->registerErrorHandling();
    $this->bootstrapRouter();
}


/**
 * Bootstrap the router instance.
 *
 * @return void
 */
public function bootstrapRouter()
{
    $this->router = new Router($this);
}

可以看到$this->router = new Router($this)这一句实例化了router，由此我们定位到了router所在位置vendor/laravel/lumen-framework/src/Routing/Router.php

group

还记得我们的入口里的router用到了group方法吗？我们来看一下group相关源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
 * Register a set of routes with a set of shared attributes.
 *
 * @param  array  $attributes
 * @param  \Closure  $callback
 * @return void
 */
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);
}


/**
 * Update the group stack with the given attributes.
 *
 * @param  array  $attributes
 * @return void
 */
protected function updateGroupStack(array $attributes)
{
    if (! empty($this->groupStack)) {
        $attributes = $this->mergeWithLastGroup($attributes);
    }
    $this->groupStack[] = $attributes;
}


/**
 * Merge the given group attributes with the last added group.
 *
 * @param  array $new
 * @return array
 */
protected function mergeWithLastGroup($new)
{
    return $this->mergeGroup($new, end($this->groupStack));
}


/**
 * Merge the given group attributes.
 *
 * @param  array  $new
 * @param  array  $old
 * @return array
 */
public function mergeGroup($new, $old)
{
    $new['namespace'] = static::formatUsesPrefix($new, $old);
    $new['prefix'] = static::formatGroupPrefix($new, $old);
    if (isset($new['domain'])) {
        unset($old['domain']);
    }
    if (isset($old['as'])) {
        $new['as'] = $old['as'].(isset($new['as']) ? '.'.$new['as'] : '');
    }
    if (isset($old['suffix']) && ! isset($new['suffix'])) {
        $new['suffix'] = $old['suffix'];
    }
    return array_merge_recursive(Arr::except($old, ['namespace', 'prefix', 'as', 'suffix']), $new);
}

先判断attributes中有无中间件middleware，有的话就解析成数组，并合并到$this->groupStack中。

这里看到middleware的解析方式，可以知道传入多个中间件的时候，除了按照官方文档'middleware' => ['auth1','auth2']这种方式外，还可以用middleware' => 'auth1|auth2'的写法，效果是一样的。

往下看，我们看到执行了call_user_func($callback, $this)，即：

1
2
3
function ($router) {
    require __DIR__.'/../routes/web.php';
}

这里会把web.php加载进来，相当于：

1
2
3
4
function ($router) {
    $router->get('list', 'ListController@index');
    $router->post('save', 'SaveController@index');
}

addRoute

接着看get、post函数，发现它们的本质都是调addRoute：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
 * Add a route to the collection.
 *
 * @param  array|string  $method
 * @param  string  $uri
 * @param  mixed  $action
 * @return void
 */
public function addRoute($method, $uri, $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：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * Parse the action into an array format.
 *
 * @param  mixed  $action
 * @return array
 */
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;
}

这里将$action转为数组，对中间件的处理也是上面一样的

继续往下看

1
2
3
4
5
6
7
8
9
10
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, '/');

这里是拼接uri的前缀和后缀，并且将attributes合并到$action

1
2
3
4

if (isset($action['as'])) {
    $this->namedRoutes[$action['as']] = $uri;
}

这里首先保存命名路由到namedRoutes中，命名路由可以方便的为特定路由生成 URL 或进行重定向，使用方式如下：

1
2
3
$router->get('profile', [
    'as' => 'profile', 'uses' => 'UserController@showProfile'
]);
1
2
3
4
5
6
7
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];
}

最后就是把method、uri、action存到routes中了，这里看到$method可以是一个数组，也就是说我们可以这样定义允许多个请求方法的路由：

1
$this->addRoute(['GET','POST'], $uri, $action);

Request

public/index.php 可以看到Lumen的入口方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$app = require __DIR__.'/../bootstrap/app.php';

/*
|--------------------------------------------------------------------------
| Run The Application
|--------------------------------------------------------------------------
|
| Once we have the application, we can handle the incoming request
| through the kernel, and send the associated response back to
| the client's browser allowing them to enjoy the creative
| and wonderful application we have prepared for them.
|
*/

$app->run();

定位到vendor/laravel/lumen-framework/src/Application.php：

1
2
use Concerns\RoutesRequests,
       Concerns\RegistersExceptionHandlers;

从而找到run方法所在文件vendor/laravel/lumen-framework/src/Concerns/RoutesRequests.php：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * Run the application and send the response.
 *
 * @param  SymfonyRequest|null  $request
 * @return void
 */
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);
    }
}

先看dispatch函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
 * Dispatch the incoming request.
 *
 * @param  SymfonyRequest|null  $request
 * @return Response
 */
public function dispatch($request = null)
{
    list($method, $pathInfo) = $this->parseIncomingRequest($request);
    try {
        $this->boot();
        // 1
        return $this->sendThroughPipeline($this->middleware, function ($request) use ($method, $pathInfo) {
            $this->instance(Request::class, $request);
            // 2
            if (isset($this->router->getRoutes()[$method.$pathInfo])) {
                return $this->handleFoundRoute([true, $this->router->getRoutes()[$method.$pathInfo]['action'], []]);
            }
            // 3
            return $this->handleDispatcherResponse(
                $this->createDispatcher()->dispatch($method, $pathInfo)
            );
        });
    } catch (Throwable $e) {
        return $this->prepareResponse($this->sendExceptionToHandler($e));
    }
}

首先拿到请求方式$method和请求路径$pathInfo，然后我们看到代理中会有三个返回，1是最外层的，最后再看，这里先看3

3这里的dispatch返回的数据结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
interface Dispatcher
{
    const NOT_FOUND = 0;
    const FOUND = 1;
    const METHOD_NOT_ALLOWED = 2;

    /**
     * Dispatches against the provided HTTP method verb and URI.
     *
     * Returns array with one of the following formats:
     *
     *     [self::NOT_FOUND]
     *     [self::METHOD_NOT_ALLOWED, ['GET', 'OTHER_ALLOWED_METHODS']]
     *     [self::FOUND, $handler, ['varName' => 'value', ...]]
     *
     * @param string $httpMethod
     * @param string $uri
     *
     * @return array
     */
    public function dispatch($httpMethod, $uri);
}

接着看一下createDispatcher：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
 * Create a FastRoute dispatcher instance for the application.
 *
 * @return Dispatcher
 */
protected function createDispatcher()
{
    return $this->dispatcher ?: \FastRoute\simpleDispatcher(function ($r) {
        foreach ($this->router->getRoutes() as $route) {
            $r->addRoute($route['method'], $route['uri'], $route['action']);
        }
    });
}

simpleDispatcher这个方法主要是创建 routeCollector 对象，用于存储所有 route

再看循环里的addRoute方法，这里用到的是vendor/nikic/fast-route/src/RouteCollector.php：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * Adds a route to the collection.
 *
 * The syntax used in the $route string depends on the used route parser.
 *
 * @param string|string[] $httpMethod
 * @param string $route
 * @param mixed  $handler
 */
public function addRoute($httpMethod, $route, $handler)
{
    $route = $this->currentGroupPrefix . $route;
    $routeDatas = $this->routeParser->parse($route);
    foreach ((array) $httpMethod as $method) {
        foreach ($routeDatas as $routeData) {
            $this->dataGenerator->addRoute($method, $routeData, $handler);
        }
    }
}

继续看$this->dataGenerator->addRoute($method, $routeData, $handler)，vendor/nikic/fast-route/src/DataGenerator/RegexBasedAbstract.php：

1
2
3
4
5
6
7
8
9

public function addRoute($httpMethod, $routeData, $handler)
{
    if ($this->isStaticRoute($routeData)) {
        $this->addStaticRoute($httpMethod, $routeData, $handler);
    } else {
        $this->addVariableRoute($httpMethod, $routeData, $handler);
    }
}

这里是对普通的路由和正则路由分别处理

然后回到$this->handleDispatcherResponse这里：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * Handle the response from the FastRoute dispatcher.
 *
 * @param  array  $routeInfo
 * @return mixed
 */
protected function handleDispatcherResponse($routeInfo)
{
    switch ($routeInfo[0]) {
        case Dispatcher::NOT_FOUND:
            throw new NotFoundHttpException;
        case Dispatcher::METHOD_NOT_ALLOWED:
            throw new MethodNotAllowedHttpException($routeInfo[1]);
        case Dispatcher::FOUND:
            return $this->handleFoundRoute($routeInfo);
    }
}

可以看到找不到路由或者请求方法不允许都会抛异常，继续看handleFoundRoute

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 * Handle a route found by the dispatcher.
 *
 * @param  array  $routeInfo
 * @return mixed
 */
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：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * Call the Closure on the array based route.
 *
 * @param  array  $routeInfo
 * @return mixed
 */
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：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 * Call a controller based route.
 *
 * @param  array  $routeInfo
 * @return mixed
 */
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]
        );
    }
}

这里通过@来分解controller和method，再用$this->make($controller)得到Controller 对象，如果是LumenController类型，则会对中间件做一些判断，最后都是调用callControllerCallable方法

Response

最后看prepareResponse方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * Prepare the response for sending.
 *
 * @param  mixed  $response
 * @return Response
 */
public function prepareResponse($response)
{
    $request = app(Request::class);
    if ($response instanceof Responsable) {
        $response = $response->toResponse($request);
    }
    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->prepare($request);
}

这里就回到了我们一开始的run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * Run the application and send the response.
 *
 * @param  SymfonyRequest|null  $request
 * @return void
 */
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);
    }
}

至此，我们的请求到响应就走完了

总结

本文只是对Request到Response的相关源码走了一遍流程，对于一些细节的东西没有深挖，但是从源码中也能学到不少东西，比如uri支持多种请求方式，比如用$this->make处理route等

Sub

扫码关注微信公众号，随时随地，掌握最新技术资讯

微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我们是<br>深圳梅沙科技后端团队<br><br>这里是我们的知识集中营<br>欢迎各路大佬交流学习