Laravel核心——Ioc服务容器源码解析（服务器解析）

首先欢迎关注我的博客&＃xff1a; www.leoyang90.cn

服务容器对对象的自动解析是服务容器的核心功能&＃xff0c;make 函数、build 函数是实例化对象重要的核心&＃xff0c;先大致看一下代码&＃xff1a;

public function make($abstract)
{$abstract &＃61; $this->getAlias($abstract);if (isset($this->deferredServices[$abstract])) {$this->loadDeferredProvider($abstract);}return parent::make($abstract);
}

public function make($abstract){return $this->resolve($abstract);}public function resolve($abstract, $parameters &＃61; []){$abstract &＃61; $this->getAlias($abstract);$needsContextualBuild &＃61; ! empty($parameters) || ! is_null($this->getContextualConcrete($abstract));// If an instance of the type is currently being managed as a singleton we&＃39;ll// just return an existing instance instead of instantiating new instances// so the developer can keep using the same objects instance every time.if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {return $this->instances[$abstract];}$concrete &＃61; $this->getConcrete($abstract);// We&＃39;re ready to instantiate an instance of the concrete type registered for// the binding. This will instantiate the types, as well as resolve any of// its "nested" dependencies recursively until all have gotten resolved.if ($this->isBuildable($concrete, $abstract)) {$object &＃61; $this->build($concrete);} else {$object &＃61; $this->make($concrete);}// If we defined any extenders for this type, we&＃39;ll need to spin through them// and apply them to the object being built. This allows for the extension// of services, such as changing configuration or decorating the object.foreach ($this->getExtenders($abstract) as $extender) {$object &＃61; $extender($object, $this);}// If the requested type is registered as a singleton we&＃39;ll want to cache off// the instances in "memory" so we can return it later without creating an// entirely new instance of an object on each subsequent request for it.if ($this->isShared($abstract) && ! $needsContextualBuild) {$this->instances[$abstract] &＃61; $object;}$this->fireResolvingCallbacks($abstract, $object);$this->resolved[$abstract] &＃61; true;return $object;}

在讲解解析流程之前&＃xff0c;我们先说说使用make函数进行解析的分类&＃xff1a;

我们详细的讲一下上图。这里我把使用make函数进行解析的情况分为大致两种&＃xff1a;

• 解析对象没有绑定过任何类&＃xff0c;例如&＃xff1a;

$app->make(&＃39;App\Http\Controllers\HomeController&＃39;);

• 解析对象绑定过实现类

对于绑定过实现类的对象可以分为两种&＃xff1a;

• 绑定的是类名&＃xff0c;例如&＃xff1a;

$app->when(&＃39;App\Http\Controllers\HomeController&＃39;)
->needs(&＃39;App\Http\Requests\InRequest&＃39;)
->give(&＃39;App\Http\Requests\TestsRequest&＃39;);

• 绑定的是闭包

对于绑定的是闭包的又可以分为&＃xff1a;

• 用户绑定闭包&＃xff0c;例如&＃xff1a;

$app->singleton(&＃39;auth&＃39;,function($app){return new AuthManager($app)
})&＃xff1b;&＃xff0f;&＃xff0f;对象类直接实现方法$app->singleton(EloquentFactory::class, function ($app) {return EloquentFactory::construct($app->make(FakerGenerator::class), database_path(&＃39;factories&＃39;)
);&＃xff0f;&＃xff0f;对象类依赖注入
});

• 服务容器外包一层闭包函数&＃xff08;make&＃xff0f;build&＃xff09;&＃xff0c;例如&＃xff1a;

$app->singleton(Illuminate\Contracts\Http\Kernel::class,App\Http\Kernel::class
);//包装make$app->singleton(App\ConSole\Kernel::class,
);//包装build

我们在这里先大致讲一下服务容器解析的流程&＃xff0c;值得注意的是其中 build 函数有可能会递归调用 make&＃xff1a;

1. 获取服务名称。

2. 加载延迟服务。判断当前的接口是否是延迟服务提供者&＃xff0c;若是延迟服务提供者&＃xff0c;那么还要对服务提供者进行注册与启动操作。

3. 解析单例。如果接口服务是已经被解析过的单例对象&＃xff0c;而且并非上下文绑定&＃xff0c;那么直接取出对象。

4. 获取注册的实现。实现方式可能是上下文绑定的&＃xff0c;也可能是 binding 数组中的闭包&＃xff0c;也有可能就是接口本身。

5. build 解析。首先判断是否需要递归。是&＃xff0c;则递归 make&＃xff1b;否&＃xff0c;则调用 build 函数&＃xff1b;直到调用 build 为止

