中文注釋版 Laravel 容器類（Container）
將 Laravel 的
illuminate/container移除掉illuminate/contracts依賴，便于靈活的在非 Laravel 框架中使用，順便機(jī)翻了一下illuminate/container的注釋，便于理解 Laravel 的容器。
相關(guān)鏈接
代碼
<?php
/*
* This file is part of the guanguans/di.
*
* (c) guanguans <ityaozm@gmail.com>
*
* This source file is subject to the MIT license that is bundled.
*/
namespace Guanguans\Di;
use ArrayAccess;
use Closure;
use LogicException;
use Psr\Container\ContainerInterface;
use ReflectionClass;
use ReflectionParameter;
/**
* This file is modified from `illuminate/container`.
*
* @see https://github.com/illuminate/container
*/
class Container implements ArrayAccess, ContainerInterface
{
/**
* The current globally available container (if any).
* 當(dāng)前的全局可用容器（如果有）。
*
* @var static
*/
protected static $instance;
/**
* An array of the types that have been resolved.
* 已解析類型的數(shù)組。
*
* @var array
*/
protected $resolved = [];
/**
* The container's bindings.
* 容器的綁定。
*
* @var array
*/
protected $bindings = [];
/**
* The container's method bindings.
* 容器的方法綁定。
*
* @var array
*/
protected $methodBindings = [];
/**
* The container's shared instances.
* 容器的共享實(shí)例。
*
* @var array
*/
protected $instances = [];
/**
* The registered type aliases.
* 注冊的類型別名。
*
* @var array
*/
protected $aliases = [];
/**
* The registered aliases keyed by the abstract name.
* 以抽象名稱為關(guān)鍵字的注冊別名。
*
* @var array
*/
protected $abstractAliases = [];
/**
* The extension closures for services.
* 服務(wù)的擴(kuò)展名閉包。
*
* @var array
*/
protected $extenders = [];
/**
* All of the registered tags.
* 所有注冊的標(biāo)簽。
*
* @var array
*/
protected $tags = [];
/**
* The stack of concretions currently being built.
* 目前正在構(gòu)建的堆棧。
*
* @var array
*/
protected $buildStack = [];
/**
* The parameter override stack.
* 參數(shù)覆蓋堆棧。
*
* @var array
*/
protected $with = [];
/**
* The contextual binding map.
* 上下文綁定圖。
*
* @var array
*/
public $contextual = [];
/**
* All of the registered rebound callbacks.
* 所有已注冊的反彈回調(diào)。
*
* @var array
*/
protected $reboundCallbacks = [];
/**
* All of the global resolving callbacks.
* 所有全局解析回調(diào)。
*
* @var array
*/
protected $globalResolvingCallbacks = [];
/**
* All of the global after resolving callbacks.
* 解決回調(diào)后的所有全局變量。
*
* @var array
*/
protected $globalAfterResolvingCallbacks = [];
/**
* All of the resolving callbacks by class type.
* 按類類型的所有解析回調(diào)。
*
* @var array
*/
protected $resolvingCallbacks = [];
/**
* All of the after resolving callbacks by class type.
* 所有按類類型解析后的回調(diào)。
*
* @var array
*/
protected $afterResolvingCallbacks = [];
/**
* Define a contextual binding.
* 定義上下文綁定。
*
* @param string $concrete
* @return \Guanguans\Di\ContextualBindingBuilder
*/
public function when($concrete)
{
return new ContextualBindingBuilder($this, $this->getAlias($concrete));
}
/**
* Determine if the given abstract type has been bound.
* 確定給定的抽象類型是否已綁定。
*
* @param string $abstract
* @return bool
*/
public function bound($abstract)
{
return isset($this->bindings[$abstract]) ||
isset($this->instances[$abstract]) ||
$this->isAlias($abstract);
}
/**
* Determine if the given abstract type has been resolved.
* 確定給定的抽象類型是否已解析。
*
* @param string $abstract
* @return bool
*/
public function resolved($abstract)
{
if ($this->isAlias($abstract)) {
$abstract = $this->getAlias($abstract);
}
return isset($this->resolved[$abstract]) ||
isset($this->instances[$abstract]);
}
/**
* Determine if a given type is shared.
* 確定給定類型是否共享。
*
* @param string $abstract
* @return bool
*/
public function isShared($abstract)
{
return isset($this->instances[$abstract]) ||
(isset($this->bindings[$abstract]['shared']) &&
$this->bindings[$abstract]['shared'] === true);
}
/**
* Determine if a given string is an alias.
* 確定給定的字符串是否為別名
*
* @param string $name
* @return bool
*/
public function isAlias($name)
{
return isset($this->aliases[$name]);
}
/**
* Register a binding with the container.
* 在容器中注冊綁定
*
* @param string|array $abstract
* @param \Closure|string|null $concrete
* @param bool $shared
* @return void
*/
public function bind($abstract, $concrete = null, $shared = false)
{
// If no concrete type was given, we will simply set the concrete type to the
// abstract type. After that, the concrete type to be registered as shared
// without being forced to state their classes in both of the parameters.
// 如果沒有給出具體類型，我們將簡單地將具體類型設(shè)置為抽象類型。
// 之后，要注冊為共享的具體類型，而不必強(qiáng)制在兩個參數(shù)中聲明其類。
$this->dropStaleInstances($abstract);
if (is_null($concrete)) {
$concrete = $abstract;
}
// If the factory is not a Closure, it means it is just a class name which is
// bound into this container to the abstract type and we will just wrap it
// up inside its own Closure to give us more convenience when extending.
// 如果工廠不是 Closure，則意味著它只是一個類名稱，
// 該類名稱綁定到此容器中，與抽象類型綁定，
// 我們將其包裝在自己的 Closure 中，以便在擴(kuò)展時為我們提供更多便利。
if (! $concrete instanceof Closure) {
$concrete = $this->getClosure($abstract, $concrete);
}
$this->bindings[$abstract] = compact('concrete', 'shared');
// If the abstract type was already resolved in this container we'll fire the
// rebound listener so that any objects which have already gotten resolved
// can have their copy of the object updated via the listener callbacks.
// 如果抽象類型已在此容器中解析，我們將觸發(fā)回彈偵聽器，
// 以便所有已解析的對象都可以通過偵聽器回調(diào)更新其對象副本。
if ($this->resolved($abstract)) {
$this->rebound($abstract);
}
}
/**
* Get the Closure to be used when building a type.
* 獲取要在構(gòu)建類型時使用的閉包。
*
* @param string $abstract
* @param string $concrete
* @return \Closure
*/
protected function getClosure($abstract, $concrete)
{
return function ($container, $parameters = []) use ($abstract, $concrete) {
if ($abstract == $concrete) {
return $container->build($concrete);
}
return $container->makeWith($concrete, $parameters);
};
}
/**
* Determine if the container has a method binding.
* 確定容器是否具有方法綁定。
*
* @param string $method
* @return bool
*/
public function hasMethodBinding($method)
{
return isset($this->methodBindings[$method]);
}
/**
* Bind a callback to resolve with Container::call.
* 綁定回調(diào)以使用 Container::call 進(jìn)行解析。
*
* @param string $method
* @param \Closure $callback
* @return void
*/
public function bindMethod($method, $callback)
{
$this->methodBindings[$method] = $callback;
}
/**
* Get the method binding for the given method.
* 獲取給定方法的方法綁定。
*
* @param string $method
* @param mixed $instance
* @return mixed
*/
public function callMethodBinding($method, $instance)
{
return call_user_func($this->methodBindings[$method], $instance, $this);
}
/**
* Add a contextual binding to the container.
* 將上下文綁定添加到容器。
*
* @param string $concrete
* @param string $abstract
* @param \Closure|string $implementation
* @return void
*/
public function addContextualBinding($concrete, $abstract, $implementation)
{
$this->contextual[$concrete][$this->getAlias($abstract)] = $implementation;
}
/**
* Register a binding if it hasn't already been registered.
* 注冊綁定（如果尚未注冊）。
*
* @param string $abstract
* @param \Closure|string|null $concrete
* @param bool $shared
* @return void
*/
public function bindIf($abstract, $concrete = null, $shared = false)
{
if (! $this->bound($abstract)) {
$this->bind($abstract, $concrete, $shared);
}
}
/**
* Register a shared binding in the container.
* 在容器中注冊共享綁定。
*
* @param string|array $abstract
* @param \Closure|string|null $concrete
* @return void
*/
public function singleton($abstract, $concrete = null)
{
$this->bind($abstract, $concrete, true);
}
/**
* "Extend" an abstract type in the container.
* “擴(kuò)展”容器中的抽象類型。
*
* @param string $abstract
* @param \Closure $closure
* @return void
*
* @throws \InvalidArgumentException
*/
public function extend($abstract, Closure $closure)
{
$abstract = $this->getAlias($abstract);
if (isset($this->instances[$abstract])) {
$this->instances[$abstract] = $closure($this->instances[$abstract], $this);
$this->rebound($abstract);
} else {
$this->extenders[$abstract][] = $closure;
if ($this->resolved($abstract)) {
$this->rebound($abstract);
}
}
}
/**
* Register an existing instance as shared in the container.
* 將現(xiàn)有實(shí)例注冊為在容器中共享的實(shí)例。
*
* @param string $abstract
* @param mixed $instance
* @return void
*/
public function instance($abstract, $instance)
{
$this->removeAbstractAlias($abstract);
$isBound = $this->bound($abstract);
unset($this->aliases[$abstract]);
// We'll check to determine if this type has been bound before, and if it has
// we will fire the rebound callbacks registered with the container and it
// can be updated with consuming classes that have gotten resolved here.
// 我們將檢查以確定此類型是否以前已綁定，
// 如果已經(jīng)綁定，將觸發(fā)在容器中注冊的反彈回調(diào)，
// 并且可以使用在這里已解決的消耗類進(jìn)行更新。
$this->instances[$abstract] = $instance;
if ($isBound) {
$this->rebound($abstract);
}
}
/**
* Remove an alias from the contextual binding alias cache.
* 從上下文綁定別名緩存中刪除別名。
*
* @param string $searched
* @return void
*/
protected function removeAbstractAlias($searched)
{
if (! isset($this->aliases[$searched])) {
return;
}
foreach ($this->abstractAliases as $abstract => $aliases) {
foreach ($aliases as $index => $alias) {
if ($alias == $searched) {
unset($this->abstractAliases[$abstract][$index]);
}
}
}
}
/**
* Assign a set of tags to a given binding.
* 將一組標(biāo)簽分配給給定的綁定。
*
* @param array|string $abstracts
* @param array|mixed ...$tags
* @return void
*/
public function tag($abstracts, $tags)
{
$tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);
foreach ($tags as $tag) {
if (! isset($this->tags[$tag])) {
$this->tags[$tag] = [];
}
foreach ((array) $abstracts as $abstract) {
$this->tags[$tag][] = $abstract;
}
}
}
/**
* Resolve all of the bindings for a given tag.
* 解決給定標(biāo)簽的所有綁定。
*
* @param string $tag
* @return array
*/
public function tagged($tag)
{
$results = [];
if (isset($this->tags[$tag])) {
foreach ($this->tags[$tag] as $abstract) {
$results[] = $this->make($abstract);
}
}
return $results;
}
/**
* Alias a type to a different name.
* 將別名別名為另一個名稱。
*
* @param string $abstract
* @param string $alias
* @return void
*/
public function alias($abstract, $alias)
{
$this->aliases[$alias] = $abstract;
$this->abstractAliases[$abstract][] = $alias;
}
/**
* Bind a new callback to an abstract's rebind event.
* 綁定一個新的回調(diào)到抽象的重新綁定事件。
*
* @param string $abstract
* @param \Closure $callback
* @return mixed
*/
public function rebinding($abstract, Closure $callback)
{
$this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback;
if ($this->bound($abstract)) {
return $this->make($abstract);
}
}
/**
* Refresh an instance on the given target and method.
* 在給定的目標(biāo)和方法上刷新實(shí)例。
*
* @param string $abstract
* @param mixed $target
* @param string $method
* @return mixed
*/
public function refresh($abstract, $target, $method)
{
return $this->rebinding($abstract, function ($app, $instance) use ($target, $method) {
$target->{$method}($instance);
});
}
/**
* Fire the "rebound" callbacks for the given abstract type.
* 為給定的抽象類型觸發(fā)“反彈”回調(diào)。
*
* @param string $abstract
* @return void
*/
protected function rebound($abstract)
{
$instance = $this->make($abstract);
foreach ($this->getReboundCallbacks($abstract) as $callback) {
call_user_func($callback, $this, $instance);
}
}
/**
* Get the rebound callbacks for a given type.
* 獲取給定類型的反彈回調(diào)
*
* @param string $abstract
* @return array
*/
protected function getReboundCallbacks($abstract)
{
if (isset($this->reboundCallbacks[$abstract])) {
return $this->reboundCallbacks[$abstract];
}
return [];
}
/**
* Wrap the given closure such that its dependencies will be injected when executed.
* 包裝給定的閉包，以便在執(zhí)行時注入其依賴項(xiàng)。
*
* @param \Closure $callback
* @param array $parameters
* @return \Closure
*/
public function wrap(Closure $callback, array $parameters = [])
{
return function () use ($callback, $parameters) {
return $this->call($callback, $parameters);
};
}
/**
* Call the given Closure / class@method and inject its dependencies.
* 調(diào)用給定的 Closure / class@method 并注入其依賴項(xiàng)。
*
* @param callable|string $callback
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
*/
public function call($callback, array $parameters = [], $defaultMethod = null)
{
return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
}
/**
* Get a closure to resolve the given type from the container.
* 獲取一個容器來解析給定類型的閉包。
*
* @param string $abstract
* @return \Closure
*/
public function factory($abstract)
{
return function () use ($abstract) {
return $this->make($abstract);
};
}
/**
* Resolve the given type with the given parameter overrides.
* 使用給定的參數(shù)覆蓋解析給定的類型。
*
* @param string $abstract
* @param array $parameters
* @return mixed
*/
public function makeWith($abstract, array $parameters)
{
return $this->resolve($abstract, $parameters);
}
/**
* Resolve the given type from the container.
* 從容器解析給定類型。
*
* @param string $abstract
* @return mixed
*/
public function make($abstract)
{
return $this->resolve($abstract);
}
/**
* Resolve the given type from the container.
* 從容器解析給定類型。
*
* @param string $abstract
* @param array $parameters
* @return mixed
*/
protected function resolve($abstract, $parameters = [])
{
$abstract = $this->getAlias($abstract);
$needsContextualBuild = ! empty($parameters) || ! is_null(
$this->getContextualConcrete($abstract)
);
// If an instance of the type is currently being managed as a singleton we'll
// just return an existing instance instead of instantiating new instances
// so the developer can keep using the same objects instance every time.
// 如果當(dāng)前正在以單例方式管理該類型的實(shí)例，
// 我們將只返回一個現(xiàn)有實(shí)例，而不是實(shí)例化新實(shí)例，
// 以便開發(fā)人員每次都可以繼續(xù)使用相同的對象實(shí)例。
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
$this->with[] = $parameters;
$concrete = $this->getConcrete($abstract);
// We'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.
// 我們已經(jīng)準(zhǔn)備好實(shí)例化為綁定注冊的具體類型的實(shí)例。
// 這將實(shí)例化類型，并以遞歸方式解析其“嵌套”依賴項(xiàng)中的任何一個，直到全部解析完畢。
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
// If we defined any extenders for this type, we'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.
// 如果我們?yōu)榇祟愋投x了任何擴(kuò)展程序，則需要遍歷它們并將其應(yīng)用于正在構(gòu)建的對象。
// 這允許擴(kuò)展服務(wù)，例如更改配置或裝飾對象。
foreach ($this->getExtenders($abstract) as $extender) {
$object = $extender($object, $this);
}
// If the requested type is registered as a singleton we'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.
// 如果將請求的類型注冊為單例，我們將將實(shí)例緩存在“內(nèi)存”中，
// 這樣??我們以后就可以返回它，而無需在隨后的每次請求上都創(chuàng)建對象的全新實(shí)例。
if ($this->isShared($abstract) && ! $needsContextualBuild) {
$this->instances[$abstract] = $object;
}
$this->fireResolvingCallbacks($abstract, $object);
// Before returning, we will also set the resolved flag to "true" and pop off
// the parameter overrides for this build. After those two things are done
// we will be ready to return back the fully constructed class instance.
// 在返回之前，我們還將解析標(biāo)記設(shè)置為 “true”，并彈出此版本的參數(shù)替代。
// 完成這兩件事之后，我們將準(zhǔn)備好返回完整構(gòu)造的類實(shí)例。
$this->resolved[$abstract] = true;
array_pop($this->with);
return $object;
}
/**
* Get the concrete type for a given abstract.
* 獲取給定摘要的具體類型。
*
* @param string $abstract
* @return mixed $concrete
*/
protected function getConcrete($abstract)
{
if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
return $concrete;
}
// If we don't have a registered resolver or concrete for the type, we'll just
// assume each type is a concrete name and will attempt to resolve it as is
// since the container should be able to resolve concretes automatically.
// 如果我們沒有該類型的注冊解析器或具體對象，我們將假設(shè)每種類型都是具體名稱，
// 并嘗試按原樣解析它，因?yàn)槿萜鲬?yīng)該能夠自動解析具體對象。
if (isset($this->bindings[$abstract])) {
return $this->bindings[$abstract]['concrete'];
}
return $abstract;
}
/**
* Get the contextual concrete binding for the given abstract.
* 獲取給定摘要的上下文具體綁定。
*
* @param string $abstract
* @return string|null
*/
protected function getContextualConcrete($abstract)
{
if (! is_null($binding = $this->findInContextualBindings($abstract))) {
return $binding;
}
// Next we need to see if a contextual binding might be bound under an alias of the
// given abstract type. So, we will need to check if any aliases exist with this
// type and then spin through them and check for contextual bindings on these.
// 接下來，我們需要查看是否可以在給定抽象類型的別名下綁定上下文綁定。
// 因此，我們將需要檢查此類型是否存在別名，然后旋轉(zhuǎn)它們并檢查這些別名的上下文綁定。
if (empty($this->abstractAliases[$abstract])) {
return;
}
foreach ($this->abstractAliases[$abstract] as $alias) {
if (! is_null($binding = $this->findInContextualBindings($alias))) {
return $binding;
}
}
}
/**
* Find the concrete binding for the given abstract in the contextual binding array.
* 在上下文綁定數(shù)組中找到給定摘要的具體綁定
*
* @param string $abstract
* @return string|null
*/
protected function findInContextualBindings($abstract)
{
if (isset($this->contextual[end($this->buildStack)][$abstract])) {
return $this->contextual[end($this->buildStack)][$abstract];
}
}
/**
* Determine if the given concrete is buildable.
* 確定給定的具體是否可構(gòu)建。
*
* @param mixed $concrete
* @param string $abstract
* @return bool
*/
protected function isBuildable($concrete, $abstract)
{
return $concrete === $abstract || $concrete instanceof Closure;
}
/**
* Instantiate a concrete instance of the given type.
* 實(shí)例化給定類型的具體實(shí)例。
*
* @param string $concrete
* @return mixed
*
* @throws \Guanguans\Di\BindingResolutionException
*/
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.
// 如果具體類型實(shí)際上是 Closure，我們將直接執(zhí)行它并返回函數(shù)的結(jié)果，
// 這允許將函數(shù)用作解析器，以便對這些對象進(jìn)行更精細(xì)的解析。
if ($concrete instanceof Closure) {
return $concrete($this, $this->getLastParameterOverride());
}
$reflector = 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.
// 如果類型不是可實(shí)例化的，則開發(fā)人員正嘗試解析抽象類型，
// 例如 Abstract Class 的接口，并且沒有為抽象注冊任何綁定，因此我們需要紓困。
if (! $reflector->isInstantiable()) {
return $this->notInstantiable($concrete);
}
$this->buildStack[] = $concrete;
$constructor = $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.
// 如果沒有構(gòu)造函數(shù)，則意味著沒有依賴項(xiàng)，我們可以立即解析對象的實(shí)例，
// 而無需從這些容器中解析任何其他類型或依賴項(xiàng)。
if (is_null($constructor)) {
array_pop($this->buildStack);
return new $concrete;
}
$dependencies = $constructor->getParameters();
// Once we have all the constructor'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.
// 一旦有了所有構(gòu)造函數(shù)的參數(shù)，就可以創(chuàng)建每個依賴實(shí)例，
// 然后使用反射實(shí)例創(chuàng)建此類的新實(shí)例，將創(chuàng)建的依賴注入其中。
$instances = $this->resolveDependencies(
$dependencies
);
array_pop($this->buildStack);
return $reflector->newInstanceArgs($instances);
}
/**
* Resolve all of the dependencies from the ReflectionParameters.
* 從 ReflectionParameters 解析所有依賴項(xiàng)。
*
* @param array $dependencies
* @return array
*/
protected function resolveDependencies(array $dependencies)
{
$results = [];
foreach ($dependencies as $dependency) {
// If this dependency has a override for this particular build we will use
// that instead as the value. Otherwise, we will continue with this run
// of resolutions and let reflection attempt to determine the result.
// 如果此依賴項(xiàng)對此特定構(gòu)建具有替代，我們將使用作為值。
// 否則，我們將繼續(xù)執(zhí)行的分辨率，并讓反射嘗試確定結(jié)果。
if ($this->hasParameterOverride($dependency)) {
$results[] = $this->getParameterOverride($dependency);
continue;
}
// If the class is null, it means the dependency is a string or some other
// primitive type which we can not resolve since it is not a class and
// we will just bomb out with an error since we have no-where to go.
// 如果該類為 null，則表示依賴項(xiàng)是字符串或其他類型的原始類型，
// 由于它不是類，因此我們無法解析，并且由于沒有位置，我們將拋出錯誤去。
$results[] = is_null($class = $dependency->getClass())
? $this->resolvePrimitive($dependency)
: $this->resolveClass($dependency);
}
return $results;
}
/**
* Determine if the given dependency has a parameter override from makeWith.
* 確定給定的依賴項(xiàng)是否具有來自 makeWith 的參數(shù)重寫。
*
* @param \ReflectionParameter $dependency
* @return bool
*/
protected function hasParameterOverride($dependency)
{
return array_key_exists(
$dependency->name,
$this->getLastParameterOverride()
);
}
/**
* Get a parameter override for a dependency.
* 獲取依賴項(xiàng)的參數(shù)覆蓋。
*
* @param \ReflectionParameter $dependency
* @return mixed
*/
protected function getParameterOverride($dependency)
{
return $this->getLastParameterOverride()[$dependency->name];
}
/**
* Get the last parameter override.
* 獲取最后一個參數(shù)覆蓋。
*
* @return array
*/
protected function getLastParameterOverride()
{
return count($this->with) ? end($this->with) : [];
}
/**
* Resolve a non-class hinted primitive dependency.
* 解析非類提示的原始依賴項(xiàng)。
*
* @param \ReflectionParameter $parameter
* @return mixed
*
* @throws \Guanguans\Di\BindingResolutionException
*/
protected function resolvePrimitive(ReflectionParameter $parameter)
{
if (! is_null($concrete = $this->getContextualConcrete('$'.$parameter->name))) {
return $concrete instanceof Closure ? $concrete($this) : $concrete;
}
if ($parameter->isDefaultValueAvailable()) {
return $parameter->getDefaultValue();
}
$this->unresolvablePrimitive($parameter);
}
/**
* Resolve a class based dependency from the container.
* 解析容器中基于類的依賴關(guān)系。
*
* @param \ReflectionParameter $parameter
* @return mixed
*
* @throws \Guanguans\Di\BindingResolutionException
*/
protected function resolveClass(ReflectionParameter $parameter)
{
try {
return $this->make($parameter->getClass()->name);
}
// If we can not resolve the class instance, we will check to see if the value
// is optional, and if it is we will return the optional parameter value as
// the value of the dependency, similarly to how we do this with scalars.
// 如果無法解析類實(shí)例，則將檢查該值是否為可選，如果為可選，
// 們將返回可選參數(shù) value 作為依賴項(xiàng)的值，類似于執(zhí)行此操作的方式標(biāo)量。
catch (BindingResolutionException $e) {
if ($parameter->isOptional()) {
return $parameter->getDefaultValue();
}
throw $e;
}
}
/**
* Throw an exception that the concrete is not instantiable.
* 拋出一個具體無法實(shí)例化的異常。
*
* @param string $concrete
* @return void
*
* @throws \Guanguans\Di\BindingResolutionException
*/
protected function notInstantiable($concrete)
{
if (! empty($this->buildStack)) {
$previous = implode(', ', $this->buildStack);
$message = "Target [$concrete] is not instantiable while building [$previous].";
} else {
$message = "Target [$concrete] is not instantiable.";
}
throw new BindingResolutionException($message);
}
/**
* Throw an exception for an unresolvable primitive.
* 為無法解析的原語拋出異常。
*
* @param \ReflectionParameter $parameter
* @return void
*
* @throws \Guanguans\Di\BindingResolutionException
*/
protected function unresolvablePrimitive(ReflectionParameter $parameter)
{
$message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}";
throw new BindingResolutionException($message);
}
/**
* Register a new resolving callback.
* 注冊一個新的解析回調(diào)。
*
* @param string $abstract
* @param \Closure|null $callback
* @return void
*/
public function resolving($abstract, Closure $callback = null)
{
if (is_string($abstract)) {
$abstract = $this->getAlias($abstract);
}
if (is_null($callback) && $abstract instanceof Closure) {
$this->globalResolvingCallbacks[] = $abstract;
} else {
$this->resolvingCallbacks[$abstract][] = $callback;
}
}
/**
* Register a new after resolving callback for all types.
* 在解析所有類型的回調(diào)之后注冊一個新的。
*
* @param string $abstract
* @param \Closure|null $callback
* @return void
*/
public function afterResolving($abstract, Closure $callback = null)
{
if (is_string($abstract)) {
$abstract = $this->getAlias($abstract);
}
if ($abstract instanceof Closure && is_null($callback)) {
$this->globalAfterResolvingCallbacks[] = $abstract;
} else {
$this->afterResolvingCallbacks[$abstract][] = $callback;
}
}
/**
* Fire all of the resolving callbacks.
* 觸發(fā)所有解析的回調(diào)。
*
* @param string $abstract
* @param mixed $object
* @return void
*/
protected function fireResolvingCallbacks($abstract, $object)
{
$this->fireCallbackArray($object, $this->globalResolvingCallbacks);
$this->fireCallbackArray(
$object,
$this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks)
);
$this->fireAfterResolvingCallbacks($abstract, $object);
}
/**
* Fire all of the after resolving callbacks.
* 解決回調(diào)后，請執(zhí)行所有操作。
*
* @param string $abstract
* @param mixed $object
* @return void
*/
protected function fireAfterResolvingCallbacks($abstract, $object)
{
$this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);
$this->fireCallbackArray(
$object,
$this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks)
);
}
/**
* Get all callbacks for a given type.
* 獲取給定類型的所有回調(diào)。
*
* @param string $abstract
* @param object $object
* @param array $callbacksPerType
*
* @return array
*/
protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
{
$results = [];
foreach ($callbacksPerType as $type => $callbacks) {
if ($type === $abstract || $object instanceof $type) {
$results = array_merge($results, $callbacks);
}
}
return $results;
}
/**
* Fire an array of callbacks with an object.
* 觸發(fā)帶有對象的回調(diào)數(shù)組。
*
* @param mixed $object
* @param array $callbacks
* @return void
*/
protected function fireCallbackArray($object, array $callbacks)
{
foreach ($callbacks as $callback) {
$callback($object, $this);
}
}
/**
* Get the container's bindings.
* 獲取容器的綁定。
*
* @return array
*/
public function getBindings()
{
return $this->bindings;
}
/**
* Get the alias for an abstract if available.
* 獲取摘要的別名（如果有）。
*
* @param string $abstract
* @return string
*
* @throws \LogicException
*/
public function getAlias($abstract)
{
if (! isset($this->aliases[$abstract])) {
return $abstract;
}
if ($this->aliases[$abstract] === $abstract) {
throw new LogicException("[{$abstract}] is aliased to itself.");
}
return $this->getAlias($this->aliases[$abstract]);
}
/**
* Get the extender callbacks for a given type.
* 獲取給定類型的擴(kuò)展程序回調(diào)。
*
* @param string $abstract
* @return array
*/
protected function getExtenders($abstract)
{
$abstract = $this->getAlias($abstract);
if (isset($this->extenders[$abstract])) {
return $this->extenders[$abstract];
}
return [];
}
/**
* Remove all of the extender callbacks for a given type.
* 刪除給定類型的所有擴(kuò)展器回調(diào)。
*
* @param string $abstract
* @return void
*/
public function forgetExtenders($abstract)
{
unset($this->extenders[$this->getAlias($abstract)]);
}
/**
* Drop all of the stale instances and aliases.
* 刪除所有過時的實(shí)例和別名。
*
* @param string $abstract
* @return void
*/
protected function dropStaleInstances($abstract)
{
unset($this->instances[$abstract], $this->aliases[$abstract]);
}
/**
* Remove a resolved instance from the instance cache.
* 從實(shí)例緩存中刪除已解析的實(shí)例。
*
* @param string $abstract
* @return void
*/
public function forgetInstance($abstract)
{
unset($this->instances[$abstract]);
}
/**
* Clear all of the instances from the container.
* 從容器中清除所有實(shí)例。
*
* @return void
*/
public function forgetInstances()
{
$this->instances = [];
}
/**
* Flush the container of all bindings and resolved instances.
* 刷新容器中的所有綁定和已解決的實(shí)例。
*
* @return void
*/
public function flush()
{
$this->aliases = [];
$this->resolved = [];
$this->bindings = [];
$this->instances = [];
$this->abstractAliases = [];
}
/**
* Set the globally available instance of the container.
* 設(shè)置容器的全局可用實(shí)例。
*
* @return static
*/
public static function getInstance()
{
if (is_null(static::$instance)) {
static::$instance = new static;
}
return static::$instance;
}
/**
* Set the shared instance of the container.
* 設(shè)置容器的共享實(shí)例。
*
* @param \Guanguans\Di\Container|null $container
* @return static
*/
public static function setInstance(Container $container = null)
{
return static::$instance = $container;
}
/**
* Determine if a given offset exists.
* 確定是否存在給定的 key 。
*
* @param string $key
* @return bool
*/
public function offsetExists($key)
{
return $this->bound($key);
}
/**
* Get the value at a given offset.
* 獲取給定 key 的值。
*
* @param string $key
* @return mixed
*/
public function offsetGet($key)
{
return $this->make($key);
}
/**
* Set the value at a given offset.
* 將值設(shè)置為給定的 key 。
*
* @param string $key
* @param mixed $value
* @return void
*/
public function offsetSet($key, $value)
{
$this->bind($key, $value instanceof Closure ? $value : function () use ($value) {
return $value;
});
}
/**
* Unset the value at a given offset.
* 以給定 key 取消設(shè)置值。
*
* @param string $key
* @return void
*/
public function offsetUnset($key)
{
unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
}
/**
* Dynamically access container services.
* 動態(tài)訪問容器服務(wù)。
*
* @param string $key
* @return mixed
*/
public function __get($key)
{
return $this[$key];
}
/**
* Dynamically set container services.
* 動態(tài)設(shè)置容器服務(wù)。
*
* @param string $key
* @param mixed $value
* @return void
*/
public function __set($key, $value)
{
$this[$key] = $value;
}
/**
* 通過其標(biāo)識符查找容器的條目并返回它。
*
* @inheritDoc
*/
public function has($id)
{
return $this->offsetExists($id);
}
/**
* 如果容器可以返回給定標(biāo)識符的條目，則返回 true 。 否則返回 false 。
*
* @inheritDoc
*/
public function get($id)
{
return $this[$id];
}
}
