前言

经过前面一系列中间件的工作，现在请求终于要达到了正确的控制器方法了。本篇文章主要讲 laravel 如何调用控制器方法，并且为控制器方法依赖注入构建参数的过程。

路由控制器的调用

我们前面已经解析过中间件的搜集与排序、pipeline 的原理，接下来就要进行路由的 run 运行函数：

  1. protected function runRouteWithinStack(Route $route, Request $request)
  2. {
  3.     $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
  4.                             $this->container->make('middleware.disable') === true;
  6.     $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
  8.     return (new Pipeline($this->container))
  9.                     ->send($request)
  10.                     ->through($middleware)
  11.                     ->then(function ($request) use ($route) {
  12.                         return $this->prepareResponse(
  13.                             $request, $route->run()
  14.                         );
  15.                     });
  16. }

路由的 run 函数主要负责路由控制器方法与路由闭包函数的运行：

  1. public function run()
  2. {
  3.     $this->container = $this->container ?: new Container;
  5.     try {
  6.         if ($this->isControllerAction()) {
  7.             return $this->runController();
  8.         }
  10.         return $this->runCallable();
  11.     } catch (HttpResponseException $e) {
  12.         return $e->getResponse();
  13.     }
  14. }

路由的运行主要靠 ControllerDispatcher 这个类：

  1. class Route
  2. {
  3.     protected function isControllerAction()
  4.     {
  5.         return is_string($this->action['uses']);
  6.     }
  8.     protected function runController()
  9.     {
  10.         return (new ControllerDispatcher($this->container))->dispatch(
  11.             $this, $this->getController(), $this->getControllerMethod()
  12.         );
  13.     }
  14. }
  16. class ControllerDispatcher
  17. {
  18.     use RouteDependencyResolverTrait;
  20.     public function dispatch(Route $route, $controller, $method)
  21.     {
  22.         $parameters = $this->resolveClassMethodDependencies(
  23.             $route->parametersWithoutNulls(), $controller, $method
  24.         );
  26.         if (method_exists($controller, 'callAction')) {
  27.             return $controller->callAction($method, $parameters);
  28.         }
  30.         return $controller->{$method}(...array_values($parameters));
  31.     }
  32. }

上面可以很清晰地看出，控制器的运行分为两步：解析函数参数、调用callAction

解析控制器方法参数

解析参数的功能主要由 ControllerDispatcher 类的 RouteDependencyResolverTrait 这一 trait 负责：

  1. trait RouteDependencyResolverTrait
  2. {
  3.     protected function resolveClassMethodDependencies(array $parameters, $instance, $method)
  4.     {
  5.         if (! method_exists($instance, $method)) {
  6.             return $parameters;
  7.         }
  9.         return $this->resolveMethodDependencies(
  10.             $parameters, new ReflectionMethod($instance, $method)
  11.         );
  12.     }
  14.     public function resolveMethodDependencies(array $parameters, ReflectionFunctionAbstract $reflector)
  15.     {
  16.         $instanceCount = 0;
  18.         $values = array_values($parameters);
  20.         foreach ($reflector->getParameters() as $key => $parameter) {
  21.             $instance = $this->transformDependency(
  22.                 $parameter, $parameters
  23.             );
  25.             if (! is_null($instance)) {
  26.                 $instanceCount++;
  28.                 $this->spliceIntoParameters($parameters, $key, $instance);
  29.             } elseif (! isset($values[$key - $instanceCount]) &&
  30.                       $parameter->isDefaultValueAvailable()) {
  31.                 $this->spliceIntoParameters($parameters, $key, $parameter->getDefaultValue());
  32.             }
  33.         }
  35.         return $parameters;
  36.     }
  37. }

控制器方法函数参数构造难点在于，参数来源有三种：

  • 路由参数赋值
  • Ioc 容器自动注入
  • 函数自带默认值

在 Ioc 容器自动注入的时候，要保证路由的现有参数中没有相应的类，防止依赖注入覆盖路由绑定的参数：

  1. protected function transformDependency(ReflectionParameter $parameter, $parameters)
  2. {
  3.     $class = $parameter->getClass();
  5.     if ($class && ! $this->alreadyInParameters($class->name, $parameters)) {
  6.         return $this->container->make($class->name);
  7.     }
  8. }
  10. protected function alreadyInParameters($class, array $parameters)
  11. {
  12.     return ! is_null(Arr::first($parameters, function ($value) use ($class) {
  13.         return $value instanceof $class;
  14.     }));
  15. }

由 Ioc 容器构造出的参数需要插入到原有的路由参数数组中：

  1. if (! is_null($instance)) {
  2.     $instanceCount++;
  4.     $this->spliceIntoParameters($parameters, $key, $instance);
  5. }
  7. protected function spliceIntoParameters(array &$parameters, $offset, $value)
  8. {
  9.     array_splice(
  10.         $parameters, $offset, 0, [$value]
  11.     );
  12. }

当路由的参数数组与 Ioc 容器构造的参数数量不足以覆盖控制器参数个数时，就要去判断控制器是否具有默认参数：

  1. elseif (! isset($values[$key - $instanceCount]) &&
  2.        $parameter->isDefaultValueAvailable()) {
  3.     $this->spliceIntoParameters($parameters, $key, $parameter->getDefaultValue());
  4. }

调用控制器方法 callAction

所有的控制器并非是直接调用相应方法的，而是通过 callAction 函数再分配，如果实在没有相应方法还会调用魔术方法 __call():

  1. public function callAction($method, $parameters)
  2. {
  3.     return call_user_func_array([$this, $method], $parameters);
  4. }
  6. public function __call($method, $parameters)
  7. {
  8.     throw new BadMethodCallException("Method [{$method}] does not exist.");
  9. }

路由闭包函数的调用

路由闭包函数的调用与控制器方法一样，仍然需要依赖注入，参数构造：

  1. protected function runCallable()
  2. {
  3.     $callable = $this->action['uses'];
  5.     return $callable(...array_values($this->resolveMethodDependencies(
  6.         $this->parametersWithoutNulls(), new ReflectionFunction($this->action['uses'])
  7.     )));
  8. }