6. 执行扩展。若当前解析对象存在扩展&＃xff0c;运行扩展函数。

7. 创造单例对象。若 shared 为真&＃xff0c;且不存在上下文绑定&＃xff0c;则放入单例数组中

8. 回调

9. 标志解析

下面我们开始详细分解代码逻辑。由于 getAlias 函数已经在 上一篇 讲过&＃xff0c;这里不会再说。而loadDeferredProvider 函数作用是加载延迟服务&＃xff0c;与容器解析关系不大&＃xff0c;我们放在以后再说。

获取注册的实现

获取解析类的真正实现&＃xff0c;函数优先去获取上下文绑定的实现&＃xff0c;否则获取 binding 数组中的实现&＃xff0c;获取不到就是直接返回自己作为实现&＃xff1a;

protected function getConcrete($abstract)
{if (! is_null($concrete &＃61; $this->getContextualConcrete($abstract))) {return $concrete;}if (isset($this->bindings[$abstract])) {return $this->bindings[$abstract][&＃39;concrete&＃39;];}return $abstract;
}

一般来说&＃xff0c;上下文绑定的服务是通过依赖注入来实现的&＃xff1a;

$this->app->when(PhotoController::class)->needs(Filesystem::class)->give(function () {return Storage::disk(&＃39;local&＃39;);});class PhotoController{protected $file;public function __construct(Filesystem $file){$this->file &＃61; $file;}
}

服务容器会在解析 PhotoController 的时候&＃xff0c;通过放射获取参数类型 Filesystem&＃xff0c;并且会把 Filesystem 自动解析为 Storage::disk(&＃39;local&＃39;)。如何实现的呢&＃xff1f;首先&＃xff0c;从 上一篇 文章我们知道&＃xff0c;当进行上下文绑定的时候&＃xff0c;实际上是维护 contextual 数组&＃xff0c;通过上下文绑定&＃xff0c;这个数组中存在&＃xff1a;

contextual[PhotoController][Filesystem] &＃61; function () { return Storage::disk(&＃39;local&＃39;); }

若是服务容器试图构造 PhotoController 类&＃xff0c;那么由于其构造函数依赖于 Filesystem&＃xff0c;所以容器必须先生成 Filesystem 类&＃xff0c;然后再注入到 PhotoController 中。

在构造 Filesystem 之前&＃xff0c;服务容器会先把 PhotoController 放入 buildStack 中&＃xff0c;继而再去解析 Filesystem。

解析 Filesystem 时&＃xff0c;运行 getContextualConcrete 函数&＃xff1a;

protected function getContextualConcrete($abstract)
{if (! is_null($binding &＃61; $this->findInContextualBindings($abstract))) {return $binding;}if (empty($this->abstractAliases[$abstract])) {return;}foreach ($this->abstractAliases[$abstract] as $alias) {if (! is_null($binding &＃61; $this->findInContextualBindings($alias))) {return $binding;}}
}protected function findInContextualBindings($abstract)
{if (isset($this->contextual[end($this->buildStack)][$abstract])) {return $this->contextual[end($this->buildStack)][$abstract];}
}

从上面可以看出&＃xff0c;getContextualConcrete 函数把当前解析的类&＃xff08;Filesystem&＃xff09;作为 abstract&＃xff0c;buildStack 最后一个类&＃xff08;PhotoController&＃xff09;作为 concrete&＃xff0c;寻找 this->contextual[concrete] [abstract] &＃xff08;contextual[PhotoController] [Filesystem]&＃xff09;中的值&＃xff0c;在这个例子里面这个数组值就是那个匿名函数。

build 解析

对于服务容器来说&＃xff0c;绑定是可以递归的&＃xff0c;例如&＃xff1a;

$app->bind(&＃39;a&＃39;,&＃39;b&＃39;);
$app->bind(&＃39;b&＃39;,&＃39;c&＃39;);
$app->bind(&＃39;c&＃39;,function(){return new C;})

遇到这样的情况&＃xff0c;bind 绑定中 getClosure 函数开始发挥作用&＃xff0c;该函数会给类包一层闭包&＃xff0c;闭包内调用 make 函数&＃xff0c;服务容器会不断递归调用 make 函数&＃xff0c;直到最后一层&＃xff0c;也就是绑定 c 的匿名函数。但是另一方面&＃xff0c;有一些绑定方式并没有调用 bind 函数&＃xff0c;例如上下文绑定 context&＃xff1a;

$this->app->when(E::class)->needs(F::class)->give(A::class);

