protected function dispatchToRouter()
    {
        return function ($request) {
            $this->app->instance('request', $request);

            return $this->router->dispatch($request);
        };
    }

     public function dispatchToRoute(Request $request)
    {
        return $this->runRoute($request, $this->findRoute($request));
    }

Route::get('/post/{id}/{name?}', function(){..}});
Route::get('/post/{id}/{name?}', 'xxController@index');
Route::resource('/post/{id}/{name?}', 'xxController');

    public function addRoute($methods, $uri, $action)
    {
        return $this->routes->add($this->createRoute($methods, $uri, $action));
    }

//D:\Projects\PHP\laravel\blog\vendor\laravel\framework\src\Illuminate\Routing\Route.php
    public function __construct($methods, $uri, $action)
    {
        $this->uri = $uri;
        $this->methods = (array) $methods;
        //解析出最终可调用的action.
        $this->action = $this->parseAction($action);

        if (in_array('GET', $this->methods) && ! in_array('HEAD', $this->methods)) {
            $this->methods[] = 'HEAD';
        }
        //action需要加prefix 类似/api/v2/post这种,则给uri加上prefix
        if (isset($this->action['prefix'])) {
            $this->prefix($this->action['prefix']);
        }
    }

Route::group( ['prefix'=>'a', 'namespaces'=>'\\Top\\ClassA', 'where'=>''], function($router) {
    Route::group(//more group...)
} )

    /**
     * An array of the routes keyed by method.
     * 'get' = > [ 'url1'=> xxx, 'url2'=>xxx]
     * 'post' = > [ 'url1'=> xxx, 'url2'=>xxx]
     * @var array
     */
    protected $routes = [];

    /**
     * A flattened array of all of the routes.
     * [ 'get.url1'=> xxx, 
        'post.url2'=>xxx
        ...
     ]
     * @var array
     */
    protected $allRoutes = [];

    /**命令路由
     * A look-up table of routes by their names.
     * ['name1'=>xxx, 'name2' =>xxx]
     * @var array
     */
    protected $nameList = [];

    /**
     * A look-up table of routes by controller action.
     * ['url1'=>'xxController@index',
        'url2'=> 'xxController@get'
        ]
     * @var array
     */
    protected $actionList = [];

    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)
    {
        // If the route has a name, we will add it to the name look-up table so that we
        // will quickly be able to find any route associate with a name and not have
        // to iterate through every route every time we need to perform a look-up.
        if ($name = $route->getName()) {
            $this->nameList[$name] = $route;
        }

        // When the route is routing to a controller we will also store the action that
        // is used by the route. This will let us reverse route to controllers while
        // processing a request and easily generate URLs to the given controllers.
        $action = $route->getAction();

        if (isset($action['controller'])) {
            $this->addToActionList($action, $route);
        }
    }

//D:\Projects\PHP\laravel\blog\vendor\laravel\framework\src\Illuminate\Routing\Router.php
    protected function findRoute($request)
    {
        //匹配的路由route对象
        $this->current = $route = $this->routes->match($request);

        //添加到IOC 容器.
        $this->container->instance(Route::class, $route);

        return $route;
    }
//D:\Projects\PHP\laravel\blog\vendor\laravel\framework\src\Illuminate\Routing\RouteCollection.php
    public function match(Request $request)
    {
        //根据GET POST这种取路由项，可能来自allRoutes or routes.
        $routes = $this->get($request->getMethod());

        // First, we will see if we can find a matching route for this current request
        // method. If we can, great, we can just return it so that it can be called
        // by the consumer. Otherwise we will check for routes with another verb.
        $route = $this->matchAgainstRoutes($routes, $request);

        if (! is_null($route)) {
            return $route->bind($request);
        }

        // If no route was found we will now check if a matching route is specified by
        // another HTTP verb. If it is we will need to throw a MethodNotAllowed and
        // inform the user agent of which HTTP verb it should use for this route.
        $others = $this->checkForAlternateVerbs($request);

        if (count($others) > 0) {
            return $this->getRouteForMethods($request, $others);
        }

        throw new NotFoundHttpException;
    }

    public function bind(Request $request)
    {
        $this->compileRoute();

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

        $this->originalParameters = $this->parameters;

        return $this;
    }

    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)
    {
        //disable的不要
        $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                                $this->container->make('middleware.disable') === true;

        //route middleware加入
        $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);

        //熟悉的pipeline，就是处理middleware
        return (new Pipeline($this->container))
                        ->send($request)
                        ->through($middleware)
                        ->then(function ($request) use ($route) {
                            return $this->prepareResponse(
                                $request, $route->run()
                            );
                        });
    }

    public function run()
    {
        $this->container = $this->container ?: new Container;

        try {
            //action是 `XXController@method`的字符串
            if ($this->isControllerAction()) {
                return $this->runController();
            }

            //action是可执行函数的形式, `function method($a,$b){...}`
            return $this->runCallable();
        } catch (HttpResponseException $e) {
            return $e->getResponse();
        }
    }

    //action是1个可执行函数 , php 允许这样调用函数
    /*
        function test() { echo 'test';}
        $name = 'test';
        $name();
    */
    protected function runCallable()
    {
        $callable = $this->action['uses'];

        return $callable(...array_values($this->resolveMethodDependencies(
            $this->parametersWithoutNulls(), new ReflectionFunction($this->action['uses'])
        )));
    }

public function index(Request $request, $id) {

}

    public function dispatch(Route $route, $controller, $method)
    {
        $parameters = $this->resolveClassMethodDependencies(
            //这个就是路由参数/post/{name}/{id}里的name,id
            $route->parametersWithoutNulls(), $controller, $method
        );

        if (method_exists($controller, 'callAction')) {
            return $controller->callAction($method, $parameters);
        }

        return $controller->{$method}(...array_values($parameters));
    }

//Closure
Route::get('/post/{id}', function(){...});

//Array with Closure, 会调用caller的闭包
Route::get('/post/{id}', ['id'=>xx. 'caller'= function(){...}]);
//Array
Route::get('/post/{id}', ['id'=>xx. 'content'=>xxx]);

//XXX实现了__invoke
Route::get('/post/{id}', new XXX::class);

//Model
\Models\Post $post;
Route::get('/post/{id}', $post);

//规定字符串,最常用的
Route::get('/post/{id}', 'PostController@index');

//D:\Projects\PHP\laravel\blog\vendor\laravel\framework\src\Illuminate\Routing\Route.php
    public function gatherMiddleware()
    {
        if (! is_null($this->computedMiddleware)) {
            return $this->computedMiddleware;
        }

        $this->computedMiddleware = [];

        //marge unique
        return $this->computedMiddleware = array_unique(array_merge(
            $this->middleware(), $this->controllerMiddleware()
        ), SORT_REGULAR);
    }

    public function gatherRouteMiddleware(Route $route)
    {
        $middleware = collect($route->gatherMiddleware())->map(function ($name) {
            return (array) MiddlewareNameResolver::resolve($name, $this->middleware, $this->middlewareGroups);
        })->flatten();

        //还要根据优先级排序
        return $this->sortMiddleware($middleware);
    }