当make(E::class)的时候&＃xff0c;getConcrete 返回 A 类&＃xff0c;而不是调用 make 函数的闭包&＃xff0c;所以并不会启动递归流程得到 C 的匿名函数&＃xff0c;所以造成 A 类完全无法解析&＃xff0c;isBuildable 函数就是解决这种问题的&＃xff0c;当发现需要解析构造的对象很有可能是递归的&＃xff0c;那么就递归调用 make 函数&＃xff0c;否则才会调用build。

...
if ($this->isBuildable($concrete, $abstract)) {$object &＃61; $this->build($concrete);} else {$object &＃61; $this->make($concrete);}
...protected function isBuildable($concrete, $abstract)
{return $concrete &＃61;&＃61;&＃61; $abstract || $concrete instanceof Closure;
}

执行扩展

获取扩展闭包&＃xff0c;并运行扩展函数&＃xff1a;

protected function getExtenders($abstract)
{$abstract &＃61; $this->getAlias($abstract);if (isset($this->extenders[$abstract])) {return $this->extenders[$abstract];}return [];
}

回调

先后启动全局的解析事件回调函数&＃xff0c;再启动针对类型的事件回调函数&＃xff1a;

protected function fireResolvingCallbacks($abstract, $object)
{$this->fireCallbackArray($object, $this->globalResolvingCallbacks);$this->fireCallbackArray($object, $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks));$this->fireAfterResolvingCallbacks($abstract, $object);
}protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
{$results &＃61; [];foreach ($callbacksPerType as $type &＃61;> $callbacks) {if ($type &＃61;&＃61;&＃61; $abstract || $object instanceof $type) {$results &＃61; array_merge($results, $callbacks);}}return $results;
}protected function fireAfterResolvingCallbacks($abstract, $object)
{$this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);$this->fireCallbackArray($object, $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks)); build 解析

make 函数承担了解析的大致框架&＃xff0c;build 主要的职责就是利用反射将类构造出来&＃xff0c;先看看主要代码&＃xff1a;

public function build($concrete)
{// If the concrete type is actually a Closure, we will just execute it and// hand back the results of the functions, which allows functions to be// used as resolvers for more fine-tuned resolution of these objects.if ($concrete instanceof Closure) {return $concrete($this, $this->getLastParameterOverride());}$reflector &＃61; new ReflectionClass($concrete);// If the type is not instantiable, the developer is attempting to resolve// an abstract type such as an Interface of Abstract Class and there is// no binding registered for the abstractions so we need to bail out.if (! $reflector->isInstantiable()) {return $this->notInstantiable($concrete);}$this->buildStack[] &＃61; $concrete;$constructor &＃61; $reflector->getConstructor();// If there are no constructors, that means there are no dependencies then// we can just resolve the instances of the objects right away, without// resolving any other types or dependencies out of these containers.if (is_null($constructor)) {array_pop($this->buildStack);return new $concrete;}$dependencies &＃61; $constructor->getParameters();// Once we have all the constructor&＃39;s parameters we can create each of the// dependency instances and then use the reflection instances to make a// new instance of this class, injecting the created dependencies in.$instances &＃61; $this->resolveDependencies($dependencies);array_pop($this->buildStack);return $reflector->newInstanceArgs($instances);
}

我们下面详细的说一下各个部分&＃xff1a;

闭包函数执行

if ($concrete instanceof Closure) {return $concrete($this, $this->getLastParameterOverride());
}

这段代码很简单&＃xff0c;但是作用很大。前面说过闭包函数有很多种类&＃xff1a;

• 用户绑定时提供的直接提供实现类的方式&＃xff1a;

$app->singleton(&＃39;auth&＃39;,function($app){return new AuthManager($app)
})&＃xff1b;&＃xff0f;&＃xff0f;对象类直接实现方法

这种情况 concrete(this) 直接就可以解析构造出具体实现类&＃xff0c;服务容器解析完毕。

• 用户绑定时提供的带有依赖注入的实现&＃xff1a;

$app->singleton(EloquentFactory::class, function ($app) {return EloquentFactory::construct($app->make(FakerGenerator::class), database_path(&＃39;factories&＃39;)
);&＃xff0f;&＃xff0f;对象类依赖注入

这种情况下&＃xff0c;concrete(this) 会转而去解析 FakerGenerator::class&＃xff0c;递归调用 make 函数。

• bind函数使用 getClosure 包装而来&＃xff1a;

function($container, $parameters &＃61; []){method &＃61; make/build;return $container->$method($concrete, $parameters);
}

这种情况&＃xff0c;concrete(this) 将会继续递归调用 make 或者 build。

反射

当 build 的参数是类名而不是闭包的时候&＃xff0c;就要利用反射构建类对象&＃xff0c;如果构建的类对象不需要依赖任何其他参数&＃xff0c;那么&＃xff1a;

$reflector &＃61; new ReflectionClass($concrete);
$constructor &＃61; $reflector->getConstructor();
if (is_null($constructor)) {return new $concrete;
}

如果需要依赖注入&＃xff0c;那么就要用反射机制来获取 __construct 函数所需要注入的依赖&＃xff0c;如果在make的时候带入参数值&＃xff0c;那么直接利用传入的参数值&＃xff1b;如果依赖是类对像&＃xff0c;那么递归调用 make 函数&＃xff1b;如果依赖是变量值&＃xff0c;那么就从上下文中或者参数默认值中去获取&＃xff1a;

...
$dependencies &＃61; $constructor->getParameters();
$instances &＃61; $this->resolveDependencies($dependencies);
...protected function resolveDependencies(array $dependencies)
{$results &＃61; [];foreach ($dependencies as $dependency) {if ($this->hasParameterOverride($dependency)) {$results[] &＃61; $this->getParameterOverride($dependency);continue;}$results[] &＃61; is_null($class &＃61; $dependency->getClass())? $this->resolvePrimitive($dependency): $this->resolveClass($dependency);}return $results;
}

解析变量值参数&＃xff0c;如果变量值在上下文绑定中设置过&＃xff0c;则去取上下文绑定的值&＃xff0c;否则通过反射去取参数默认值&＃xff0c;如果没有默认值&＃xff0c;那么就要终止报错&＃xff1a;

protected function resolvePrimitive(ReflectionParameter $parameter)
{if (! is_null($concrete &＃61; $this->getContextualConcrete(&＃39;$&＃39;.$parameter->name))) {return $concrete instanceof Closure ? $concrete($this) : $concrete;}if ($parameter->isDefaultValueAvailable()) {return $parameter->getDefaultValue();}$this->unresolvablePrimitive($parameter);
}protected function hasParameterOverride($dependency)
{return array_key_exists($dependency->name, $this->getLastParameterOverride());
}protected function getParameterOverride($dependency)
{return $this->getLastParameterOverride()[$dependency->name];
}protected function getLastParameterOverride()
{return count($this->with) ? end($this->with) : [];
}

解析类参数&＃xff0c;利用服务容器进行依赖注入&＃xff1a;

protected function resolveClass(ReflectionParameter $parameter)
{try {return $this->make($parameter->getClass()->name);}catch (BindingResolutionException $e) {if ($parameter->isOptional()) {return $parameter->getDefaultValue();}throw $e;}
}

buildstack 解析栈

值的注意的是服务容器里面有个 buildStack&＃xff0c;每次利用反射对参数进行依赖注入的时候&＃xff0c;都要向这个数组中压入当前的解析对象&＃xff0c;前面说过这部分是为了上下文绑定而设计的&＃xff1a;

...
$this->buildStack[] &＃61; $concrete;//压入数组栈中
...
$instances &＃61; $this->resolveDependencies($dependencies);&＃xff0f;&＃xff0f;解析依赖注入的参数
array_pop($this->buildStack);&＃xff0f;&＃xff0f;弹出数组栈
... 解析标签

使用标签绑定的类&＃xff0c;将会使用 tagged 来解析:

public function tagged($tag)
{$results &＃61; [];if (isset($this->tags[$tag])) {foreach ($this->tags[$tag] as $abstract) {$results[] &＃61; $this->make($abstract);}}return $results;
} call方法注入

服务容器中&＃xff0c;我们直接使用或者间接的使用 make 来构造服务对象&＃xff0c;但是在实际的应用场景中&＃xff0c;会有这样的需求&＃xff1a;我们拥有一个对象或者闭包函数&＃xff0c;想要调用它的一个函数&＃xff0c;但是它函数里面却有其他类的参数&＃xff0c;这个就需要进行 call 方法注入

public function call($callback, array $parameters &＃61; [], $defaultMethod &＃61; null)
{return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
}

在 上一篇 文章中&＃xff0c;我们说过&＃xff0c;call 函数中的 callback 参数有以下几种形式&＃xff1a;

• 闭包 Closure

• class&＃64;method

• 类静态函数&＃xff0c;class::method

• 类静态函数&＃xff1a; [ className&＃xff0f;classObj, method ]&＃xff1b;类非静态函数&＃xff1a; [ classObj, method ]

• 若 defaultMethod 不为空&＃xff0c;className
  首先&＃xff0c;我们先看看 call 方法注入的流程图&＃xff1a;

从流程图中我们可以看出来&＃xff0c;虽然调用 call 的形式有 5 种&＃xff0c;但是实际最终的形式是三种&＃xff0c;第二种和第五种被转化为了第四种。
接下来&＃xff0c;我们详细的解析源码&＃xff1a;

call

先看一下 call 方法的主体&＃xff1a;

public static function call($container, $callback, array $parameters &＃61; [], $defaultMethod &＃61; 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));});
}

可以看出来&＃xff0c;call 方法注入主要有 4 个大的步骤&＃xff1a;

1. 对于 className&＃64;method 和 className-defaultMethod&＃xff0c;实例化 className 为类对象&＃xff0c;转化为 [ classObj, method ]。

2. 判断 [ classObj &＃xff0f; classname, method ] 是否存在被绑定的方法&＃xff0c;如果有则调用。

3. 利用服务容器解析依赖的参数。

4. 调用 call_user_func_array。

实例化类对象

在这里 className&＃64;method 和 className-defaultMethod 两种情况被转化为 [ classObj, method ]&＃xff0c; className会被实例化为类对象&＃xff0c;并重新调用 call&＃xff1a;

protected static function isCallableWithAtSign($callback)
{return is_string($callback) && strpos($callback, &＃39;&＃64;&＃39;) !&＃61;&＃61; false;
}protected static function callClass($container, $target, array $parameters &＃61; [], $defaultMethod &＃61; null)
{$segments &＃61; explode(&＃39;&＃64;&＃39;, $target);$method &＃61; count($segments) &＃61;&＃61; 2? $segments[1] : $defaultMethod;if (is_null($method)) {throw new InvalidArgumentException(&＃39;Method not provided.&＃39;);}return static::call($container, [$container->make($segments[0]), $method], $parameters);
}

执行绑定方法

针对 [ className&＃xff0f;classObj, method ], 调用被绑定的方法&＃xff1a;

protected static function callBoundMethod($container, $callback, $default)
{if (! is_array($callback)) {return value($default);}$method &＃61; static::normalizeMethod($callback);if ($container->hasMethodBinding($method)) {return $container->callMethodBinding($method, $callback[0]);}return value($default);
}protected static function normalizeMethod($callback)
{$class &＃61; is_string($callback[0]) ? $callback[0] : get_class($callback[0]);return "{$class}&＃64;{$callback[1]}";
}public function hasMethodBinding($method)
{return isset($this->methodBindings[$method]);
} public function callMethodBinding($method, $instance)
{return call_user_func($this->methodBindings[$method], $instance, $this);
}

那么这个被绑定的方法 methodBindings 从哪里来呢&＃xff0c;就是 上一篇 文章提的 bindMethod&＃xff1a;

public function bindMethod($method, $callback)
{$this->methodBindings[$method] &＃61; $callback;
}

从上面可以看出来&＃xff0c;methodBindings 中 callback 参数一定是 classname&＃64;method 形式的。

实例化依赖

这一步就要通过反射来获取函数方法需要注入的参数类型&＃xff0c;然后利用服务容器对参数类型进行解析构建&＃xff1a;

protected static function getMethodDependencies($container, $callback, array $parameters &＃61; [])
{$dependencies &＃61; [];foreach (static::getCallReflector($callback)->getParameters() as $parameter) {static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);}return array_merge($dependencies, $parameters);
}

getCallReflector 函数利用反射来获取参数类型&＃xff0c;值得注意的是class::method是需要拆分处理的&＃xff1a;

protected static function getCallReflector($callback)
{if (is_string($callback) && strpos($callback, &＃39;::&＃39;) !&＃61;&＃61; false) {$callback &＃61; explode(&＃39;::&＃39;, $callback);}return is_array($callback)? new ReflectionMethod($callback[0], $callback[1]): new ReflectionFunction($callback);
}

利用传入的参数&＃xff0c;利用服务容器构建解析参数类型&＃xff0c;或者获取参数默认值&＃xff1a;

protected static function addDependencyForCallParameter($container, $parameter,array &$parameters, &$dependencies)
{if (array_key_exists($parameter->name, $parameters)) {$dependencies[] &＃61; $parameters[$parameter->name];unset($parameters[$parameter->name]);} elseif ($parameter->getClass()) {$dependencies[] &＃61; $container->make($parameter->getClass()->name);} elseif ($parameter->isDefaultValueAvailable()) {$dependencies[] &＃61; $parameter->getDefaultValue();}
}

call_user_func_array

关于这个函数可以参考 Laravel学习笔记之Callback Type

call_user_func_array($callback, static::getMethodDependencies($container, $callback, $parameters));

Written with StackEdit.